◆ AI Coding Agents

GitHub Copilot CLI

v1.0.81 commercial

GitHub Copilot CLI is an AI-powered command-line tool that generates shell commands and explains terminal operations using natural language.

source ↗ rss ↗ last repo push Aug 19, 2026

echo "$COPILOT_TOKEN" | copilot login --with-token
export PLUGINS_DASHBOARD=false
copilot
copilot -p "Refactor the auth module" --agent myplugin:refactor-agent --usage-output-file usage.json
/worktree new
{
  "pinnedPrompts": true,
  "extraKnownMarketplaces": [
    {
      "url": "https://plugins.example.com",
      "autoUpdate": true
    }
  ],
  "sandbox": {
    "allowDevToolAccess": true,
    "auth": {
      "git": true,
      "gh": true
    }
  }
}
copilot --plan --mode autopilot
/worktree new
{
  "allowDevToolAccess": true,
  "extraKnownMarketplaces": [
    {
      "url": "https://plugins.example.com",
      "autoUpdate": true
    }
  ]
}
/new-worktree
/permissions
allowDevToolCaches: false
forceRemoteSettingsRefresh: true
copilot login --web-flow
copilot login --device-code
copilot login --web-flow
copilot login --device-code
/limits predict
sidebar.hoverFocus: false
sidebar.accentActiveSession: true
/experimental on
/limits predict
/experimental on
stayInAutopilot: false
/model plan gemini-3.6-flash
/model plan off
/model plan gemini-3.6-flash
/model plan off
/model --session
copilot plugins install --skill ./my-skill --scope project
/settings shellShortcut on
{
  "githubMcpToolsets": ["repos", "issues"],
  "githubMcpTools": ["create_pull_request", "list_issues"]
}
copilot plugins marketplace browse
copilot plugins marketplace add <marketplace-url>
copilot -p --no-sandbox
{
  "model": "gpt-5.6",
  "effort": "high",
  "contextTier": "full",
  "deny": {
    "mcp": ["untrusted-server"]
  }
}
plugins:
  - name: my-plugin
    source:
      url: https://github.com/org/my-plugin
      sha: a3f8c21d9e4b7065f1234567890abcdef1234567
/mcp list
stayInAutopilot: true
/delegate --base main
/usage
/worktree fix the login redirect
copilot skill list
copilot --resume
/security-review
{
  "mcpServers": {
    "my-server": {
      "command": "npx",
      "args": ["my-mcp-server"],
      "deferTools": true
    }
  }
}
/every 1d /chronicle standup
/subagents
{
  "beepOnSchedule": false
}
/worktree feature/my-branch
builtInAgents:
  rubberDuckAutoInvoke: false
lsp:
  servers:
    my-server:
      bash: true
      cwd: "$PLUGIN_ROOT/workspace"
/experimental on
/every 10m summarize open pull requests
/experimental on
/after 30m remind me to review the deployment checklist
{
  "showTipsOnStartup": false
}
copilot config set builtInAgents.rubberDuck true
permissions:
  disableBypassPermissionsMode: true
/autopilot Refactor the authentication module to use OAuth 2.0 PKCE flow
session.create({ pluginDirectories: ["/path/to/my-plugins"] })
/compact focus on the database migration steps only
---
name: my-large-agent
deferred-tool-loading: true
---
copilot --continue -C /path/to/other/dir
"terminalProgress": true
/security-review
/chronicle search "authentication flow"
auth:
  redirectPort: 9876
COPILOT_PLUGIN_DIR_ONLY=1 copilot --plugin-dir ./plugins chat
/autopilot
/fork
gh copilot -C ~/projects/my-service
copilot -p 'Explain the architecture shown in this diagram' --attachment ./architecture.png
copilot --experimental
GITHUB_COPILOT_PROMPT_MODE_EXTENSIONS=true copilot -p 'Run the project lint extension and summarise findings'
copilot --max-autopilot-continues 10
GITHUB_COPILOT_PROMPT_MODE_WORKSPACE_MCP=1 copilot -p 'summarize open PRs in this repo'
COPILOT_HOME=~/.config/copilot-work copilot plugin list
ctrl+x → b
copilot completion zsh > ~/.zsh/completions/_copilot && source ~/.zshrc
/keep-alive
/remote
/remote off
gh copilot --name my-feature-work
# later...
gh copilot --resume=my-feature-work
continueOnAutoMode: true
hooks:
  - event: tool_call
    http:
      url: https://hooks.example.com/copilot
      method: POST
gh copilot --resume a3f92b1
gh copilot --print-debug-info
gh copilot --session-idle-timeout 30m
/statusline branch quota
servers:
  - name: my-mcp-server
    url: https://mcp.example.com/v1
/ask What does the OWASP Top 10 say about injection attacks?
copilot plugin marketplace update
echo "Plugin installed at: $COPILOT_PLUGIN_ROOT"
/env
/add-dir ./src
gh copilot /diff
/rewind
/allow-all on
# run your automated task
/allow-all off
/allow-all show
{
  "hooks": {
    "pre_tool_call": [
      {
        "command": "./scripts/audit.sh",
        "args": ["{{project_dir}}", "{{plugin_data_dir}}"]
      }
    ]
  }
}
# .claude/settings.json  — committed to the repo
{
  "model": "claude-3-7-sonnet-20250219",
  "reasoning_effort": "high"
}

# .claude/settings.local.json  — git-ignored, personal overrides
{
  "reasoning_effort": "low"
}
/new 'Run the full test suite and summarise failures'
statusLine.command: ~/.local/bin/my-status ${PROJECT:-default}
/undo
{ "statusLine": true, "effortLevel": "high", "autoUpdatesChannel": "stable" }
{
  "hooks": {
    "pre-commit": "npm run lint"
  }
}
# In your system message config, set mode to 'customize' to enable section-level overrides
# Register a subagentStart hook in your SDK session setup to supply additional prompt context to each spawned subagent
COPILOT_CUSTOM_INSTRUCTIONS_DIRS=./team-instructions copilot
copilot --plugin-dir ./my-plugin
/pr
/changelog last 5
/changelog since 1.0.0
/changelog summarize
disableAllHooks: true
gh copilot /pr view local
mergeStrategy: squash
command: echo 'Running hook'
timeout: 30
gh copilot prompt --output-format json 'Summarize open TODOs in this repo' | jq '.content'
copy_on_select: true
enabledPlugins:
  - my-org/copilot-plugin-terraform
  - ssh://[email protected]/infra/copilot-plugin-k8s
copilot --plugin-dir ./my-local-plugin
{
  "marketplaces": ["https://example.com/my-marketplace"],
  "launchMessage": "Welcome to the team repo!"
}
/chronicle standup
/research How do supply-chain attacks target npm packages?
gh copilot suggest --help
/plugin install "/Users/analyst/My Plugins/vuln-scanner"
{
  "plugins": [
    {
      "name": "my-remote-plugin",
      "source": "https://github.com/my-org/my-copilot-plugin"
    }
  ]
}
/mcp reload
include_coauthor: false
/init suppress
/streamer-mode
{
  "servers": {
    "my-mcp-server": {
      "command": "npx",
      "args": ["my-mcp-package"]
    }
  }
}
/mcp show
gh copilot plugin marketplace add https://example.com/my-copilot-plugin
/tasks
copilot login
/theme
launch_messages:
  - 'Welcome to Copilot CLI. Remember to review AI suggestions before applying.'
/allow-all
echo '# summarize\nSummarize the current diff in one paragraph.' > .claude/commands/summarize.md
/diff
/mcp show <server-name>
gh copilot --acp
copilot update
/plugin install github.com/example-org/copilot-plugin
/init
/resume
# then press / to filter sessions by keyword
/diff
gh copilot --enable-all-github-mcp-tools
& summarize all open pull requests and save the results to pr-summary.md
/cd ~/projects/my-repo
gh copilot suggest --allow-all 'set up a new node project with eslint'
gh copilot suggest --share-gist 'Write a bash script to rotate AWS credentials'
/compact
/context
/share
COPILOT_GITHUB_TOKEN=${{ secrets.COPILOT_TOKEN }} gh copilot suggest -p 'write a bash script to archive logs older than 30 days'
gh copilot suggest --agent security-reviewer 'Review this PR for injection vulnerabilities'
/delegate Fix all TODO comments in the authentication module
gh copilot --enable-all-github-mcp-tools
copilot --disable-parallel-tools-execution
copilot --disallow-temp-dir
copilot --stream off
copilot help config
copilot --additional-mcp-config @base.json --additional-mcp-config @overrides.json
copilot --additional-mcp-config '{"mcpServers": {"my-tool": {"command": "my-tool-server", "args": []}}}'
log_level = debug
copilot -p --allow-all-paths
{
  "env": {
    "GITHUB_ACCESS_TOKEN": "${GITHUB_TOKEN}"
  }
}
/usage
copilot --continue
! grep -r 'TODO' ./src
/model claude-sonnet-4-5
copilot --allow-tool 'shell(npm run test:*)' --deny-tool 'shell(*)'

Summary

GitHub Copilot CLI is a commercial AI tool that brings AI-powered coding assistance to the command line, enabling users to build, debug, and refactor code through natural language conversation. Accessing your repositories, issues, and pull requests is possible using natural language, all authenticated with your GitHub account. It is run as a command-line tool on Linux, macOS, and Windows. This is aimed at application developers, and its documentation does not name a comparable product. The project continues to iterate based on user feedback.

GitHub Copilot CLI is an AI-powered command-line tool that generates shell commands and explains terminal operations using natural language.

What GitHub Copilot CLI answers

Does it support other custom extensions?

the coding agent supports custom MCP servers to extend capabilities

What operating systems can I use it on?

it runs on Linux, macOS, and Windows

What is needed to run it on Windows?

PowerShell version 6 or higher

Can I run complex actions without risk?

every action has a preview that requires explicit approval before it executes

How deep is its integration with GitHub context?

it accesses repositories, issues, and pull requests using natural language with your authenticated GitHub account

Can I extend its functionality?

it takes advantage of the coding agent shipping with GitHub's MCP server and supports custom MCP servers

Command line

composed command

option surface across analysed releases

options at that release added, per release removed, per release

option	found in	since	description

Values are placeholders taken from each option’s declared default. Nothing is executed here — the output shown is a recording of a run that already happened.

Release history

v1.0.81 Aug 27, 2026 · issue 009

Copilot CLI v1.0.81 adds plugins dashboard, WAM auth, hooks trace context, --with-token login, per-agent usage metrics, and more.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.81 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.81
```
└──▷ TRY IT
Authenticate in a CI pipeline or script by piping a token directly to copilot login without interactive prompts.
```
$ echo "$COPILOT_TOKEN" | copilot login --with-token
```
Opt a machine out of the plugins dashboard so the legacy workflow is preserved for automated or headless environments.
```
$ export PLUGINS_DASHBOARD=false
copilot
```
Capture per-agent usage breakdown to a JSON file after a headless run with a plugin-contributed agent, for quota and cost tracking.
```
$ copilot -p "Refactor the auth module" --agent myplugin:refactor-agent --usage-output-file usage.json
```
- ›Adds --with-token flag to copilot login to read an auth token from stdin, enabling non-interactive authentication pipelines.
- ›Adds PLUGINS_DASHBOARD=false environment variable to opt out of the plugins dashboard and the copilot plugins command.
- ›Adds copilot app subcommand to open the GitHub Copilot app in the current directory.
- ›Adds defaultMode and defaultPermissionMode settings to configure startup mode and approval behavior for new interactive sessions.
- ›Adds --add-dir flag to discover skills and custom agents from additional directories.
+24 moreshow less
- ›Adds per-agent usage metrics to --usage-output-file JSON output.
- ›Adds traceparent (and tracestate when vendor state is present) inputs to hooks, plus env vars on command hooks, so hooks can receive the current OpenTelemetry trace context and emit correlated spans.
- ›Adds since_turn parameter support to read_agent calls, which now consistently return full turn history unless since_turn is provided.
- ›Ships MCP 2026-07-28 protocol support to CLI, SDK, IDE, and in-memory clients.
- ›Adds Ctrl+E in /sandbox to open settings.json in your editor.
- ›Adds Ctrl+Space to toggle voice dictation.
- ›Adds Ctrl+X → G keyboard shortcut to expand or collapse the autopilot goal panel.
- ›Windows: remote MCP servers protected by Microsoft Entra ID can now authenticate through the OS broker (WAM), typically with no prompt; other platforms and machines without the broker library keep the existing browser flow.
- ›ACP clients now receive subagent IDs, raw event subscriptions, and live title, mode, command, and plan updates.
- ›models.list now includes service-published infoMessages and warningMessages per model.
- ›Adds support for Gemini 3.7 Flash and xhigh reasoning effort for Grok 4.6.
- ›Auto mode now adapts model selection as a task evolves during a conversation.
- ›/plugin now flags installed plugins and marketplaces with a newer upstream version and offers an Update action.
- ›Path-sourced plugins in a local directory-source marketplace now load live from their real directory, taking effect on /restart or a new session without needing /plugin update.
- ›Managed settings now win per entry for enabledPlugins and extraKnownMarketplaces, preventing local overrides of organization-pinned plugins or marketplaces.
- ›forceRemoteSettingsRefresh now fails closed: when set, the cached managed-settings policy is never served or used as a fetch-failure fallback, blocking startup on an unconfirmed policy and applying the restrictive undetermined-policy posture (non-default MCP servers blocked, bypass-permissions mode disabled, policy-gated plugin install/update mutations blocked).
- ›Hook lifecycle events (hook.start/hook.end) from hooks inside a subagent are now recorded on that subagent's session and re-emitted on its parent.
- ›Shows each user instruction file separately in /instructions.
- ›Shows model data retention warnings with links in the /model picker.
- ›A session sandboxed by an enterprise managed policy now displays that fact on the timeline, including when the policy arrives mid-session.
- ›Agents, skills, and MCP servers contributed by installed plugins are no longer dropped in non-interactive (-p) runs, so --agent <plugin>:<agent> works headlessly without --plugin-dir.
- ›Sandboxed builds on Windows now create scratch caches on first run, enabling cargo, go, Gradle, and ccache without a warm cache.
- ›Blocks an MCP server blocked by enterprise policy now shown as blocked in /mcp instead of spinning as pending.
- ›x is now the delete key in /sandbox config, /settings, /mcp, the sessions dialog, and the diff comments summary.
└──▷ BREAKING ON UPGRADE
- !The PLUGINS_DASHBOARD opt-out environment variable and the legacy skills picker it kept alive have been removed.
- !The /plugins slash command has been removed; its resources moved to /plugin, /mcp, /skills, /subagents, and /instructions. Enabling and disabling hooks and LSP servers is temporarily unavailable as those toggles existed only in the removed /plugins dashboard.
- !/skills, bare /mcp, and /mcp show (with no server name) always open the plugins dashboard; there is no longer an opt-out via PLUGINS_DASHBOARD=false.
v1.0.79 Aug 10, 2026 · issue -009

GitHub Copilot CLI v1.0.79 adds worktree sessions, tgrep monorepo search, multi-session management, and a renamed sandbox policy key.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.79 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.79
```
└──▷ TRY IT
Start a fresh implementation branch without leaving your current session — useful when you want Copilot to work on a feature in isolation from HEAD.
```
$ /worktree new
```
Opt in to prompt pinning and auto-update a private marketplace's plugins on every session start.
json
```
{
  "pinnedPrompts": true,
  "extraKnownMarketplaces": [
    {
      "url": "https://plugins.example.com",
      "autoUpdate": true
    }
  ],
  "sandbox": {
    "allowDevToolAccess": true,
    "auth": {
      "git": true,
      "gh": true
    }
  }
}
```
- ›Renames sandbox setting allowDevToolCaches to allowDevToolAccess in settings.json (and managed/MDM policy) — the old key is silently ignored, so an existing false opt-out reverts to the default (on).
- ›Moves sandbox auth settings from sandbox.gitAuth/sandbox.ghAuth to sandbox.auth.git/sandbox.auth.gh in settings.json; old keys are rejected as invalid rather than ignored.
- ›Adds worktreeBaseRef setting to control whether /worktree, /worktree new, and --worktree start from HEAD or the remote default branch (all three now default to HEAD).
- ›Adds /worktree new subcommand to start a new session in a new worktree.
- ›Adds --plan flag combinable with --mode autopilot to plan first and then implement without waiting for approval.
+23 moreshow less
- ›Adds /sandbox command to show effective sandbox paths, denials, and network access.
- ›Adds /app command to open the current session in the GitHub Copilot desktop app (requires GitHub Copilot app 1.1.3 or later).
- ›Adds pinnedPrompts setting (default false) to enable prompt pinning; automatically stays off on terminals under 30 rows unless set explicitly.
- ›Adds autoUpdate: true option on extraKnownMarketplaces entries in user settings to auto-update plugins at session start.
- ›Makes /model session-scoped by default; use /config model to set defaults for future sessions.
- ›Replaces ripgrep with tgrep (trigram-indexed grep) for fast regex search in large monorepos.
- ›Adds support for the kimi-k3 model in the model picker.
- ›Adds enterprise allow-auto-only policy support so /allow-all auto works while full allow-all remains blocked.
- ›Allows enterprise-managed sandbox policy to enforce a proxy URL while keeping credentials user-controlled.
- ›Agent Plugins spec plugins can now ship extensions under a com.github.copilot/extensions/ directory.
- ›Adds multi-session management via a Sessions tab and sidebar.
- ›Model picker groups models into Recent, Recommended, New, and other sections, with Shift+Tab switching grouping views.
- ›Sandboxed git now authenticates to Azure DevOps, GitHub Enterprise Server, GitLab, and other non-GitHub remotes with stored HTTPS credentials.
- ›Sandboxed wrapper builds (make and friends) receive dev tool caches based on build manifests in the working directory.
- ›Ask user multi-select prompts now include an Other option for free-text answers.
- ›Improves teleported subagent /tasks navigation with nested tree browsing, current/all and finished-task filters, and a live timeline.
- ›Tool directories on PATH inside a workspace (.venv/bin, node_modules/.bin, an in-repo GOPATH) no longer turn that workspace area read-only in the sandbox.
- ›Sandboxed commands can use UNIX-domain sockets on macOS, unblocking tools like tsx, vite, esbuild, and jest workers.
- ›Sandboxed commands work when the working directory lives on a Windows Dev Drive.
- ›Sandboxed commands can reach the network on recent Windows builds where outbound connections were previously blocked.
- ›A sandbox that cannot start an MCP server now fails in seconds instead of stalling the session.
- ›Supports prompt and shell command queuing in local sessions to run in order after the current task finishes.
- ›Adds (disabled) tags for inactive sandbox settings with explanations in the /sandbox configuration dialog.
└──▷ BREAKING ON UPGRADE
- !The sandbox setting allowDevToolCaches is renamed to allowDevToolAccess in settings.json and managed/MDM policy; the old key is silently ignored, so an existing allowDevToolCaches: false opt-out reverts to the default (enabled). Rename it in settings.json and any managed/MDM policy.
- !Sandbox auth settings keys moved from sandbox.gitAuth/sandbox.ghAuth to sandbox.auth.git/sandbox.auth.gh in settings.json; old keys are rejected as invalid. No automatic migration is provided.
v1.0.79 Aug 10, 2026 · issue 002

Copilot CLI v1.0.79 adds worktree branching control, combined plan+autopilot mode, sandbox policy inspection, tgrep for monorepos, and multi-session management.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.79 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.79
```
└──▷ TRY IT
Plan a complex refactor first, then let autopilot implement it end-to-end without approval prompts between steps.
```
$ copilot --plan --mode autopilot
```
Start a new isolated worktree session for a feature branch without leaving your current session.
```
$ /worktree new
```
After renaming allowDevToolCaches, enable auto-updating a private plugin marketplace and restore the dev-tool access opt-out.
settings.json
```
{
  "allowDevToolAccess": true,
  "extraKnownMarketplaces": [
    {
      "url": "https://plugins.example.com",
      "autoUpdate": true
    }
  ]
}
```
- ›Renames sandbox setting allowDevToolCaches to allowDevToolAccess in settings.json (and managed/MDM policy) to reflect that it covers dev-tool config and registries, not just caches — see breaking changes.
- ›Moves sandbox auth settings from sandbox.gitAuth/sandbox.ghAuth to sandbox.auth.git/sandbox.auth.gh in settings.json; old keys are ignored and SDK requests still sending them are rejected.
- ›Adds worktreeBaseRef setting to control whether /worktree, /worktree new, and --worktree start from HEAD or the remote default branch; all three now default to HEAD.
- ›Adds pinnedPrompts setting (default false) to enable prompt pinning; also suppressed by default on terminals under 30 rows.
- ›Adds autoUpdate: true field on extraKnownMarketplaces entries in user settings to auto-update marketplace plugins at session start.
+25 moreshow less
- ›Adds /sandbox policy command to show effective sandbox paths, denials, and network access.
- ›Adds /worktree new command to start a new session in a new worktree.
- ›Combines --plan with --mode autopilot to plan first, then implement without waiting for approval.
- ›Adds /app command to open the current session in the GitHub Copilot desktop app (requires Copilot app 1.1.3 or later).
- ›Adds support for the kimi-k3 model in the model picker.
- ›Makes /model session-scoped by default; use /config model to set defaults for future sessions.
- ›Adds enterprise allow-auto-only policy support so /allow-all auto works while full allow-all remains blocked.
- ›Allows enterprise-managed sandbox policy to enforce a proxy URL while keeping credentials user-controlled.
- ›Replaces ripgrep with tgrep (trigram-indexed grep) for fast regex search in large monorepos.
- ›Agent Plugins spec plugins can now ship extensions under a com.github.copilot/extensions/ directory.
- ›Model picker groups models into Recent, Recommended, New, and other sections; Shift+Tab switches grouping views.
- ›Sandboxed git now authenticates to Azure DevOps, GitHub Enterprise Server, GitLab, and other non-GitHub remotes with stored HTTPS credentials.
- ›Adds multi-session management from a Sessions tab and sidebar.
- ›Sandboxed wrapper builds (make and friends) receive dev-tool caches based on build manifests in the working directory.
- ›Queues prompts, shell commands, and supported slash commands in local sessions to run in order after the current task finishes.
- ›Ask user multi-select prompts include an Other option for free-text answers.
- ›Improves teleported subagent /tasks navigation with nested tree browsing, current/all and finished-task filters, and a live steerable timeline.
- ›Workspace tool directories on PATH (.venv/bin, node_modules/.bin, in-repo GOPATH) no longer force that workspace portion read-only in the sandbox.
- ›Sandboxed commands can use UNIX-domain sockets on macOS again, unblocking tools that use local IPC pipes (tsx, vite, esbuild, jest workers).
- ›Sandboxed commands work when the working directory lives on a Windows Dev Drive.
- ›On Linux, searches and most shell commands blocked by the sandbox now offer to re-run outside it.
- ›A sandbox that cannot start an MCP server now fails in seconds instead of stalling the session.
- ›Plugin custom agents honor deferred-tool-loading frontmatter.
- ›Login links are clickable during web and device-code sign-in.
- ›The /sandbox configuration dialog shows where sandbox settings are stored in settings.json and tags inactive settings as (disabled) with explanations.
└──▷ BREAKING ON UPGRADE
- !The sandbox setting allowDevToolCaches is renamed to allowDevToolAccess in settings.json and managed/MDM policy; the old key is silently ignored, so an existing false opt-out reverts to the default (on) — rename the key in both places.
- !Sandbox auth settings moved from sandbox.gitAuth/sandbox.ghAuth to sandbox.auth.git/sandbox.auth.gh in settings.json; old keys are ignored and SDK requests still sending them are rejected as invalid.
- !--worktree now defaults to starting from HEAD instead of the remote default branch; set worktreeBaseRef to restore the previous behavior.
v1.0.78 Aug 3, 2026 · issue -016

GitHub Copilot CLI v1.0.78 adds /new-worktree and /permissions commands, ACP token usage exposure, and a new allowDevToolCaches sandbox setting.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.78 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.78
```
└──▷ TRY IT
Start a parallel investigation in an isolated worktree without disturbing your current working tree or conversation.
```
$ /new-worktree
```
Switch approval modes on the fly mid-session instead of restarting the CLI.
```
$ /permissions
```
- ›Adds /new-worktree (experimental) command to create a new git worktree and start a fresh conversation inside it.
- ›Adds /permissions command to switch between approval modes mid-session.
- ›Adds allowDevToolCaches sandbox setting (on by default) to grant sandboxed builds access to toolchain caches, registries, and installs; set to false to opt out.
- ›Adds forceRemoteSettingsRefresh managed setting to require a fresh managed-settings fetch on every startup.
- ›Adds /settings showToolDurations to control display of per-tool-call elapsed time in timeline headers (on by default, live-ticking for calls of at least 5 seconds).
+14 moreshow less
- ›Exposes token usage in ACP prompt results and live usage_update notifications.
- ›ACP mode now supports closing sessions via the closeSession request.
- ›Managed settings now fall back to the persistent cache on any fetch failure (network error, non-success HTTP status, or malformed response), and fail open when no usable cached policy is available.
- ›Startup now warns about unknown top-level keys in user settings.json (e.g. misspelled settings) instead of silently ignoring them.
- ›Shell completion for --model now suggests auto and all supported model names.
- ›The sessionEnd hook for stdin-piped runs now fires once per completed agent turn with reason complete (or error), matching -p behavior, instead of firing once at shutdown with user_exit.
- ›Switching sessions no longer restarts MCP servers or rebuilds hook state, preventing stale-hook errors in concurrent turns.
- ›Refreshes deferred MCP tools automatically after OAuth authentication.
- ›Sandbox bypass from a bypass prompt now applies only to the current session; new sessions start sandboxed again.
- ›When the sandbox blocks a shell command and bypass is allowed, CLI offers to re-run it outside the sandbox without re-querying the model.
- ›First-party plugins automatically update to their latest version at session start.
- ›Resuming long sessions is dramatically faster and memory-lighter: a 230 MB, 74k-event transcript now loads in under a second (vs. ~10 seconds previously) at roughly one-quarter peak memory, by reading history once in parallel at startup.
- ›Long session transcripts now render progressively to keep scrolling responsive.
- ›Copilot login now defaults to the browser flow for local desktop subprocesses without a TTY (including IDE integrations); remote and headless environments continue using device code.
└──▷ BREAKING ON UPGRADE
- !The /allow-all auto safety-judge model is no longer user-configurable; the judge model is now selected automatically.
- !Managed settings now fail open — starting without the unconfirmed server restriction — when no usable cached policy is available, reversing the prior fail-closed behavior.
v1.0.78 Aug 3, 2026 · issue 002

