GitHub Copilot CLI — The AI Toolchain

GitHub Copilot CLI v1.0.81

Thu, 27 Aug 2026 17:10:08 GMT

Copilot CLI v1.0.81 adds plugins dashboard, WAM auth, hooks trace context, `--with-token` login, per-agent usage metrics, and more. • 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. • 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 :` 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 changes: • 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`.

GitHub Copilot CLI v1.0.79

Mon, 10 Aug 2026 16:19:16 GMT

GitHub Copilot CLI v1.0.79 adds worktree sessions, tgrep monorepo search, multi-session management, and a renamed sandbox policy key. • 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. • 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 changes: • 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.

GitHub Copilot CLI v1.0.79

Mon, 10 Aug 2026 16:19:16 GMT

Copilot CLI v1.0.79 adds worktree branching control, combined plan+autopilot mode, sandbox policy inspection, tgrep for monorepos, and multi-session management. • 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. • 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 changes: • 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.

GitHub Copilot CLI v1.0.78

Mon, 03 Aug 2026 23:30:25 GMT

GitHub Copilot CLI v1.0.78 adds /new-worktree and /permissions commands, ACP token usage exposure, and a new `allowDevToolCaches` sandbox setting. • 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). • 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 changes: • 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.

GitHub Copilot CLI v1.0.78

Mon, 03 Aug 2026 23:30:25 GMT

Copilot CLI v1.0.78 adds /new-worktree, /permissions, allowDevToolCaches sandbox setting, ACP token-usage exposure, and live tool-call duration timers. • 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. • 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 changes: • 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`).

GitHub Copilot CLI v1.0.77

Thu, 30 Jul 2026 23:36:02 GMT

Copilot CLI v1.0.77 adds browser OAuth login, MDM sandbox policy, and Ctrl+G in-prompt editor • 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.

GitHub Copilot CLI v1.0.77

Thu, 30 Jul 2026 23:36:02 GMT

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. • 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. • Allows reasoning effort to be omitted so the server selects the default.

GitHub Copilot CLI v1.0.76

Thu, 30 Jul 2026 01:09:30 GMT

Copilot CLI v1.0.76 adds grok-4.5 support, a multi-session sidebar, enterprise sandbox enforcement, /limits predict, and a queue manager. • 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. • 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`.

GitHub Copilot CLI v1.0.76

Thu, 30 Jul 2026 01:09:30 GMT

Copilot CLI v1.0.76 adds grok-4.5 support, /limits predict, Sessions sidebar, enterprise sandbox enforcement, and a directable queue manager. • 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. • 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.

GitHub Copilot CLI v1.0.75

Fri, 24 Jul 2026 19:54:03 GMT

GitHub Copilot CLI v1.0.75 adds support for Claude Opus 5 as a selectable model. • Adds Claude Opus 5 as an available model, selectable via the `/model` slash command.

GitHub Copilot CLI v1.0.74

Thu, 23 Jul 2026 22:05:57 GMT

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. • 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. • 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.

GitHub Copilot CLI v1.0.74

Thu, 23 Jul 2026 22:05:57 GMT

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. • 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. • 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.

GitHub Copilot CLI v1.0.72

Mon, 20 Jul 2026 17:51:15 GMT

Copilot CLI v1.0.72 adds shell shortcut, per-session model switching, skill installs, full plugin management, and a navigable Sessions sidebar. • 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 ` 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. • 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 ` 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 changes: • 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.

GitHub Copilot CLI v1.0.71

Thu, 16 Jul 2026 01:54:36 GMT

Copilot CLI v1.0.71 adds /voice device selection, canvas support, plugins marketplace subcommands, /worktree+/move split, and configurable subagent depth controls. • 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. • 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 --help` or `copilot skill --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 changes: • 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 ` form is not supported — use `copilot mcp --help` or `copilot skill --help` instead.

GitHub Copilot CLI v1.0.70

Fri, 10 Jul 2026 01:28:35 GMT

Copilot CLI v1.0.70 adds GPT-5.6, sandbox session flags, /refine prompt rewriting, repo-pinned model policy, and paginated MCP resource RPCs. • 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`. • 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.

GitHub Copilot CLI v1.0.69

Tue, 07 Jul 2026 21:19:09 GMT

Copilot CLI v1.0.69 adds /mcp list, auto allow-all LLM-judged approvals, delegate PR branching, and a /plugins dashboard. • 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. • 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 changes: • `/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).

GitHub Copilot CLI v1.0.68

Wed, 01 Jul 2026 21:17:41 GMT

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. • 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. • 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`.

GitHub Copilot CLI v1.0.67

Tue, 30 Jun 2026 22:18:23 GMT

