Fix background summarization fallback gaps and improve summarization budget (#4981)

* Fix background summarization fallback gaps and improve summarization budget

- Record failure metadata on turn for all background compaction noResult
  paths, matching how foreground compaction tracks failures
- Add foreground summarization fallback when post-render background
  compaction produces no usable result at ≥95% context usage
- Use unreduced endpoint for both foreground and background summarization
  since they are separate LLM calls that don't share token space
- Filter deferred tool schemas from summarization prompt when Anthropic
  tool search is enabled to prevent budget_exceeded in Full mode
- Add Full→Simple fallback log and SimulateSummarizationError debug setting
- Deduplicate explanatory comments at summarization call sites
- Add tests for background summarizer noResult state machine paths
  and background failure metadata recording on turns

* Address Copilot review comments

- Remove unused endpoint parameter from _startBackgroundSummarization
- Remove duplicate backgroundSummarizer test (overlaps with existing)
- Clarify summarization.spec.tsx tests as contract tests

Author: bhavyaus

src/extension/intents/node/agentIntent.ts

@@ -510,6 +510,10 @@ export class AgentIntentInvocation extends EditCodeIntentInvocation implements I
 				this._persistSummaryOnTurn(bgResult, promptContext, this._lastRenderTokenCount);
 				this._sendBackgroundCompactionTelemetry('preRender', 'applied', contextRatio, promptContext);
 				summaryAppliedThisIteration = true;
+			} else {
+				this.logService.warn(`[Agent] background compaction state was Completed but consumeAndReset returned no result`);
+				this._sendBackgroundCompactionTelemetry('preRender', 'noResult', contextRatio, promptContext);
+				this._recordBackgroundCompactionFailure(promptContext, 'preRender');
 			}
 		}
 
@@ -531,8 +535,14 @@ export class AgentIntentInvocation extends EditCodeIntentInvocation implements I
 				this._sendBackgroundCompactionTelemetry('preRenderBlocked', 'applied', contextRatio, promptContext);
 				summaryAppliedThisIteration = true;
 			} else {
-				this.logService.debug(`[Agent] background compaction finished but produced no usable result`);
+				this.logService.debug(`[Agent] background compaction finished but produced no usable result — will attempt foreground summarization if budget exceeded`);
 				this._sendBackgroundCompactionTelemetry('preRenderBlocked', 'noResult', contextRatio, promptContext);
+				this._recordBackgroundCompactionFailure(promptContext, 'preRenderBlocked');
+				// Don't attempt a foreground fallback here — the main render below
+				// will either succeed (context estimate was pessimistic) or throw
+				// BudgetExceededError, which the catch block handles with foreground
+				// summarization. Short-circuiting here would skip the main render
+				// unnecessarily when it might still fit.
 			}
 		}
 
@@ -582,8 +592,10 @@ export class AgentIntentInvocation extends EditCodeIntentInvocation implements I
 
 			this.logService.debug(`[Agent] ${reason}, triggering summarization`);
 			try {
-				const renderer = PromptRenderer.create(this.instantiationService, endpoint, this.prompt, {
+				const renderer = PromptRenderer.create(this.instantiationService, this.endpoint, this.prompt, {
 					...renderProps,
+					endpoint: this.endpoint,
+					promptContext: this._buildSummarizationPromptContext(renderProps.promptContext),
 					triggerSummarize: true,
 				});
 				return await renderer.render(progress, token);
@@ -692,6 +704,7 @@ export class AgentIntentInvocation extends EditCodeIntentInvocation implements I
 					} else {
 						this.logService.debug(`[Agent] background compaction produced no usable result after budget exceeded — falling back to synchronous summarization`);
 						this._sendBackgroundCompactionTelemetry(budgetExceededTrigger, 'noResult', contextRatio, promptContext);
+						this._recordBackgroundCompactionFailure(promptContext, budgetExceededTrigger);
 						// Background compaction failed — fall back to synchronous summarization
 						result = await renderWithSummarization(`budget exceeded(${e.message}), background compaction failed`);
 					}
@@ -758,12 +771,19 @@ export class AgentIntentInvocation extends EditCodeIntentInvocation implements I
 					result = await reRenderer.render(progress, token);
 					this._lastRenderTokenCount = result.tokenCount;
 				} else {
-					this.logService.debug(`[Agent] post-render background compaction finished but produced no usable result`);
+					this.logService.debug(`[Agent] post-render background compaction finished but produced no usable result — falling back to foreground summarization`);
 					this._sendBackgroundCompactionTelemetry('postRenderBlocked', 'noResult', postRenderRatio, promptContext);
+					this._recordBackgroundCompactionFailure(promptContext, 'postRenderBlocked');
+					try {
+						result = await renderWithSummarization('post-render background compaction noResult fallback');
+						this._lastRenderTokenCount = result.tokenCount;
+					} catch (e) {
+						this.logService.error(e, `[Agent] post-render foreground summarization fallback also failed — using original render result`);
+					}
 				}
 			} else if (postRenderRatio >= 0.80 && (backgroundSummarizer.state === BackgroundSummarizationState.Idle || backgroundSummarizer.state === BackgroundSummarizationState.Failed)) {
 				// At ≥ 80% with no running compaction (or a previous failure) — kick off background work.
-				this._startBackgroundSummarization(backgroundSummarizer, props, endpoint, token, postRenderRatio);
+				this._startBackgroundSummarization(backgroundSummarizer, props, token, postRenderRatio);
 			}
 		}
 