Copilot CLI v1.0.78 adds /new-worktree, /permissions, allowDevToolCaches sandbox setting, ACP token-usage exposure, and live tool-call duration timers.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.78 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.78
```
└──▷ USE IT
Opt sandboxed builds out of automatic toolchain-cache access when you need a fully isolated, clean-room build environment.
yaml
```
allowDevToolCaches: false
```
Force a fresh fetch of managed settings on startup to ensure the latest enterprise policy is always applied before the session begins.
yaml
```
forceRemoteSettingsRefresh: true
```
- ›Adds /settings showToolDurations to disable live tool-call duration timers in timeline headers (on by default; only shown for calls of at least 5 seconds).
- ›Adds experimental /new-worktree command to create a new git worktree and start a new conversation inside it.
- ›Adds /permissions command to switch between approval modes interactively.
- ›Adds allowDevToolCaches sandbox setting (on by default) to grant sandboxed builds access to toolchain caches, registries, and installs; set to false to opt out.
- ›Adds forceRemoteSettingsRefresh managed setting to require a fresh managed-settings fetch on every startup.
+16 moreshow less
- ›Exposes token usage in ACP prompt results and live usage_update notifications.
- ›ACP mode now supports closing sessions via the closeSession request.
- ›Managed settings now fall back to the persistent cache when a server-managed settings fetch fails (network error, non-success HTTP status, or malformed response), and fail open when no usable cached policy is available.
- ›Shell completion for --model now suggests auto and all supported model names.
- ›Warns on startup about unknown top-level keys in user settings.json (e.g. misspelled settings) instead of silently ignoring them.
- ›sessionEnd hook for stdin-piped runs now fires once per completed agent turn with reason complete (or error if the turn failed), matching -p behavior, instead of once at shutdown with user_exit.
- ›First-party plugins automatically update to the latest version at session start.
- ›Sandbox bypass from a bypass prompt applies only to that session; new sessions start sandboxed again.
- ›When the sandbox blocks a shell command and bypass is allowed, the CLI offers to re-run it outside the sandbox without re-querying the model.
- ›Switching sessions no longer restarts MCP servers or rebuilds hook state, preventing stale-hook errors in parallel turns.
- ›Refreshes deferred MCP tools automatically after OAuth authentication.
- ›Resumes long session transcripts dramatically faster with parallel, single-pass history loading at startup.
- ›Long session transcripts now render progressively to keep scrolling responsive.
- ›The /allow-all auto safety-judge model is now selected automatically and is no longer user-configurable.
- ›Ctrl+Q now enqueues the highlighted mid-text skill completion instead of the partial token.
- ›Copilot login defaults to the browser flow for local desktop subprocesses without a TTY (including IDE integrations); remote and headless environments continue using device code.
└──▷ BREAKING ON UPGRADE
- !The /allow-all auto safety-judge model is no longer user-configurable; any existing user configuration for the judge model is ignored.
- !A stdin-piped run that exits before completing a turn now fires no sessionEnd hook (previously fired once at shutdown with user_exit).
v1.0.77 Jul 30, 2026 · issue -020

Copilot CLI v1.0.77 adds browser OAuth login, MDM sandbox policy, and Ctrl+G in-prompt editor
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.77 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.77
```
└──▷ TRY IT
Force browser-based OAuth login on a machine where you want to avoid the device-code flow.
```
$ copilot login --web-flow
```
Force device-code login on a local terminal when you prefer not to open a browser.
```
$ copilot login --device-code
```
- ›Adds --web-flow and --device-code flags to copilot login to force browser-based or device-code OAuth mode; browser OAuth is now the default on local interactive terminals, device code remains default on remote/headless terminals; mode is also selectable via the interactive /login command.
- ›Adds support for enforcing managed sandbox policy via macOS and Windows native MDM settings.
- ›Adds Ctrl+G keyboard shortcut to open your editor for freeform ask_user answers without closing the prompt.
- ›Unconditional autopilot approval now disables the sandbox for the current session when bypass is allowed.
- ›Allows reasoning effort to be omitted so the server can select the default.
v1.0.77 Jul 30, 2026 · issue 002

Copilot CLI v1.0.77 adds browser OAuth login with --web-flow/--device-code flags, Ctrl+G editor for freeform answers, and MDM sandbox policy enforcement.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.77 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.77
```
└──▷ TRY IT
Force browser-based OAuth login on a machine where you want a GUI auth flow instead of the device-code fallback.
```
$ copilot login --web-flow
```
Force device-code login explicitly on a local terminal where browser OAuth is now the default, e.g. in a script or restricted environment.
```
$ copilot login --device-code
```
- ›Adds --web-flow and --device-code flags to copilot login to force browser-based OAuth or device-code authentication respectively; browser OAuth is now the default on local interactive terminals, device code remains default on remote/headless terminals.
- ›Adds browser-based OAuth login as a selectable option in the interactive /login command.
- ›Adds Ctrl+G keybinding to open your editor for freeform ask_user answers without closing the prompt.
- ›Supports enforcing managed sandbox policy via macOS and Windows native MDM settings.
- ›Unconditional autopilot approval now disables the sandbox for the current session when bypass is allowed.
+1 moreshow less
- ›Allows reasoning effort to be omitted so the server selects the default.
v1.0.76 Jul 30, 2026 · issue -020

Copilot CLI v1.0.76 adds grok-4.5 support, a multi-session sidebar, enterprise sandbox enforcement, /limits predict, and a queue manager.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.76 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.76
```
└──▷ TRY IT
Get a suggested AI-credit limit before starting a long autopilot task, based on your session history.
```
$ /limits predict
```
Keep the active sidebar card visually distinct but disable hover-to-focus for a less distracting split-view experience.
yaml
```
sidebar.hoverFocus: false
sidebar.accentActiveSession: true
```
Enable the multi-session Sessions sidebar to manage concurrent Copilot sessions during a complex investigation.
```
$ /experimental on
```
- ›Adds sidebar.hoverFocus and sidebar.accentActiveSession config keys to the split-view sidebar: hover-to-focus is off by default (opt in with sidebar.hoverFocus), and the active session card is accented by default (opt out with sidebar.accentActiveSession).
- ›Adds stayInAutopilot setting to control whether autopilot remains selected after task_complete; set to false to return to interactive mode after each task.
- ›Adds /limits predict subcommand to suggest a session AI-credit limit based on similar past sessions.
- ›Adds enable/disable controls in /plugins for plugins, instructions, agents, LSP servers, and hooks.
- ›Adds support for the grok-4.5 model.
+14 moreshow less
- ›Adds a new Sessions sidebar for managing multiple concurrent sessions — switch between them, spawn new ones, and see their status; enable with /experimental on.
- ›Adds a directable queue manager to reorder, edit, remove, repeat, and immediately send queued messages; Ctrl+C removes your own newest queued message.
- ›Enterprise administrators can enforce a restrictive sandbox floor via managed settings that tighten (but never loosen) the user's sandbox policy; the /sandbox dialog surfaces org-configured managed values with locked fields and managed filesystem paths.
- ›Supports configurable timed refreshes for custom status-line commands.
- ›Changing the mouse setting mid-session now takes effect immediately via /settings mouse on|off or the /settings dialog, without requiring a restart.
- ›web_fetch now follows HTTP redirects, requesting permission for redirect targets on different origins and showing redirect origin context.
- ›web_fetch routes through the configured sandbox proxy when outbound is allowed, and denies egress when network.allowOutbound is false.
- ›Sandbox denied paths are enforced for relative and symlinked entries on macOS and Linux.
- ›MCP tools load faster from definition-scoped snapshots, with process-wide and per-server cache opt-outs.
- ›Renders inline images in Rio terminals that support Kitty graphics.
- ›Voice mode pauses playing media before recording and resumes it afterward on macOS and Windows.
- ›Shows the number of active scheduled prompts in the footer.
- ›Queued mid-turn /model changes are now applied after the current response finishes.
- ›The /instructions picker now respects --no-custom-instructions.
v1.0.76 Jul 30, 2026 · issue 002

Copilot CLI v1.0.76 adds grok-4.5 support, /limits predict, Sessions sidebar, enterprise sandbox enforcement, and a directable queue manager.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.76 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.76
```
└──▷ TRY IT
Get a suggested AI-credit limit before starting a long autopilot task, so you can set a budget based on similar past sessions.
```
$ /limits predict
```
Enable the experimental Sessions sidebar to manage multiple concurrent Copilot sessions without restarting.
```
$ /experimental on
```
Keep autopilot running between tasks by default, or opt out so the agent returns to interactive mode after each task_complete.
yaml
```
stayInAutopilot: false
```
- ›Adds sidebar.hoverFocus opt-in config key and sidebar.accentActiveSession opt-out config key for the split-view sidebar, letting you tune hover-to-focus and active-session accent behavior per preference.
- ›Adds /limits predict command to suggest an AI-credit session limit based on similar past sessions.
- ›Adds /settings mouse on|off to toggle mouse support mid-session with immediate effect (also settable via the /settings dialog).
- ›Adds stayInAutopilot setting: set to false to return to interactive mode automatically after each task_complete instead of staying in autopilot.
- ›Adds enable/disable controls in /plugins for plugins, instructions, agents, LSP servers, and hooks.
+19 moreshow less
- ›Adds support for the grok-4.5 model.
- ›Adds a New Sessions sidebar for managing multiple concurrent sessions (switch, spawn, view status); enable with /experimental on.
- ›Adds /limits predict to suggest a session AI-credit limit from similar sessions.
- ›Adds a directable queue manager to reorder, edit, remove, repeat, and immediately send queued messages; Ctrl+C removes your own newest queued message.
- ›Enterprise administrators can enforce a restrictive sandbox floor via managed settings that tighten (but never loosen) the user's sandbox policy; the /sandbox dialog surfaces org-configured managed values with locked fields and managed filesystem paths.
- ›Sandbox denied paths are now enforced for relative and symlinked entries on macOS and Linux.
- ›web_fetch now follows HTTP redirects, asking permission for redirect targets on different origins and showing redirect origin; routes through the configured sandbox proxy when outbound is allowed, and denies egress when network.allowOutbound is false.
- ›MCP tools load faster from definition-scoped snapshots, with process-wide and per-server cache opt-outs.
- ›Adds configurable timed refreshes for custom status-line commands.
- ›Queue mid-turn /model changes to apply after the current response finishes.
- ›Inline images now render in Rio terminals that support Kitty graphics.
- ›Voice mode pauses playing media before recording and resumes it afterward (macOS and Windows).
- ›Shows the number of active scheduled prompts in the footer.
- ›Shows recent shell output for large commands that write to a file.
- ›The /instructions picker now respects --no-custom-instructions.
- ›Unsent prompt text stays with the session it was typed for rather than following the user to a switched session.
- ›URL permission prompts retain their sandbox-bypass warning and the model's reason when a host integration rebuilds the prompt.
- ›userPromptSubmitted hook output is now bounded at 10 MiB per invocation; type mismatches for modifiedPrompt, modifiedTransformedPrompt, and responseContent fields are warned and ignored rather than corrupting the session.
- ›/diff scrolls and syntax-highlights large multi-file diffs faster.
v1.0.75 Jul 24, 2026 · issue 002

GitHub Copilot CLI v1.0.75 adds support for Claude Opus 5 as a selectable model.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.75 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.75
```
- ›Adds Claude Opus 5 as an available model, selectable via the /model slash command.
v1.0.74 Jul 23, 2026 · issue -027

GitHub Copilot CLI v1.0.74 adds Open Plugin Spec v1 / mcp.json support, gemini-3.6-flash, and a dedicated plan-mode model picker.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.74 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.74
```
└──▷ TRY IT
Pick a faster or cheaper model exclusively for plan-mode exploration without affecting your main session model.
```
$ /model plan gemini-3.6-flash
```
Clear a previously set plan-mode model so plan mode falls back to the current session model.
```
$ /model plan off
```
- ›Adds /model plan (or /model --plan) subcommand to select a dedicated model for plan mode; accepts a model ID, off to clear the override, or no argument to open the interactive picker — reverts to the session model on exit.
- ›Adds support for Open Plugin Spec v1 plugin manifests and mcp.json configuration files.
- ›Adds gemini-3.6-flash as a supported model.
- ›The /mcp add and /mcp edit wizard now preserves = characters in environment variable values (e.g. base64-padded secrets and tokens).
- ›The $ interactive shell shortcut now opens a shell even while the agent is working.
+8 moreshow less
- ›Plan mode allows session-folder planning artifacts while still blocking file mutations outside the session folder.
- ›Adds a first-run splash screen to opt into the default sandbox.
- ›Shows Tab in the /settings footer to switch scope tabs.
- ›IDE integration reconnects reliably when the CLI reloads MCP servers or changes directory.
- ›Steering interrupts shell output waits without stopping the running command.
- ›Increases the Responses API request size limit, enabling larger payloads.
- ›Downscales oversized tool-result images so CAPI Responses requests continue uninterrupted.
- ›Resume search matches session titles even when whitespace differs.
v1.0.74 Jul 23, 2026 · issue 002

Copilot CLI v1.0.74 adds Open Plugin Spec v1 and mcp.json support, a /model plan command, gemini-3.6-flash, and sandbox opt-in splash.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.74 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.74
```
└──▷ TRY IT
Pick a dedicated model for plan mode so your planning pass uses a cheaper/faster model than your main session model.
```
$ /model plan gemini-3.6-flash
```
Clear the plan-mode model override and fall back to the session model.
```
$ /model plan off
```
- ›Adds /model plan (or /model --plan) to select a model for plan mode; accepts a model id, off to clear, or no id to open the picker — reverts to the session model on exit.
- ›Adds support for Open Plugin Spec v1 plugin manifests and mcp.json configuration.
- ›Adds the $ interactive shell shortcut to open a shell even while the agent is working.
- ›Adds support for the gemini-3.6-flash model.
- ›The /mcp add and /mcp edit wizard now preserves = characters in environment variable values (e.g. base64 padding), storing secrets and tokens correctly.
+6 moreshow less
- ›Plan mode now allows session-folder planning artifacts while still blocking clear file mutations outside the session folder.
- ›Shows a first-run splash screen to opt into the default sandbox.
- ›Subagent timelines in /tasks now identify whether prompts originated from the main agent or another subagent.
- ›Resume search matches session titles even when whitespace differs.
- ›Shows Tab in the /settings footer to switch scope tabs.
- ›Increases the Responses API request size limit.
v1.0.72 Jul 20, 2026 · issue -030

Copilot CLI v1.0.72 adds shell shortcut, per-session model switching, skill installs, full plugin management, and a navigable Sessions sidebar.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.72 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.72
```
└──▷ TRY IT
Switch model, reasoning effort, or context window for just the current session without touching your global defaults.
```
$ /model --session
```
Install a local skill into a repository's project scope so it is available only within that repo.
```
$ copilot plugins install --skill ./my-skill --scope project
```
Enable the $ shell shortcut so you can drop into an interactive shell at any point during a session.
```
$ /settings shellShortcut on
```
- ›Adds agentStop hook early-exit logic: CLI ends the turn after 8 consecutive blocks and passes a stop_hook_active flag to agentStop hooks so they can detect and self-limit forced continuation.
- ›Adds opt-in git and gh authentication inside the OS sandbox.
- ›Adds update/uninstall verbs to /plugins, extends enable/disable/remove to target plugins, MCP servers, or skills via --plugin, --mcp, and --skill flags or a positional kind, and supports installing skills with /plugins install --skill.
- ›Adds /plugins install --skill <file, URL, or directory> to install skills from the CLI; append --scope project on a file or URL install to scope it to the repository.
- ›Adds copilot plugins remove --skill for skill removal.
+19 moreshow less
- ›Adds /plugins help command plus skill, MCP, and marketplace management for full /plugins parity.
- ›Adds /model --session (-s) to change model, reasoning effort, or context window for just the current session without touching global settings.
- ›Type $ at the prompt to open an interactive shell in the current session directory; enable with /settings shellShortcut on (off by default).
- ›Adds renderHexColors setting (on by default) to toggle hex-color swatches; inline code hex values like #FF0000 now render as color swatches.
- ›Sandbox macOS keychain access now defaults off; re-enable it in /sandbox when a command needs it.
- ›Toggling /sandbox restarts only local MCP servers and leaves remote servers connected.
- ›copilot skill list strips terminal control characters from skill names and descriptions, preventing crafted skills from injecting ANSI escape sequences into listing output.
- ›Exposes default values in /settings and lets boolean settings cycle back to their default.
- ›Masks secret values in /settings show output.
- ›Detects VS Code, Cursor, and Windsurf through parent processes in /terminal-setup.
- ›Multi-turn subagents are always enabled, allowing follow-up messages to running agents.
- ›Enables tool search for Claude Haiku 4.5+.
- ›Delivers scheduled prompts as steering messages when the agent is busy.
- ›Requires SSO for remote control when managed settings demand it.
- ›Lifecycle and subagent hook commands run in the current session directory after /cd.
- ›/worktree <task> and /move now propagate folder trust to the new worktree before switching when the source is already trusted.
- ›Nested markdown lists render correctly in buffered output (-p --stream off and detail screens): sub-bullets are indented and no longer flattened onto the parent line.
- ›Reveals full file paths when expanding compact editing rows.
- ›Keeps /add-dir directories visible in the agent context across turns.
└──▷ BREAKING ON UPGRADE
- !Sandbox macOS keychain access now defaults off; setups relying on keychain access inside the sandbox must explicitly re-enable it via /sandbox.
- !Command approvals no longer carry over to another repository after switching with /cd; approvals must be re-granted in the new repository context.
- !/terminal-setup now refuses to modify a VS Code keybindings.json that contains a JSON syntax error instead of rewriting it.
v1.0.71 Jul 16, 2026 · issue -034

Copilot CLI v1.0.71 adds /voice device selection, canvas support, plugins marketplace subcommands, /worktree+/move split, and configurable subagent depth controls.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.71 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.71
```
└──▷ USE IT
Persist a curated set of GitHub MCP tools across sessions so only the tools your team needs are available.
json
```
{
  "githubMcpToolsets": ["repos", "issues"],
  "githubMcpTools": ["create_pull_request", "list_issues"]
}
```
Browse available plugin marketplaces and add a new one without leaving the CLI.
```
$ copilot plugins marketplace browse
copilot plugins marketplace add <marketplace-url>
```
- ›Adds plugins marketplace subcommands to list, add, remove, browse, and update plugin marketplaces.
- ›Persists GitHub MCP toolset and tool configuration via settings.json keys githubMcpToolsets, githubMcpTools, etc.
- ›Adds /voice devices command to choose and persist the microphone used for voice mode.
- ›Adds subagents.maxDepth setting (up to 128) to control maximum sub-agent nesting depth; default lowered from 6 to 4.
- ›Adds a configurable maximum for Ctrl+R command history.
+29 moreshow less
- ›Splits /worktree and /move into distinct commands: /worktree creates a new worktree leaving uncommitted changes behind, while new /move carries uncommitted changes into the new worktree.
- ›Adds --add-github-mcp-tool "*" support to enable all GitHub MCP tools at once.
- ›Adds canvas support in the CLI for extension-driven interactions.
- ›Adds a pinned prompts setting in /settings to control prompt pinning.
- ›Adds Repo and Repo (local) scope tabs to the /settings dashboard.
- ›Marks disabled skills in copilot skill list and its JSON output.
- ›Plan mode hard-blocks built-in tool calls that would modify the workspace (file edits and mutating shell commands) while planning; MCP and external tools remain allowed.
- ›Honors COPILOT_TASK_WAIT_TIMEOUT_SECONDS in copilot -p --autopilot the same way plain -p does.
- ›Honors --context in fresh interactive sessions.
- ›Shows --plugin-dir plugins in copilot plugin list and surfaces --plugin-dir warnings in the terminal.
- ›Validates --max-autopilot-continues to reject NaN, negative, and fractional values.
- ›Rejects --continue when used with --resume.
- ›Rejects malformed --allow-tool and --deny-tool patterns with an error message.
- ›Allows copilot update and /update to accept stable as a channel.
- ›Prompt mode exits non-zero when a --share or --share-gist export fails.
- ›Adds local and cloud cost profiles to /chronicle cost-tips recommendations.
- ›Refreshes memory context after 30 minutes in long-lived sessions.
- ›Shows repo-enabled plugins in /plugin list and skill pickers.
- ›Bare copilot mcp and copilot skill now print help and exit 0, matching copilot plugin; use copilot mcp <subcommand> --help or copilot skill <subcommand> --help for subcommand help.
- ›Honors NO_COLOR in the CLI even when chalk has cached a color level.
- ›Enforces the sandbox filesystem policy on LSP file reads and rename edits.
- ›Server mode reconnects OAuth MCP servers from cached tokens.
- ›Uses ctrl+x → x to close a session and ctrl+x → h to hide the split sidebar.
- ›Shows retained shell output in /tasks Shell Details for finished tasks.
- ›Highlights standalone hex colors inline in Markdown.
- ›Shows an error when --name is used with --session-id for an existing session.
- ›Switching to autopilot mid-turn now auto-answers questions asked during that same turn.
- ›Shows the startup banner only on the first launch when set to once.
- ›Startup now shows a warning identifying offending values in an invalid settings.json instead of silently ignoring settings.
└──▷ BREAKING ON UPGRADE
- !The default maximum sub-agent nesting depth is lowered from 6 to 4; setups relying on recursive sub-agent delegation beyond depth 4 will be blocked unless subagents.maxDepth is explicitly raised.
- !/worktree no longer carries uncommitted changes into the new worktree — use the new /move command for that behavior.
- !--continue is now rejected when used together with --resume.
- !Bare copilot mcp and copilot skill now print help and exit 0 instead of running a default action; the implicit help <subcommand> form is not supported — use copilot mcp <subcommand> --help or copilot skill <subcommand> --help instead.
v1.0.70 Jul 10, 2026 · issue -040

Copilot CLI v1.0.70 adds GPT-5.6, sandbox session flags, /refine prompt rewriting, repo-pinned model policy, and paginated MCP resource RPCs.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.70 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.70
```
└──▷ TRY IT
Temporarily disable the sandbox for a single session (e.g. to run a privileged setup script) without overwriting your saved sandbox preference.
```
$ copilot -p --no-sandbox
```
Pin a repository's Copilot model, effort level, and MCP deny list so all contributors share the same policy automatically.
json
```
{
  "model": "gpt-5.6",
  "effort": "high",
  "contextTier": "full",
  "deny": {
    "mcp": ["untrusted-server"]
  }
}
```
Pin a marketplace plugin to a specific commit so your team always runs a known-good version.
yaml
```
plugins:
  - name: my-plugin
    source:
      url: https://github.com/org/my-plugin
      sha: a3f8c21d9e4b7065f1234567890abcdef1234567
