Agent host session hangs forever when a startup-config change restarts the CLI client mid-turn

[roblourens]

Agent host: a startup-config change (sessionSync) restarts the CLI client mid-turn and the session hangs forever

What happens

CopilotAgent._restartClientIfStartupConfigChanged() tears down the CopilotClient whenever a startup-only config value changes, even if a turn is actively running:

if (this._client) {
    this._logService.info(`[Copilot] Startup config changed (${changed}), restarting CopilotClient`);
    this._sessions.clearAndDisposeAll();
    await this._stopClient();
}

CopilotAgentSession never finalizes its in-flight turn on disposal — ChatTurnComplete / ChatTurnCancelled / ChatError are only emitted in response to SDK events (_completeActiveTurn, _beginSteeringTurn). A disposed session gets no more SDK events, so nothing closes the turn.

Net effect: the client's turn stays open forever. The UI spins with no output, no error, and no way to recover other than reloading.

Evidence (from an Agent Host debug log bundle)

Time (local)	Event
09:05:03	chat/turnStarted turnId=request_bbf818da-…
09:05–09:26	~30 tool calls run normally under that turn
09:26:44	Tool started: apply_patch, assistant.turn_start — model still working
09:27:02	[DefaultAccount] Managed settings fetch returned non-success status 404; falling back to local-only policy
09:27:06	[Copilot] Startup config changed (sessionSync=true), restarting CopilotClient
09:27:07	session.shutdown; CLI subprocess exits
after	No chat/turnComplete, no chat/turnCancelled, no chat/error is ever sent for request_bbf818da
11:36	~2h later the user exports logs; session still shows as running

The agent host process itself stayed healthy — it kept serving a different session for another 2 hours. Only the session with the in-flight turn was orphaned.

Note that sessionSync maps to chat.sessionSync.enabled, which is experiment-driven (experiment: { mode: 'auto' }) and policy-controlled (CopilotSessionSync / cloud_session_storage_enabled). It can flip on its own from an async experiment or policy refresh, so this can kill a running turn with no user action at all. That's what happened here — the flip landed 4s after a managed-settings fetch 404'd.

How it regressed

The original implementation only restarted when idle — #317390 (5d8b31703319):

if (this._client && this._sessions.size === 0) {
    ...
    await this._stopClient();
}

#319430 (225f0854cc65) removed the _sessions.size === 0 guard so the rubber duck toggle would take effect immediately. That PR's own commit message notes the change: "Corrects the misleading 'only if idle' restart comment to match the new behavior (active sessions are disposed on a startup-config change)."

Later PRs added more restart triggers to the same unguarded path (enterpriseHost, copilotSdkLogLevel, systemProxy), widening the window.

Suggested fix

Two independent problems, both worth fixing:

1. Don't kill live work. Restore an idle check: defer the restart until all sessions are idle (or at minimum until no turn is running), rather than disposing sessions mid-turn. Especially important because sessionSync can change without any user action.
2. Never leave a turn open. Finalize the in-flight turn when a CopilotAgentSession is disposed — emit ChatError (or ChatTurnCancelled) + ChatTurnComplete so the client stops spinning and the user sees something actionable. This should be dispose-driven so it also covers shutdown() and releaseSession().

Possibly related

At 16:06:46Z a steering turn was started and completed while the original turn was still open, with no turnComplete for the original — so the chat had two overlapping open turns even before the restart. May be a separate _beginSteeringTurn bug.

(Written by Copilot)

[roblourens]

Repro steps

You don't need session sync, an experiment flip, or a policy change to reproduce this. Any setting that the Copilot CLI client only reads at startup will do — the easiest is the Rubber Duck Agent toggle in Host Settings.

1. Open the Agent Host log

Run Developer: Show Logs... from the Command Palette (F1) and pick Agent Host. Leave this Output pane visible — this is where you'll see the result. Keep it on the side, not covering the chat.

2. Start a long-running turn

In an agent-host session (a Copilot session in the Agents window or the chat panel), ask for something that runs for a while, so you have time to act while it's working. For example:

Run a shell command that sleeps for 90 seconds, then tell me what the current directory is.

Wait until you can see it actually working — a tool call in progress, or streaming text. Do not wait for it to finish.

3. Change a startup-only setting while the turn is still running

Right-click any session in the sessions list and choose Open Host Settings (also available as Open Host Settings from the Command Palette). A settings.jsonc editor opens.

Set rubberDuck to the opposite of its current value, e.g.:

{
    "rubberDuck": true
}

Save the file (Ctrl+S / Cmd+S) — the change is applied on save. Do this while the turn from step 2 is still running.

4. Observe

🐛 Broken (before this fix) — the Agent Host log shows:

[Copilot] Startup config changed (rubberDuck=true), restarting CopilotClient

and the session hangs forever: the spinner keeps going, no further output arrives, no error is shown, and Stop doesn't help. It never completes, because the turn was killed mid-flight and nothing tells the UI. Only reloading the window clears it.

✅ Fixed — the log instead shows:

[Copilot] Deferring CopilotClient restart (startup config changed: rubberDuck=true) until 1 in-flight turn(s) finish

the turn runs to completion normally, and only then does the restart happen:

[Copilot] Restarting CopilotClient (startup config changed: rubberDuck=true)

Send one more message afterwards to confirm the session still works — the client restarted cleanly and the new setting value is now in effect.

Also worth checking

The same deferral should apply to the other startup-only settings, if you want to spot-check more than one: copilotSdkLogLevel (also in Host Settings), the chat.sessionSync.enabled setting, and chat.agentHost.systemProxy.enabled. Each should log Deferring CopilotClient restart … when changed mid-turn, and Restarting CopilotClient … once the turn ends.

Verifying with no turn running is worth one pass too: change rubberDuck while the session is idle and the log should go straight to Restarting CopilotClient (…) with no Deferring line — the restart should not be postponed when there's nothing to protect.

Fixed by #327483.

(Written by Copilot)