GitHub Copilot CLI v1.0.67 adds Claude Sonnet 5 support, MCP OAuth fixes for Entra tenant vanity domains, and session resume hints. • 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. • 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 changes: • Session limits below 30 AI credits are no longer accepted; any configuration setting a lower limit must be updated.

GitHub Copilot CLI v1.0.66

Tue, 30 Jun 2026 13:17:19 GMT

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. • Adds `--allow-all-mcp-server-instructions` flag to optionally include instructions from all MCP servers in system prompts. • Adds `--dynamic-retrieval skills=` 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`. • 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 changes: • `COPILOT_HOME` and `--config-dir` no longer load skills from `~/.agents/skills`.

GitHub Copilot CLI v1.0.65

Wed, 24 Jun 2026 21:41:13 GMT

GitHub Copilot CLI v1.0.65 adds a `copilot skill` subcommand, CI check status bar, and shell-history search across modes. • 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`. • 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.

GitHub Copilot CLI v1.0.64

Tue, 23 Jun 2026 17:21:01 GMT

Copilot CLI v1.0.64 adds worktree sessions, /diagnose, /mcp registry, CSV MCP output, and a batch of new commands and aliases. • Adds experimental `--worktree [name]` (`-w`) flag (enable with `/experimental`) that creates or reuses a git worktree under `.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. • 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 changes: • 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.

GitHub Copilot CLI v1.0.63

Tue, 16 Jun 2026 00:47:09 GMT

Copilot CLI v1.0.63 adds `deferTools` MCP config, alphabetic `--help` sorting, per-session agent mode, and an experimental `/rewind` overhaul. • 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. • 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.

GitHub Copilot CLI v1.0.62

Sat, 13 Jun 2026 19:58:18 GMT

Copilot CLI v1.0.62 adds Kerberos proxy auth, diff file tree, session-scoped extensions, `/app` command, and schedulable slash commands. • 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. • 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 changes: • Shell commands now run via lightweight process spawning instead of a pseudo-terminal; interactive input via `write_bash` is no longer supported.

GitHub Copilot CLI v1.0.61

Tue, 09 Jun 2026 22:02:34 GMT

Copilot CLI v1.0.61 adds /settings dialog, /worktree command, mTLS OTLP export, Claude Fable 5, and indexed monorepo grep. • 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. • 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.

GitHub Copilot CLI v1.0.60

Fri, 05 Jun 2026 16:46:20 GMT

Copilot CLI v1.0.60 adds max Anthropic reasoning effort, new nav keys, `-r` resume shorthand, and expanded LSP/MCP/ACP controls. • 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. • 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 changes: • 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.

GitHub Copilot CLI v1.0.58

Tue, 02 Jun 2026 16:01:14 GMT

GitHub Copilot CLI v1.0.58 enables Rubber Duck and Remote JSON RPC by default, adds scheduled prompts and new experimental UI • 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.

GitHub Copilot CLI v1.0.57

Mon, 01 Jun 2026 18:40:11 GMT

Copilot CLI v1.0.57 adds HTTP/2 opt-in, COPILOT_HOME support, showTipsOnStartup setting, and smarter MCP/LSP/plugin behaviors. • 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. • `/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`.

GitHub Copilot CLI v1.0.56

Fri, 29 May 2026 20:06:37 GMT

GitHub Copilot CLI v1.0.56 adds rubber duck agent config, MCP structured content surfacing, and smarter token-reduction defaults. • 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. • 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.

GitHub Copilot CLI v1.0.55

Thu, 28 May 2026 19:56:11 GMT

GitHub Copilot CLI v1.0.55 adds /autopilot, per-MCP token visibility, Claude Opus 4.8, and new permissions controls. • Adds `permissions.disableBypassPermissionsMode` setting to prevent users from enabling allow-all/yolo mode. • Adds `/autopilot ` 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. • 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.

GitHub Copilot CLI v1.0.52

Sat, 23 May 2026 22:44:38 GMT

Copilot CLI v1.0.52 adds deferred tool loading for agents, /compact focus instructions, /usage quota bars, and HTTP/1.1 auto-retry. • 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 ` 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. • 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.

GitHub Copilot CLI v1.0.51

Wed, 20 May 2026 21:44:33 GMT