```
- ›Adds --sandbox and --no-sandbox flags to toggle the OS-level shell sandbox on or off for the current session only, without persisting the change to saved settings (composable with -p).
- ›Adds sha field in plugin source configuration to pin plugins to an exact commit SHA.
- ›Adds --repo and --local flags to /settings and /model commands.
- ›Adds paginated session.mcp.resources RPCs — read, list, and listTemplates — for MCP server resources.
- ›Lets a trusted repository pin the model, effort level, and context tier and extend URL/MCP/skill deny lists via .github/copilot/settings.json.
+14 moreshow less
- ›Adds /refine command to rewrite a rough, stream-of-consciousness prompt into a clear one.
- ›Adds GPT-5.6 model support.
- ›Adds preToolUse hooks that exit with code 2 to deny tool calls.
- ›Marks locally-spawned MCP servers running inside the sandbox in /mcp list output (e.g. connected (sandboxed)).
- ›Exposes SDK APIs to manage live MCP servers in running sessions.
- ›Enables web_fetch to work through mandatory HTTPS proxies.
- ›Adds hide and search functionality on the Gists tab.
- ›Adds a setting to show or hide timeline timestamps.
- ›Enables Forge to create draft skills when it finds a clear workflow pattern.
- ›Opens the plan file or research report with Ctrl+Y in any mode.
- ›Long-running sessions now refresh enterprise managed settings hourly.
- ›Makes markdown links and bare URLs in the timeline and tool output clickable.
- ›Adds Tab key to switch the context window in /model.
- ›Prefills /chronicle search so it can accept a query directly.
v1.0.69 Jul 7, 2026 · issue -043

Copilot CLI v1.0.69 adds /mcp list, auto allow-all LLM-judged approvals, delegate PR branching, and a /plugins dashboard.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.69 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.69
```
└──▷ TRY IT
List all attached MCP servers and their current status mid-session without interrupting the agent.
```
$ /mcp list
```
Keep the CLI in autopilot mode automatically after a task completes, useful for unattended batch workflows.
yaml
```
stayInAutopilot: true
```
Create a delegate PR targeting a specific branch instead of the current branch.
```
$ /delegate --base main
```
- ›Adds /mcp list subcommand to show attached MCP servers and their status; /mcp list and /plugin list can now run while the agent is working.
- ›Adds stayInAutopilot setting (default false) that keeps the CLI in autopilot mode after an autopilot task completes.
- ›Adds /delegate --base flag to choose a target branch when creating delegate PRs; default target is now the current branch.
- ›Adds /allow-all auto mode that auto-approves requests an LLM judge evaluates as acceptable; now requires experimental mode (/experimental on or --experimental) instead of the AUTO_APPROVAL env var or feature flag.
- ›Adds minimal reasoning effort support for the gemini-3.5-flash model.
+23 moreshow less
- ›Adds a /plugins dashboard to manage installed plugin extensions.
- ›Supports reloading installed plugin extensions without restarting a session.
- ›Supports signing in to MCP servers through the CLI OAuth callback flow.
- ›Enables opening the /mcp manager while the agent is working to enable or disable servers mid-turn; add, edit, delete, and re-auth actions remain paused until the turn finishes.
- ›Adds file and folder completion to /sandbox path entries.
- ›web_fetch now follows the active sandbox network policy, denying outbound or local targets the policy blocks, and supports one-time bypass approval via sandbox.allowBypass.
- ›Displays reasoning-effort labels in the CLI footer.
- ›Shows descriptions for sandbox userPolicy settings in /settings.
- ›Rejects explicitly empty --name= values when starting a session.
- ›Rejects empty --session-id= and --resume= values instead of silently ignoring them.
- ›Applies --reasoning-effort reliably when the CLI starts.
- ›Surfaces skill loading errors and warnings in skill list.
- ›Auto-approval timeline entries now include the request subject such as command, path, URL, or tool name.
- ›Shows /rubber-duck in pre-auth help and self-documentation.
- ›Labels built-in file edits with a (sandbox policy) badge instead of (sandboxed), reflecting best-effort sandbox policy behavior.
- ›Shows disabled servers as disabled in /lsp test.
- ›Allows WSL UNC paths for local files in the CLI.
- ›Warns when multiple plugins define the same MCP server.
- ›Warns when static context uses most of the prompt budget and blocks requests when little conversation room remains.
- ›Confirms before resuming a remote session from a different repository.
- ›Delays read-only remote session creation until the first message is sent.
- ›Includes files inside new untracked directories in /diff local edits.
- ›Updates a backgrounded session's branch label in the Sessions split view when its working directory changes.
└──▷ BREAKING ON UPGRADE
- !/allow-all auto now requires experimental mode (/experimental on or --experimental) instead of the AUTO_APPROVAL env var or feature flag; existing setups relying on the env var or feature flag will need to switch.
- !The (sandboxed) badge on built-in file edits is renamed to (sandbox policy).
v1.0.68 Jul 1, 2026 · issue -049

GitHub Copilot CLI v1.0.68 adds kimi-k2.7-code model support, inline tab-completion aliases, plan budget visibility, and session management from the agents screen.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.68 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.68
```
└──▷ TRY IT
Check plan budget consumption mid-session without leaving the CLI.
```
$ /usage
```
- ›Adds support for the kimi-k2.7-code model.
- ›Tab completion now shows slash command aliases inline (e.g. /pr automerge|agentmerge).
- ›Shows plan budget details in the statusline and /usage for supported plans.
- ›Browse, resume, and switch between sessions from the agents screen.
- ›Focused field in the /mcp config form is marked with a '❯ ' chevron, not color alone.
+8 moreshow less
- ›Keeps IDE tools available during transient IDE disconnects, returning a clear error while disconnected and recovering automatically when the IDE reconnects.
- ›Tells the agent when the working directory changes between turns so it uses the new directory for commands and relative paths.
- ›Shows descriptions for slash-command input choices.
- ›Custom agents keep their tool filters in nested subagents.
- ›Lets device-managed settings override server-managed settings.
- ›Finds agents and instructions under Win32 extended-length paths on Windows.
- ›Defaults to a steady vertical-bar cursor in interactive sessions.
- ›Updates the Sessions sidebar branch after /cd and /worktree.
v1.0.67 Jun 30, 2026 · issue -050

GitHub Copilot CLI v1.0.67 adds Claude Sonnet 5 support, MCP OAuth fixes for Entra tenant vanity domains, and session resume hints.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.67 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.67
```
- ›Adds Claude Sonnet 5 as a supported model.
- ›MCP OAuth against Microsoft Entra servers behind a tenant vanity domain (e.g. Copilot Studio) now correctly refreshes and re-authenticates.
- ›Subagent sessions now inherit parent tool restrictions, preventing privilege-scope mismatches in nested agent calls.
- ›Disabling the sandbox mid-session now takes effect immediately, stopping shell and search commands from re-prompting to bypass it.
- ›Session limits are now required to be at least 30 AI credits.
+4 moreshow less
- ›Tool calls continue when hooks time out rather than halting the turn.
- ›Prompt mode exit summary now shows a resume hint to continue the session.
- ›Host custom agent load failures now surface warnings and errors.
- ›Ctrl+Q enqueues the highlighted slash-command argument completion.
└──▷ BREAKING ON UPGRADE
- !Session limits below 30 AI credits are no longer accepted; any configuration setting a lower limit must be updated.
v1.0.66 Jun 30, 2026 · issue -050

Copilot CLI v1.0.66 adds Claude Opus 4.8 Fast, /chronicle skills review, persisted dynamic retrieval, desktop notifications, and major /pr auto and /worktree upgrades.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.66 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.66
```
└──▷ TRY IT
Start a worktree with a task description to auto-name the branch and run the task as the first prompt — useful for spinning up focused, isolated work from a single command.
```
$ /worktree fix the login redirect
```
- ›Adds --allow-all-mcp-server-instructions flag to optionally include instructions from all MCP servers in system prompts.
- ›Adds --dynamic-retrieval skills=<on|off> flag and persisted dynamicRetrieval setting to enable or disable embeddings-based retrieval of skills.
- ›Adds --config-dir flag (alongside COPILOT_HOME env var) that stops loading skills from ~/.agents/skills.
- ›Adds /chronicle skills review subcommand for reviewing proposed draft skill changes with options to accept, reject, or defer each draft.
- ›Adds sessionLimits option key to control session limits, which now apply across the current conversation and reset on /clear.
+39 moreshow less
- ›Adds toggle to enable or disable individual MCP servers from the MCP list view in the CLI.
- ›Adds read_agent support for since_turn: 0 to correctly return all turns including turn 0.
- ›Adds /lsp logs command and read_agent integration to view LSP server logs.
- ›Adds --yolo session flag behavior: auto-accepts opt-in MCP consent prompts while still showing system permission prompts.
- ›Adds /rename command support in remote-hosted (cloud and relay) sessions.
- ›Supports Claude Opus 4.8 Fast as a new model option (deprecates Claude Opus 4.6 Fast).
- ›MCP add/edit form now accepts HTTP-style Key: value headers for server configuration.
- ›Adds @ file and # GitHub ref completions in relay sessions.
- ›Adds experimental response limits controls to CLI settings.
- ›Lets managed settings configure OpenTelemetry export.
- ›Enables /pr auto to run a self-paced loop that fixes one issue per run and paces around CI to drive PRs to green; /pr automerge continues until the PR is merged; manageable via /loop or /every.
- ›Pass a task string to /worktree (e.g. /worktree fix the login redirect) to name the branch from the task and run it as the first prompt in the new worktree.
- ›With no argument, /worktree now names the branch from uncommitted changes and recent conversation using your active model.
- ›/worktree preserves branch names exactly as typed (e.g. feature/JIRA-123) instead of flattening to a slug.
- ›Adds /share improvements to manage synced session visibility using Mission Control links.
- ›Shows desktop notifications on macOS from the CLI, including for attention prompts and idle sessions.
- ›Shows merge status for each pull request in the Pull Requests tab with on-demand refresh via r.
- ›Configures subagent concurrency and depth limits in /settings (available to usage-based billing users).
- ›Consolidates color palette settings under /settings theme.
- ›Lets integrations read and write CLI user settings.
- ›Lets custom agents set reasoning effort in their definitions.
- ›Shows quota snapshots for WebSocket Responses requests in the timeline.
- ›Shows submit times next to user prompts in the timeline.
- ›Expands @-style imports in AGENTS.md, CLAUDE.md, and Copilot instruction files.
- ›Prompts to install gh CLI when it is missing in GitHub repositories.
- ›Adds GitHub attachment variants to prompt rendering.
- ›Adds (sandboxed) badge on compact Search timeline entries and shows sandbox-bypass warnings labeling bypassed commands.
- ›Renders the timeline as a compact highlight reel with single-line tool and reasoning rows for all users.
- ›Shows the current pull request link as a status-line item.
- ›Shows the active agent mode in the working footer text.
- ›Shows accurate Anthropic reasoning token counts in the timeline.
- ›Lets grep and glob retry blocked searches after sandbox approval.
- ›Git commands work in sandboxed linked worktrees.
- ›Allows skills with the same name from different plugins to coexist.
- ›Inline hook settings now handle nested Claude-style hook groups.
- ›MCP OAuth-authenticated remote servers recover automatically after mid-session token expiry, triggering non-interactive reconnect on 401.
- ›BYOK sessions using Anthropic models no longer hit HTTP 400 errors from adaptive-thinking mismatches.
- ›Performs tokenizer warmup in parallel on a background thread for improved startup performance.
- ›Filters non-JSON stdout lines from MCP servers during startup.
└──▷ BREAKING ON UPGRADE
- !COPILOT_HOME and --config-dir no longer load skills from ~/.agents/skills.
v1.0.65 Jun 24, 2026 · issue -056

GitHub Copilot CLI v1.0.65 adds a copilot skill subcommand, CI check status bar, and shell-history search across modes.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.65 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.65
```
└──▷ TRY IT
List all currently active skills to audit what capabilities are loaded.
```
$ copilot skill list
```
Enable the CI status bar item to monitor branch check runs without leaving the CLI.
📍In the CLI, open /settings and enable the CI check status bar item to display passing/running/failing state for the current branch.
- ›Adds copilot skill subcommand (and /skill alias for /skills) to list, add, and remove skills from a file, URL, or directory.
- ›Adds an opt-in status bar item showing CI check status (passing/running/failing) for the current branch.
- ›Up/down history and Ctrl+R reverse search now include past shell commands while in normal mode, so shell commands can be recalled without first typing ! to enter shell mode.
- ›/cd now persists the working directory so resuming a session returns to it, and discovers custom agents in the new directory.
- ›Saves custom status line commands in /settings.
+5 moreshow less
- ›Open canvases resume automatically after restarting the CLI.
- ›Includes userPromptSubmitted hook additionalContext in the model-facing prompt.
- ›Parses /every schedules on the session's main model.
- ›Silent MCP OAuth refresh reuses the granted scope so reconnects stay signed in.
- ›Keeps custom-agent subagent model selections when using BYOK providers.
v1.0.64 Jun 23, 2026 · issue -057

Copilot CLI v1.0.64 adds worktree sessions, /diagnose, /mcp registry, CSV MCP output, and a batch of new commands and aliases.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.64 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.64
```
└──▷ TRY IT
Pick up exactly where you left off in the most recent session for the current repo without hunting for a session ID.
```
$ copilot --resume
```
Run a security review on the current codebase — now available to all users without needing the experimental flag.
```
$ /security-review
```
- ›Adds experimental --worktree [name] (-w) flag (enable with /experimental) that creates or reuses a git worktree under <repo>.worktrees/ and starts the session inside it.
- ›Adds --continue and --resume flags that select the most recent session for the current repository.
- ›Shows --remote-export and --no-remote-export in --help output.
- ›OpenTelemetry: chat spans after a successful compaction now carry gen_ai.conversation.compacted=true, with the summary emitted as a CompactionPart in gen_ai.input.messages.
- ›OpenTelemetry GenAI spans now emit gen_ai.usage.cache_read.input_tokens, gen_ai.usage.cache_creation.input_tokens, and gen_ai.usage.reasoning.output_tokens per the GenAI semantic conventions spec.
+52 moreshow less
- ›OpenTelemetry GenAI chat spans emit gen_ai.request.reasoning.level for the configured reasoning effort.
- ›Adds /diagnose command to analyze session logs.
- ›Adds /mcp registry installation for browsing and installing MCP servers.
- ›Adds /branch as an alias for /fork, matching Claude Code's command naming.
- ›Adds /loop as an alias for the /every command.
- ›Adds CSV output support for MCP tools.
- ›Makes /security-review available to all users without --experimental.
- ›Adds tab completion for /agent names.
- ›Configures the rubber-duck subagent in /subagents, including a complementary model strategy that picks an opposite-family model.
- ›Adds model family aliases (opus, sonnet, haiku, gpt, gemini) in the model setting.
- ›Adds Ctrl+Backspace binding in /terminal-setup for Windows Terminal.
- ›Adds SDK support for host-provided OAuth tokens for remote MCP servers.
- ›Supports static OAuth client overrides, including client secrets, for MCP server authentication.
- ›Adds websocket responses support for BYOK OpenAI-compatible providers.
- ›Adds an option to bypass the sandbox for shell commands.
- ›Adds mouse click and double-click selection to paginated lists.
- ›Adds inline image rendering in the CLI.
- ›Adds argument-hint frontmatter support for skills.
- ›Adds a Folder column to the resume picker to show each session's working directory.
- ›Adds a setting to hide the conversation scrollbar.
- ›Sets an HTTP(S) proxy via a user setting.
- ›Shows installed plugin MCP servers in mcp commands.
- ›Discovers MCP servers provided by installed plugins.
- ›Marketplace plugins that declare MCP servers in marketplace.json now authenticate correctly with OAuth.
- ›Adds Ctrl+Q to enqueue a prompt while a completion picker is open.
- ›Autopilot mode auto-handles elicitation, ask_user, sampling, and permission prompts (including on launch with --autopilot and during continuation turns) instead of surfacing dialogs.
- ›Autopilot mode returns to interactive mode after the agent calls task_complete.
- ›Applies MCP org policy when sessions create or reload MCP servers.
- ›Respects deferTools on MCP servers configured in custom agent frontmatter.
- ›Custom agents using a tools wildcard * now respect the deferredToolLoading opt-in switch.
- ›/diff shows a session diff of Copilot's changes in non-git folders.
- ›Syntax-highlights shell commands in the timeline.
- ›Shows per-model token totals in /usage and speeds up large history scans.
- ›Shows the pay-as-you-go additional usage budget at launch, refreshes it after a request is rejected for hitting the additional spend limit, and shows a friendly message when the additional usage limit is reached.
- ›Resumed sessions reproduce the original attached-file references even if those files later change on disk, avoiding prompt-cache resets.
- ›Attached images and PDFs persist across session resume even if the source file is later changed or deleted.
- ›Images returned by tools stay visible to the model across later turns and after resuming a session.
- ›Allows disabling task and explore built-in subagents.
- ›Forwards typed rejection feedback from preToolUse prompts to the model.
- ›Automatically follows system light and dark mode changes.
- ›Preserves open canvas instances across reconnects and restarts.
- ›Resume sessions by name even when the name contains spaces.
- ›Hides unsupported slash commands in remote-hosted sessions.
- ›Allows /allow-all to work in relay sessions.
- ›Allows /update to restart sessions started with copilot -r.
- ›Remote export keeps running after /clear and /session info keeps the task URL.
- ›Click filenames in /diff tree to jump to that file's first change.
- ›Experimental: in the compact timeline, click a tool-call or reasoning row to expand or collapse just that entry.
- ›Loads workspace MCP servers in trusted server-mode sessions.
- ›The /settings search field supports readline editing keys and cursor movement.
- ›Preserves Markdown blockquotes in /share exports.
- ›Keeps task companion tools available to custom agents that use the task or agent alias.
└──▷ BREAKING ON UPGRADE
- !OpenTelemetry GenAI span attribute names for cache and reasoning token counts are corrected to gen_ai.usage.cache_read.input_tokens, gen_ai.usage.cache_creation.input_tokens, and gen_ai.usage.reasoning.output_tokens; pipelines consuming the previous underscore-separated names will stop receiving data.
- !Terminal-reported color scheme support is removed.
- !The legacy intent-reporting tool is removed from the CLI.
- !The bogus Ctrl+Enter VS Code keybinding created by old /terminal-setup is removed.
v1.0.63 Jun 16, 2026 · issue -064

Copilot CLI v1.0.63 adds deferTools MCP config, alphabetic --help sorting, per-session agent mode, and an experimental /rewind overhaul.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.63 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.63
```
└──▷ USE IT
Keep an MCP server's tools always available in the palette even when tool search is active, so specialised tools are never pruned from context.
json
```
{
  "mcpServers": {
    "my-server": {
      "command": "npx",
      "args": ["my-mcp-server"],
      "deferTools": true
    }
  }
}
```
- ›Adds deferTools option to MCP server config to keep a server's tools always available even when tool search is enabled.
- ›PostToolUse hook matchers (e.g. Edit|Write) are now honored so formatters and linters run only after the tools they target.
- ›Options in --help output now sort alphabetically, including options with two long flags.
- ›Press w in /diff to hide whitespace-only changes.
- ›Blocked image attachments now explain actionable next steps: enable vision via the 'Editor preview features' policy, switch to a vision-capable model, or try a different image.
+9 moreshow less
- ›Auth validation errors (e.g. VPN or IP allowlist failures) are shown in the sign-in banner with guidance to check network access.
- ›Shows fork-based pull requests in /pr and the branch PR badge.
- ›Shows the spill file path when read_bash output is too large.
- ›Includes recent local sessions in /chronicle standup.
- ›Agent mode is tracked per session and no longer carries over when you create, clear, or switch sessions.
- ›Pressing Enter opens the highlighted issue details.
- ›Plan review menus work on strict OpenAI-compatible backends.
- ›Retries transient 401 auth failures in HMAC and OAuth modes.
- ›Resumes remote sessions when the local and remote repository names differ only by case.
v1.0.62 Jun 13, 2026 · issue -067

Copilot CLI v1.0.62 adds Kerberos proxy auth, diff file tree, session-scoped extensions, /app command, and schedulable slash commands.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.62 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.62
```
└──▷ TRY IT
Schedule a daily standup summary without leaving the chat — useful for teams running recurring agent workflows.
```
$ /every 1d /chronicle standup
```
Configure a subagent's model and reasoning effort for a heavier analysis task via the picker.
```
$ /subagents
```
- ›Adds session.create and session.resume SDK methods to configure session memory for SDK clients.
- ›Adds /app slash command to open the GitHub app or a browser fallback.
- ›Adds /every and /after slash commands that can now schedule other slash commands (e.g. /every 1d /chronicle standup).
- ›Adds allow-all state to custom statusLine.command and shows a 'YOLO' (allow all) indicator in the footer.
- ›Adds file tree sidebar and inline comment editor to the /diff view.
+12 moreshow less
- ›Adds content search, match highlighting, and n/N navigation in diff view.
- ›Supports configuring subagent model, reasoning effort, and context tier via user settings or the /subagents (also /agents) picker.
- ›Automatically authenticates through corporate forward proxies using Kerberos/Negotiate (SPNEGO).
- ›Adds session-scoped extensions and canvases.
- ›Enables plugins to ship extensions, making them installable via the plugin marketplace.
- ›Discovers custom agents in nested .github/agents and .claude/agents directories when the session starts from a subdirectory of the repository root.
- ›Pressing W on an expanded issue or pull request details view creates a worktree.
- ›Pressing / on the Issues or Pull Requests tab searches GitHub with server-side filtering.
- ›Makes the MCP server config form easier to use with a picker-based flow.
- ›Maps MCP server names containing dots and slashes to valid Responses API namespaces.
- ›Honors max_output_tokens for BYOK Responses providers.
- ›Runs shell commands via lightweight process spawning instead of a pseudo-terminal.
└──▷ BREAKING ON UPGRADE
- !Shell commands now run via lightweight process spawning instead of a pseudo-terminal; interactive input via write_bash is no longer supported.
v1.0.61 Jun 9, 2026 · issue -071

Copilot CLI v1.0.61 adds /settings dialog, /worktree command, mTLS OTLP export, Claude Fable 5, and indexed monorepo grep.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.61 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.61
```
└──▷ USE IT
Suppress the terminal beep after a scheduled /every job completes — useful in shared or quiet environments.
json
```
{
  "beepOnSchedule": false
}
```
Create a new git worktree and move uncommitted changes into it — handy for switching context without stashing.
```
$ /worktree feature/my-branch
```
- ›Adds tabs setting in settings.json to configure home tab bar visibility, order, and hidden tabs.
- ›Adds beepOnSchedule setting to disable completion beeps for scheduled /every and /after runs.
- ›Adds /settings interactive dialog to browse and edit all user settings in one place.
- ›Adds /worktree command (aliased /move) to create a new git worktree and switch into it, moving any uncommitted changes along.
- ›Auto-loads MCP servers from .github/mcp.json workspace config file.
+19 moreshow less
- ›Adds http/protobuf OTLP HTTP export via standard OTel protocol env vars.
- ›Adds mTLS and private-CA support for OTLP telemetry export over HTTPS.
- ›Adds support for Claude Fable 5 model.
- ›Press / in the /agent picker to filter agents by name.
- ›/help now lists $HOME/.copilot/instructions/**/*.instructions.md alongside other user-level instruction locations.
- ›Grep searches in large monorepos now use an indexed search engine for significantly faster results.
- ›Use natural language with /every and /after to schedule tasks using cron expressions, calendar times, or relative durations.
- ›/after and /every commands now appear in the /experimental slash command list.
- ›/env output hides internal hooks and shows full file paths for hook sources.
- ›/sessions now navigates to the Sessions tab instead of opening an overlay.
- ›/fork shows a 'Creating fork...' progress notification while the fork is being created.
- ›/mcp search works correctly with external registries.
- ›Exit shell mode by pressing Esc or Ctrl+C on an empty prompt, in addition to Backspace.
- ›Number-key selection in pickers (e.g. /agent) works for items 10 and beyond.
- ›GitHub theme adapts to light terminals with an authentic GitHub Primer light color palette.
- ›Adds full-screen scrollbar.
- ›Prompt mode surfaces model-load errors on stderr instead of exiting silently.
- ›Symlinked directories now appear in @-file picker suggestions.
- ›Gemini models work correctly with MCP tools that use nullable schema types.
v1.0.60 Jun 5, 2026 · issue -075

Copilot CLI v1.0.60 adds max Anthropic reasoning effort, new nav keys, -r resume shorthand, and expanded LSP/MCP/ACP controls.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.60 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.60
```
└──▷ USE IT
Disable automatic rubber duck agent invocation so the agent only activates on explicit request.
yaml
```
builtInAgents:
  rubberDuckAutoInvoke: false
