GitHub Copilot CLI 1.0.49 fixes hooks and memory

GitHub Copilot CLI 1.0.49 adds hook context handling, memory commands, and several terminal fixes.

GitHub shipped Copilot CLI 1.0.49 on 2026-05-18, and the release note is packed with small but meaningful changes. The headline fix is simple: postToolUse hook additionalContext now reaches the model as a system message instead of disappearing.

This release also arrives with a long list of agent, terminal, and MCP updates, plus support for Alpine Linux through musl libc. In other words, this is the kind of version that matters to people who actually use the CLI every day, not just people skimming changelogs.

The real fix is about context, not syntax

The most important line in the release notes is the one about postToolUse hooks. Before 1.0.49, additionalContext could be collected and then dropped on the floor. Now it is injected as a system message, which means the model can actually see it and react to it.

That matters because hook data is only useful if it survives the trip from tool execution to model input. For teams wiring Copilot CLI into custom workflows, this turns hooks from a logging side channel into something closer to an input pipeline.

There is also a subtle but important pattern here: GitHub is tightening the glue between the CLI, the agent, and the surrounding tool ecosystem. The release adds support for Copilot CLI in more environments, while also making the tool behavior easier to reason about when hooks, sessions, and MCP servers all overlap.

• postToolUse hook context is no longer discarded
• Repo hooks in .github/hooks/ now load in prompt mode when the folder is trusted
• File diffs are reported correctly to ACP clients for all edit tool types
• Document attachment paths are included in context, including Windows copy-as-path inputs

Memory, sessions, and agent commands are getting more practical

Version 1.0.49 adds a cluster of commands that make the CLI feel less like a thin wrapper and more like a real working assistant. The new /memory on|off|show command gives users direct control over persistent memory, while /session id exposes the current session ID and can copy it to the clipboard.

GitHub also added /chronicle search for searching session content by keyword or topic, plus /exit with a print option so you can dump the session before quitting. And then there is /rubber-duck, which asks an independent critique agent to review the current work. That one is easy to mock until you are staring at a weird prompt chain at 11 p.m.

“The rubber duck debugging method is a great way to solve problems.” — Andrew Hunt and David Thomas

The command set also shows where GitHub thinks the CLI is headed. It is not enough for the agent to generate output. It needs memory, traceability, and ways to inspect its own work without forcing users to leave the terminal.

That focus shows up in the smaller fixes too. The prompt now collapses to a single line when empty and grows naturally as you type. Mouse clicks land correctly even when the input contains wide characters such as CJK text or emoji. These are the kinds of details that separate a demo from a tool people trust.

• /memory now supports persistent on, off, and status checks
• /chronicle search adds session-wide search
• /session id makes session tracking easier for support and debugging
• /rubber-duck adds an independent critique workflow

MCP and OAuth changes matter for real deployments

A lot of the release note is about MCP server behavior, and that is a good sign. GitHub Copilot CLI is increasingly useful only when it can talk cleanly to external tools, and that means authentication, startup speed, and metadata handling all need to behave.

In 1.0.49, static OAuth clients now persist registration for token refreshes, and MCP servers with no args field are treated as an empty list instead of breaking. The release also adds auth.redirectPort so teams can pin the OAuth callback to a fixed port, which is the sort of detail you appreciate the moment you try running this behind a stricter local setup.

GitHub’s own Changelog has been full of Copilot-related updates, but this release is especially focused on the plumbing. The CLI now shows stdio for MCP servers instead of the vague “local” label, and servers using OAuth stay connected when auth happened in a separate session.

There is also a practical platform win: Alpine Linux support via musl libc. That broadens the number of environments where the CLI can run without container workarounds or distro-specific hacks.

• Static OAuth clients now keep token refresh registration
• auth.redirectPort can pin OAuth callbacks to a fixed port
• Empty MCP args lists are accepted
• Alpine Linux support is now included

The terminal polish is the part users will notice first

Some of the changes are invisible until they save you from a bad session. The progress bar now renders correctly in tmux, box-drawing characters behave on Windows terminals that are not using UTF-8, and the loading indicator matches the active mode, whether that is plan, autopilot, or shell.

GitHub also fixed a bunch of interaction details that make the CLI feel less brittle. Pressing Enter on a highlighted subcommand completion now inserts the selection instead of sending the partial command. The editor launched with Ctrl+G no longer steals keystrokes or forces a double press. The input area grows with terminal height instead of stopping at three lines.

For people who care about cost, token accounting got a tune-up too. The release notes say input token usage now includes cached tokens, and the formatting has been updated to make that clearer. That is a small change on paper, but it matters when you are trying to understand why a session cost more than expected.

If you compare 1.0.49 with the pre-releases that followed on 1.0.51-3, 1.0.51-2, and 1.0.51, the direction is clear: GitHub is iterating quickly on agent controls, session visibility, and tool integration.

• tmux progress bars now render properly
• Windows terminals handle box characters better
• Highlighted completions insert correctly on Enter
• Terminal input grows with available height

What this release says about Copilot CLI’s direction

Copilot CLI 1.0.49 is not a flashy release, and that is exactly why it matters. It fixes the places where an agentic terminal tool can quietly fail: context passing, session state, OAuth refresh, and the little terminal behaviors that make people lose trust fast.

GitHub is clearly treating the CLI as a serious control surface for Copilot workflows, not a side project. If you are already using hooks or MCP servers, this is a version worth testing early. If you are not, the new commands and session tools give you a good reason to start.

The next question is whether GitHub keeps tightening the feedback loop between hooks, memory, and external tools without turning the CLI into something too complex to predict. Based on this release, that is the direction it is moving, and the users who feel it first will be the ones running the tool in real terminals, on real repos, every day.