GitHub Copilot CLI v1.0.51 adds session resumption, /security-review, /chronicle cost-tips, secret scanning for commits/PRs, and new hook controls. • Adds `--session-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. • 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.

GitHub Copilot CLI v1.0.49

Tue, 19 May 2026 00:02:51 GMT

GitHub Copilot CLI v1.0.49 adds /chronicle search, /rubber-duck, /memory, /session id, plugin bulk-update, Alpine Linux support, and more. • 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. • 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.

GitHub Copilot CLI v1.0.47

Wed, 13 May 2026 14:43:44 GMT

GitHub Copilot CLI v1.0.47 adds named fork sessions, j/k navigation in /diff, and improved --resume for cloud agent sessions. • 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.

GitHub Copilot CLI v1.0.46

Tue, 12 May 2026 20:53:50 GMT

Copilot CLI v1.0.46 auto-approves read-only gh commands and warns on deprecated CLI versions • 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.

GitHub Copilot CLI v1.0.45

Mon, 11 May 2026 17:43:12 GMT

GitHub Copilot CLI v1.0.45 adds `/autopilot` and `/fork` slash commands, PowerShell fallback, and OpenTelemetry GenAI metrics. • 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.

GitHub Copilot CLI v1.0.44

Fri, 08 May 2026 19:39:07 GMT

GitHub Copilot CLI v1.0.44 adds mid-input slash commands, multi-skill invocation, LLM-bypass hooks, and a `prerelease` argument to `copilot update`. • 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.

GitHub Copilot CLI v1.0.43

Wed, 06 May 2026 22:00:39 GMT

GitHub Copilot CLI v1.0.43 adds account display in the status line and server-side model routing in Auto mode. • 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.

GitHub Copilot CLI v1.0.42

Wed, 06 May 2026 14:57:18 GMT

GitHub Copilot CLI v1.0.42 adds `-C ` flag, richer MCP diagnostics, and a new rubber-duck agent in `/experimental`. • Adds `-C ` 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. • Exit message resume command now shows the session ID instead of an auto-generated name when the session has not been renamed.

GitHub Copilot CLI v1.0.41

Tue, 05 May 2026 20:45:24 GMT

Copilot CLI v1.0.41 adds experimental MCP Tasks, --attachment flag, auto shell completions, and prompt-mode extension loading. • 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. • 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.

GitHub Copilot CLI v1.0.40

Fri, 01 May 2026 13:10:31 GMT

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. • 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. • 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 changes: • `--config-dir` is deprecated in favor of the `COPILOT_HOME` environment variable.

GitHub Copilot CLI v1.0.39

Tue, 28 Apr 2026 23:25:04 GMT

GitHub Copilot CLI v1.0.39 adds ACP permission toggling, four new slash commands, and background task control via 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. • Improves `--resume` session picker with better tab layout, status display, and progressive loading.

GitHub Copilot CLI v1.0.37

Mon, 27 Apr 2026 23:07:10 GMT

GitHub Copilot CLI v1.0.37 adds shell completion scripts, session sort cycling, and default location-based permission persistence. • Adds `copilot completion ` 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.

GitHub Copilot CLI v1.0.36

Fri, 24 Apr 2026 18:39:17 GMT

GitHub Copilot CLI v1.0.36 adds `/keep-alive`, `/remote` toggle, and a session-diff statusline among other UX improvements. • 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. • 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 changes: • 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.

GitHub Copilot CLI v1.0.35

Thu, 23 Apr 2026 23:24:24 GMT

GitHub Copilot CLI v1.0.35 adds HTTP hooks, named sessions, new slash commands, and MCP/LSP improvements. • Adds `COPILOT_GH_HOST` environment variable to set the GitHub hostname, taking precedence over `GH_HOST`. • Adds `--name` flag to name sessions and `--resume=` 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 `, 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. • 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 changes: • 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`.

GitHub Copilot CLI v1.0.33

Mon, 20 Apr 2026 17:05:34 GMT

Copilot CLI v1.0.33 adds new slash command aliases, earlier rate-limit warnings, and vim-style task navigation. • 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. • 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.

GitHub Copilot CLI v1.0.32

Fri, 17 Apr 2026 21:51:43 GMT

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. • 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. • 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.

GitHub Copilot CLI v1.0.30

Thu, 16 Apr 2026 19:10:02 GMT

GitHub Copilot CLI v1.0.30 adds `/statusline` command to customize the status bar and expands image paste to Ctrl+V and Meta+V. • 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 changes: • The `--list-env` flag (which logged loaded plugins, agents, skills, and MCP servers in prompt mode) has been removed.

GitHub Copilot CLI v1.0.29

Thu, 16 Apr 2026 15:03:23 GMT

GitHub Copilot CLI v1.0.29 adds `--list-env` flag, `COPILOT_AGENT_SESSION_ID`, Claude Opus 4.7 support, and HTTP-default MCP config. • 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.

GitHub Copilot CLI v1.0.28

Thu, 16 Apr 2026 00:06:11 GMT

GitHub Copilot CLI v1.0.28 adds remote session resumption, terminal title opt-out, and live custom instruction reloading. • 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.

GitHub Copilot CLI v1.0.27

Wed, 15 Apr 2026 01:23:17 GMT

Adds `/ask` command and `copilot plugin marketplace update` to GitHub Copilot CLI v1.0.27 • 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.

GitHub Copilot CLI v1.0.26

Tue, 14 Apr 2026 18:45:32 GMT

Copilot CLI v1.0.26 adds plugin root env vars, localhost-only ACP binding, and remote control renaming across flag and command help. • 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`). • 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.