```
Set a custom working directory and shell for an LSP server, using a plugin variable for the path.
yaml
```
lsp:
  servers:
    my-server:
      bash: true
      cwd: "$PLUGIN_ROOT/workspace"
```
- ›Adds builtInAgents.rubberDuckAutoInvoke setting to control automatic rubber duck agent invocation (disabled by default).
- ›LSP server config now accepts bash, powershell, and cwd keys; cwd supports plugin vars like PLUGIN_ROOT, and command launch default cwd stays project-root unless cwd is overridden.
- ›Adds -r as a shorthand for --resume when reopening sessions.
- ›Adds --available-tools, --excluded-tools, and --reasoning-effort flags support in ACP mode.
- ›Adds maximum reasoning effort level for Anthropic models and makes all effort levels available on every plan.
+19 moreshow less
- ›Adds ACP allow_all config option to apply unrestricted permissions for tools, paths, and URLs.
- ›Adds vim-style navigation keys (g, G, Ctrl+D, Ctrl+U) to the /diff view.
- ›Adds billing help topic with an overview of AI credit usage features.
- ›Repurposes ctrl+s to stash and pop the current prompt (Claude Code parity); the slash-command picker remains available by typing /.
- ›/context now separates Custom Instructions from the system prompt and cross-references per-server MCP tool token costs with /mcp.
- ›/env command now shows hook counts and source provenance for active hooks.
- ›Shows cache write tokens alongside cache read tokens in the /usage display.
- ›Shows Mission Control sharing status of synced sessions in the /session info view.
- ›Shows session link in /session info table when remote exporting or steering.
- ›MCP tools added or removed by a server mid-turn are now available immediately in the same turn.
- ›Prompts for approval before running commands that set dynamic-loader or git-config environment variables (e.g. LD_PRELOAD, GIT_EXTERNAL_DIFF).
- ›BYOK file attachments larger than 5 MiB now send successfully via the OpenAI Responses provider.
- ›Rewind picker now shows working-tree diff stats (+added −removed) at each checkpoint.
- ›Enables creating a git worktree for a pull request directly from the pull requests screen.
- ›Auto-links bare #number issue and PR references to the current git repository.
- ›Enforces bypass permissions policy for --allow-all-tools, --allow-all-paths, and --allow-all-urls flags.
- ›Adds missing keyboard shortcuts (?, ctrl+q, ctrl+r, ctrl+z, ctrl+y, shift+enter) to /help content.
- ›Tab-completes .. parent traversal in slash-command path arguments instead of switching tabs.
- ›IDE picker appends a process id to entries sharing the same editor and folder, making git worktrees of the same repo distinguishable.
└──▷ BREAKING ON UPGRADE
- !On Windows, executables are no longer discovered in the working directory when invoking by bare name (e.g. git). Add the working directory to PATH to restore previous discovery behavior.
v1.0.58 Jun 2, 2026 · issue -078

GitHub Copilot CLI v1.0.58 enables Rubber Duck and Remote JSON RPC by default, adds scheduled prompts and new experimental UI
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.58 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.58
```
└──▷ TRY IT
Schedule a recurring prompt to run at a set interval inside an experimental session.
```
$ /experimental on
/every 10m summarize open pull requests
```
Schedule a one-time prompt to fire after a delay — useful for reminders or deferred tasks.
```
$ /experimental on
/after 30m remind me to review the deployment checklist
```
- ›Enables Rubber Duck mode by default in all sessions.
- ›Enables Remote JSON RPC by default.
- ›Adds /every and /after subcommands under /experimental to schedule prompts.
- ›Adds /theme command under /experimental for a new GitHub theme.
- ›Adds a new experimental UI (activate with Turn /experimental on) with quick access to issues, pull requests, and gists.
v1.0.57 Jun 1, 2026 · issue -079

Copilot CLI v1.0.57 adds HTTP/2 opt-in, COPILOT_HOME support, showTipsOnStartup setting, and smarter MCP/LSP/plugin behaviors.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.57 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.57
```
└──▷ USE IT
Disable startup tips in a scripted or CI-adjacent interactive session by setting showTipsOnStartup in repo-level config.
json
```
{
  "showTipsOnStartup": false
}
```
- ›Adds COPILOT_ENABLE_HTTP2=1 environment variable to opt into HTTP/2 transport; default networking is now HTTP/1.1 for broader reliability.
- ›Adds COPILOT_HOME environment variable to control the server discovery registry directory.
- ›Adds showTipsOnStartup setting to control whether startup tips are displayed at session start.
- ›Adds extraKnownMarketplaces support in .github/copilot/settings.json so copilot plugin marketplace list honors repo-level marketplace registries.
- ›/lsp show, /lsp test, and /lsp reload now correctly discover project LSP config when the CLI is launched from a subdirectory.
+8 moreshow less
- ›/diff defaults to branch diff when there are no unstaged changes.
- ›In Azure DevOps-only repositories, the built-in GitHub MCP server now exposes the web_search tool instead of being fully disabled.
- ›Canvas providers can return file:// URLs in open results, enabling local file previews.
- ›Canceling a running shell command via Ctrl+C (on a !command or agent command, including sandboxed and background-promoted shells) now terminates the entire process tree.
- ›preToolUse hook errors now deny the tool call instead of silently permitting execution.
- ›Plugin slash commands (/plugin install, uninstall, update, marketplace add/remove/browse) now show immediate progress feedback during operations.
- ›Surfaces the underlying reason (e.g. GitHub API rate limit) when SDK auth-token validation fails, replacing a misleading generic error message.
- ›Actionable error message shown when the GitHub API rate limit is hit during copilot update.
v1.0.56 May 29, 2026 · issue -082

GitHub Copilot CLI v1.0.56 adds rubber duck agent config, MCP structured content surfacing, and smarter token-reduction defaults.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.56 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.56
```
└──▷ TRY IT
Enable or disable the rubber duck agent without editing config files manually.
```
$ copilot config set builtInAgents.rubberDuck true
```
- ›Adds builtInAgents.rubberDuck setting to enable or disable the rubber duck agent via copilot config.
- ›MCP tools that return both content text and a structuredContent payload now surface both to the agent; literal JSON serialization (per MCP spec §5.2.6) is deduplicated, otherwise the two are concatenated.
- ›When gh CLI is on PATH, the GitHub MCP server now omits redundant gh-replaceable tools by default, reducing token usage.
- ›Free and Student users can select models other than Auto in the model picker.
- ›Reasoning effort picker respects model capabilities, hiding options unsupported by the current model.
+3 moreshow less
- ›Diff view uses a continuous scroll layout with sticky file and hunk headers, full terminal width, and theme-aware colors.
- ›web_fetch tool prefers markdown content when available, using HTTP content negotiation for cleaner results from documentation sites.
- ›Context window tier selection now persists durably in session events and survives SDK-only resume paths, reapplying tier-derived limits to request, compaction, and truncation logic.
v1.0.55 May 28, 2026 · issue -083

GitHub Copilot CLI v1.0.55 adds /autopilot, per-MCP token visibility, Claude Opus 4.8, and new permissions controls.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.55 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.55
```
└──▷ USE IT
Prevent users or scripts from enabling unrestricted allow-all mode in a shared or regulated environment.
yaml
```
permissions:
  disableBypassPermissionsMode: true
```
Keep an autopilot session locked to a specific objective so the model does not drift from the declared task.
```
$ /autopilot Refactor the authentication module to use OAuth 2.0 PKCE flow
```
Mount a local Open Plugins directory for a single session via the RPC API without affecting other sessions.
javascript
```
session.create({ pluginDirectories: ["/path/to/my-plugins"] })
```
- ›Adds permissions.disableBypassPermissionsMode setting to prevent users from enabling allow-all/yolo mode.
- ›Adds /autopilot <objective> command (with /goal as an alias) to keep autopilot sessions focused on a declared objective.
- ›Adds pluginDirectories parameter to session.create and session.resume RPC calls, letting SDK clients mount Open Plugins-format directories per session.
- ›Shows per-MCP-server token usage in /mcp and breaks out MCP tool tokens separately in /context.
- ›Adds --plugin-dir skill precedence ordering: project > plugin-dir > personal > custom, so --plugin-dir skills now override personal-home (~/.copilot, ~/.agents) skills of the same name.
+16 moreshow less
- ›Adds support for owner/repo#ref syntax when adding plugins from the marketplace.
- ›Adds Claude Opus 4.8 to the available model selection.
- ›Reports Claude thinking (reasoning) tokens in session usage summaries for all users.
- ›Enables the cell-based terminal renderer for all users by default.
- ›Surfaces extension log files per extension inside the extensions_manage tool to aid failure diagnosis.
- ›Discovers project extensions in .github/extensions within non-git (folder-backed) workspaces.
- ›Discovers custom agents and skills recursively in subdirectories.
- ›Allows /statusline and /theme commands to run while the agent is actively executing.
- ›Adds hook progress streaming that shows real-time status messages from long-running hooks in the timeline.
- ›Opens MCP configuration in its own dedicated screen with scrollable server and tool lists.
- ›Adds /env output that now shows loaded extensions with their status and source.
- ›Enables deletion of remote sessions directly from the session picker.
- ›Shows a warning when remote-controlled sessions are disabled by organization policy.
- ›Free and Student plan users on token-based billing are restricted to Auto model selection, with an explanation shown in the model picker.
- ›Progress indicators integrate natively with tmux 3.6b pane progress state.
- ›Detects PowerShell 7 correctly when pwsh.exe is installed as a Microsoft Store App Execution Alias.
v1.0.52 May 23, 2026 · issue -088

Copilot CLI v1.0.52 adds deferred tool loading for agents, /compact focus instructions, /usage quota bars, and HTTP/1.1 auto-retry.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.52 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.52
```
└──▷ TRY IT
Shape what an AI-compacted summary focuses on — useful when a long session covers multiple topics and you want the summary scoped to a specific area.
```
$ /compact focus on the database migration steps only
```
Enable deferred tool loading for a custom agent with a large tool list so tool-search discovery works without loading all tools upfront.
yaml
```
---
name: my-large-agent
deferred-tool-loading: true
---
```
Resume a saved session from a different working directory, overriding the saved cwd.
```
$ copilot --continue -C /path/to/other/dir
```
- ›Adds deferred-tool-loading key in agent frontmatter to enable opt-in deferred tool loading for custom agents with large tool lists, unlocking tool-search discovery.
- ›Adds optional focus instructions argument to /compact to shape the compaction summary.
- ›Adds /usage quota progress bars for session and weekly limits.
- ›Migrates legacy nested oauth.clientId and oauth.callbackPort keys in MCP server configs to the supported oauthClientId and auth.redirectPort keys instead of silently dropping them.
- ›Adds -C <dir> flag override so sessions resume in their saved working directory, with flags whose values are relative paths (e.g. --attachment, --log-dir) resolving from the saved cwd.
+8 moreshow less
- ›Status line command now supports plain shell commands in addition to executable script paths.
- ›Requests that time out due to an HTTP/2 upload stall automatically retry over HTTP/1.1.
- ›Reasoning tokens now display as a parenthetical on the output token count in the token usage summary.
- ›Context window tier selection (default ~200K vs 1M tokens) is now enforced end-to-end, constraining compaction, truncation, and token display.
- ›Non-interactive subcommands (plugin list, mcp list, help, version) no longer consume stdin.
- ›General-purpose subagents use GPT-5.4 or GPT-5.5 when available.
- ›/restart and /update preserve the current session ID after restarting.
- ›Adds vertical scrollbar with mouse drag support to the main conversation view.
v1.0.51 May 20, 2026 · issue -091

