gsd-pi 2.77.0 → 2.78.0-dev.aeeb2ca00

package/packages/pi-coding-agent/src/core/agent-session-tool-refresh.test.ts

@@ -1,64 +1,133 @@
-// GSD-2 — Regression tests for #3616: tool list persistence across newSession() calls
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+// Regression test for #3616: newSession() must restore the full tool set
+// when cwd is unchanged.
+//
+// The bug: extensions may narrow the active tool list via setActiveTools()
+// during a session. Without a refresh in the else branch of newSession(),
+// the narrowed set persists into the next session — breaking auto-mode
+// subagent sessions that expect a full tool palette.
+//
+// Verified behaviourally: construct an AgentSession, wrap _refreshToolRegistry
+// to record its args, call newSession() with cwd unchanged, and assert that
+// a refresh was requested with includeAllExtensionTools: true.
 
-import test, { describe } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { afterEach, beforeEach, describe, it } from "node:test";
 
-const source = readFileSync(
-	join(process.cwd(), "packages/pi-coding-agent/src/core/agent-session.ts"),
-	"utf-8",
-);
+import { Agent } from "@gsd/pi-agent-core";
+import { AgentSession } from "./agent-session.js";
+import { AuthStorage } from "./auth-storage.js";
+import { ModelRegistry } from "./model-registry.js";
+import { DefaultResourceLoader } from "./resource-loader.js";
+import { SessionManager } from "./session-manager.js";
+import { SettingsManager } from "./settings-manager.js";
 