GitHub Copilot CLI v1.0.25

Mon, 13 Apr 2026 13:47:46 GMT

GitHub Copilot CLI v1.0.25 adds MCP server install from registry, `/env`, `/remote`, and remote session control via `--remote`. • 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. • 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.

GitHub Copilot CLI v1.0.24

Fri, 10 Apr 2026 23:30:25 GMT

Copilot CLI v1.0.24: hooks now propagate modifiedArgs and custom agents accept VS Code display names • `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.

GitHub Copilot CLI v1.0.23

Fri, 10 Apr 2026 13:59:33 GMT

GitHub Copilot CLI v1.0.23 adds --mode, --autopilot, and --plan flags for direct agent mode entry plus Tasks API steering. • 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. • `Ctrl+L` clears the terminal screen without clearing the current conversation session.

GitHub Copilot CLI v1.0.22

Thu, 09 Apr 2026 19:36:36 GMT

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. • 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. • 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 changes: • `.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.

GitHub Copilot CLI v1.0.21

Tue, 07 Apr 2026 21:34:08 GMT

GitHub Copilot CLI v1.0.21 adds `copilot mcp` for MCP server management and snake_case hook payloads. • 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.

GitHub Copilot CLI v1.0.20

Tue, 07 Apr 2026 12:20:48 GMT

Copilot CLI v1.0.20 adds an OpenTelemetry monitoring help topic and makes /yolo state persist across /restart • 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.

GitHub Copilot CLI v1.0.19

Mon, 06 Apr 2026 21:43:52 GMT

Copilot CLI v1.0.19 persists MCP state across sessions and adds OpenTelemetry streaming latency tracking. • 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.

GitHub Copilot CLI v1.0.18

Sat, 04 Apr 2026 04:01:13 GMT

GitHub Copilot CLI v1.0.18 adds a Critic agent, async notification hooks, and a `preToolUse` permission suppression flag. • 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.

GitHub Copilot CLI v1.0.17

Fri, 03 Apr 2026 00:33:38 GMT

GitHub Copilot CLI v1.0.17 adds built-in skills and HTTPS MCP OAuth redirect support. • 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.

GitHub Copilot CLI v1.0.16

Thu, 02 Apr 2026 16:52:14 GMT

GitHub Copilot CLI v1.0.16 adds a PermissionRequest hook for scripted tool approval and MCP timeline visibility. • 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 changes: • The `marketplaces` repository setting has been removed; use `extraKnownMarketplaces` instead.

GitHub Copilot CLI v1.0.15

Wed, 01 Apr 2026 17:12:54 GMT

Copilot CLI v1.0.15 adds MCP server config RPCs, OAuth device-code flow, /mcp auth, /share html, and branch-diff toggle. • 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. • 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 changes: • 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.

GitHub Copilot CLI v1.0.13

Mon, 30 Mar 2026 17:29:44 GMT

Copilot CLI v1.0.13 adds conversation rewind timeline, MCP LLM sampling requests, and faster startup via V8 compile cache. • 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. • 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 changes: • Support for the `gemini-3-pro-preview` model has been removed.

GitHub Copilot CLI v1.0.12

Thu, 26 Mar 2026 22:19:02 GMT

GitHub Copilot CLI v1.0.12 adds plugin env vars, new /allow-all subcommands, session name auto-gen, and OTEL span improvements. • 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. • 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 changes: • The `--alt-screen` flag and `alt_screen` setting are removed; alt screen is now always enabled and cannot be disabled.

GitHub Copilot CLI v1.0.11

Mon, 23 Mar 2026 20:22:11 GMT

GitHub Copilot CLI v1.0.11 adds monorepo skill discovery, per-session working directories, and merged extension hooks. • 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. • 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.

GitHub Copilot CLI v1.0.10

Fri, 20 Mar 2026 16:57:45 GMT

Copilot CLI v1.0.10 adds /undo, multi-session support, --effort alias, SDK elicitation dialogs, and camelCase config keys. • 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. • 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.

GitHub Copilot CLI v1.0.9

Thu, 19 Mar 2026 03:52:35 GMT

GitHub Copilot CLI v1.0.9 adds `include_gitignored` config option to surface gitignored files in @ file search. • Adds `include_gitignored` config option to include gitignored files in @ file search results.

GitHub Copilot CLI v1.0.8

Wed, 18 Mar 2026 19:38:21 GMT

GitHub Copilot CLI v1.0.8 adds hook definitions in settings files, MCP registry validation, and flexible --resume by task ID • 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. • 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.

GitHub Copilot CLI v1.0.7

Tue, 17 Mar 2026 17:52:04 GMT

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. • 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 (`%`). • 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.