GitHub Copilot CLI v1.0.51 adds session resumption, /security-review, /chronicle cost-tips, secret scanning for commits/PRs, and new hook controls.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.51 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.51
```
└──▷ USE IT
Enable OSC 9;4 terminal progress indicators so your terminal emulator shows task progress in the taskbar or tab.
json
```
"terminalProgress": true
```
Trigger an experimental security review of your staged or recent code changes without leaving the CLI.
```
$ /security-review
```
- ›Adds --session-id=<id> flag to resume known sessions or tasks, or start new sessions with a specific UUID.
- ›Adds terminalProgress setting to enable or disable OSC 9;4 terminal progress indicators.
- ›Adds /security-review slash command (experimental) to review code changes for security vulnerabilities.
- ›Adds /chronicle cost-tips subcommand for personalized token usage and cost reduction recommendations.
- ›Adds preMcpToolCall hook for hook providers to control outgoing MCP request metadata.
+10 moreshow less
- ›Extends postToolUse hooks to inject additionalContext into successful tool results.
- ›Secret scanning now covers commit messages and PR descriptions, redacting secrets before they are published.
- ›/remote commands now respect organization remote control and cloud policy, showing a clear error when disabled.
- ›/remote command can now be used while the agent is actively working.
- ›/memory show displays documentation links for learning about and managing Copilot Memory.
- ›MCP servers using OAuth stay connected when authentication was performed in a separate session.
- ›GitHub MCP web search tool is available immediately without requiring a tool search.
- ›Customizable status line in the terminal footer displays session info such as model, context window, and git branch.
- ›MCP tool loading at startup is faster for users with many HTTP-based MCP servers.
- ›Input area grows responsively with terminal height instead of capping at 3 lines.
v1.0.49 May 19, 2026 · issue -092

GitHub Copilot CLI v1.0.49 adds /chronicle search, /rubber-duck, /memory, /session id, plugin bulk-update, Alpine Linux support, and more.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.49 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.49
```
└──▷ TRY IT
Search all content across a session to quickly find a prior discussion or decision by keyword.
```
$ /chronicle search "authentication flow"
```
Pin the MCP OAuth callback to a fixed port to avoid firewall or redirect-URI conflicts.
yaml
```
auth:
  redirectPort: 9876
```
Lock plugin loading to a controlled directory for reproducible CI environments, suppressing auto-discovery.
```
$ COPILOT_PLUGIN_DIR_ONLY=1 copilot --plugin-dir ./plugins chat
```
- ›Adds auth.redirectPort config option to pin the OAuth callback to a fixed port for MCP servers.
- ›Adds COPILOT_PLUGIN_DIR_ONLY environment variable to disable automatic plugin discovery, enabling deterministic plugin sets when combined with --plugin-dir.
- ›Adds copilot plugin update --all to update all installed plugins in a single command.
- ›Adds /chronicle search subcommand to search all session content by keyword or topic.
- ›Adds /session id subcommand to display the current session ID and copy it to the clipboard.
+23 moreshow less
- ›Adds /memory on|off|show slash command to enable, disable, or view persistent memory status.
- ›Adds /exit print option to print the session transcript to the terminal before exiting.
- ›Adds /rubber-duck command (experimental) to invoke an independent critique of the agent's current work.
- ›Adds experimental /mcp search command to search and install MCP servers from a registry.
- ›Adds experimental tool search with deferred loading for MCP and external tools.
- ›Adds 'None' reasoning effort option in the reasoning effort picker to disable model reasoning entirely.
- ›Extends --plugin-dir and --additional-mcp-config to work in --server / --headless mode.
- ›Injects postToolUse hook additionalContext as a system message to the model instead of silently discarding it.
- ›Hooks (preToolUse, postToolUse, subagentStart, subagentStop) now fire correctly for sub-agent tool calls.
- ›Plugins loaded via --plugin-dir now correctly register their agents as available task(agent_type=...) subagents in prompt mode.
- ›Repo hooks in .github/hooks/ now load automatically in prompt mode (-p) when the folder is already trusted.
- ›Prompt mode (-p) automatically loads workspace MCP sources when the current folder is already trusted.
- ›Adds support for running the CLI on Alpine Linux (musl libc).
- ›Memory permission prompts now name the scope of a stored memory — user scope or the specific owner/repo for repository scope — and timeline entries show (for user) / (shared with repository collaborators).
- ›Auto-links GitHub issue and PR references (owner/repo#number) in assistant responses.
- ›Auto-update downloads the smaller platform-specific package instead of the universal one when available.
- ›Content-filtered model responses now display an explanation instead of a blank assistant turn.
- ›Reduces PowerShell syntax errors on Windows by avoiding && chaining when using legacy PowerShell 5.x.
- ›PromptFrame UI now renders inside tmux when the outer terminal is ghostty, WezTerm, or kitty (detected via tmux list-clients).
- ›Document attachment paths are included in context so the agent can reference pasted file paths, including Windows 'Copy as path' inputs.
- ›MCP stdio servers now display type as 'stdio' instead of 'local' for consistency.
- ›MCP server configurations with no args field are now accepted and treated as an empty args list.
- ›Input prompt collapses to a single line when empty and grows naturally as text is entered.
v1.0.47 May 13, 2026 · issue -098

GitHub Copilot CLI v1.0.47 adds named fork sessions, j/k navigation in /diff, and improved --resume for cloud agent sessions.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.47 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.47
```
- ›The /fork command now accepts an optional name, and forked sessions display their origin in the sessions dialog.
- ›The --resume flag now supports Copilot cloud agent sessions where the agent hasn't pushed any changes to its branch.
- ›The /diff view now supports j/k keys for up/down navigation.
- ›Copilot Max subscribers now see only the models available to their subscription tier.
v1.0.46 May 12, 2026 · issue -099

Copilot CLI v1.0.46 auto-approves read-only gh commands and warns on deprecated CLI versions
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.46 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.46
```
- ›Read-only gh CLI commands (list, view, status, diff, etc.) are auto-approved without prompting for user confirmation.
- ›Displays a warning when the CLI version is deprecated and premium model access may be lost.
- ›Long lines in diff view wrap at terminal width instead of being truncated.
v1.0.45 May 11, 2026 · issue -100

GitHub Copilot CLI v1.0.45 adds /autopilot and /fork slash commands, PowerShell fallback, and OpenTelemetry GenAI metrics.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.45 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.45
```
└──▷ TRY IT
Switch to autopilot mode mid-conversation to let Copilot execute multi-step tasks without per-step confirmations.
```
$ /autopilot
```
Fork the current session to explore an alternative approach without losing the original conversation context.
```
$ /fork
```
- ›Adds /autopilot slash command to toggle between interactive and autopilot modes mid-session.
- ›Adds /fork slash command to fork the current session into a new independent session.
- ›Falls back to powershell.exe (Windows PowerShell) when pwsh (PowerShell 7+) is not available on Windows.
- ›OpenTelemetry output now aligns with GenAI semantic conventions: MCP tool calls emit standard tool_call spans and a new gen_ai.client.operation.duration metric tracks tool execution time.
- ›CLI startup is up to ~1.5s faster on terminals with limited OSC color query support.
v1.0.44 May 8, 2026 · issue -103

GitHub Copilot CLI v1.0.44 adds mid-input slash commands, multi-skill invocation, LLM-bypass hooks, and a prerelease argument to copilot update.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.44 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.44
```
- ›Adds optional prerelease argument to copilot update and /update to fetch the latest prerelease build.
- ›Supports userPromptSubmitted hooks that handle requests directly, bypassing the LLM and returning a response without making a model call.
- ›Slash commands can now appear mid-input, and multiple skills can be invoked in a single message.
v1.0.43 May 6, 2026 · issue -105

GitHub Copilot CLI v1.0.43 adds account display in the status line and server-side model routing in Auto mode.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.43 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.43
```
- ›Adds a username toggle to the /statusline picker to display the active account in the footer.
- ›Auto mode now uses server-side model routing for improved real-time model selection.
- ›Shows download progress when running the update command.
- ›MCP server child processes (e.g. started via npx or uvx) are now fully terminated when a session ends.
v1.0.42 May 6, 2026 · issue -105

GitHub Copilot CLI v1.0.42 adds -C <directory> flag, richer MCP diagnostics, and a new rubber-duck agent in /experimental.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.42 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.42
```
└──▷ TRY IT
Start Copilot CLI in a specific project directory without cd-ing first — useful in scripts or multi-repo workflows.
```
$ gh copilot -C ~/projects/my-service
```
- ›Adds -C <directory> flag to change the working directory before starting, mirroring the git -C pattern.
- ›MCP server failure warnings now include stderr output to help diagnose connection errors.
- ›MCP server failure warnings now suggest a directly runnable /mcp show command when the server name contains whitespace.
- ›Adds a rubber-duck agent for GPT sessions, powered by Claude, available under /experimental.
- ›Remote session export now supports non-GitHub repositories and repo-less directories.
+1 moreshow less
- ›Exit message resume command now shows the session ID instead of an auto-generated name when the session has not been renamed.
v1.0.41 May 5, 2026 · issue -106

Copilot CLI v1.0.41 adds experimental MCP Tasks, --attachment flag, auto shell completions, and prompt-mode extension loading.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.41 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.41
```
└──▷ TRY IT
Attach a screenshot or document to a non-interactive Copilot prompt — useful in CI pipelines or scripts where you need to feed visual or binary content alongside a question.
```
$ copilot -p 'Explain the architecture shown in this diagram' --attachment ./architecture.png
```
Enable experimental MCP Tasks so long-running MCP tools execute as background agents you can track without blocking your session.
```
$ copilot --experimental
```
Allow project extensions and management tools to load in prompt mode — set before invoking a non-interactive Copilot command in CI.
```
$ GITHUB_COPILOT_PROMPT_MODE_EXTENSIONS=true copilot -p 'Run the project lint extension and summarise findings'
```
- ›Adds --attachment flag in non-interactive (-p/--prompt) mode to attach files (images or native documents) to the initial prompt.
- ›Adds experimental MCP Tasks support: MCP tools with taskSupport: "required" run as non-blocking background agents trackable via list_agents and read_agent — available when experimental mode is enabled via /experimental on or the --experimental flag.
- ›Extensions now load in prompt mode (-p); user extensions load by default, while project extensions and management tools require the GITHUB_COPILOT_PROMPT_MODE_EXTENSIONS=true environment variable.
- ›Shell completions (bash, zsh, fish) are automatically installed on first run and updated after copilot update.
- ›Slash command picker now searches command descriptions and underlines matched characters.
+5 moreshow less
- ›Remote session connection errors now show your logged-in account and tailored remediation steps.
- ›Memory tool confirmation prompt now shows the scope (repository or user) when requesting permission to store a memory.
- ›Markdown formatting now renders in ask-user prompt questions.
- ›Tab-completing slash commands that accept arguments now adds a trailing space automatically.
- ›@-mention completion supports ./ paths, no longer adds a trailing space on directories, and shows project files before workspace roots.
v1.0.40 May 1, 2026 · issue -110

Copilot CLI v1.0.40 adds headless MCP OAuth, autopilot continuation limits, new env-var gates for prompt mode, and session/agent features for all users.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.40 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.40
```
└──▷ TRY IT
Cap autopilot at 10 continuation messages for long-running agentic tasks without manual intervention.
```
$ copilot --max-autopilot-continues 10
```
Run prompt mode with workspace MCP enabled in a CI pipeline that opts in explicitly, keeping other prompt-mode runs sandboxed by default.
```
$ GITHUB_COPILOT_PROMPT_MODE_WORKSPACE_MCP=1 copilot -p 'summarize open PRs in this repo'
```
Point the CLI at a non-default config directory using the new preferred environment variable instead of the deprecated flag.
```
$ COPILOT_HOME=~/.config/copilot-work copilot plugin list
```
- ›Adds --max-autopilot-continues flag to configure the default limit of 5 continuation messages in autopilot mode.
- ›Adds GITHUB_COPILOT_PROMPT_MODE_REPO_HOOKS and GITHUB_COPILOT_PROMPT_MODE_WORKSPACE_MCP environment variables to opt in to repo hooks and workspace MCP in prompt mode (-p), making prompt mode secure-by-default.
- ›Promotes --config-dir deprecation in favor of the COPILOT_HOME environment variable for specifying the config directory; --config-dir still propagates correctly to plugin subcommands.
- ›Adds support for client_credentials OAuth grant type for MCP servers, enabling fully headless authentication without a browser.
- ›Adds toggle for custom statusLine.command visibility in the statusline picker.
+15 moreshow less
- ›Adds agent config option for ACP clients (e.g. Zed) to list and switch custom agents.
- ›Makes session history, file tracking, and the /chronicle command available to all users.
- ›Enables /clear and /new to reset the active custom agent selection.
- ›Adds auto-detection of Azure DevOps repositories to automatically disable the GitHub MCP server.
- ›Enables skills as slash commands in ACP clients, matching the existing CLI experience.
- ›ACP clients now display the agent's live plan as it works through multi-step tasks.
- ›Upgrades /research to use an orchestrator/subagent model for more thorough deep research results.
- ›Automatically cleans up old CLI package versions from disk during auto-update.
- ›Remote session statusline now shows the remote working directory and branch instead of local context.
- ›Remote control link now shows the full URL in the timeline instead of 'Open in browser'.
- ›Prints 'Exiting...' to stderr immediately on Ctrl+C during prompt mode so shutdown progress is visible.
- ›Ctrl+C and double-Esc now remove pending queued messages one at a time instead of all at once.
- ›Mouse selection works while the /ask response dialog is open, enabling highlighting and copying of content.
- ›Slash command suggestions now rank prefix matches above fuzzy matches.
- ›Improves CLI startup speed by loading custom CA certificates asynchronously.
└──▷ BREAKING ON UPGRADE
- !--config-dir is deprecated in favor of the COPILOT_HOME environment variable.
v1.0.39 Apr 28, 2026 · issue -113

GitHub Copilot CLI v1.0.39 adds ACP permission toggling, four new slash commands, and background task control via ctrl+x → b.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.39 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.39
```
└──▷ TRY IT
Offload a long-running build or test command to the background so you can continue issuing prompts without waiting for it to finish.
```
$ ctrl+x → b
```
- ›Adds /compact, /context, /usage, and /env slash commands for ACP sessions.
- ›Allows ACP clients to toggle allow-all permission mode via session configuration.
- ›Press ctrl+x → b to move the current running task or shell command to the background.
- ›/remote status output now shows actionable hints for each connection state.
- ›Slash command argument picker opens immediately at exact command boundaries without requiring a trailing space.
+1 moreshow less
- ›Improves --resume session picker with better tab layout, status display, and progressive loading.
v1.0.37 Apr 27, 2026 · issue -114

GitHub Copilot CLI v1.0.37 adds shell completion scripts, session sort cycling, and default location-based permission persistence.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.37 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.37
```
└──▷ TRY IT
Bootstrap persistent shell completions for Copilot CLI so subcommands, flags, and choice values tab-complete in your shell.
```
$ copilot completion zsh > ~/.zsh/completions/_copilot && source ~/.zshrc
```
- ›Adds copilot completion <bash|zsh|fish> subcommand to generate static shell completion scripts covering subcommands, flags, and known choice values.
- ›Location-based permission persistence is now enabled by default, carrying approvals across sessions for the same directory without re-approval.
- ›Press s in the session picker to cycle sort order across four modes: relevance, last used, created, or name.
- ›/ask responses now render full markdown, including tables and formatted links.
- ›ACP model config options now expose description and metadata fields for clients using the configOptions API.
v1.0.36 Apr 24, 2026 · issue -117

GitHub Copilot CLI v1.0.36 adds /keep-alive, /remote toggle, and a session-diff statusline among other UX improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.36 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.36
```
└──▷ TRY IT
Prevent your workstation from sleeping during a long-running Copilot CLI session without enabling experimental mode.
```
$ /keep-alive
```
Check whether remote control is active, then disable it mid-session.
```
$ /remote
/remote off
```
- ›Adds /keep-alive command (now available without experimental mode) to prevent system sleep while Copilot CLI is active.
- ›Adds /remote command with /remote on and /remote off subcommands to show current remote-control status and toggle it.
- ›Adds a changes statusline toggle to display added/removed line counts for the current session.
- ›Subcommand picker now shows a ❯ selection indicator next to the highlighted item.
- ›Requires double Esc to cancel in-flight work, preventing accidental interruptions.
+3 moreshow less
- ›Disabled skills no longer appear in the slash command list.
- ›Custom agents, skills, and commands from ~/.claude/ are no longer loaded by Copilot CLI.
- ›Claude Opus 4.6 now uses medium reasoning effort by default.
└──▷ BREAKING ON UPGRADE
- !Hooks with preToolUse.matcher now run only for tool names that fully match the regex — previously, the matcher was ignored and hooks ran unconditionally.
- !Custom agents, skills, and commands from ~/.claude/ are no longer loaded by Copilot CLI; any tooling relying on that path will stop working after upgrade.
v1.0.35 Apr 23, 2026 · issue -118

GitHub Copilot CLI v1.0.35 adds HTTP hooks, named sessions, new slash commands, and MCP/LSP improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.35 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.35
```
└──▷ TRY IT
Name a new session and later resume it by name, keeping context across invocations.
```
$ gh copilot --name my-feature-work
# later...
gh copilot --resume=my-feature-work
```
Automatically switch to auto model on rate limit instead of pausing, useful for unattended agentic runs.
yaml
```
continueOnAutoMode: true
```
Route hook events to a webhook endpoint instead of a local script, enabling remote audit or automation pipelines.
yaml
```
hooks:
  - event: tool_call
    http:
      url: https://hooks.example.com/copilot
      method: POST
```
- ›Adds COPILOT_GH_HOST environment variable to set the GitHub hostname, taking precedence over GH_HOST.
- ›Adds --name flag to name sessions and --resume=<name> to resume them by name.
- ›Adds continueOnAutoMode config option to automatically switch to auto model on rate limit instead of pausing.
- ›Adds /session delete, /session delete <id>, and /session delete-all subcommands, plus x-to-delete in the session picker.
- ›Adds HTTP hook support, allowing hooks to POST JSON payloads to a configured URL instead of running a local command.
+21 moreshow less
- ›Moves user settings storage to ~/.copilot/settings.json, separate from internal state in config.json.
- ›LSP server entries in lsp.json now support configurable spawn, initialization, and warmup timeouts.
- ›Adds a GitHub-style contribution graph to /usage that adapts to terminal color mode and falls back to distinct glyphs in no-color terminals.
- ›grep and glob tools now accept multiple search paths.
- ›Slash commands support tab-completion for arguments and subcommands.
- ›Adds Ctrl+Y (in addition to Tab) to accept the highlighted option in completion popups (@-mentions, path completions, slash commands).
- ›--continue now prefers resuming sessions from the current working directory instead of the most recently touched session.
- ›Shell escape commands (!) now use $SHELL when set, instead of always invoking /bin/sh.
- ›Status line script now includes context window fields matching the model badge and /context output.
- ›Custom agent name is now visible in the statusline footer and can be toggled via /statusline.
- ›MCP server names with spaces and special characters are now supported.
- ›Pattern-specific instruction files (.github/instructions/*.instructions.md) no longer include their full body in the system prompt on every session.
- ›Plugins take effect immediately after install without requiring a restart.
- ›Configure Copilot agent now has shell access on Windows.
- ›Tab navigation supports Home/End keys to jump to first and last tab.
- ›Context window indicator in the statusline is now hidden by default.
- ›Self-correcting custom tool calls in agentic loop.
- ›/update and /version commands now honor the configured update channel.
- ›Session selector shows branch names, idle/in-use status, and has improved search with cursor support.
- ›Model change notification shows both the previous and new model name.
- ›Sync task calls block until completion under MULTI_TURN_AGENTS instead of auto-promoting to background after 60 seconds; sync no longer returns a reusable agent_id — use mode: "background" for follow-ups.
└──▷ BREAKING ON UPGRADE
- !Sync task calls under MULTI_TURN_AGENTS no longer return a reusable agent_id; use mode: 'background' for follow-up calls instead.
- !User settings are now stored in ~/.copilot/settings.json instead of config.json.
v1.0.33 Apr 20, 2026 · issue -121

Copilot CLI v1.0.33 adds new slash command aliases, earlier rate-limit warnings, and vim-style task navigation.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.33 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.33
```
- ›Adds /bug, /continue, /release-notes, /export, and /reset as slash command aliases.
- ›Adds /upgrade as an alias for the /update command.
- ›Resuming a remote session with --resume or --continue automatically inherits the --remote flag without re-specifying it.
- ›Adds j/k vim-style navigation and x to kill tasks in the tasks dialog.
- ›Shows usage limit warnings at 50% and 95% capacity for earlier notice before hitting rate limits.
+4 moreshow less
- ›Slash command picker suggests similar commands when an unrecognized or misspelled slash command is typed.
- ›Sub-agents in auto mode now inherit the session model.
- ›Non-interactive mode waits for all background agents to finish before exiting.
- ›Lists ctrl+t (toggle reasoning display) in the /help and ? overlay.
v1.0.32 Apr 17, 2026 · issue -124

GitHub Copilot CLI v1.0.32 adds --connect, --print-debug-info, --session-idle-timeout, short session ID resumption, auto model selection, and file attachment to prompts.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.32 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.32
```
└──▷ TRY IT
Resume a previous session using just the first 7+ hex characters of its ID instead of the full ID.
```
$ gh copilot --resume a3f92b1
```
Diagnose environment or terminal capability issues by printing version and environment details.
```
$ gh copilot --print-debug-info
```
Set a session idle timeout so long-running unattended sessions are automatically cleaned up.
```
$ gh copilot --session-idle-timeout 30m
```
- ›Adds --connect flag to directly connect to a remote session by ID without additional steps.
- ›Adds --print-debug-info flag to display version, terminal capabilities, and environment variables — useful for diagnosing environment issues.
- ›Adds --session-idle-timeout flag to configure session idle timeout (disabled by default).
- ›Allows short session ID prefixes (7+ hex characters) with --resume and /resume instead of requiring the full ID.
- ›Adds auto as a selectable model value, letting Copilot automatically pick the best available model for each session.
+6 moreshow less
- ›Supports attaching document files to prompts for the agent to read and reason about.
- ›Shows warnings when approaching 75% and 90% of weekly usage limits.
- ›Rate-limited sessions now pause queued messages and automatically retry instead of dropping them.
- ›Skills that exceed the token limit remain discoverable and invocable by name.
- ›Current date and time in agent context now includes local timezone offset.
- ›/feedback saves the bundle to TEMP when the working directory is not writable.
v1.0.30 Apr 16, 2026 · issue -125

GitHub Copilot CLI v1.0.30 adds /statusline command to customize the status bar and expands image paste to Ctrl+V and Meta+V.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.30 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.30
```
└──▷ TRY IT
Trim the status bar to only the current branch and quota to reduce visual noise during long sessions.
```
$ /statusline branch quota
```
- ›Adds /statusline command (with /footer alias) to customize which items appear in the status bar, supporting: directory, branch, effort, context window, and quota.
- ›Extends image paste from clipboard to both Ctrl+V and Meta+V across all platforms.
└──▷ BREAKING ON UPGRADE
- !The --list-env flag (which logged loaded plugins, agents, skills, and MCP servers in prompt mode) has been removed.
v1.0.29 Apr 16, 2026 · issue -125

GitHub Copilot CLI v1.0.29 adds --list-env flag, COPILOT_AGENT_SESSION_ID, Claude Opus 4.7 support, and HTTP-default MCP config.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.29 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.29
```
└──▷ USE IT
Define a remote MCP server without specifying a type, relying on the new http default.
yaml
```
servers:
  - name: my-mcp-server
    url: https://mcp.example.com/v1
```
- ›Adds --list-env flag to prompt mode, logging all loaded plugins, agents, skills, and MCP servers — useful for verifying environment configuration in CI pipelines.
- ›Injects COPILOT_AGENT_SESSION_ID as an environment variable into shell commands and MCP servers, enabling session-scoped tracking across tool calls.
- ›Remote MCP server config now allows omitting the type field, defaulting to http when unspecified.
- ›Adds support for Claude Opus 4.7 as a model option.
v1.0.28 Apr 16, 2026 · issue -125

GitHub Copilot CLI v1.0.28 adds remote session resumption, terminal title opt-out, and live custom instruction reloading.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.28 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.28
```
- ›Adds COPILOT_DISABLE_TERMINAL_TITLE environment variable to opt out of terminal title updates.
- ›Enables connecting to CLI remote control sessions directly from the --resume picker.
- ›Custom instructions and skills now refresh from disk automatically after /clear or /new, removing the need to restart.
v1.0.27 Apr 15, 2026 · issue -126

Adds /ask command and copilot plugin marketplace update to GitHub Copilot CLI v1.0.27
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.27 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.27
```
└──▷ TRY IT
Ask a one-off question mid-session without polluting the ongoing conversation context.
```
$ /ask What does the OWASP Top 10 say about injection attacks?
```
Refresh all plugin catalogs to pick up newly published or updated plugins from the marketplace.
```
$ copilot plugin marketplace update
```
- ›Adds /ask command to ask a quick question without affecting conversation history.
- ›Adds copilot plugin marketplace update command to refresh plugin catalogs.
- ›Status bar now shows @files and #issues hints while typing, and /help hint when the slash command picker is open.
v1.0.26 Apr 14, 2026 · issue -127

Copilot CLI v1.0.26 adds plugin root env vars, localhost-only ACP binding, and remote control renaming across flag and command help.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.26 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.26
```
└──▷ TRY IT
Access the plugin installation directory inside a plugin hook script to reference bundled assets or binaries.
```
$ echo "Plugin installed at: $COPILOT_PLUGIN_ROOT"
```
- ›Plugin hooks now receive PLUGIN_ROOT, COPILOT_PLUGIN_ROOT, and CLAUDE_PLUGIN_ROOT environment variables pointing to the plugin's installation directory.
- ›ACP server now binds to localhost only, preventing unintended network exposure.
- ›Renames 'steering' to 'remote control' in --remote flag and /remote command help text.
- ›Remote tab now shows Copilot coding agent tasks and supports remote control without requiring a pull request.
- ›Enterprise login now accepts hostnames without a URL scheme (e.g. github.example.com).
+4 moreshow less
- ›Instruction files with specific applyTo patterns are consolidated into a table instead of inlining full content, reducing context window usage.
- ›ctrl+o now expands all timeline entries, matching the behavior of ctrl+e.
- ›Adds deprecation warning when installing plugins from repos, URLs, or local paths.
- ›Session scope selector in sync prompt is now keyboard-navigable with left/right arrow keys.
v1.0.25 Apr 13, 2026 · issue -128

GitHub Copilot CLI v1.0.25 adds MCP server install from registry, /env, /remote, and remote session control via --remote.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.25 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.25
```
└──▷ TRY IT
Inspect all loaded environment context — instructions, MCP servers, skills, agents, and plugins — at any point in a session.
```
$ /env
```
Add a local subdirectory to context using a relative path, without needing to resolve the absolute path first.
```
$ /add-dir ./src
```
- ›Adds --remote flag and /remote command to remotely control CLI sessions.
- ›Adds /env command to display loaded environment details including instructions, MCP servers, skills, agents, and plugins.
- ›Respects --config-dir flag when selecting the active model.
- ›Supports installing MCP servers from the registry with guided configuration directly in the CLI.
- ›ACP clients can now supply MCP servers (stdio, HTTP, SSE) when starting or loading sessions.
+4 moreshow less
- ›MCP remote server connections automatically retry on transient network failures.
- ›/share html shows a file:// URL and supports Ctrl+X O to open the file directly.
- ›/logout shows a warning when signed in via gh CLI, PAT, API key, or environment variable, since /logout only manages OAuth sessions.
- ›Adds Alt+D keybinding to delete the word in front of the cursor in text input.
v1.0.24 Apr 10, 2026 · issue -131

Copilot CLI v1.0.24: hooks now propagate modifiedArgs and custom agents accept VS Code display names
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.24 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.24
```
- ›preToolUse hooks now correctly propagate modifiedArgs/updatedInput and additionalContext fields, enabling hooks to pass modified arguments and extra context downstream.
- ›Custom agent model field now accepts VS Code display names and vendor suffixes (e.g., Claude Sonnet 4.5, GPT-5.4 (copilot)) in addition to raw model IDs.
- ›The --remote flag is now respected when the session sync prompt appears on first run inside a GitHub repo.
- ›Redesigned exit screen with Copilot mascot and a cleaner usage summary layout.
v1.0.23 Apr 10, 2026 · issue -131

GitHub Copilot CLI v1.0.23 adds --mode, --autopilot, and --plan flags for direct agent mode entry plus Tasks API steering.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.23 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.23
```
- ›Adds --mode, --autopilot, and --plan flags to launch the CLI directly in a specific agent mode.
- ›Enables /diff, /agent, /feedback, /ide, and /tuikit slash commands while the agent is actively running.
- ›Remote tab now surfaces Copilot coding agent tasks and supports steering them via the Tasks API.
- ›Migration notice for .vscode/mcp.json now includes a jq command to migrate your config to .mcp.json.
- ›Displays reasoning token usage in the per-model token breakdown when nonzero.
+1 moreshow less
- ›Ctrl+L clears the terminal screen without clearing the current conversation session.
v1.0.22 Apr 9, 2026 · issue -132

GitHub Copilot CLI v1.0.22 adds bearer token BYOK auth, a skills field for custom agents, plugin post-install messages, and tighter sub-agent limits.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.22 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.22
```
- ›Custom agents can now declare a skills field in their configuration to eagerly load skill content into agent context at startup.
- ›Adds support for bearer token authentication for BYOK Anthropic models.
- ›CLI now reads MCP server configuration exclusively from .mcp.json; .vscode/mcp.json and .devcontainer/devcontainer.json are no longer recognized as MCP server config sources.
- ›Adds sub-agent depth and concurrency limits to prevent runaway agent spawning.
- ›Plugin agents now respect the model specified in their frontmatter.
+5 moreshow less
- ›Plugins can now display a post-install message with setup instructions after installation.
- ›Plugins remain enabled across sessions and auto-install on startup based on user config.
- ›sessionStart and sessionEnd hooks now fire once per session in interactive mode instead of once per prompt.
- ›Warns when resuming a session that is already in use by another CLI or application.
- ›Shows a clear message to contact your organization administrator when remote sessions are blocked by policy.
└──▷ BREAKING ON UPGRADE
- !.vscode/mcp.json and .devcontainer/devcontainer.json are removed as MCP server config sources; the CLI now only reads .mcp.json. Existing setups relying on .vscode/mcp.json will stop loading MCP servers until config is migrated to .mcp.json (a migration hint appears when .vscode/mcp.json is detected without .mcp.json).
- !sessionStart and sessionEnd hooks now fire once per session rather than once per prompt in interactive mode; setups that relied on per-prompt hook execution will behave differently.
v1.0.21 Apr 7, 2026 · issue -134

GitHub Copilot CLI v1.0.21 adds copilot mcp for MCP server management and snake_case hook payloads.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.21 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.21
```
- ›Adds copilot mcp command for managing MCP servers.
- ›Hooks configured with PascalCase event names now receive VS Code-compatible snake_case payloads containing hook_event_name, session_id, and ISO 8601 timestamps.
v1.0.20 Apr 7, 2026 · issue -134

Copilot CLI v1.0.20 adds an OpenTelemetry monitoring help topic and makes /yolo state persist across /restart
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.20 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.20
```
- ›Adds copilot help monitoring topic covering OpenTelemetry configuration details and examples.
- ›Makes /yolo and --yolo behave identically, with /yolo state now persisting across /restart.
- ›Azure OpenAI BYOK now defaults to the GA versionless v1 route when no API version is configured.
- ›Spinner stays active until background agents and shell commands finish, with user input available throughout.
v1.0.19 Apr 6, 2026 · issue -135

Copilot CLI v1.0.19 persists MCP state across sessions and adds OpenTelemetry streaming latency tracking.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.19 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.19
```
- ›Adds github.copilot.time_to_first_chunk attribute to chat spans in OpenTelemetry monitoring for streaming latency visibility.
- ›/mcp enable and /mcp disable now persist across sessions, surviving restarts without re-configuration.
- ›Subagent spans now use INTERNAL span kind in OpenTelemetry, enabling more accurate trace categorization.
- ›Slash command timeline entries now include the command name (e.g., 'Review', 'Plan') for better audit context.
v1.0.18 Apr 4, 2026 · issue -137

GitHub Copilot CLI v1.0.18 adds a Critic agent, async notification hooks, and a preToolUse permission suppression flag.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.18 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.18
```
- ›Sets permissionDecision: 'allow' in a preToolUse hook to suppress the tool approval prompt entirely.
- ›Adds a notification hook event that fires asynchronously on shell completion, permission prompts, elicitation dialogs, and agent completion.
- ›New Critic agent automatically reviews plans and complex implementations using a complementary model to catch errors early (experimental, Claude models only).
- ›Session resume picker now groups sessions by branch and repository on first use.
v1.0.17 Apr 3, 2026 · issue -138

GitHub Copilot CLI v1.0.17 adds built-in skills and HTTPS MCP OAuth redirect support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.17 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.17
```
- ›Supports HTTPS redirect URIs in MCP OAuth flows via a self-signed certificate fallback, enabling compatibility with providers that require HTTPS (such as Slack).
- ›Adds built-in skills to the CLI, starting with a guide for customizing Copilot cloud agent's environment.
- ›/resume session picker now loads significantly faster when working with large session histories.
v1.0.16 Apr 2, 2026 · issue -139

GitHub Copilot CLI v1.0.16 adds a PermissionRequest hook for scripted tool approval and MCP timeline visibility.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.16 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.16
```
- ›Adds PermissionRequest hook to allow scripts to programmatically approve or deny tool permission requests.
- ›MCP tool calls now display tool name and parameter summary in the timeline.
- ›MCP servers now reconnect correctly with valid authentication when the working directory changes, and load correctly after login, user switch, and /mcp reload.
└──▷ BREAKING ON UPGRADE
- !The marketplaces repository setting has been removed; use extraKnownMarketplaces instead.
v1.0.15 Apr 1, 2026 · issue -140

Copilot CLI v1.0.15 adds MCP server config RPCs, OAuth device-code flow, /mcp auth, /share html, and branch-diff toggle.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.15 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.15
```
└──▷ TRY IT
Review all changes on the current branch against the merge-base using the branch diff toggle in /diff mode.
```
$ gh copilot /diff
```
- ›Adds mcp.config.list, mcp.config.add, mcp.config.update, and mcp.config.remove server RPCs for managing persistent MCP server configuration.
- ›Adds COPILOT_HOME environment variable, replacing nonstandard XDG variables, with automatic data migration.
- ›Adds /mcp auth command and re-authentication UI for MCP OAuth servers, including account switching support.
- ›Adds device code flow (RFC 8628) as a fallback for MCP OAuth in headless and CI environments.
- ›Adds postToolUseFailure hooks for tool errors; postToolUse now runs only after successful tool calls.
+7 moreshow less
- ›Adds /share html command to export sessions and research reports as self-contained interactive HTML files.
- ›Config settings askUser, autoUpdate, storeTokenPlaintext, logLevel, skillDirectories, and disabledSkills now use camelCase names (snake_case still accepted).
- ›Adds branch diff toggle to /diff mode for viewing full branch changes vs merge-base.
- ›Adds Home/End and Page Up/Page Down keyboard navigation to the diff viewer.
- ›MCP servers that are slow to connect no longer block the agent from starting.
- ›Adds a default option to the custom agent picker to deselect the current agent.
- ›Drops support for gpt-5.1-codex, gpt-5.1-codex-mini, and gpt-5.1-codex-max models.
└──▷ BREAKING ON UPGRADE
- !Nonstandard XDG environment variables are replaced by COPILOT_HOME; existing setups relying on those XDG variables must migrate to COPILOT_HOME.
- !gpt-5.1-codex, gpt-5.1-codex-mini, and gpt-5.1-codex-max models are removed and can no longer be selected.
- !Ctrl+D no longer queues a message; use Ctrl+Q or Ctrl+Enter to queue instead.
- !Text selection no longer auto-copies; Ctrl+C or right-click is now required to copy selected text.
- !postToolUse hooks no longer run after failed tool calls; use the new postToolUseFailure hook for error handling.
v1.0.13 Mar 30, 2026 · issue -142

Copilot CLI v1.0.13 adds conversation rewind timeline, MCP LLM sampling requests, and faster startup via V8 compile cache.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.13 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.13
```
└──▷ TRY IT
Roll back a conversation to an earlier point when an agent went down a wrong path.
```
$ /rewind
```
- ›New /rewind command and double-Esc gesture open a timeline picker that can roll back to any point in conversation history, not just the previous snapshot.
- ›MCP servers can now request LLM inference (sampling) with user approval via a new review prompt.
- ›MCP servers blocked by allowlist policy are now hidden from /mcp show.
- ›CLI startup time reduced by running terminal detection, auth, and git operations in parallel, and by a V8 compile cache that cuts parse and compile time on repeated invocations.
- ›MCP server OAuth authentication now works when the CLI runs in ACP mode.
+3 moreshow less
- ›MCP registry lookups gain automatic retries and request timeouts for improved reliability.
- ›Reasoning effort setting now applies correctly when using Bring Your Own Model (BYOM) providers.
- ›Splits $BROWSER on spaces to support browser launch configurations that include arguments.
└──▷ BREAKING ON UPGRADE
- !Support for the gemini-3-pro-preview model has been removed.
v1.0.12 Mar 26, 2026 · issue -146

GitHub Copilot CLI v1.0.12 adds plugin env vars, new /allow-all subcommands, session name auto-gen, and OTEL span improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.12 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.12
```
└──▷ TRY IT
Temporarily grant broad permissions for an automated task, then revoke them and verify the state, all without leaving the CLI.
```
$ /allow-all on
# run your automated task
/allow-all off
/allow-all show
```
Expose the project root and plugin data directory to a custom hook script so it can locate project-specific assets at runtime.
json
```
{
  "hooks": {
    "pre_tool_call": [
      {
        "command": "./scripts/audit.sh",
        "args": ["{{project_dir}}", "{{plugin_data_dir}}"]
      }
    ]
  }
}
```
Store team-shared scan rules in .claude/settings.json and personal overrides (e.g. local model preferences) in .claude/settings.local.json, both picked up automatically per repo.
json
```
# .claude/settings.json  — committed to the repo
{
  "model": "claude-3-7-sonnet-20250219",
  "reasoning_effort": "high"
}

# .claude/settings.local.json  — git-ignored, personal overrides
{
  "reasoning_effort": "low"
}
```
- ›Adds CLAUDE_PROJECT_DIR and CLAUDE_PLUGIN_DATA environment variables to plugin hooks, plus {{project_dir}} and {{plugin_data_dir}} template variables in hook configurations.
- ›Extends /allow-all (alias /yolo) with on, off, and show subcommands to enable, disable, or check allow-all mode from the CLI.
- ›Reads .claude/settings.json and .claude/settings.local.json as additional repository-level config sources.
- ›OTEL hook executions are now recorded as span events instead of child spans, reducing trace clutter in distributed tracing backends.
- ›/session rename auto-generates a session name from conversation history when called without a name argument.
+7 moreshow less
- ›Status line payload now includes a session_name field alongside the existing session_id.
- ›Model picker opens in full-screen view with inline reasoning effort adjustment using ← / → arrow keys; active reasoning effort level (e.g. '(high)') appears in the model display header.
- ›/yolo path permissions now persist after using /clear to start a new session.
- ›Ctrl+Y in plan mode opens the most recent research report when no plan exists yet.
- ›OSC 8 hyperlinks are now clickable in VS Code terminals.
- ›/clear preserves MCP server state into the new session.
- ›Workspace MCP servers are now correctly loaded and visible to the agent.
└──▷ BREAKING ON UPGRADE
- !The --alt-screen flag and alt_screen setting are removed; alt screen is now always enabled and cannot be disabled.
v1.0.11 Mar 23, 2026 · issue -149

GitHub Copilot CLI v1.0.11 adds monorepo skill discovery, per-session working directories, and merged extension hooks.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.11 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.11
```
└──▷ TRY IT
Seed a fresh session with an immediate task without typing a follow-up message — useful in CI kick-off or scripted workflows.
```
$ /new 'Run the full test suite and summarise failures'
```
Surface a custom status command that expands home-directory and environment-variable paths, e.g. to show a per-project Git status line.
yaml
```
statusLine.command: ~/.local/bin/my-status ${PROJECT:-default}
```
- ›Adds ~/.agents/skills/ as a personal skill discovery directory, aligning with the VS Code GHCP4A extension default.
- ›Supports statusLine.command path expansion for ~ and environment variables such as $HOME and ${VAR:-default}.
- ›Custom instructions, MCP servers, skills, and agents are now discovered at every directory level from the working directory up to the git root, enabling full monorepo support.
- ›/new and /clear commands now accept an optional prompt to seed the new session with a first message.
- ›/clear now abandons the current session entirely, while /new starts a fresh conversation with the old session kept backgrounded.
+7 moreshow less
- ›Extension hooks from multiple extensions now merge instead of overwriting each other or hooks from hooks.json.
- ›sessionStart hook additionalContext is now injected into the conversation.
- ›Shows a warning when MCP servers are blocked by policy (e.g. allowlist enforcement), and enforces the organization policy for third-party MCP servers for all users.
- ›MCP OAuth authentication now works with servers that support Dynamic Client Registration but host authorization metadata at a non-standard URL (e.g. the Atlassian Rovo MCP Server).
- ›Background agent progress — current intent and tool calls completed — now surfaces in read_agent and task timeout responses.
- ›GitHub MCP server user configuration is respected when connecting to remote hosts.
- ›Startup 'Environment loaded' message now shows the count of loaded hooks.
v1.0.10 Mar 20, 2026 · issue -152

Copilot CLI v1.0.10 adds /undo, multi-session support, --effort alias, SDK elicitation dialogs, and camelCase config keys.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.10 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.10
```
└──▷ TRY IT
Roll back a bad AI-generated edit mid-session without manually reverting files.
```
$ /undo
```
Use the new camelCase config key to pin the status line display in your config file.
json
```
{ "statusLine": true, "effortLevel": "high", "autoUpdatesChannel": "stable" }
```
- ›Adds --effort as a shorthand alias for --reasoning-effort flag.
- ›Adds /undo command to undo the last turn and revert file changes made during a session.
- ›Renames config settings to camelCase: includeCoAuthoredBy, effortLevel, autoUpdatesChannel, and statusLine (old snake_case names still accepted).
- ›Workspace MCP servers from .mcp.json, .vscode/mcp.json, and devcontainer.json are now loaded only after folder trust is confirmed.
- ›Plugins loaded via --plugin-dir now appear in /plugin list under a separate 'External Plugins' section.
+6 moreshow less
- ›SDK clients can register custom slash commands when starting or joining a session.
- ›SDK clients can show elicitation dialogs to the user via session.ui.elicitation.
- ›Adds experimental support for multiple concurrent sessions.
- ›Model picker reorganizes models into 'Available', 'Blocked/Disabled', and 'Upgrade' tabs based on user plan and policy.
- ›/copy writes formatted HTML to clipboard on Windows for pasting into Word, Outlook, and Teams.
- ›Plugins using .claude-plugin/ or .plugin/ manifest directories now load their MCP and LSP servers.
v1.0.9 Mar 19, 2026 · issue -153

GitHub Copilot CLI v1.0.9 adds include_gitignored config option to surface gitignored files in @ file search.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.9 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.9
```
- ›Adds include_gitignored config option to include gitignored files in @ file search results.
v1.0.8 Mar 18, 2026 · issue -154

GitHub Copilot CLI v1.0.8 adds hook definitions in settings files, MCP registry validation, and flexible --resume by task ID
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.8 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.8
```
└──▷ USE IT
Define repo-level hooks declaratively in a local settings file so they apply automatically on trust confirmation.
json
```
{
  "hooks": {
    "pre-commit": "npm run lint"
  }
}
```
- ›Adds support for defining hooks in settings.json, settings.local.json, and config.json.
- ›Enables validation of MCP servers against configured registries via the experimental MCP_ALLOWLIST feature flag.
- ›Extends --resume to accept a task ID in addition to a session ID.
- ›Adds an extension mode setting to control extensibility.
- ›Alternate screen buffer is now enabled by default for a cleaner terminal experience.
+2 moreshow less
- ›Idle subagents are now hidden from the /tasks view after 2 minutes of inactivity, reducing clutter.
- ›Ctrl-C in prompt mode now exits immediately instead of waiting for the request to complete.
v1.0.7 Mar 17, 2026 · issue -155

GitHub Copilot CLI v1.0.7 adds GPT-5.4-mini, a subagentStart hook, experimental SDK session APIs, and a new 'customize' system message mode.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.7 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.7
```
└──▷ TRY IT
Override a specific section of the system prompt without replacing the entire message — useful for tailoring assistant behavior per project.
```
$ # In your system message config, set mode to 'customize' to enable section-level overrides
```
Use the subagentStart hook to inject extra context (e.g. project metadata) whenever a subagent is spawned during a multi-agent workflow.
```
$ # Register a subagentStart hook in your SDK session setup to supply additional prompt context to each spawned subagent
```
- ›Adds customize mode to system message config for section-level system prompt overrides.
- ›Adds experimental SDK session APIs to list and manage skills, MCP servers, and plugins, with optional config auto-discovery from the working directory.
- ›Adds subagentStart hook that fires when a subagent is spawned, supporting injection of additional context into the subagent's prompt.
- ›Adds support for the gpt-5.4-mini model in the model picker.
- ›Branch indicator in the header now distinguishes unstaged changes (*), staged changes (+), and untracked files (%).
+2 moreshow less
- ›Double-Esc clears input when text is present, or triggers undo when the prompt is empty, with a hint shown after the first Esc.
- ›Pro and trial users now see all models they are entitled to in the model picker.
v1.0.6 Mar 16, 2026 · issue -156

Copilot CLI v1.0.6 adds dynamic tool search for Claude models, cross-platform hook configs, Open Plugin spec support, and expanded GitHub MCP tool flags.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.6 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.6
```
└──▷ TRY IT
Load custom instruction files from a project-specific directory so the agent picks up team guidelines automatically.
```
$ COPILOT_CUSTOM_INSTRUCTIONS_DIRS=./team-instructions copilot
```
Load a plugin from a local directory so .claude-plugin/plugin.json is discovered and the plugin's tools are available to the agent.
```
$ copilot --plugin-dir ./my-plugin
```
- ›Adds --enable-all-github-mcp-tools, --add-github-mcp-toolset, and --add-github-mcp-tool flags now taking effect in SDK (ACP mode).
- ›Adds skipPermission per-tool setting so extension tools can bypass permission prompts individually while still using the permissions system.
- ›Adds COPILOT_CUSTOM_INSTRUCTIONS_DIRS environment variable support for loading custom instruction file paths correctly.
- ›Hook configuration files now accept PascalCase event names alongside camelCase, enabling a single hook config to work across VS Code, Claude Code, and the CLI without modification.
- ›Hook config files now support Claude Code's nested matcher/hooks structure and optional type field.
+9 moreshow less
- ›Adds support for the Open Plugins spec: .lsp.json file locations, exclusive path mode, and : namespace separator for loading plugin and marketplace manifests.
- ›Plugins using .claude-plugin/plugin.json are discovered when loaded via --plugin-dir.
- ›Instruction file frontmatter applyTo field now accepts both string and array values.
- ›Enables dynamic tool discovery and use with tool search for Claude models.
- ›Sub-agents launched by the task tool receive human-readable IDs based on their name (e.g., math-helper-0) instead of generic agent-0 identifiers.
- ›The create_pull_request tool now includes the PR URL in its output so the agent can share the direct link.
- ›read_agent output now includes inbound messages that triggered each turn in multi-turn agents.
- ›Autopilot task_complete summary is now required and renders as markdown.
- ›Subagent elapsed time in /tasks view now freezes when idle and resumes when active.
v1.0.5 Mar 13, 2026 · issue -158

Copilot CLI v1.0.5 adds /pr for pull-request automation, /extensions management, richer file mentions, and a preCompact hook.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.5 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.5
```
└──▷ TRY IT
Kick off automated PR creation and CI-fix loop from inside a Copilot CLI session.
```
$ /pr
```
Browse recent release notes or summarize a range of versions without leaving the session.
```
$ /changelog last 5
/changelog since 1.0.0
/changelog summarize
```
- ›Adds /pr command to create and view pull requests, automatically fix CI failures, address review feedback, and resolve merge conflicts.
- ›Adds /extensions command to view, enable, and disable CLI extensions from within the session.
- ›Adds /version command to display the CLI version and check for updates without leaving the session.
- ›Extends /changelog with last <N>, since <version>, and summarize subcommands to browse and summarize multiple release notes at once.
- ›Adds preCompact hook to run commands before context compaction starts.
+7 moreshow less
- ›Expands @ file mentions to support paths outside the project: absolute paths (@/usr/...), home directory (@~/...), and relative parent paths (@../...).
- ›Enables multi-turn conversations with background agents via the write_agent tool for sending follow-up messages.
- ›Syntax highlighting in /diff now covers 17 programming languages.
- ›Toggleing experimental mode with /experimental on|off automatically restarts the CLI to apply changes immediately.
- ›Shows a clear error when a classic Personal Access Token (ghp_) is set in environment variables instead of silently exiting.
- ›Surfaces the API request ID in the timeline when errors occur after retries are exhausted.
- ›Hooks config files that omit the version field are now accepted by the CLI.
v1.0.4 Mar 11, 2026 · issue -160

Copilot CLI v1.0.4 adds RPC shell execution, OpenTelemetry tracing, CommonJS extensions, and a new configure-copilot sub-agent
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.4 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.4
```
└──▷ USE IT
Prevent all hooks from running in a non-interactive CI environment by disabling them at the config level.
yaml
```
disableAllHooks: true
```
Check the current PR's status in the terminal without leaving the CLI.
```
$ gh copilot /pr view local
```
- ›Adds session.shell.exec and session.shell.kill RPC methods for executing shell commands with streaming stdout/stderr output.
- ›Adds --reasoning-effort CLI flag to set the reasoning effort level for agent sessions.
- ›Adds disableAllHooks flag to disable all hooks from a configuration file.
- ›Replaces /pr open with /pr view [local|web] to view PR status locally or open it in the browser.
- ›Adds configure-copilot sub-agent for managing MCP servers, custom agents, and skills via the task tool.
+9 moreshow less
- ›Enables OpenTelemetry instrumentation for observability into agent sessions, LLM calls, and tool executions.
- ›Extensions can now be written as CommonJS modules using the extension.cjs format.
- ›Hooks can now request user confirmation before tool execution with an ask permission decision.
- ›Supports Azure DevOps repository identification in session logs.
- ›Adaptive color engine with dynamic color modes and an interactive theme picker, with graceful degradation on limited-color terminals and Windows.
- ›Shows loaded extensions count in the 'Environment loaded' startup message.
- ›Path permission dialog now offers a one-time approval option in addition to adding the path to the allowed list.
- ›Shows individual instruction file names in the /instructions picker with [external] labels for injected files.
- ›Custom agents from --plugin-dir plugins now load correctly in ACP mode.
└──▷ BREAKING ON UPGRADE
- !/pr open is replaced by /pr view [local|web]; any scripts or workflows invoking /pr open will need to be updated.
v1.0.3 Mar 9, 2026 · issue -162

Copilot CLI v1.0.3 adds MCP config from devcontainer.json, --binary-version flag, /restart command, Windows Terminal support, and more.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.3 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.3
```
└──▷ USE IT
Update the renamed merge strategy key in your project config to avoid unknown-field warnings after upgrading.
yaml
```
mergeStrategy: squash
```
- ›Adds --binary-version flag to query the CLI binary version without launching a full session.
- ›Reads MCP server configuration from .devcontainer/devcontainer.json.
- ›Adds extraKnownMarketplaces repository setting to replace marketplace definitions.
- ›Adds /restart command to hot restart the CLI while preserving the current session.
- ›Extends /terminal-setup command with Windows Terminal support.
+12 moreshow less
- ›Documents GH_HOST, HTTP_PROXY, HTTPS_PROXY, NO_COLOR, and NO_PROXY environment variables in help output.
- ›The mergeStrategy config key replaces the former merge_strategy key (renamed for consistency).
- ›Enables alternate screen buffer by default for staff users.
- ›Makes Extensions available as an experimental feature, allowing custom tools and hooks via @github/copilot-sdk.
- ›Type quit to exit the CLI, in addition to the existing exit command.
- ›/reset-allowed-tools now fully undoes /allow-all and re-triggers the autopilot permission dialog.
- ›MCP servers with non-conforming outputSchema are now accessible.
- ›/add-dir directories persist across session changes such as /clear and /resume.
- ›Background task notifications display in the timeline with expandable detail.
- ›Retry status messages display to show progress during server error recovery.
- ›Loading spinner shown in diff mode while fetching changes.
- ›/init suggestion is suppressed when .github/instructions/ already contains instructions.
└──▷ BREAKING ON UPGRADE
- !The merge_strategy config key is renamed to mergeStrategy; existing configs using merge_strategy must be updated.
v1.0.2 Mar 6, 2026 · issue -165

GitHub Copilot CLI v1.0 GA adds cross-platform hook config aliases and interactive form improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.0.2 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v1.0.2
```
└──▷ USE IT
Define a single hook command that runs on any OS without separate bash/powershell entries.
yaml
```
command: echo 'Running hook'
timeout: 30
```
- ›Adds command field in hook configs as a cross-platform alias for bash/powershell, simplifying multi-OS hook definitions.
- ›Adds timeout as an alias for timeoutSec in hook configurations.
- ›Adds exit as a bare command to close the CLI session.
- ›Enum fields in ask_user forms now accept custom (free-text) responses, and the form submits with the Enter key.
v0.0.423 Mar 6, 2026 · issue -165

Copilot CLI v0.0.423 adds dangerous-command guardrails, MCP OAuth URL flows, and EMU/GHE gist blocking.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.423 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.423
```
- ›MCP servers can now request users to visit a URL for out-of-band interactions such as OAuth flows or API key entry.
- ›Blocks /share gist for EMU and GHE Cloud users with a clear error message instead of silently failing.
- ›Prompts users for confirmation before executing shell commands with potentially dangerous expansion or substitution patterns.
- ›Elicitation enum and boolean fields now require Enter to confirm a selection, with a ✓ indicator for confirmed values vs ❯ for the browsing cursor.
- ›Improves explore agent precision and large repository support with better context sharing.
+1 moreshow less
- ›Diff mode renders correctly on Windows with CRLF line endings.
v0.0.422 Mar 5, 2026 · issue -166

GitHub Copilot CLI v0.0.422 adds GPT-5.4, JSON output mode, startup hooks, plugin SSH installs, and session metrics logging.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.422 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.422
```
└──▷ TRY IT
Pipe Copilot CLI output into jq for programmatic processing of responses in CI or scripts.
```
$ gh copilot prompt --output-format json 'Summarize open TODOs in this repo' | jq '.content'
```
Auto-copy selected text to clipboard whenever you highlight it in alt-screen mode — useful for quickly grabbing code snippets.
yaml
```
copy_on_select: true
```
Ensure a standard set of plugins is installed automatically for every session by declaring them in config.
yaml
```
enabledPlugins:
  - my-org/copilot-plugin-terraform
  - ssh://[email protected]/infra/copilot-plugin-k8s
```
- ›Adds --output-format json flag to emit JSONL in prompt mode for programmatic integrations.
- ›Adds copy_on_select config option to auto-copy selected text to clipboard in alt-screen mode.
- ›Adds enabledPlugins config key for automatic plugin installation at startup.
- ›Adds exitPlanMode.request protocol method for SDK plan approval support.
- ›Renames launch_messages config setting to companyAnnouncements — existing configs using launch_messages must be updated.
+12 moreshow less
- ›Renames repository config file from .github/copilot/config.json to settings.json — existing repo-level config files must be moved.
- ›Session usage metrics (requests, tokens, code changes) are now persisted to events.jsonl after each session ends.
- ›Loads personal hooks from ~/.copilot/hooks in addition to repo-level .github/hooks.
- ›Adds /copy command to copy the last response to clipboard.
- ›Adds startup prompt hooks to auto-submit prompts or slash commands when a session starts.
- ›Supports installing plugins from ssh:// URLs.
- ›Adds GPT-5.4 model support.
- ›Plugin-contributed LSP servers are now loaded, started, and shown in /lsp show.
- ›Adds Ctrl+R reverse incremental command history search (matching Bash behavior).
- ›Adds mouse scroll support to /diff in alt-screen mode.
- ›Automatic notifications when background shell commands and agents complete.
- ›/delegate now prompts for a target remote in multi-remote repositories.
└──▷ BREAKING ON UPGRADE
- !The launch_messages config setting is renamed to companyAnnouncements; existing configs using launch_messages will need to be updated.
- !The repository config file is renamed from .github/copilot/config.json to settings.json; existing repo-level config files must be moved to the new path.
v0.0.421 Mar 3, 2026 · issue -168

GitHub Copilot CLI v0.0.421 adds repo-level config, --plugin-dir flag, MCP Elicitations, and COPILOT_CLI=1 env var for Git hooks.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.421 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.421
```
└──▷ TRY IT
Load and test a locally developed plugin without publishing it to a marketplace.
```
$ copilot --plugin-dir ./my-local-plugin
```
Share marketplace sources and launch messages across a team by committing a repo-level config file.
json
```
{
  "marketplaces": ["https://example.com/my-marketplace"],
  "launchMessage": "Welcome to the team repo!"
}
```
- ›Adds --plugin-dir flag to load a plugin from a local directory instead of a marketplace.
- ›Adds COPILOT_CLI=1 environment variable so Git hooks can detect Copilot CLI subprocesses and skip interactive prompts.
- ›Supports repo-level configuration via .github/copilot/config.json for shared project settings such as marketplaces and launch messages.
- ›Reads extraKnownMarketplaces from .claude/settings.json (project-level) for Claude plugin compatibility.
- ›Adds structured form input for the ask_user tool using MCP Elicitations (experimental).
+8 moreshow less
- ›ACP clients can now configure reasoning effort via session config options.
- ›AUTO theme reads the terminal's ANSI color palette directly so colors match the user's terminal theme.
- ›Clickable PR reference displayed next to branch name in the status bar.
- ›Mouse text selection is automatically copied to the Linux primary selection buffer (middle-click to paste).
- ›Links in the terminal are now clickable and open in the default browser.
- ›Markdown tables render with proper column widths, word wrap, and Unicode borders that adapt to terminal width.
- ›Autopilot permission dialog now appears on first prompt submission instead of on mode switch.
- ›Uses consistent ~/.copilot/pkg path for auto-update instead of XDG_STATE_HOME.
v0.0.420 Feb 27, 2026 · issue -171

GitHub Copilot CLI v0.0.420 adds issue/PR/discussion referencing and smarter auto-updates.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.420 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.420
```
- ›Type # in the CLI prompt to reference GitHub issues, pull requests, and discussions as context.
- ›Auto-update now also updates the binary executable, not just the JS package.
- ›Plugin and marketplace git repos update correctly after force-pushes and tag-based installs.
v0.0.419 Feb 27, 2026 · issue -171

GitHub Copilot CLI v0.0.419 adds /chronicle session history command, new keyboard shortcuts, and expanded MCP server support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.419 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.419
```
└──▷ TRY IT
Generate a standup summary from your current session's history at the start of a work day.
```
$ /chronicle standup
```
- ›Adds /chronicle command with standup, tips, and improve subcommands powered by session history (experimental).
- ›Adds --mouse/--no-mouse flag and mouse config key to disable mouse mode in alt-screen views.
- ›Adds Ctrl+F/Ctrl+B as page-down/page-up shortcuts for scrolling in alt-screen views.
- ›Adds Ctrl+G keyboard shortcut for editing prompts in an external editor and dismissing UI elements.
- ›MCP server env vars referenced in command, args, or cwd fields are automatically included in the server environment.
+5 moreshow less
- ›MCP server names now support dots, slashes, and @ characters, enabling npm-style names like @modelcontextprotocol/server and io.github/server.
- ›/mcp enable now works for built-in servers that were previously auto-disabled before configuration.
- ›Home and End keys now jump to the top and bottom of the alt-screen scroll buffer.
- ›AUTO theme now uses the terminal's actual ANSI color palette for more accurate colors across terminal themes.
- ›/diagnose shows a helpful message when no session has been started yet.
v0.0.417 Feb 25, 2026 · issue -173

GitHub Copilot CLI v0.0.417 adds a /research command for deep research with exportable reports.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.417 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.417
```
└──▷ TRY IT
Run a deep research query and export the results as a report.
```
$ /research How do supply-chain attacks target npm packages?
```
- ›Adds /research command for deep research with exportable reports.
- ›Plugin skills and commands now load from custom paths declared in plugin.json.
- ›Plugin agents and skills are available immediately after install without restarting.
v0.0.416 Feb 24, 2026 · issue -174

Copilot CLI v0.0.416 enforces MCP server policy, improves narrow-terminal status layout, and expands --help content.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.416 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.416
```
└──▷ TRY IT
Discover all available flags and examples for a subcommand after the expanded --help content lands.
```
$ gh copilot suggest --help
```
- ›Enforces the Copilot MCP policy by blocking third-party MCP servers when the policy does not permit them.
- ›Expands --help output with descriptions, examples, and sorted flags.
- ›Status line automatically switches to a two-line layout on narrow terminals, keeping CWD, branch, and model info readable at any terminal width.
- ›Streaming response size counter now updates continuously during tool calls and reasoning, and resets between requests.
- ›Undo operations now always require confirmation before proceeding.
└──▷ BREAKING ON UPGRADE
- !Undo operations now always require confirmation — previously unconfirmed undo flows will pause for input.
v0.0.415 Feb 23, 2026 · issue -175

GitHub Copilot CLI v0.0.415 adds model field for custom agents, show_file tool, and overhauled /mcp show grouping
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.415 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.415
```
└──▷ TRY IT
Install a locally developed plugin whose directory path includes spaces, without renaming the directory.
```
$ /plugin install "/Users/analyst/My Plugins/vuln-scanner"
```
- ›Adds model field to custom agent configuration, letting practitioners specify which model powers a given agent.
- ›Adds show_file tool for presenting code and diffs to the user inline during a session.
- ›Adds /plugin marketplace add and /plugin install support for local paths that contain spaces.
- ›Upgrades /mcp show to group servers into User, Workspace, Plugins, and Built-in sections with full keyboard navigation.
- ›Plan approval menu now surfaces model-curated actions with a recommended option highlighted first, including autopilot+fleet for parallelizable work.
+3 moreshow less
- ›Adds env loading indicator displaying skills, MCPs, plugins, and other resources being loaded at startup.
- ›Agent now self-reports which model is powering it when asked during a session.
- ›Adds Ctrl+A/E to cycle through visual lines in wrapped input, Home/End to navigate within a visual line, and Ctrl+Home/End to jump to text boundaries.
v0.0.413 Feb 20, 2026 · issue -178

GitHub Copilot CLI v0.0.413 adds remote plugin sources, configurable status line, and alt-screen mode on by default under --experimental
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.413 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.413
```
└──▷ USE IT
Reference a remote plugin from a GitHub repo in your marketplace.json so the plugin is fetched automatically without local installation.
json
```
{
  "plugins": [
    {
      "name": "my-remote-plugin",
      "source": "https://github.com/my-org/my-copilot-plugin"
    }
  ]
}
```
- ›Enables alt-screen mode by default when running with the --experimental flag.
- ›Adds configurable status line support to display dynamic session information via custom shell scripts.
- ›Supports remote plugin sources (GitHub repos and git URLs) in marketplace.json plugin entries.
- ›Adds ctrl+insert keybinding to copy selected text in the alt-screen view.
- ›Renders session info in the main view footer in alt-screen mode.
+4 moreshow less
- ›Displays heading content from reasoning for GPT models.
- ›Increases LSP request timeout from 30s to 90s.
- ›Improves code search speed in large repos.
- ›Skill files with YAML array syntax for allowed-tools now load correctly.
v0.0.412 Feb 19, 2026 · issue -179

GitHub Copilot CLI v0.0.412 adds /mcp reload, /update, exit_plan_mode, cross-session memory, --bash-env, and more.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.412 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.412
```
└──▷ TRY IT
Reload updated MCP server configuration mid-session without restarting Copilot CLI.
```
$ /mcp reload
```
- ›Adds --bash-env flag to source BASH_ENV in shell sessions.
- ›Adds disable-model-invocation frontmatter field for skills to control model invocation.
- ›Adds Configure LSP server request timeouts in lsp.json.
- ›Adds /mcp reload command to reload MCP configuration without restarting.
- ›Adds /update command to view changelog and update instructions.
+18 moreshow less
- ›Adds exit_plan_mode tool with a plan approval dialog for reviewing and accepting plans.
- ›Supports ~/.copilot/instructions/*.instructions.md files for user-level instructions applied across all repositories.
- ›Allows /reset-allowed-tools to run during active agent execution.
- ›Adds cross-session memory (experimental): query past work, files, and PRs across sessions.
- ›Command files no longer require YAML frontmatter — plain Markdown files now derive name and description automatically.
- ›Adds ctrl+y keybinding to edit the current plan in a terminal editor.
- ›Adds ctrl+x ctrl+e keybinding to edit the prompt in a preferred terminal editor.
- ›Extends terminal editor support to Windows.
- ›Hides custom agents with user-invocable: false set from the /agents picker.
- ›Config file syntax errors now surface a warning instead of silently crashing.
- ›Adds double-click word and triple-click line selection in alt-screen text selection.
- ›/fleet mode dispatches more subagents in parallel for faster execution, with orchestrator validation of subagent work.
- ›Instructions and skills pickers open as full-screen alt-screen views when alt-screen mode is enabled.
- ›Session picker opens instantly without a loading flash when multiple sessions exist.
- ›Shows a warning in the timeline when skills fail to load at startup, with a prompt to run /skills for details.
- ›/clear now preserves the current agent mode (autopilot, plan, or interactive).
- ›MCP error messages now include the server name for easier diagnosis.
- ›MCP servers with invalid tool schemas no longer silently drop all tools.
v0.0.411 Feb 17, 2026 · issue -181

Copilot CLI v0.0.411 adds Claude Sonnet 4.6, --alt-screen syntax, include_coauthor config, MCP Windows Registry support, and SDK APIs for plan/autopilot/fleet.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.411 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.411
```
└──▷ USE IT
Suppress the Co-authored-by trailer in commits made by Copilot — useful when your org policy disallows it or you want cleaner git history.
yaml
```
include_coauthor: false
```
- ›Adds --alt-screen on and --alt-screen off flag syntax to explicitly control alt-screen mode.
- ›Adds include_coauthor config option to disable the Co-authored-by trailer in git commits.
- ›Adds SDK APIs for plan mode, autopilot, fleet, and workspace files.
- ›Supports MCP servers sourced from the Windows On-Device Registry.
- ›Adds support for the Claude Sonnet 4.6 model.
+3 moreshow less
- ›Custom agents now use disable-model-invocation instead of infer (backward compatible).
- ›Autopilot mode and /fleet command are now available to all users.
- ›Memory storage timeline now shows subject, fact, and citations.
v0.0.410 Feb 14, 2026 · issue -184

GitHub Copilot CLI v0.0.410 adds /init suppress, repo-level validation tool controls, ACP session loading, and new keyboard/shell ergonomics.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.410 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.410
```
└──▷ TRY IT
Silence per-repo init suggestions after the feature is noisy in a monorepo.
```
$ /init suppress
```
- ›Adds /init suppress subcommand to control init suggestions on a per-repository basis.
- ›Adds repo-level settings to disable individual validation tools.
- ›Extends skill name validation to support underscores, dots, and spaces; makes name and description optional in skill frontmatter with sensible fallbacks.
- ›Supports tilde (~) expansion in MCP server cwd configuration.
- ›ACP server now supports loading existing sessions.
+9 moreshow less
- ›Adds Ctrl+Z suspend/resume support on Unix platforms.
- ›Adds Ctrl+D to exit the CLI on an empty prompt.
- ›Adds Ctrl+N and Ctrl+P as arrow-key alternatives in the input prompt.
- ›Shell mode is now accessed only via ! and is removed from the Shift+Tab cycle.
- ›Shift+Enter inserts newlines in terminals that support the kitty keyboard protocol.
- ›Adds Page Up / Page Down keyboard scrolling in alt-screen mode.
- ›MCP server errors and loading issues now surface in the timeline.
- ›Shows IDE file-selection indicator in the status bar when connected to an IDE.
- ›Appends a Copilot co-authored-by trailer to git commits created by the tool.
v0.0.409 Feb 12, 2026 · issue -186

GitHub Copilot CLI v0.0.409 adds VS Code integration, a quick-help overlay, scrollable diffs, and default plugin marketplaces.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.409 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.409
```
- ›Adds list_copilot_spaces tool to the default GitHub MCP config, exposing Copilot Spaces discovery out of the box.
- ›New quick-help overlay: press ? to display grouped shortcuts and commands, navigable with arrow keys.
- ›Includes default plugin marketplaces (copilot-plugins, awesome-copilot) for easier plugin discovery.
- ›/diff now runs in full-screen alt-screen mode.
- ›Permission prompts with long diffs are scrollable in alt-screen mode.
+2 moreshow less
- ›Theme preview appears above the theme list in screen-reader mode.
- ›Subagents now return complete responses.
v0.0.408 Feb 12, 2026 · issue -186

GitHub Copilot CLI v0.0.408 adds /streamer-mode, mouse text selection in --alt-screen, and substring matching in slash command autocomplete.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.408 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.408
```
└──▷ TRY IT
Hide model names and quota details when screen-sharing or recording a demo.
```
$ /streamer-mode
```
- ›Adds /streamer-mode slash command to hide preview model names and quota details during streaming sessions.
- ›Adds mouse text selection support in --alt-screen mode.
- ›MCP servers now respect the cwd working directory property.
- ›Adds substring matching to slash command autocomplete, making commands easier to find without exact-prefix input.
- ›Changes the run command keyboard shortcut from ctrl+p to ctrl+s.
└──▷ BREAKING ON UPGRADE
- !The run command shortcut has changed from ctrl+p to ctrl+s; muscle memory or documented workflows using ctrl+p to run commands will no longer work.
v0.0.407 Feb 11, 2026 · issue -187

GitHub Copilot CLI v0.0.407 adds /on-air mode, --alt-screen, --resume with UUID, /instructions, workspace-local MCP via .vscode/mcp.json, and a tools.list RPC.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.407 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.407
```
└──▷ USE IT
Configure workspace-local MCP servers so the project's agent tooling is checked in alongside the code.
json
```
{
  "servers": {
    "my-mcp-server": {
      "command": "npx",
      "args": ["my-mcp-package"]
    }
  }
}
```
- ›Adds --alt-screen flag to enable experimental alternate screen buffer mode.
- ›Adds --resume flag that creates new sessions with a provided UUID.
- ›Adds workspace-local MCP server configuration via .vscode/mcp.json.
- ›Adds tools.list RPC to query all available built-in tools at runtime.
- ›Adds /on-air mode to hide model names and quota details during streaming sessions.
+18 moreshow less
- ›Adds /instructions command to view and toggle custom instruction files.
- ›Adds Ctrl+P shortcut to run slash commands while preserving current input (replaces Ctrl+X → /).
- ›Remaps Ctrl+d to delete the character after the cursor; queuing is moved to Ctrl+q (or Ctrl+Enter).
- ›Adds Tab / Shift+Tab to cycle modes forward and backward, with shell now treated as a mode.
- ›Exposes session context in session.list SDK response.
- ›Adds live preview of diffs and markdown in the theme picker, plus colorblind and tritanopia theme variants.
- ›Adds an option to permanently approve tool permissions for a specific location.
- ›Adds agent type and description display in read_agent timeline entries.
- ›Windows slash flags (e.g., dir /B) are no longer misidentified as file paths.
- ›MCP servers using Microsoft OAuth now configure automatically without manual client ID setup.
- ›/tasks shows Recent Activity for background agents.
- ›Quota exceeded errors now link directly to Copilot settings with actionable guidance.
- ›Subagents fall back to the session model when the default model is blocked by policy.
- ›Streaming responses automatically retry when interrupted by server errors.
- ›Skill changes from /skills commands take effect immediately without restarting.
- ›Ctrl+b and Ctrl+f cursor movement are now available on all platforms.
- ›Terminal title works on all TTY terminals.
- ›Autopilot mode now works with custom agents that specify explicit tools.
└──▷ BREAKING ON UPGRADE
- !Ctrl+d no longer queues exit — queueing is moved to Ctrl+q (or Ctrl+Enter); Ctrl+d now deletes the character after the cursor.
v0.0.406 Feb 7, 2026 · issue -191

GitHub Copilot CLI v0.0.406 adds Claude Opus 4.6 Fast, a /changelog command, --no-experimental flag, and richer MCP tool support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.406 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.406
```
└──▷ TRY IT
Check which MCP tools are currently enabled or disabled without leaving the CLI.
```
$ /mcp show
```
Add a third-party plugin directly from a URL via the plugin marketplace.
```
$ gh copilot plugin marketplace add https://example.com/my-copilot-plugin
```
- ›New --no-experimental flag disables all experimental features at invocation time.
- ›New /changelog command lets users view release notes directly from the CLI.
- ›New /mcp show command displays enabled/disabled status for MCP tools.
- ›MCP tool responses now include structured content (images, resources) for richer UI display in VS Code.
- ›plugin marketplace add now accepts URLs as sources when adding plugins.
+4 moreshow less
- ›Commands from plugins are now translated into skills, expanding the skill surface automatically.
- ›Adds support for Claude Opus 4.6 Fast (Preview) as an available model.
- ›Markdown formatting now renders in non-interactive mode output.
- ›Displays a warning when the authenticated user has no Copilot subscription.
v0.0.405 Feb 5, 2026 · issue -193

GitHub Copilot CLI v0.0.405 adds /experimental help screen and uppercase support for plugin and marketplace names.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.405 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.405
```
- ›Adds /experimental command that displays a help screen listing all available experimental features.
- ›Plugins can now bundle LSP server configurations.
- ›Plugin and marketplace names now support uppercase letters.
v0.0.404 Feb 5, 2026 · issue -193

GitHub Copilot CLI v0.0.404 adds claude-opus-4.6 support, /tasks command, background agents for all users, and GITHUB_TOKEN in agent shells.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.404 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.404
```
└──▷ TRY IT
Check on long-running background tasks dispatched during a Copilot session.
```
$ /tasks
```
- ›Adds GITHUB_TOKEN environment variable access inside agent shell sessions.
- ›Adds /tasks command to view and manage background tasks.
- ›Adds support for the claude-opus-4.6 model.
- ›MCP server configurations now default to all tools when the tools parameter is not specified.
- ›/allow-all and /yolo now execute immediately without an additional confirmation step.
+3 moreshow less
- ›Cancelling the --resume session picker now starts a new session instead of exiting.
- ›Enables background agents for all users.
- ›MCP servers now shut down concurrently, improving exit performance.
v0.0.403 Feb 5, 2026 · issue -193

GitHub Copilot CLI v0.0.403 adds ACP model usage/enablement info, comma-separated tools in agent frontmatter, and reasoning summaries on by default.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.403 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.403
```
- ›ACP model info now includes usage multiplier and enablement status.
- ›Supports comma-separated tools in custom agent frontmatter.
- ›Reasoning summaries are enabled by default for supporting models.
- ›Skills with unknown frontmatter fields now load with warnings instead of being silently skipped.
- ›Config files preserve custom fields when the CLI updates them.
v0.0.402 Feb 3, 2026 · issue -195

GitHub Copilot CLI v0.0.402 adds ACP agent/plan session modes, MCP-to-ACP config bridging, and plugin lifecycle hooks.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.402 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.402
```
- ›ACP server now supports agent and plan session modes.
- ›MCP configuration now applies to ACP mode, bridging existing MCP setups into ACP workflows.
- ›Plugins can now provide hooks for session lifecycle events.
- ›Plugin update command now works for direct plugins and handles Windows file locks.
- ›Custom agents with unknown fields now load with warnings instead of errors, improving forward compatibility.
+1 moreshow less
- ›Custom agents receive environment context when run as subagents.
v0.0.401 Feb 3, 2026 · issue -195

GitHub Copilot CLI v0.0.401 adds copilot login, agent lifecycle hooks, .agents/skills auto-loading, and Claude-style MCP config support.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.401 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.401
```
└──▷ TRY IT
Authenticate with GitHub Copilot from the terminal using the new login subcommand.
```
$ copilot login
```
- ›Adds copilot login subcommand with ACP terminal-auth support for authenticating from the CLI.
- ›Adds agentStop and subagentStop hooks to control agent completion lifecycle.
- ›Supports .agents/skills directory for auto-loading skills without manual registration.
- ›Supports Claude-style .mcp.json format without a mcpServers wrapper, broadening MCP config compatibility.
- ›MCP tools returning structuredContent now display correctly in the CLI.
+2 moreshow less
- ›Adds shift+enter keybinding for inserting new lines in the VS Code integrated terminal.
- ›/diff displays accurate line numbers with a dual-column layout.
v0.0.400 Jan 30, 2026 · issue -199

GitHub Copilot CLI v0.0.400 adds autopilot mode, MCP server lifecycle management, a /theme command, and a copilot plugin subcommand.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.400 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.400
```
└──▷ TRY IT
Switch the terminal UI to a GitHub-branded theme interactively during a session.
```
$ /theme
```
Configure a startup announcement shown to all users when the ACP server starts.
yaml
```
launch_messages:
  - 'Welcome to Copilot CLI. Remember to review AI suggestions before applying.'
```
- ›Adds copilot plugin subcommand for non-interactive plugin management from the CLI.
- ›Adds /theme command with GitHub Dark and Light theme options via a theme picker.
- ›Adds launch_messages config key for configuring startup announcements.
- ›ACP server now supports permission flags: --yolo, --allow-all, and related permissions config.
- ›CLI sends DELETE requests to remove MCP servers on shutdown, enabling clean MCP server lifecycle management.
+11 moreshow less
- ›Adds MCP server instructions support.
- ›Adds autopilot mode for autonomous task completion (experimental).
- ›ACP server supports changing models during a session.
- ›Adds fuzzy search to the model picker.
- ›Code Review tool handles large changesets by ignoring build artifacts and limiting to 100 files.
- ›Timeline displays user responses to ask_user tool prompts with the username.
- ›Improves compatibility with remote MCP servers that use OAuth.
- ›Diff mode file list uses carousel navigation, showing up to 5 files at a time.
- ›Adds support for UNIX keyboard bindings (Ctrl+A/E/W/U/K, Alt+arrows) and multiline content in text inputs.
- ›Ordered lists now display with numbers instead of dashes, and Markdown table headers display in bold.
- ›Shows a progress indicator in the terminal tab when the model is thinking.
└──▷ BREAKING ON UPGRADE
- !Bundled LSP servers (TypeScript, Python) have been removed.
v0.0.399 Jan 29, 2026 · issue -200

GitHub Copilot CLI v0.0.399 adds /allow-all, /yolo, /diff, and .claude/commands/ single-file command support alongside AI-named sessions.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.399 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.399
```
└──▷ TRY IT
Quickly approve all permission prompts for an entire session without repeated confirmations — useful when running trusted, wide-ranging automation.
```
$ /allow-all
```
Drop a single Markdown file into .claude/commands/ to expose a lightweight slash command without building a full skill.
```
$ echo '# summarize\nSummarize the current diff in one paragraph.' > .claude/commands/summarize.md
```
Inspect all file changes made during the current session before committing.
```
$ /diff
```
- ›Adds /allow-all and /yolo slash commands to auto-approve all permissions for the duration of a session.
- ›Supports .claude/commands/ single-file commands as a simpler alternative to skills.
- ›Adds /diff command to review session changes with visual indicators and scroll acceleration.
- ›Adds Ctrl+X then / keyboard shortcut to invoke slash commands without losing current input.
- ›Extends /usage to include token consumption from sub-agents (e.g., the general-purpose agent).
+5 moreshow less
- ›Adds double-Esc to undo/rewind to previous session states.
- ›Adds LSP (Language Server Protocol) tool for code intelligence (requires staff flag).
- ›Sessions now receive AI-generated names derived from the first message.
- ›Adds Copilot option in the agent creation wizard to auto-generate agent name, description, and instructions from an initial description.
- ›Skills remain effective after conversation history is compacted.
v0.0.398 Jan 28, 2026 · issue -201

GitHub Copilot CLI v0.0.398 adds middle-truncation for narrow terminal headers and cross-directory skill invocation.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.398 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.398
```
- ›Skills defined in parent directories are now invocable from subdirectories, and skill resolution works in non-git directories.
- ›CLI header now uses middle-truncation for long paths in narrow terminals, preserving the first and last folders for readability.
v0.0.397 Jan 28, 2026 · issue -201

GitHub Copilot CLI v0.0.397 adds MCP server inspection, --acp Agent Client Protocol flag, and directory @mention autocomplete.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.397 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.397
```
└──▷ TRY IT
Inspect an MCP server's details and the tools it exposes before invoking them in a session.
```
$ /mcp show <server-name>
```
Start Copilot CLI as an Agent Client Protocol server so an external agent or orchestrator can connect to it programmatically.
```
$ gh copilot --acp
```
- ›Adds /mcp show <server-name> subcommand to display MCP server details and available tools.
- ›Adds --acp flag to start the CLI as an Agent Client Protocol server.
- ›Directories now appear in @mention autocomplete for referencing paths inline.
- ›Content pasted into the prompt over 30 KB is automatically saved to workspace files.
v0.0.396 Jan 27, 2026 · issue -202

GitHub Copilot CLI v0.0.396 adds copilot version, copilot update, /init, /experimental, and preToolUse hook argument control.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.396 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.396
```
└──▷ TRY IT
Keep the Copilot CLI up to date without leaving the terminal.
```
$ copilot update
```
Install a community plugin directly from a GitHub repo to extend Copilot with custom agents or tools.
```
$ /plugin install github.com/example-org/copilot-plugin
```
Bootstrap Copilot instructions for a new repository so Copilot understands project conventions from the start.
```
$ /init
```
- ›Adds copilot version and copilot update commands for version inspection and self-updating from the CLI.
- ›Adds /experimental command and --experimental flag to opt into experimental features.
- ›Adds /init command to generate Copilot instructions for a project.
- ›Adds preToolUse hooks that can now deny tool execution and modify arguments before a tool runs.
- ›Extends /plugin install to support GitHub repos, URLs, and local paths as install sources.
+7 moreshow less
- ›Extends tool filtering flags to apply to subagents, not just top-level tool calls.
- ›Adds interactive CLI wizard for creating custom agents.
- ›Enables plugins to provide custom agents.
- ›Allows skill names to include uppercase letters.
- ›Adds Ctrl+E keybinding to move the cursor to end of line while typing without expanding the timeline.
- ›Extends /skills add to work with directories that contain SKILL.md directly.
- ›Makes /diff show changes from the entire repository when run from a subdirectory.
v0.0.395 Jan 26, 2026 · issue -203

GitHub Copilot CLI v0.0.395 adds /mcp show server visibility, plugin skill execution, and line-specific /diff commenting.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.395 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.395
```
- ›Adds /mcp show command to display all configured MCP servers, including defaults, servers from additional configuration, and servers from installed plugins.
- ›Adds commenting to /diff mode for line-specific feedback.
- ›Plugin skills are now usable by the agent in sessions.
- ›Loads local shell configuration in agent sessions.
- ›Completed tool calls now display in prompt mode.
v0.0.394 Jan 24, 2026 · issue -205

GitHub Copilot CLI v0.0.394 adds GitHub Enterprise Cloud support, infinite SDK sessions, and new session-search and slash-command queuing shortcuts.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.394 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.394
```
└──▷ TRY IT
Resume a previous session quickly by searching session history by name instead of scrolling.
```
$ /resume
# then press / to filter sessions by keyword
```
- ›Adds GitHub Enterprise Cloud (*.ghe.com) support to the /delegate command.
- ›The /delegate command now accepts an optional prompt and uses conversation context when invoked.
- ›Queue slash commands alongside messages using Ctrl+D.
- ›Press / to search sessions inside /resume.
- ›SDK supports infinite sessions with automatic context compaction.
+2 moreshow less
- ›Deduplicates identical model instruction files to save context window space.
- ›Git status now updates on-demand instead of polling every 15 seconds, reducing background overhead.
v0.0.393 Jan 23, 2026 · issue -206

GitHub Copilot CLI v0.0.393 adds GHE Cloud remote agents, MCP tool names in events, and Esc-Esc snapshot undo
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.393 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.393
```
- ›Exposes MCP server and tool names in tool.execution_start events for improved error handling and observability.
- ›Adds Esc-Esc keybinding to undo file changes back to any previous snapshot.
- ›Adds support for GHE Cloud (*.ghe.com) remote custom agents.
- ›Shows conversation compaction status as timeline messages instead of a header indicator.
v0.0.392 Jan 22, 2026 · issue -207

GitHub Copilot CLI v0.0.392 adds a /plugin marketplace command, /rename session alias, and inline diff display.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.392 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.392
```
- ›Adds /plugin command for plugin marketplace management.
- ›Adds /plugin update subcommand to update installed plugins.
- ›Adds /rename command as an alias for /session rename.
- ›Edit tool now displays diffs when expanded in the timeline.
v0.0.389 Jan 22, 2026 · issue -207

GitHub Copilot CLI v0.0.389 adds OAuth 2.0 MCP auth, /diff and /models commands, MSI installer, and parallel shell execution.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.389 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.389
```
└──▷ TRY IT
Review every file change the agent has made in the current session before committing or discarding them.
```
$ /diff
```
- ›Adds /diff command to review all changes made during the current session.
- ›Adds /models as an alias for the existing /model command.
- ›Adds MSI installer for Windows, providing a native installation path alongside the npm package.
- ›MCP servers can now authenticate using OAuth 2.0 with automatic token management and refresh.
- ›Supports invoking skills using slash commands in the form /skill-name.
+5 moreshow less
- ›Shell commands (!) can now run in parallel while the agent is actively working.
- ›Plugins can bundle MCP servers that load automatically when the plugin is installed.
- ›Removes the Node version requirement from the npm package.
- ›Displays progress messages from MCP tools inline in the session timeline.
- ›Messages sent during /compact are automatically queued rather than dropped.
v0.0.388 Jan 20, 2026 · issue -209

GitHub Copilot CLI v0.0.388 adds a /review command and expands --enable-all-github-mcp-tools to read-write MCP tools.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.388 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.388
```
└──▷ TRY IT
Enable read-write GitHub MCP tools to allow Copilot to perform write operations on your behalf.
```
$ gh copilot --enable-all-github-mcp-tools
```
- ›Adds /review command to analyze code changes directly in the CLI.
- ›The --enable-all-github-mcp-tools flag now enables read-write GitHub MCP tools, expanding beyond the previous read-only scope.
- ›Redesigns the CLI header with a branded mascot and streamlined welcome message.
- ›Session event messages are now more concise and visually clean.
- ›/share gist now shows a helpful error message when used on GitHub Enterprise Cloud with data residency.
v0.0.387 Jan 20, 2026 · issue -209

GitHub Copilot CLI v0.0.387 adds interactive clarification, plan mode, and large-directory support
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.387 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.387
```
- ›Adds ask_user tool for interactive clarification questions during sessions
- ›Adds plan mode with a dedicated panel for viewing implementation plans
- ›Skill tool now handles large directories without exceeding context limits
v0.0.385 Jan 19, 2026 · issue -210

GitHub Copilot CLI v0.0.385 adds infinite sessions via compaction checkpoints, MCP server management with /agent, and combined custom instruction files.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.385 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.385
```
- ›Enables infinite sessions with automatic long-running context management through compaction checkpoints.
- ›Adds MCP server management when swapping between custom agents with /agent.
- ›Combines all custom instruction files instead of using priority-based fallbacks.
- ›Adds Escape key to cancel a manual /compact command.
- ›Displays current intent in the terminal tab title.
+1 moreshow less
- ›Limits store_memory tool inclusion to sessions where memory is enabled for the user.
v0.0.384 Jan 16, 2026 · issue -213

GitHub Copilot CLI v0.0.384 adds background delegation, /cd alias, extended thinking, cross-session memory, and proxy improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.384 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.384
```
└──▷ TRY IT
Delegate a long-running task to run in the background without blocking your current session.
```
$ & summarize all open pull requests and save the results to pr-summary.md
```
Switch working directory using the new shorthand alias instead of /cwd.
```
$ /cd ~/projects/my-repo
```
- ›Adds & prefix shortcut to delegate prompts to run in the background, equivalent to the existing /delegate command.
- ›Adds /cd as an alias for the /cwd command.
- ›Enables extended thinking for Anthropic Claude models.
- ›Injects repo memories into the prompt and adds a memory storage tool to remember facts across sessions.
- ›Allows users to configure reasoning effort for GPT models.
+9 moreshow less
- ›Files created by the CLI are now available for @-mention.
- ›Supports proxy URLs without a scheme (e.g., localhost:9999).
- ›Tab completion now cycles based on the typed prefix rather than the completed text.
- ›Selecting 'approve for session' now auto-approves pending parallel permission requests of the same type.
- ›Reasoning view setting persists across sessions.
- ›Custom agent discovery now follows symbolic links to agent definition files.
- ›MCP servers now start correctly for custom agents.
- ›Shell commands now display error output when they fail.
- ›Screen reader mode shows static text instead of animated spinners during login.
v0.0.381 Jan 13, 2026 · issue -216

GitHub Copilot CLI v0.0.381 adds --allow-all/--yolo permission flags, /new alias, and prefix-filtered shell history navigation.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.381 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.381
```
└──▷ TRY IT
Grant all tool permissions in one shot when you trust the session and want to skip per-permission prompts.
```
$ gh copilot suggest --allow-all 'set up a new node project with eslint'
```
- ›Adds --allow-all and --yolo flags to enable all permissions at once without individual prompts.
- ›Adds /new as an alias for the /clear command in chat.
- ›Shell mode history navigation now filters by prefix — typing a partial command like !git and pressing up arrow cycles only through matching previous commands.
v0.0.380 Jan 13, 2026 · issue -216

GitHub Copilot CLI v0.0.380 adds interactive --agent mode, sub-agent abort propagation, large-file reads, and mid-thinking message queuing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.380 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.380
```
- ›The --agent flag now works in interactive mode, enabling agent-driven workflows without leaving the interactive shell.
- ›Allows reading files larger than 10 MB when the view_range parameter is specified in the view tool.
- ›Supports sending messages while Copilot is thinking, allowing users to steer the response or queue follow-up prompts.
- ›Adds custom agent tool aliasing for the task tool.
- ›Auto-compaction now runs in the background without blocking the conversation.
+3 moreshow less
- ›Inline feedback is provided when rejecting tool permission requests so agents can continue without halting on denied permissions.
- ›Large output hints now suggest appropriate tools for different content types, including JSON.
- ›The web-fetch tool now rejects file:// URLs and redirects users to the view tool instead.
v0.0.376 Jan 8, 2026 · issue -221

GitHub Copilot CLI v0.0.376 adds GraphQL ID session loading, image processing in task tool subagents, and disk-offloaded large tool outputs.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.376 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.376
```
- ›Enables loading remote sessions by GraphQL ID or via a session picker.
- ›Task tool subagents can now process images.
- ›Large tool outputs are written to disk and models are directed toward efficient search tools to handle them.
v0.0.375 Jan 7, 2026 · issue -222

GitHub Copilot CLI v0.0.375 adds Ctrl+T reasoning toggle and --share/--share-gist flags for session sharing
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.375 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.375
```
└──▷ TRY IT
Share a Copilot CLI session as a Gist from a CI pipeline or non-interactive script.
```
$ gh copilot suggest --share-gist 'Write a bash script to rotate AWS credentials'
```
- ›Adds --share and --share-gist flags for session sharing in non-interactive mode.
- ›Adds Ctrl+T keyboard shortcut to toggle reasoning summaries for supported models.
- ›SVG files are now treated as text files instead of binary images, enabling them to be read and edited as source.
v0.0.374 Jan 2, 2026 · issue -227

GitHub Copilot CLI v0.0.374 adds auto-compaction, a /compact command, built-in subagents, and a web_fetch tool.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.374 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.374
```
└──▷ TRY IT
Manually compact a long conversation context before hitting the token ceiling, preserving session continuity.
```
$ /compact
```
- ›Adds /compact command to manually compact the conversation context.
- ›Adds web_fetch built-in tool for fetching web content directly within a session.
- ›Introduces auto-compaction that triggers automatically at 95% of the token limit to keep sessions alive.
- ›Introduces built-in subagents for exploring and managing tasks.
v0.0.373 Dec 30, 2025 · issue -230

GitHub Copilot CLI v0.0.373 adds tab completion for path arguments and enables Copilot Spaces tools in GitHub MCP Server.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.373 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.373
```
- ›Adds tab completion for path arguments in slash commands like /cwd and /add-dir.
- ›Enables Copilot Spaces tools in GitHub MCP Server.
- ›Device code authorization polling now begins immediately instead of waiting for clipboard and browser to open.
- ›GitHub URL resolution now works correctly for GHE (GitHub Enterprise) environments.
- ›Kill command filtering now correctly allows commands where 'kill' appears as an argument rather than a command name.
v0.0.372 Dec 19, 2025 · issue -241

GitHub Copilot CLI v0.0.372 adds /context token usage, --resume for remote sessions, and URL permission controls.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.372 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.372
```
└──▷ TRY IT
Check how much of your context window is consumed before sending a large prompt.
```
$ /context
```
- ›Adds /context command to visualize token usage in the current session.
- ›Adds --resume flag to continue remote sessions locally.
- ›Adds URL permission controls affecting common shell commands that access the web.
- ›Enables disabled models directly in the CLI when selecting or specifying them.
v0.0.370 Dec 18, 2025 · issue -242

GitHub Copilot CLI v0.0.370 adds --available-tools and --excluded-tools flags, STDIO MCP server type, and SHA256 checksum publishing.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.370 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.370
```
- ›Adds --available-tools and --excluded-tools CLI flags to filter which tools the model can use during a session.
- ›Adds STDIO as a synonymous type for Local when configuring MCP servers in the CLI configuration UI.
- ›Publishes SHA256 checksums for CLI executables alongside each release.
- ›Diff display now uses your configured git pager (e.g. delta, diff-so-fancy) instead of the default pager.
- ›Loads CA certificates from system stores and environment variables, enabling use in corporate/proxy environments.
+4 moreshow less
- ›Improves /model error messages to show which models are available and which are unavailable.
- ›Model picker adopts a two-column layout with aligned multipliers and clearer visual indicators.
- ›Log levels now output all messages at the specified level and higher severity.
- ›Uses the platform-specific executable from npm install when available.
v0.0.363 Nov 24, 2025 · issue -266

GitHub Copilot CLI v0.0.363 adds three new models, GITHUB_ASKPASS auth support, and MCP servers in --prompt mode.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.363 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.363
```
- ›Adds GITHUB_ASKPASS environment variable support for non-interactive authentication flows.
- ›Enables MCP servers to work in --prompt mode.
- ›Adds Opus 4.5, GPT-4.1, and GPT-5-Mini as available models in GitHub Copilot CLI.
- ›Image data paste now prioritizes pasting the contents of image files instead of their file icons.
v0.0.362 Nov 20, 2025 · issue -270

GitHub Copilot CLI v0.0.362 adds clipboard image paste and removes shell commands from Bash/PowerShell history
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.362 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.362
```
- ›Shell commands entered in the CLI are no longer written to Bash and PowerShell history files, preventing sensitive prompts from persisting in shell history.
- ›Paste image data directly from the clipboard into the CLI without saving to disk first.
v0.0.359 Nov 17, 2025 · issue -273

GitHub Copilot CLI v0.0.359 adds /share command, image context via drag-and-drop, and USE_BUILTIN_RIPGREP env var.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.359 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.359
```
└──▷ TRY IT
Save the current session to a GitHub Gist for sharing with a teammate after an investigation.
```
$ /share
```
- ›Adds USE_BUILTIN_RIPGREP environment variable to optionally use ripgrep from PATH instead of the bundled binary.
- ›Adds /share command to save the current session as a markdown file or GitHub Gist.
- ›Supports adding images to context via drag-and-drop or by pasting paths to image files.
- ›copilot -p no longer interactively prompts for permission requests.
└──▷ BREAKING ON UPGRADE
- !copilot -p no longer interactively prompts for permission requests — scripts or workflows relying on that interactive prompt will behave differently after upgrade.
v0.0.356 Nov 13, 2025 · issue -277

GitHub Copilot CLI v0.0.356 adds GPT-5.1, GPT-5.1-Codex, and GPT-5.1-Codex-Mini model options.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.356 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.356
```
- ›Adds GPT-5.1, GPT-5.1-Codex, and GPT-5.1-Codex-Mini as available models in GitHub Copilot CLI (public preview).
v0.0.355 Nov 12, 2025 · issue -278

GitHub Copilot CLI v0.0.355 bundles ripgrep with new grep and glob tools and enhances /session output and self-help via /help.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.355 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.355
```
- ›Adds grep and glob tools backed by bundled ripgrep for faster codebase searching.
- ›Enables the CLI agent to read its own /help and README to answer questions about its own capabilities.
- ›Adds more detail and improved styling to the /session command's output.
- ›Improves parsing of VSCode-formatted custom agents using the .agent.md suffix.
v0.0.354 Nov 3, 2025 · issue -287

GitHub Copilot CLI v0.0.354 adds COPILOT_GITHUB_TOKEN auth, MCP tool notifications, and Actions workspace auto-config.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.354 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.354
```
└──▷ TRY IT
Authenticate Copilot CLI in a CI pipeline using a dedicated token instead of the general-purpose GH_TOKEN.
```
$ COPILOT_GITHUB_TOKEN=${{ secrets.COPILOT_TOKEN }} gh copilot suggest -p 'write a bash script to archive logs older than 30 days'
```
- ›Adds COPILOT_GITHUB_TOKEN environment variable for authentication, taking precedence over GH_TOKEN.
- ›Supports MCP server tool notifications.
- ›MCP servers running in GitHub Actions environments automatically use GITHUB_WORKSPACE as the working directory.
- ›Exits with a nonzero code when -p mode fails due to LLM backend errors (auth failures, quota exhaustion, network issues), enabling reliable CI failure detection.
v0.0.353 Oct 28, 2025 · issue -293

GitHub Copilot CLI v0.0.353 adds custom agents and async task delegation via /delegate.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.353 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.353
```
└──▷ TRY IT
Invoke a named custom agent noninteractively to run a scoped task without entering the interactive prompt.
```
$ gh copilot suggest --agent security-reviewer 'Review this PR for injection vulnerabilities'
```
Hand off a long-running remediation task to Copilot in the background while you continue other work — Copilot opens a PR and completes the changes asynchronously.
```
$ /delegate Fix all TODO comments in the authentication module
```
- ›Adds --agent <agent> flag (noninteractive) and /agent slash command (interactive) to explicitly invoke custom agents; agent definitions are loaded from ~/.copilot/agents, .github/agents in the current repo, or the organization's .github repository.
- ›Adds /delegate slash command to asynchronously hand off a task to the Copilot coding agent — unstaged changes are committed to a new branch, a PR is opened, and Copilot completes the work in the background.
v0.0.350 Oct 24, 2025 · issue -297

GitHub Copilot CLI v0.0.350 trims default MCP tool set for context efficiency and adds --enable-all-github-mcp-tools flag.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.350 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.350
```
└──▷ TRY IT
Re-enable the full GitHub MCP tool surface when your workflow depends on tools excluded from the new default set.
```
$ gh copilot --enable-all-github-mcp-tools
```
- ›Adds --enable-all-github-mcp-tools flag to opt back into the full set of GitHub MCP server tools when needed.
- ›Limits the default GitHub MCP server tool set to a curated subset — covering code/repo navigation (get_file_contents, search_code, search_repositories, list_branches, list_commits, get_commit), issue management (get_issue, list_issues, get_issue_comments, search_issues), PR management (pull_request_read, list_pull_requests, search_pull_requests), workflow info (list_workflows, list_workflow_runs, get_workflow_run, get_job_logs, get_workflow_run_logs), and user search (user_search) — to conserve context window space.
v0.0.349 Oct 22, 2025 · issue -299

Copilot CLI gains parallel tool execution and temp directory access, both controllable via new flags.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.349 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.349
```
└──▷ TRY IT
Run Copilot CLI in environments where parallel tool calls could cause unintended side effects and you want sequential, one-at-a-time confirmation.
```
$ copilot --disable-parallel-tools-execution
```
Run Copilot CLI in a restricted environment where the model should not be able to read or write the system temp directory.
```
$ copilot --disallow-temp-dir
```
- ›Adds --disable-parallel-tools-execution flag to control the new parallel tool calling behavior, where the model can invoke multiple tools simultaneously (each requiring individual confirmation).
- ›Adds --disallow-temp-dir flag to control the new default behavior of granting the model access to the system temp directory.
- ›Adds /quit as an alias for /exit.
v0.0.348 Oct 22, 2025 · issue -299

GitHub Copilot CLI v0.0.348 streams output token-by-token, controllable with --stream off
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.348 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.348
```
└──▷ TRY IT
Disable token-by-token streaming when you need clean, non-incremental output — useful in scripts or CI pipelines.
```
$ copilot --stream off
```
- ›Adds token-by-token streaming of Copilot's output, with --stream off to disable it.
- ›Reduces memory footprint when handling shell commands that produce very large outputs.
v0.0.344 Oct 18, 2025 · issue -303

GitHub Copilot CLI v0.0.344 enables the GitHub MCP server in prompt mode and adds detached process execution in the bash tool.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.344 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.344
```
└──▷ TRY IT
Quickly check which models are available for your Copilot CLI configuration without leaving the terminal.
```
$ copilot help config
```
- ›Adds list of supported models to copilot help config output.
- ›Enables the GitHub MCP server in prompt mode.
- ›Adds support in the bash tool for executing detached processes.
v0.0.343 Oct 16, 2025 · issue -305

GitHub Copilot CLI v0.0.343 adds --additional-mcp-config for per-session MCP server overrides and a new Claude Haiku 4.5 model.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.343 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.343
```
└──▷ TRY IT
Temporarily inject or override an MCP server for a single session without touching your permanent config — useful for testing a new tool or applying environment-specific overrides in CI.
```
$ copilot --additional-mcp-config @base.json --additional-mcp-config @overrides.json
```
Quickly add an MCP server inline without creating a config file, ideal for one-off sessions.
```
$ copilot --additional-mcp-config '{"mcpServers": {"my-tool": {"command": "my-tool-server", "args": []}}}'
```
- ›Adds --additional-mcp-config flag to temporarily add or override MCP server configuration per session, accepting inline JSON (e.g. '{"mcpServers": {"my-tool": {...}}}') or a file path prefixed with @; the flag can be passed multiple times with later values overriding earlier ones.
- ›Adds Claude Haiku 4.5 as a selectable model, accessible via the /model slash command.
- ›Adds a prompt to run /terminal-setup when needed to enable multi-line input.
- ›Adds a shimmer effect to the 'Thinking...' indicator and allows cycling through slash commands from the bottom of the list back to the top.
v0.0.342 Oct 16, 2025 · issue -305

Copilot CLI v0.0.342 overhauled session logging, enables Kitty protocol multi-line input, and adds persistent log_level config.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.342 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.342
```
└──▷ USE IT
Persist debug-level logging across all Copilot CLI sessions so you can diagnose model-access or policy errors without re-setting flags each time.
ini
```
log_level = debug
```
- ›Adds persistent log_level option in ~/.copilot/config to control debug log verbosity without per-session flags; supported values: none, error, warning, info, debug, all, default.
- ›New session state stored in ~/.copilot/session-state; legacy sessions retained in ~/.copilot/history-session-state and migrated automatically when resumed via copilot --resume.
- ›Enables non-interactive GitHub Enterprise logins by honoring the GH_HOST environment variable in PAT and gh authentication modes.
- ›Enables the Kitty keyboard protocol by default, unlocking multi-line input via Shift+Ctrl on supported terminals.
- ›Adds /terminal-setup command to enable multi-line input in VS Code and its forks.
+2 moreshow less
- ›Adds gradlew to the list of commands whose subcommands can be allow-listed.
- ›New session logging format decouples session storage from timeline display, improving scalability for future features.
v0.0.341 Oct 15, 2025 · issue -306

GitHub Copilot CLI v0.0.341 adds /terminal-setup command and premium multipliers to /model list.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.341 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.341
```
- ›Adds /terminal-setup command to configure multi-line input on terminals that do not implement the kitty protocol.
- ›Adds each model's premium request multiplier to the /model list output (all currently supported models shown as 1x).
v0.0.340 Oct 13, 2025 · issue -308

GitHub Copilot CLI v0.0.340 adds --allow-all-paths flag, improved Windows support, and better API error debugging.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.340 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.340
```
└──▷ TRY IT
Run Copilot CLI in path-restricted mode while granting access to all paths upfront, skipping per-path approval prompts.
```
$ copilot -p --allow-all-paths
```
Update an MCP server config to correctly reference an environment variable after the literal-value parsing change.
json
```
{
  "env": {
    "GITHUB_ACCESS_TOKEN": "${GITHUB_TOKEN}"
  }
}
```
- ›Adds --allow-all-paths argument to approve access to all paths without per-path prompts in -p mode.
- ›Adds a prompt to approve new paths when running in -p mode, giving users explicit control over path access.
- ›Improves debugging output by including the Copilot API request ID for model call errors and stack traces for client errors.
- ›Removes the 'Windows support is experimental' warning, reflecting significant Windows stability improvements.
└──▷ BREAKING ON UPGRADE
- !MCP server env values in ~/.copilot/mcp-config.json are now treated as literal strings instead of environment variable references. Existing configs must prefix values with ${...} (e.g. change "GITHUB_ACCESS_TOKEN": "GITHUB_TOKEN" to "GITHUB_ACCESS_TOKEN": "${GITHUB_TOKEN}") to preserve the previous behavior of reading from the CLI environment.
v0.0.339 Oct 10, 2025 · issue -311

GitHub Copilot CLI v0.0.339 improves MCP server setup with full shell-style command input in /mcp add
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.339 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.339
```
- ›The Command field in /mcp add now accepts a full shell-style command string to start an MCP server, replacing the previous comma-separated argument syntax.
v0.0.337 Oct 8, 2025 · issue -313

GitHub Copilot CLI v0.0.337 adds multi-line input for Kitty-protocol terminals and new cursor movement shortcuts.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.337 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.337
```
- ›Supports multi-line input in terminals that implement the Kitty keyboard protocol.
- ›Adds Ctrl+B and Ctrl+F keybindings for moving the cursor backward and forward in the input line.
- ›Adds validation for MCP server names.
- ›OAuth login UI now begins polling as soon as the device code is generated, improving reliability over SSH connections.
v0.0.336 Oct 7, 2025 · issue -314

GitHub Copilot CLI v0.0.336 adds proxy support via HTTP_PROXY/HTTPS_PROXY and a persistent screen-reader preference prompt.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.336 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.336
```
- ›Enables proxy support via HTTPS_PROXY and HTTP_PROXY environment variables regardless of Node version.
- ›Adds a prompt for users who launch with --screen-reader to persistently save the screen-reader preference.
- ›Significantly reduces token consumption, round trips per problem, and time to result.
v0.0.335 Oct 6, 2025 · issue -315

GitHub Copilot CLI v0.0.335 adds inline file diffs in the timeline and slash command argument hints.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.335 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.335
```
- ›Shows file diffs in the timeline by default, giving immediate visibility into file edits without requiring Ctrl+R.
- ›Displays argument hints inline in the slash command input box to guide command usage.
- ›Adds a warning when proxy support is used in an incompatible environment (Node <24 or required environment variables not set).
- ›Improves interface display in terminals narrower than 80 columns.
- ›Reduces color usage and improves spacing in Markdown rendering.
v0.0.334 Oct 3, 2025 · issue -317

GitHub Copilot CLI v0.0.334 adds paste compaction and a context-limit warning to help manage long sessions.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.334 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.334
```
- ›Pasting more than 10 lines now displays a compact token (e.g. [Paste #1 - 15 lines]) instead of flooding the terminal.
- ›Adds a warning when conversation context reaches ≤20% of the model's remaining limit, prompting users to start a new session before truncation occurs.
- ›Adds the current version to startup logs to aid in bug reporting.
v0.0.333 Oct 2, 2025 · issue -318

GitHub Copilot CLI v0.0.333 adds image input, shell passthrough via !, /usage stats, and --continue session resumption.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.333 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.333
```
└──▷ TRY IT
Check how many Premium requests and tokens you have consumed mid-session without waiting for session end.
```
$ /usage
```
Pick up where you left off by resuming the most recently closed Copilot CLI session.
```
$ copilot --continue
```
Run a shell command directly without sending it to the model — useful for quick one-offs inside a Copilot session.
```
$ ! grep -r 'TODO' ./src
```
- ›Adds --continue flag to resume the most recently closed session.
- ›Adds /usage slash command to report Premium request usage, session time, code changes, and per-model token use — also printed automatically at session end.
- ›Adds ! prefix to bypass the model and execute shell commands directly from the Copilot CLI prompt.
- ›Adds image input support via @-mention to attach image files as model input.
- ›Improves --screen-reader mode by replacing icons in the session timeline with descriptive text labels.
v0.0.331 Oct 1, 2025 · issue -319

GitHub Copilot CLI v0.0.331 filters inaccessible models from /model list and adds a scrollbar to the @ file picker.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.331 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.331
```
- ›The /model list now filters out models the user cannot access (due to Copilot plan or geographic region), preventing model_not_supported errors from appearing at runtime.
- ›Adds a scrollbar to the @ file mentioning picker and increases the active buffer size to 10 items.
- ›Up/down arrow keys now correctly navigate / and @ menu options while the agent is running.
v0.0.329 Sep 29, 2025 · issue -321

GitHub Copilot CLI v0.0.329 adds Claude Sonnet 4.5 as default, a /model command, and glob matching for shell tool rules.
└──▷ GET THIS VERSION
```
$ git clone --branch v0.0.329 https://github.com/github/copilot-cli.git
# already have the repo? check out this version:
$ git checkout v0.0.329
```
└──▷ TRY IT
Switch to a specific model mid-session without leaving the CLI.
```
$ /model claude-sonnet-4-5
```
Restrict the agent to only npm test variants while blocking all other shell commands, using glob syntax.
```
$ copilot --allow-tool 'shell(npm run test:*)' --deny-tool 'shell(*)'
```
- ›Adds /model slash command to switch models interactively (/model opens a picker; /model <model> sets the model directly).
- ›Adds glob matching to --allow-tool and --deny-tool shell rules, e.g. shell(npm run test:*) matches any shell command beginning with npm run test.
- ›Adds Claude Sonnet 4.5 support and makes it the default model.
- ›Displays the currently selected model above the input text box.
- ›Improves copilot --resume interface with relative time display and session message count.
+2 moreshow less
- ›Changes Ctrl+r to expand only recent timeline items; Ctrl+e then expands all.
- ›Limits the input text box to 10 scrollable lines so long prompts no longer fill the screen.

GitHub Copilot CLI

Summary

What GitHub Copilot CLI answers

Examples

Command line

Release history