-describe("#3616 — newSession() must restore full tool set", () => {
-	test("newSession() calls _refreshToolRegistry with includeAllExtensionTools when cwd is unchanged", () => {
-		// Find the newSession method
-		const newSessionStart = source.indexOf("async newSession(options?:");
-		assert.ok(newSessionStart >= 0, "should find newSession method");
+let testDir: string;
 
-		// Get the method body (up to the next top-level method)
-		const methodBody = source.slice(newSessionStart, newSessionStart + 3000);
+async function createSession(): Promise<AgentSession> {
+	const agentDir = join(testDir, "agent-home");
+	const authStorage = AuthStorage.inMemory({});
+	const modelRegistry = new ModelRegistry(authStorage, join(agentDir, "models.json"));
+	const settingsManager = SettingsManager.inMemory();
+	const resourceLoader = new DefaultResourceLoader({
+		cwd: testDir,
+		agentDir,
+		settingsManager,
+		noExtensions: true,
+		noPromptTemplates: true,
+		noThemes: true,
+	});
+	await resourceLoader.reload();
 
-		// Verify the cwd-changed branch rebuilds tools
-		assert.ok(
-			methodBody.includes("if (this._cwd !== previousCwd)"),
-			"should have cwd-change guard",
-		);
+	return new AgentSession({
+		agent: new Agent(),
+		sessionManager: SessionManager.inMemory(testDir),
+		settingsManager,
+		cwd: testDir,
+		resourceLoader,
+		modelRegistry,
+	});
+}
+
+describe("#3616 — newSession() restores narrowed tool set when cwd unchanged", () => {
+	beforeEach(() => {
+		testDir = mkdtempSync(join(tmpdir(), "agent-session-tool-refresh-"));
+	});
+
+	afterEach(() => {
+		rmSync(testDir, { recursive: true, force: true });
+	});
 
-		// Verify the else branch exists and refreshes tools with includeAllExtensionTools
-		const elseIdx = methodBody.indexOf("} else {");
-		assert.ok(elseIdx >= 0, "should have else branch for cwd-unchanged case");
+	it("calls _refreshToolRegistry with includeAllExtensionTools: true when cwd unchanged", async () => {
+		const session = await createSession();
+		// Pin _cwd so newSession()'s `process.cwd()` branch takes the
+		// cwd-unchanged path. The production code compares `this._cwd !==
+		// previousCwd`; we force equality by setting _cwd to current cwd.
+		(session as any)._cwd = process.cwd();
+
+		const refreshCalls: Array<{ includeAllExtensionTools?: boolean }> = [];
+		const originalRefresh = (session as any)._refreshToolRegistry.bind(session);
+		(session as any)._refreshToolRegistry = (options?: { includeAllExtensionTools?: boolean }) => {
+			refreshCalls.push(options ?? {});
+			return originalRefresh(options);
+		};
+
+		const ok = await session.newSession();
+		assert.equal(ok, true);
 
-		const elseBranch = methodBody.slice(elseIdx, elseIdx + 800);
 		assert.ok(
-			elseBranch.includes("_refreshToolRegistry"),
-			"else branch should call _refreshToolRegistry",
+			refreshCalls.length > 0,
+			"newSession() should invoke _refreshToolRegistry in the cwd-unchanged branch",
 		);
 		assert.ok(
-			elseBranch.includes("includeAllExtensionTools: true"),
-			"else branch should pass includeAllExtensionTools: true to restore narrowed tools",
+			refreshCalls.some((o) => o.includeAllExtensionTools === true),
+			`at least one _refreshToolRegistry call must pass includeAllExtensionTools: true; observed=${JSON.stringify(refreshCalls)}`,
 		);
 	});
 
-	test("newSession() references #3616 in the else-branch comment", () => {
-		const idx = source.indexOf("#3616");
-		assert.ok(idx >= 0, "source should reference issue #3616 for the tool restore fix");
+	it("agent.reset() does not clear _state.tools (tools persist across reset)", () => {
+		// Structural invariant protecting #3616: if reset() starts clearing
+		// tools, newSession()'s refresh becomes the only defense against loss.
+		// Assertion is behavioural — seed tools, call reset(), observe survival.
+		const agent = new Agent();
+		const tool = {
+			name: "test_tool",
+			description: "x",
+			schema: { type: "object", properties: {}, additionalProperties: false } as any,
+			execute: async () => ({ content: [] }),
+		};
+		(agent as any)._state.tools = [tool];
+		agent.reset();
+		assert.deepEqual(
+			(agent as any)._state.tools,
+			[tool],
+			"Agent.reset() must preserve _state.tools",
+		);
 	});
 
-	test("agent.reset() does not clear _state.tools (tools persist across reset)", () => {
-		// This is a structural invariant — if reset() starts clearing tools,
-		// the newSession() refresh becomes the only defense against tool loss.
-		const agentSource = readFileSync(
-			join(process.cwd(), "packages/pi-agent-core/src/agent.ts"),
-			"utf-8",
-		);
-		const resetStart = agentSource.indexOf("reset()");
-		assert.ok(resetStart >= 0, "should find reset() method");
-		const resetBody = agentSource.slice(resetStart, resetStart + 400);
+	it("takes the cwd-changed branch (rebuilds runtime) when cwd differs", async () => {
+		const session = await createSession();
+		// Force the cwd-changed branch: set _cwd to something that won't equal process.cwd().
+		(session as any)._cwd = join(testDir, "some", "other", "cwd");
+
+		let buildRuntimeCalled = false;
+		let buildRuntimeIncludedAll = false;
+		const originalBuild = (session as any)._buildRuntime.bind(session);
+		(session as any)._buildRuntime = (options?: { includeAllExtensionTools?: boolean }) => {
+			buildRuntimeCalled = true;
+			if (options?.includeAllExtensionTools === true) buildRuntimeIncludedAll = true;
+			return originalBuild(options);
+		};
+
+		const ok = await session.newSession();
+		assert.equal(ok, true);
+
+		assert.ok(buildRuntimeCalled, "cwd-changed branch must rebuild the tool runtime");
 		assert.ok(
-			!resetBody.includes("tools"),
-			"reset() should NOT touch _state.tools — tools are managed by agent-session",
+			buildRuntimeIncludedAll,
+			"cwd-changed branch must rebuild with includeAllExtensionTools: true",
 		);
 	});
 });

package/packages/pi-coding-agent/src/core/compaction/compaction.test.ts

@@ -9,7 +9,8 @@ import { describe, it, mock } from "node:test";
 import type { AgentMessage } from "@gsd/pi-agent-core";
 import type { Model, AssistantMessage } from "@gsd/pi-ai";
 
-import { generateSummary, estimateTokens, chunkMessages } from "./compaction.js";
+import { generateSummary, estimateTokens, chunkMessages, isDegenerateSummary, CompactionProducedNoSummaryError } from "./compaction.js";
+import { estimateSerializedTokens } from "./utils.js";
 
 // ---------------------------------------------------------------------------
 // Helpers
@@ -21,6 +22,39 @@ function makeUserMessage(tokenCount: number): AgentMessage {
 	return { role: "user", content: text } as unknown as AgentMessage;
 }
 
+/**
+ * Create a tool-result message of approximately `rawTokenCount` uncapped tokens.
+ * Post-truncation, this estimates to ~500 tokens (TOOL_RESULT_MAX_CHARS / 4).
+ *
+ * Used to exercise the #4665 regression: before the fix, chunkMessages used
+ * estimateTokens (pre-truncation), so a 100K-token tool result forced its own
+ * chunk even though it serialized to ~500 tokens. After the fix, many tool
+ * results coalesce into a single chunk.
+ */
+function makeToolResultMessage(rawTokenCount: number): AgentMessage {
+	const text = "y".repeat(rawTokenCount * 4);
+	return {
+		role: "toolResult",
+		toolCallId: `call_${rawTokenCount}`,
+		content: [{ type: "text", text }],
+	} as unknown as AgentMessage;
+}
+
+/**
+ * Create a branch-summary message with a specific summary length. Summary
+ * messages are intentionally NOT truncated by the serializer (they're already
+ * concise), so this is the right tool to force chunking post-fix.
+ */
+function makeBranchSummaryMessage(approxTokens: number): AgentMessage {
+	const summary = "z".repeat(approxTokens * 4);
+	return {
+		role: "branchSummary",
+		summary,
+		fromId: "test",
+		timestamp: 0,
+	} as unknown as AgentMessage;
+}
+
 /** Create a mock model with a given context window. */
 function makeModel(contextWindow: number): Model<any> {
 	return {
@@ -60,45 +94,97 @@ describe("chunkMessages", () => {
 	});
 
 	it("splits messages into multiple chunks when they exceed budget", () => {
+		// Use branchSummary messages — they aren't capped by the serializer, so
+		// their post-serialization size matches their raw size. Each 50k-token
+		// summary must get its own chunk under an 80k budget.
 		const messages: AgentMessage[] = [
-			makeUserMessage(50_000),
-			makeUserMessage(50_000),
-			makeUserMessage(50_000),
+			makeBranchSummaryMessage(50_000),
+			makeBranchSummaryMessage(50_000),
+			makeBranchSummaryMessage(50_000),
 		];
-		// Budget of 80k tokens means each 50k message gets its own chunk
-		// (or two fit together if budget allows)
 		const chunks = chunkMessages(messages, 80_000);
 		assert.ok(chunks.length > 1, `Expected multiple chunks, got ${chunks.length}`);
-		// All messages should be present across chunks
 		const totalMessages = chunks.reduce((sum, c) => sum + c.length, 0);
 		assert.equal(totalMessages, 3);
 	});
 
 	it("puts a single oversized message in its own chunk", () => {
-		const messages: AgentMessage[] = [
-			makeUserMessage(200_000), // Way over any reasonable budget
-		];
+		// Use branchSummary — not truncated by the serializer — to force the
+		// oversized-single-message path. A user message with the same raw size
+		// would cap to ~500 tokens and fit in any reasonable budget.
+		const messages: AgentMessage[] = [makeBranchSummaryMessage(200_000)];
 		const chunks = chunkMessages(messages, 80_000);
 		assert.equal(chunks.length, 1);
 		assert.equal(chunks[0].length, 1);
 	});
 
 	it("preserves message order across chunks", () => {
-		// Create messages with identifiable sizes
 		const messages: AgentMessage[] = [
-			makeUserMessage(30_000), // ~30k tokens
-			makeUserMessage(30_000),
-			makeUserMessage(30_000),
-			makeUserMessage(30_000),
+			makeBranchSummaryMessage(30_000),
+			makeBranchSummaryMessage(30_000),
+			makeBranchSummaryMessage(30_000),
+			makeBranchSummaryMessage(30_000),
 		];
 		const chunks = chunkMessages(messages, 50_000);
-		// Reconstruct original order
 		const flat = chunks.flat();
 		assert.equal(flat.length, 4);
 		for (let i = 0; i < flat.length; i++) {
 			assert.strictEqual(flat[i], messages[i], `Message ${i} should be in order`);
 		}
 	});
+
+	// ---------------------------------------------------------------------------
+	// #4665 regression: token estimation must reflect serializer truncation
+	// ---------------------------------------------------------------------------
+
+	it("(#4665) does not over-split when tool results dominate — they serialize to ~500 tokens", () => {
+		// Ten 100K-token tool results. Under the old pre-truncation estimator
+		// this would estimate to ~1M tokens and force 10+ tiny chunks. Under
+		// the new estimator each caps to ~500 tokens (TOOL_RESULT_MAX_CHARS/4),
+		// so 10 of them total ~5K tokens and fit in a single generous budget.
+		const messages: AgentMessage[] = Array.from({ length: 10 }, () =>
+			makeToolResultMessage(100_000),
+		);
+		const chunks = chunkMessages(messages, 50_000);
+		assert.equal(
+			chunks.length,
+			1,
+			"ten 100K-token tool results should coalesce into one chunk (cap=2000 chars → ~500 tokens each)",
+		);
+		assert.equal(chunks[0].length, 10);
+	});
+
+	it("(#4665) estimateSerializedTokens caps toolResult at TOOL_RESULT_MAX_CHARS/4", () => {
+		const huge = makeToolResultMessage(100_000);
+		const serialized = estimateSerializedTokens(huge);
+		const raw = estimateTokens(huge);
+		assert.ok(raw > 50_000, `raw estimator should report the real size, got ${raw}`);
+		assert.ok(
+			serialized < 1_000,
+			`serialized estimator should cap at ~500 tokens, got ${serialized}`,
+		);
+	});
+
+	it("(#4665) estimateSerializedTokens also caps large user content and assistant thinking", () => {
+		const hugeUser = makeUserMessage(50_000);
+		assert.ok(
+			estimateSerializedTokens(hugeUser) < 1_000,
+			"user content > cap must be truncated in the estimator",
+		);
+
+		// Assistant with a huge thinking block + huge text block
+		const hugeAssistant: AgentMessage = {
+			role: "assistant",
+			content: [
+				{ type: "thinking", thinking: "t".repeat(100_000) },
+				{ type: "text", text: "r".repeat(100_000) },
+			],
+		} as unknown as AgentMessage;
+		assert.ok(
+			estimateSerializedTokens(hugeAssistant) < 2_000,
+			"assistant thinking + text must each cap; total under 2x TOOL_RESULT_MAX_CHARS/4",
+		);
+	});
 });
 
 // ---------------------------------------------------------------------------
@@ -107,18 +193,22 @@ describe("chunkMessages", () => {
 
 describe("generateSummary — chunked fallback (#2932)", () => {
 	it("calls _completeFn multiple times when messages exceed model context window", async () => {
-		// Arrange: 3 messages of ~80k tokens each = ~240k total, model has 200k window
+		// Use branchSummary messages — not capped by the serializer — so the
+		// chunker's post-truncation view matches the raw view. 3 × 80k summaries
+		// totalling 240k tokens must exceed a 200k context window.
 		const messages: AgentMessage[] = [
-			makeUserMessage(80_000),
-			makeUserMessage(80_000),
-			makeUserMessage(80_000),
+			makeBranchSummaryMessage(80_000),
+			makeBranchSummaryMessage(80_000),
+			makeBranchSummaryMessage(80_000),
 		];
 		const model = makeModel(200_000);
 		const reserveTokens = 16_384;
 
-		// Verify our test setup: messages really do exceed the model window
+		// Verify our test setup: messages really do exceed the model window.
+		// Use estimateSerializedTokens because that's what generateSummary uses
+		// for its "does this fit?" decision post-#4665.
 		let totalTokens = 0;
-		for (const m of messages) totalTokens += estimateTokens(m);
+		for (const m of messages) totalTokens += estimateSerializedTokens(m);
 		assert.ok(
 			totalTokens > model.contextWindow,
 			`Test setup: ${totalTokens} tokens should exceed ${model.contextWindow} context window`,
@@ -138,7 +228,12 @@ describe("generateSummary — chunked fallback (#2932)", () => {
 			} else {
 				calls.push("initial");
 			}
-			return makeFakeResponse("Summary of chunk");
+			// Return a non-degenerate summary (>100 chars). Short responses like
+			// "Summary of chunk" would trip the #4665 degenerate-output guard,
+			// which is exactly what we don't want to test here.
+			return makeFakeResponse(
+				"## Goal\nDetailed summary of this chunk describing the work completed, files touched, and decisions made. At least 100 characters so the degenerate guard does not trip.",
+			);
 		});
 
 		const summary = await generateSummary(
@@ -197,13 +292,14 @@ describe("generateSummary — chunked fallback (#2932)", () => {
 
 	it("passes previousSummary through chunked summarization", async () => {
 		const messages: AgentMessage[] = [
-			makeUserMessage(80_000),
-			makeUserMessage(80_000),
-			makeUserMessage(80_000),
+			makeBranchSummaryMessage(80_000),
+			makeBranchSummaryMessage(80_000),
+			makeBranchSummaryMessage(80_000),
 		];
 		const model = makeModel(200_000);
 		const reserveTokens = 16_384;
-		const previousSummary = "Previous session summary content";
+		const previousSummary =
+			"Previous session summary content — intentionally verbose enough to clear the degenerate-summary threshold so this test exercises the actual propagation path.";
 
 		const prompts: string[] = [];
 		const mockComplete = mock.fn(async (_model: any, context: any) => {
@@ -213,7 +309,9 @@ describe("generateSummary — chunked fallback (#2932)", () => {
 					? userMsg.content
 					: userMsg?.content?.[0]?.text ?? "";
 			prompts.push(text);
-			return makeFakeResponse("Chunk summary");
+			return makeFakeResponse(
+				"Chunk summary with sufficient length to clear the #4665 degenerate-output guard threshold of 100 characters — this must be longer.",
+			);
 		});
 
 		await generateSummary(
@@ -234,3 +332,245 @@ describe("generateSummary — chunked fallback (#2932)", () => {
 		);
 	});
 });
+
+// ---------------------------------------------------------------------------
+// #4665 regression — iterative chain must not propagate degenerate summaries
+// ---------------------------------------------------------------------------
+
+describe("(#4665) degenerate summary guard", () => {
+	it("isDegenerateSummary detects the known failure patterns", () => {
+		assert.equal(isDegenerateSummary(undefined), false);
+		assert.equal(isDegenerateSummary(""), true, "empty string is degenerate");
+		assert.equal(isDegenerateSummary("too short"), true, "short output is degenerate");
+		assert.equal(
+			isDegenerateSummary("The user asked me to summarize an empty conversation"),
+			true,
+			"known failure phrase 'empty conversation' is degenerate",
+		);
+		assert.equal(
+			isDegenerateSummary("No conversation to summarize"),
+			true,
+			"'no conversation to summarize' is degenerate",
+		);
+		assert.equal(
+			isDegenerateSummary(
+				"## Goal\nRefactor the compaction pipeline.\n## Done\n- Updated utils.ts\n- Added tests for #4665 regression path",
+			),
+			false,
+			"a real multi-section summary over 100 chars is not degenerate",
+		);
+	});
+
+	it("does not propagate a degenerate first-chunk summary forward (no 'preserve nothing' chain)", async () => {
+		// Force the chunked path with uncapped summary messages.
+		const messages: AgentMessage[] = [
+			makeBranchSummaryMessage(80_000),
+			makeBranchSummaryMessage(80_000),
+			makeBranchSummaryMessage(80_000),
+		];
+		const model = makeModel(200_000);
+		const reserveTokens = 16_384;
+
+		// Responses: chunk 0 returns degenerate ("empty conversation"). Chunks
+		// 1 and 2 return real summaries. Pre-fix behavior: the chunk-0 output
+		// is fed into UPDATE_SUMMARIZATION_PROMPT for chunks 1+, which says
+		// "PRESERVE all existing information" — so emptiness is preserved.
+		// Post-fix: the degenerate chunk-0 output must not become runningSummary.
+		let callIndex = 0;
+		const responses = [
+			"The user asked me to summarize an empty conversation.",
+			"## Done\n- Refactored the serializer to head+tail truncation.\n- Updated chunker to use post-serialization token estimate.",
+			"## Done\n- Added regression tests for #4665 including this propagation guard.\n- Verified isDegenerateSummary handles known failure patterns.",
+		];
+		const seenPrompts: string[] = [];
+		const mockComplete = mock.fn(async (_model: any, context: any) => {
+			const userMsg = context.messages?.[0];
+			const text =
+				typeof userMsg?.content === "string"
+					? userMsg.content
+					: userMsg?.content?.[0]?.text ?? "";
+			seenPrompts.push(text);
+			const response = responses[Math.min(callIndex, responses.length - 1)];
+			callIndex++;
+			return makeFakeResponse(response);
+		});
+
+		const summary = await generateSummary(
+			messages,
+			model,
+			reserveTokens,
+			undefined,
+			undefined,
+			undefined,
+			undefined,
+			mockComplete,
+		);
+
+		// The returned summary must be one of the real chunk summaries — not
+		// the degenerate "empty conversation" output, and not an empty string.
+		assert.ok(
+			!isDegenerateSummary(summary),
+			`final summary should not be degenerate. got: ${JSON.stringify(summary)}`,
+		);
+		assert.ok(
+			summary.includes("Refactored") || summary.includes("regression tests"),
+			"final summary should carry real information from chunks 1 or 2",
+		);
+	});
+
+	it("retries the first chunk once with the initial prompt if the first pass is degenerate", async () => {
+		// Force chunked path with a single large chunk. Mock returns degenerate
+		// on the first call and a real summary on the retry.
+		const messages: AgentMessage[] = [
+			makeBranchSummaryMessage(80_000),
+			makeBranchSummaryMessage(80_000),
+		];
+		const model = makeModel(100_000); // small window forces chunking
+		const reserveTokens = 16_384;
+
+		const responses = [
+			"", // first attempt: empty string → degenerate
+			"## Goal\nReal summary produced on the retry pass after the initial pass came back empty — this should land as the running summary.",
+			"## Done\n- Added retry-on-degenerate-first-chunk behavior to the iterative summarizer so empty outputs don't poison the chain.",
+		];
+		let callIndex = 0;
+		const mockComplete = mock.fn(async () => {
+			const response = responses[Math.min(callIndex, responses.length - 1)];
+			callIndex++;
+			return makeFakeResponse(response);
+		});
+
+		const summary = await generateSummary(
+			messages,
+			model,
+			reserveTokens,
+			undefined,
+			undefined,
+			undefined,
+			undefined,
+			mockComplete,
+		);
+
+		assert.ok(
+			!isDegenerateSummary(summary),
+			"final summary must not be degenerate after the retry took effect",
+		);
+		assert.ok(
+			mockComplete.mock.callCount() >= 3,
+			`expected at least 3 calls (first attempt, retry, second chunk), got ${mockComplete.mock.callCount()}`,
+		);
+	});
+
+	// -------------------------------------------------------------------------
+	// R1 — retry non-first chunks too + observable log when both attempts fail
+	// -------------------------------------------------------------------------
+
+	it("(R1) retries a degenerate NON-FIRST chunk before silently dropping it", async () => {
+		// Use a small model window to force exactly 2 chunks from 2 messages.
+		// Chunk 0 ok, chunk 1 degenerate on first try then real on retry.
+		// Chunk 1's recovered content must reach the final summary.
+		const messages: AgentMessage[] = [
+			makeBranchSummaryMessage(80_000),
+			makeBranchSummaryMessage(80_000),
+		];
+		const model = makeModel(100_000);
+		const reserveTokens = 16_384;
+
+		const CHUNK0_SUMMARY = "## Done\n- Chunk 0 real summary with enough length to clear the degenerate threshold of 100 characters — easily.";
+		const CHUNK1_RETRY_SUMMARY = "## Done\n- Chunk 1 recovered on retry — its content must appear in the final summary or the R1 fix regressed for non-first chunks.";
+
+		let callIndex = 0;
+		const responses = [
+			CHUNK0_SUMMARY,           // chunk 0
+			"empty conversation",     // chunk 1 first try → degenerate
+			CHUNK1_RETRY_SUMMARY,     // chunk 1 retry → real
+		];
+		const mockComplete = mock.fn(async () => {
+			const r = responses[Math.min(callIndex, responses.length - 1)];
+			callIndex++;
+			return makeFakeResponse(r);
+		});
+
+		const summary = await generateSummary(
+			messages,
+			model,
+			reserveTokens,
+			undefined,
+			undefined,
+			undefined,
+			undefined,
+			mockComplete,
+		);
+
+		assert.equal(
+			mockComplete.mock.callCount(),
+			3,
+			"expected 3 calls: chunk 0 + chunk 1 initial + chunk 1 retry",
+		);
+		assert.ok(
+			summary.includes("recovered on retry"),
+			`final summary must include chunk 1's retry content (R1: non-first chunks must also retry), got: ${JSON.stringify(summary)}`,
+		);
+	});
+
+	// -------------------------------------------------------------------------
+	// R6 — empty output must not be silently written as a compaction entry
+	// -------------------------------------------------------------------------
+
+	it("(R6) throws CompactionProducedNoSummaryError when every chunk is degenerate AND no previousSummary", async () => {
+		const messages: AgentMessage[] = [
+			makeBranchSummaryMessage(80_000),
+			makeBranchSummaryMessage(80_000),
+		];
+		const model = makeModel(100_000);
+		const reserveTokens = 16_384;
+
+		// Every response is degenerate, both initial and retry attempts.
+		const mockComplete = mock.fn(async () => makeFakeResponse("empty conversation"));
+
+		await assert.rejects(
+			() => generateSummary(
+				messages,
+				model,
+				reserveTokens,
+				undefined,
+				undefined,
+				undefined,
+				undefined, // no previousSummary
+				mockComplete,
+			),
+			(err: unknown) => err instanceof CompactionProducedNoSummaryError,
+			"expected CompactionProducedNoSummaryError when all chunks degenerate and no previousSummary",
+		);
+	});
+
+	it("(R6) falls back to previousSummary when every chunk is degenerate", async () => {
+		const messages: AgentMessage[] = [
+			makeBranchSummaryMessage(80_000),
+			makeBranchSummaryMessage(80_000),
+		];
+		const model = makeModel(100_000);
+		const reserveTokens = 16_384;
+		const previousSummary =
+			"Previously-computed summary from the last compaction — deliberately long enough to clear the degenerate-output threshold.";
+
+		const mockComplete = mock.fn(async () => makeFakeResponse("empty conversation"));
+
+		const result = await generateSummary(
+			messages,
+			model,
+			reserveTokens,
+			undefined,
+			undefined,
+			undefined,
+			previousSummary,
+			mockComplete,
+		);
+
+		assert.equal(
+			result,
+			previousSummary,
+			"when all chunks degenerate, must fall back to previousSummary rather than return empty string",
+		);
+	});
+});