GitHub Copilot CLI v1.0.6

Mon, 16 Mar 2026 22:44:31 GMT

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. • 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. • 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.

GitHub Copilot CLI v1.0.5

Fri, 13 Mar 2026 09:56:40 GMT

Copilot CLI v1.0.5 adds /pr for pull-request automation, /extensions management, richer file mentions, and a preCompact hook. • 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 `, `since `, and `summarize` subcommands to browse and summarize multiple release notes at once. • Adds `preCompact` hook to run commands before context compaction starts. • 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.

GitHub Copilot CLI v1.0.4

Wed, 11 Mar 2026 19:52:33 GMT

Copilot CLI v1.0.4 adds RPC shell execution, OpenTelemetry tracing, CommonJS extensions, and a new configure-copilot sub-agent • 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. • 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 changes: • `/pr open` is replaced by `/pr view [local|web]`; any scripts or workflows invoking `/pr open` will need to be updated.

GitHub Copilot CLI v1.0.3

Mon, 09 Mar 2026 23:28:51 GMT

Copilot CLI v1.0.3 adds MCP config from devcontainer.json, --binary-version flag, /restart command, Windows Terminal support, and more. • 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. • 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 changes: • The `merge_strategy` config key is renamed to `mergeStrategy`; existing configs using `merge_strategy` must be updated.

GitHub Copilot CLI v1.0.2

Fri, 06 Mar 2026 21:33:05 GMT

GitHub Copilot CLI v1.0 GA adds cross-platform hook config aliases and interactive form improvements. • 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.

GitHub Copilot CLI v0.0.423

Fri, 06 Mar 2026 16:39:07 GMT

Copilot CLI v0.0.423 adds dangerous-command guardrails, MCP OAuth URL flows, and EMU/GHE gist blocking. • 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. • Diff mode renders correctly on Windows with CRLF line endings.

GitHub Copilot CLI v0.0.422

Thu, 05 Mar 2026 23:51:09 GMT

GitHub Copilot CLI v0.0.422 adds GPT-5.4, JSON output mode, startup hooks, plugin SSH installs, and session metrics logging. • 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. • 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 changes: • 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.

GitHub Copilot CLI v0.0.421

Tue, 03 Mar 2026 18:12:57 GMT

GitHub Copilot CLI v0.0.421 adds repo-level config, `--plugin-dir` flag, MCP Elicitations, and `COPILOT_CLI=1` env var for Git hooks. • 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). • 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`.

GitHub Copilot CLI v0.0.420

Fri, 27 Feb 2026 18:47:56 GMT

GitHub Copilot CLI v0.0.420 adds issue/PR/discussion referencing and smarter auto-updates. • 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.

GitHub Copilot CLI v0.0.419

Fri, 27 Feb 2026 01:57:59 GMT

GitHub Copilot CLI v0.0.419 adds /chronicle session history command, new keyboard shortcuts, and expanded MCP server support. • 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. • 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.

GitHub Copilot CLI v0.0.417

Wed, 25 Feb 2026 00:19:04 GMT

GitHub Copilot CLI v0.0.417 adds a `/research` command for deep research with exportable reports. • 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.

GitHub Copilot CLI v0.0.416

Tue, 24 Feb 2026 19:59:57 GMT

Copilot CLI v0.0.416 enforces MCP server policy, improves narrow-terminal status layout, and expands --help content. • 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 changes: • Undo operations now always require confirmation — previously unconfirmed undo flows will pause for input.

GitHub Copilot CLI v0.0.415

Mon, 23 Feb 2026 21:46:06 GMT

GitHub Copilot CLI v0.0.415 adds `model` field for custom agents, `show_file` tool, and overhauled `/mcp show` grouping • 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. • 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.

GitHub Copilot CLI v0.0.413

Fri, 20 Feb 2026 23:32:06 GMT

GitHub Copilot CLI v0.0.413 adds remote plugin sources, configurable status line, and alt-screen mode on by default under `--experimental` • 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. • 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.

GitHub Copilot CLI v0.0.412

Thu, 19 Feb 2026 22:58:40 GMT

GitHub Copilot CLI v0.0.412 adds `/mcp reload`, `/update`, `exit_plan_mode`, cross-session memory, `--bash-env`, and more. • 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. • 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.

GitHub Copilot CLI v0.0.411

Tue, 17 Feb 2026 20:53:42 GMT

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. • 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. • 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.

GitHub Copilot CLI v0.0.410

Sat, 14 Feb 2026 00:52:35 GMT

GitHub Copilot CLI v0.0.410 adds `/init suppress`, repo-level validation tool controls, ACP session loading, and new keyboard/shell ergonomics. • 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. • 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.

GitHub Copilot CLI v0.0.409

Thu, 12 Feb 2026 22:09:48 GMT