@@ -831,7 +851,6 @@ export class AgentIntentInvocation extends EditCodeIntentInvocation implements I
 	private _startBackgroundSummarization(
 		backgroundSummarizer: BackgroundSummarizer,
 		props: AgentPromptProps,
-		endpoint: IChatEndpoint,
 		token: vscode.CancellationToken,
 		contextRatio: number,
 	): void {
@@ -846,8 +865,10 @@ export class AgentIntentInvocation extends EditCodeIntentInvocation implements I
 				toolCallResults: props.promptContext.toolCallResults ? { ...props.promptContext.toolCallResults } : undefined,
 			}
 		};
-		const bgRenderer = PromptRenderer.create(this.instantiationService, endpoint, this.prompt, {
+		const bgRenderer = PromptRenderer.create(this.instantiationService, this.endpoint, this.prompt, {
 			...snapshotProps,
+			endpoint: this.endpoint,
+			promptContext: this._buildSummarizationPromptContext(snapshotProps.promptContext),
 			triggerSummarize: true,
 			summarizationSource: 'background',
 		});
@@ -957,6 +978,48 @@ export class AgentIntentInvocation extends EditCodeIntentInvocation implements I
 		));
 	}
 
+	/**
+	 * Build a promptContext for summarization that filters availableTools to
+	 * non-deferred tools when Anthropic tool search is enabled. Deferred tool
+	 * schemas are unnecessary in the summarization prompt (which uses
+	 * tool_choice: 'none') and can push the prompt over the token budget.
+	 */
+	private _buildSummarizationPromptContext(promptContext: IBuildPromptContext): IBuildPromptContext {
+		if (!promptContext.tools?.availableTools) {
+			return promptContext;
+		}
+		const toolSearchEnabled = isAnthropicToolSearchEnabled(this.endpoint, this.configurationService);
+		if (!toolSearchEnabled) {
+			return promptContext;
+		}
+		const nonDeferredTools = promptContext.tools.availableTools.filter(t => this.toolDeferralService.isNonDeferredTool(t.name));
+		return {
+			...promptContext,
+			tools: {
+				...promptContext.tools,
+				availableTools: nonDeferredTools,
+			},
+		};
+	}
+
+	/**
+	 * Record a background compaction failure on the current turn's metadata,
+	 * matching how foreground compaction records its failures.
+	 */
+	private _recordBackgroundCompactionFailure(promptContext: IBuildPromptContext, trigger: string): void {
+		const turn = promptContext.conversation?.getLatestTurn();
+		turn?.setMetadata(new SummarizedConversationHistoryMetadata(
+			'', // no toolCallRoundId for failures
+			'', // no summary text for failures
+			{
+				model: this.endpoint.model,
+				source: 'background',
+				outcome: `noResult_${trigger}`,
+				contextLengthBefore: this._lastRenderTokenCount,
+			},
+		));
+	}
+
 	private _sendBackgroundCompactionTelemetry(
 		trigger: string,
 		outcome: string,

src/extension/prompts/node/agent/test/backgroundSummarizer.spec.ts

@@ -216,4 +216,40 @@ describe('BackgroundSummarizer', () => {
 		]);
 		expect(summarizer.state).toBe(BackgroundSummarizationState.Completed);
 	});
+
+	test('waitForCompletion resolves without error even when work fails', async () => {
+		// agentIntent.ts calls waitForCompletion without try/catch in the
+		// blocking paths — verify it swallows the error.
+		const summarizer = new BackgroundSummarizer(100_000);
+		summarizer.start(async _token => {
+			throw new Error('network timeout');
+		});
+		// Should not throw
+		await summarizer.waitForCompletion();
+		expect(summarizer.state).toBe(BackgroundSummarizationState.Failed);
+	});
+
+	test('cancel during waitForCompletion leaves state Idle with no result', async () => {
+		// Tests the race where a caller is awaiting completion and cancellation happens
+		const summarizer = new BackgroundSummarizer(100_000);
+		let resolveFn: () => void;
+		const gate = new Promise<void>(resolve => { resolveFn = resolve; });
+		summarizer.start(async _token => {
+			await gate;
+			return { summary: 'test', toolCallRoundId: 'r1' };
+		});
+		// Start awaiting completion (captures the promise but doesn't resolve yet)
+		const completionPromise = summarizer.waitForCompletion();
+		// Cancel while waitForCompletion is pending
+		summarizer.cancel();
+		// Let the work resolve so the promise settles
+		resolveFn!();
+		await completionPromise;
+		await new Promise<void>(resolve => setTimeout(resolve, 0));
+
+		// State should be Idle (cancel resets) and no result available
+		const result = summarizer.consumeAndReset();
+		expect(result).toBeUndefined();
+		expect(summarizer.state).toBe(BackgroundSummarizationState.Idle);
+	});
 });