agentHost: keep the parent's output after a background subagent settles

The pipeline derives the turn from the prompt queue head, so a parent that
spawns background subagents ends its own turn and every message after it
arrives with no turn id. `ClaudeSdkMessageRouter.handle` dropped those
outright, silently at every log level, so once the subagents settled and the
parent resumed the chat showed nothing further. The transcript kept all of it,
which is why restarting the agent host made the whole response appear.

Anchor a message that arrives with no active turn to the turn that spawned a
subagent still running. The spawn records that turn first-writer-wins like its
other fields, the registry exposes it while the spawn is outstanding, and the
router resolves through it before deciding to drop.

This makes the live path agree with the restored one: replay already
attributes the post-subagent output to the spawning turn.

Fixes #332073

Author: RyanEwen

src/vs/platform/agentHost/node/claude/claudeSdkMessageRouter.ts

@@ -65,20 +65,26 @@ export class ClaudeSdkMessageRouter extends Disposable {
 		this._clientToolOwner = clientToolOwner;
 	}
 
+	/**
+	 * Routes one SDK message. A message arriving with no active turn is anchored
+	 * to the turn that spawned a still-running subagent, because the parent
+	 * resumes producing output once those settle.
+	 */
 	async handle(message: SDKMessage, turnId: string | undefined, context?: IClaudeSdkMessageContext): Promise<void> {
+		const resolvedTurnId = turnId ?? this._subagents.outstandingSpawnTurnId();
 		if (message.type === 'assistant') {
 			this._editObserver.observeAssistant(message, context?.mode, context?.clientContext);
-		} else if (message.type === 'user' && turnId !== undefined) {
-			await this._editObserver.observeUser(message, turnId, this._mapperState);
+		} else if (message.type === 'user' && resolvedTurnId !== undefined) {
+			await this._editObserver.observeUser(message, resolvedTurnId, this._mapperState);
 		}
-		if (turnId === undefined) {
+		if (resolvedTurnId === undefined) {
 			return;
 		}
 		try {
 			const signals = mapSDKMessageToAgentSignals(
 				message,
 				this._chatChannelUri,
-				turnId,
+				resolvedTurnId,
 				this._mapperState,
 				this._logService,
 				this._subagents,

src/vs/platform/agentHost/node/claude/claudeSubagentRegistry.ts

@@ -56,6 +56,7 @@ export class SubagentSpawn {
 	subagentType: string | undefined;
 	description: string | undefined;
 	prompt: string | undefined;
+	turnId: string | undefined;
 
 	private _agentId: string | undefined;
 	private _announced = false;
@@ -88,6 +89,10 @@ export class SubagentSpawn {
 		return true;
 	}
 
+	get completed(): boolean {
+		return this._completed;
+	}
+
 	markCompleted(): boolean {
 		if (this._completed) {
 			return false;
@@ -110,6 +115,7 @@ export interface ISubagentSpawnInit {
 	readonly subagentType?: string;
 	readonly description?: string;
 	readonly prompt?: string;
+	readonly turnId?: string;
 }
 
 /**
@@ -159,9 +165,25 @@ export class SubagentRegistry extends Disposable {
 		if (init?.prompt !== undefined && spawn.prompt === undefined) {
 			spawn.prompt = init.prompt;
 		}
+		if (init?.turnId !== undefined && spawn.turnId === undefined) {
+			spawn.turnId = init.turnId;
+		}
 		return spawn;
 	}
 
+	/**
+	 * The turn that spawned a subagent still running, so output the parent
+	 * produces after its own turn ended can be anchored to that turn.
+	 */
+	outstandingSpawnTurnId(): string | undefined {
+		for (const spawn of this._spawns.values()) {
+			if (!spawn.completed && spawn.turnId !== undefined) {
+				return spawn.turnId;
+			}
+		}
+		return undefined;
+	}
+
 	getSpawn(toolUseId: string): SubagentSpawn | undefined {
 		return this._spawns.get(toolUseId);
 	}

src/vs/platform/agentHost/node/claude/claudeSubagentSignals.ts

@@ -165,7 +165,7 @@ export function buildTopLevelSubagentReadyAction(
 	const agentName = typeof input?.subagent_type === 'string' ? input.subagent_type : undefined;
 	const prompt = typeof input?.prompt === 'string' ? input.prompt : undefined;
 	const inputJson = block.input !== undefined ? safeStringify(block.input) : undefined;
-	registry.recordSpawn(block.id, { subagentType: agentName, description, prompt });
+	registry.recordSpawn(block.id, { subagentType: agentName, description, prompt, turnId });
 	const meta: Mutable<IToolCallMeta> = { ...buildClaudeToolCallMeta(block.name) };
 	if (!meta.toolKind) {
 		meta.toolKind = 'subagent';

src/vs/platform/agentHost/test/node/claudeAgent.test.ts

@@ -4037,6 +4037,44 @@ suite('ClaudeAgent', () => {
 		});
 	});
 
+	test('output the parent produces after a background subagent settles still reaches the chat', async () => {
+		const { agent, sdk } = createTestContext(disposables);
+		await agent.authenticate(GITHUB_COPILOT_PROTECTED_RESOURCE.resource, 'tok');
+
+		const created = await createSession(agent, { workingDirectories: [URI.file('/work')] });
+		const sessionId = created.sdkSessionId;
+		const PARENT = 'toolu_bg_resume';
+
+		sdk.nextQueryMessages = [
+			makeSystemInitMessage(sessionId),
+			makeAssistantMessage(sessionId, [
+				{ type: 'tool_use', id: PARENT, name: 'Task', input: { description: 'Audit', subagent_type: 'Explore', prompt: 'go' } },
+			]),
+			{ type: 'system', subtype: 'task_started', task_id: 't1', tool_use_id: PARENT, description: 'bg' } as unknown as SDKMessage,
+			// The parent ends its own turn here, so the prompt queue drains.
+			makeResultSuccess(sessionId),
+			// It resumes when the subagent settles, so these arrive with no turn.
+			makeStreamEvent(sessionId, makeMessageStart()),
+			makeStreamEvent(sessionId, makeContentBlockStartText(0)),
+			makeStreamEvent(sessionId, makeTextDelta(0, 'the audit agent came back')),
+			makeStreamEvent(sessionId, makeContentBlockStop(0)),
+			makeStreamEvent(sessionId, makeMessageStop()),
+		];
+
+		const signals: AgentSignal[] = [];
+		disposables.add(agent.onDidChatProgress(s => signals.push(s)));
+
+		await agent.chats.sendMessage(defaultChatUri(created.session), 'hi', undefined, undefined, 'turn-1', undefined, undefined, chatContext(defaultChatUri(created.session)));
+
+		// `sendMessage` settles on the result; the loop still drains what follows.
+		const resumed = () => signals.some(s => JSON.stringify(s).includes('the audit agent came back'));
+		for (let i = 0; i < 50 && !resumed(); i++) {
+			await tick();
+		}
+
+		assert.strictEqual(resumed(), true, `expected the resumed parent output to produce a signal; saw kinds: ${signals.map(s => s.kind).join(', ')}`);
+	});
+
 	test('canonical SDKAssistantMessage with text content does not double-emit signals already produced by stream_event partials (Phase 6.1 / Cycle F)', async () => {
 		// CONTEXT.md M8:875 — partials are advisory, final
 		// `SDKAssistantMessage` is canonical. With `includePartialMessages:

src/vs/platform/agentHost/test/node/claudeSubagentSignals.test.ts

@@ -396,6 +396,39 @@ suite('claudeSubagentSignals — Phase 12 emission', () => {
 		});
 	});
 
+	test('a background spawn records its turn and exposes it until it completes', () => {
+		const state = new ClaudeMapperState();
+		const log = new NullLogService();
+		const registry = r();
+		const PARENT = 'toolu_bg_anchor';
+
+		mapSDKMessageToAgentSignals(
+			makeAssistantMessage(SESSION_ID, [
+				{ type: 'tool_use', id: PARENT, name: 'Task', input: { description: 'Audit', subagent_type: 'Explore', prompt: 'go' } },
+			]),
+			SESSION, TURN_ID, state, log, registry,
+		);
+		mapSDKMessageToAgentSignals(
+			{ type: 'system', subtype: 'task_started', task_id: 't1', tool_use_id: PARENT, description: 'bg' } as unknown as SDKMessage,
+			SESSION, TURN_ID, state, log, registry,
+		);
+		const whileRunning = registry.outstandingSpawnTurnId();
+
+		mapSDKMessageToAgentSignals(
+			{ type: 'system', subtype: 'task_notification', task_id: 't1', tool_use_id: PARENT, status: 'completed', output_file: 'o', summary: 's' } as unknown as SDKMessage,
+			SESSION, TURN_ID, state, log, registry,
+		);
+
+		// The router anchors the parent's post-turn output to this turn.
+		assert.deepStrictEqual({
+			whileRunning,
+			afterCompletion: registry.outstandingSpawnTurnId(),
+		}, {
+			whileRunning: TURN_ID,
+			afterCompletion: undefined,
+		});
+	});
+
 	// #region focused contract tests on the extracted exports
 
 	test('buildTopLevelSubagentReadyAction omits _meta description/agentName when input fields are missing or wrong-typed; still records the spawn', () => {