GitHub Copilot CLI v0.0.409 adds VS Code integration, a quick-help overlay, scrollable diffs, and default plugin marketplaces. • 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. • Theme preview appears above the theme list in screen-reader mode. • Subagents now return complete responses.

GitHub Copilot CLI v0.0.408

Thu, 12 Feb 2026 12:28:28 GMT

GitHub Copilot CLI v0.0.408 adds `/streamer-mode`, mouse text selection in `--alt-screen`, and substring matching in slash command autocomplete. • 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 changes: • 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.

GitHub Copilot CLI v0.0.407

Wed, 11 Feb 2026 20:16:29 GMT

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. • 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. • 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 changes: • `Ctrl+d` no longer queues exit — queueing is moved to `Ctrl+q` (or `Ctrl+Enter`); `Ctrl+d` now deletes the character after the cursor.

GitHub Copilot CLI v0.0.406

Sat, 07 Feb 2026 19:10:25 GMT

GitHub Copilot CLI v0.0.406 adds Claude Opus 4.6 Fast, a `/changelog` command, `--no-experimental` flag, and richer MCP tool support. • 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. • 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.

GitHub Copilot CLI v0.0.405

Thu, 05 Feb 2026 22:47:57 GMT

GitHub Copilot CLI v0.0.405 adds `/experimental` help screen and uppercase support for plugin and marketplace names. • 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.

GitHub Copilot CLI v0.0.404

Thu, 05 Feb 2026 19:08:11 GMT

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. • 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. • 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.

GitHub Copilot CLI v0.0.403

Thu, 05 Feb 2026 08:43:23 GMT

GitHub Copilot CLI v0.0.403 adds ACP model usage/enablement info, comma-separated tools in agent frontmatter, and reasoning summaries on by default. • 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.

GitHub Copilot CLI v0.0.402

Tue, 03 Feb 2026 21:35:14 GMT

GitHub Copilot CLI v0.0.402 adds ACP agent/plan session modes, MCP-to-ACP config bridging, and plugin lifecycle hooks. • 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. • Custom agents receive environment context when run as subagents.

GitHub Copilot CLI v0.0.401

Tue, 03 Feb 2026 15:12:15 GMT

GitHub Copilot CLI v0.0.401 adds `copilot login`, agent lifecycle hooks, `.agents/skills` auto-loading, and Claude-style MCP config support. • 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. • Adds `shift+enter` keybinding for inserting new lines in the VS Code integrated terminal. • `/diff` displays accurate line numbers with a dual-column layout.

GitHub Copilot CLI v0.0.400

Fri, 30 Jan 2026 22:28:27 GMT

GitHub Copilot CLI v0.0.400 adds autopilot mode, MCP server lifecycle management, a `/theme` command, and a `copilot plugin` subcommand. • 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. • 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 changes: • Bundled LSP servers (TypeScript, Python) have been removed.

GitHub Copilot CLI v0.0.399

Thu, 29 Jan 2026 19:13:51 GMT

GitHub Copilot CLI v0.0.399 adds `/allow-all`, `/yolo`, `/diff`, and `.claude/commands/` single-file command support alongside AI-named sessions. • 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). • 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.

GitHub Copilot CLI v0.0.398

Wed, 28 Jan 2026 19:53:38 GMT

GitHub Copilot CLI v0.0.398 adds middle-truncation for narrow terminal headers and cross-directory skill invocation. • 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.

GitHub Copilot CLI v0.0.397

Wed, 28 Jan 2026 17:19:07 GMT

GitHub Copilot CLI v0.0.397 adds MCP server inspection, `--acp` Agent Client Protocol flag, and directory @mention autocomplete. • Adds `/mcp show ` 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.

GitHub Copilot CLI v0.0.396

Tue, 27 Jan 2026 20:27:52 GMT

GitHub Copilot CLI v0.0.396 adds `copilot version`, `copilot update`, `/init`, `/experimental`, and `preToolUse` hook argument control. • 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. • 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.

GitHub Copilot CLI v0.0.395

Mon, 26 Jan 2026 18:09:55 GMT

GitHub Copilot CLI v0.0.395 adds `/mcp show` server visibility, plugin skill execution, and line-specific `/diff` commenting. • 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.

GitHub Copilot CLI v0.0.394

Sat, 24 Jan 2026 03:48:40 GMT

GitHub Copilot CLI v0.0.394 adds GitHub Enterprise Cloud support, infinite SDK sessions, and new session-search and slash-command queuing shortcuts. • 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. • 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.

GitHub Copilot CLI v0.0.393

Fri, 23 Jan 2026 15:32:27 GMT

GitHub Copilot CLI v0.0.393 adds GHE Cloud remote agents, MCP tool names in events, and Esc-Esc snapshot undo • 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.

GitHub Copilot CLI v0.0.392

Thu, 22 Jan 2026 23:08:59 GMT

GitHub Copilot CLI v0.0.392 adds a `/plugin` marketplace command, `/rename` session alias, and inline diff display. • 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.

GitHub Copilot CLI v0.0.389

Thu, 22 Jan 2026 02:31:11 GMT

GitHub Copilot CLI v0.0.389 adds OAuth 2.0 MCP auth, `/diff` and `/models` commands, MSI installer, and parallel shell execution. • 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`. • 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.

GitHub Copilot CLI v0.0.388

Tue, 20 Jan 2026 20:30:08 GMT

GitHub Copilot CLI v0.0.388 adds a `/review` command and expands `--enable-all-github-mcp-tools` to read-write 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.

GitHub Copilot CLI v0.0.387

Tue, 20 Jan 2026 01:27:40 GMT

GitHub Copilot CLI v0.0.387 adds interactive clarification, plan mode, and large-directory support • 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

GitHub Copilot CLI v0.0.385

Mon, 19 Jan 2026 18:54:45 GMT

GitHub Copilot CLI v0.0.385 adds infinite sessions via compaction checkpoints, MCP server management with `/agent`, and combined custom instruction files. • 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. • Limits `store_memory` tool inclusion to sessions where memory is enabled for the user.

GitHub Copilot CLI v0.0.384

Fri, 16 Jan 2026 06:41:28 GMT

GitHub Copilot CLI v0.0.384 adds background delegation, `/cd` alias, extended thinking, cross-session memory, and proxy improvements. • 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. • 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.

GitHub Copilot CLI v0.0.381

Tue, 13 Jan 2026 18:58:23 GMT

GitHub Copilot CLI v0.0.381 adds `--allow-all`/`--yolo` permission flags, `/new` alias, and prefix-filtered shell history navigation. • 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.

GitHub Copilot CLI v0.0.380

Tue, 13 Jan 2026 02:45:16 GMT

GitHub Copilot CLI v0.0.380 adds interactive `--agent` mode, sub-agent abort propagation, large-file reads, and mid-thinking message queuing. • 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. • 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.

GitHub Copilot CLI v0.0.376

Thu, 08 Jan 2026 15:06:15 GMT

GitHub Copilot CLI v0.0.376 adds GraphQL ID session loading, image processing in task tool subagents, and disk-offloaded large tool outputs. • 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.

GitHub Copilot CLI v0.0.375

Wed, 07 Jan 2026 16:11:21 GMT

GitHub Copilot CLI v0.0.375 adds Ctrl+T reasoning toggle and `--share`/`--share-gist` flags for session sharing • 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.

GitHub Copilot CLI v0.0.374

Fri, 02 Jan 2026 20:06:50 GMT

GitHub Copilot CLI v0.0.374 adds auto-compaction, a `/compact` command, built-in subagents, and a `web_fetch` tool. • 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.

GitHub Copilot CLI v0.0.373

Tue, 30 Dec 2025 15:19:10 GMT

GitHub Copilot CLI v0.0.373 adds tab completion for path arguments and enables Copilot Spaces tools in GitHub MCP Server. • 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.

GitHub Copilot CLI v0.0.372

Fri, 19 Dec 2025 23:04:42 GMT

GitHub Copilot CLI v0.0.372 adds `/context` token usage, `--resume` for remote sessions, and URL permission controls. • 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.

GitHub Copilot CLI v0.0.370

Thu, 18 Dec 2025 15:41:30 GMT

GitHub Copilot CLI v0.0.370 adds `--available-tools` and `--excluded-tools` flags, STDIO MCP server type, and SHA256 checksum publishing. • 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. • 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.

GitHub Copilot CLI v0.0.363

Mon, 24 Nov 2025 21:17:46 GMT

GitHub Copilot CLI v0.0.363 adds three new models, `GITHUB_ASKPASS` auth support, and MCP servers in `--prompt` mode. • 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.

GitHub Copilot CLI v0.0.362

Thu, 20 Nov 2025 21:41:29 GMT

GitHub Copilot CLI v0.0.362 adds clipboard image paste and removes shell commands from Bash/PowerShell history • 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.

GitHub Copilot CLI v0.0.359

Mon, 17 Nov 2025 23:15:16 GMT

GitHub Copilot CLI v0.0.359 adds `/share` command, image context via drag-and-drop, and `USE_BUILTIN_RIPGREP` env var. • 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 changes: • `copilot -p` no longer interactively prompts for permission requests — scripts or workflows relying on that interactive prompt will behave differently after upgrade.

GitHub Copilot CLI v0.0.356

Thu, 13 Nov 2025 19:08:45 GMT

GitHub Copilot CLI v0.0.356 adds GPT-5.1, GPT-5.1-Codex, and GPT-5.1-Codex-Mini model options. • Adds GPT-5.1, GPT-5.1-Codex, and GPT-5.1-Codex-Mini as available models in GitHub Copilot CLI (public preview).

GitHub Copilot CLI v0.0.355

Wed, 12 Nov 2025 22:27:57 GMT

GitHub Copilot CLI v0.0.355 bundles ripgrep with new `grep` and `glob` tools and enhances `/session` output and self-help via `/help`. • 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.

GitHub Copilot CLI v0.0.354

Mon, 03 Nov 2025 23:04:05 GMT

GitHub Copilot CLI v0.0.354 adds `COPILOT_GITHUB_TOKEN` auth, MCP tool notifications, and Actions workspace auto-config. • 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.

GitHub Copilot CLI v0.0.353

Tue, 28 Oct 2025 17:07:14 GMT

GitHub Copilot CLI v0.0.353 adds custom agents and async task delegation via `/delegate`. • Adds `--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.

GitHub Copilot CLI v0.0.350

Fri, 24 Oct 2025 00:32:55 GMT

GitHub Copilot CLI v0.0.350 trims default MCP tool set for context efficiency and adds `--enable-all-github-mcp-tools` flag. • 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.

GitHub Copilot CLI v0.0.349

Wed, 22 Oct 2025 22:06:22 GMT

Copilot CLI gains parallel tool execution and temp directory access, both controllable via new flags. • 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`.

GitHub Copilot CLI v0.0.348

Wed, 22 Oct 2025 00:52:27 GMT

GitHub Copilot CLI v0.0.348 streams output token-by-token, controllable with `--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.

GitHub Copilot CLI v0.0.344

Sat, 18 Oct 2025 00:49:26 GMT

GitHub Copilot CLI v0.0.344 enables the GitHub MCP server in prompt mode and adds detached process execution in the bash tool. • 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.

GitHub Copilot CLI v0.0.343

Thu, 16 Oct 2025 21:40:25 GMT

GitHub Copilot CLI v0.0.343 adds `--additional-mcp-config` for per-session MCP server overrides and a new Claude Haiku 4.5 model. • 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.

GitHub Copilot CLI v0.0.342

Thu, 16 Oct 2025 01:15:20 GMT

Copilot CLI v0.0.342 overhauled session logging, enables Kitty protocol multi-line input, and adds persistent log_level config. • 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. • 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.

GitHub Copilot CLI v0.0.341

Wed, 15 Oct 2025 03:04:02 GMT

GitHub Copilot CLI v0.0.341 adds `/terminal-setup` command and premium multipliers to `/model` list. • 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).

GitHub Copilot CLI v0.0.340

Mon, 13 Oct 2025 21:36:48 GMT

GitHub Copilot CLI v0.0.340 adds `--allow-all-paths` flag, improved Windows support, and better API error debugging. • 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 changes: • 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.

GitHub Copilot CLI v0.0.339

Fri, 10 Oct 2025 20:17:17 GMT

GitHub Copilot CLI v0.0.339 improves MCP server setup with full shell-style command input in `/mcp add` • 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.

GitHub Copilot CLI v0.0.337

Wed, 08 Oct 2025 21:36:11 GMT

GitHub Copilot CLI v0.0.337 adds multi-line input for Kitty-protocol terminals and new cursor movement shortcuts. • 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.

GitHub Copilot CLI v0.0.336

Tue, 07 Oct 2025 21:28:11 GMT

GitHub Copilot CLI v0.0.336 adds proxy support via HTTP_PROXY/HTTPS_PROXY and a persistent screen-reader preference prompt. • 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.

GitHub Copilot CLI v0.0.335

Mon, 06 Oct 2025 22:06:46 GMT

GitHub Copilot CLI v0.0.335 adds inline file diffs in the timeline and slash command argument hints. • 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.

GitHub Copilot CLI v0.0.334

Fri, 03 Oct 2025 23:06:17 GMT

GitHub Copilot CLI v0.0.334 adds paste compaction and a context-limit warning to help manage long sessions. • 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.

GitHub Copilot CLI v0.0.333

Thu, 02 Oct 2025 21:51:01 GMT

GitHub Copilot CLI v0.0.333 adds image input, shell passthrough via `!`, `/usage` stats, and `--continue` session resumption. • 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.

GitHub Copilot CLI v0.0.331

Wed, 01 Oct 2025 12:42:35 GMT

GitHub Copilot CLI v0.0.331 filters inaccessible models from `/model` list and adds a scrollbar to the `@` file picker. • 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.

GitHub Copilot CLI v0.0.329

Mon, 29 Sep 2025 18:59:51 GMT

GitHub Copilot CLI v0.0.329 adds Claude Sonnet 4.5 as default, a `/model` command, and glob matching for shell tool rules. • Adds `/model` slash command to switch models interactively (`/model` opens a picker; `/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. • 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.