test(compaction): pin previous-summary restoration boundary

steipete · steipete · commit 8ad8cfdd1bb3 · 2026-07-17T17:41:00.000+01:00
diff --git a/src/agents/agent-hooks/compaction-safeguard.test.ts b/src/agents/agent-hooks/compaction-safeguard.test.ts
@@ -2021,6 +2021,7 @@ describe("compaction-safeguard recent-turn preservation", () => {
     const messages = requireArray(call.messages);
     expect(JSON.stringify(messages[0])).toContain("<previous-compaction-summary>");
     expect(JSON.stringify(messages[0])).toContain("Old duplicated section");
+    expect(result.compaction?.summary).not.toContain("Old duplicated section");
   });
 
   it("preserves the prior summary when staged summarization returns a generic fallback", async () => {
diff --git a/src/agents/compaction.circuit-breaker.test.ts b/src/agents/compaction.circuit-breaker.test.ts
@@ -85,14 +85,19 @@ describe("compaction staged fallback circuit breaker", () => {
       .mockResolvedValueOnce("oldest summary")
       .mockRejectedValueOnce(new Error("fetch failed"))
       .mockResolvedValueOnce("newest summary")
-      .mockResolvedValueOnce("merged summary");
+      .mockResolvedValueOnce("merged: oldest summary + newest summary");
 
     // The oldest split carries whatever context the caller needs redistilled, and it
     // made it into the merge. Reporting a fallback here makes callers re-add it.
     await expect(summarize()).resolves.toEqual({
       kind: "summary",
-      text: "merged summary",
+      text: "merged: oldest summary + newest summary",
     });
     expect(agentSessionMocks.generateSummary).toHaveBeenCalledTimes(4);
+    expect(agentSessionMocks.generateSummary.mock.calls[3]?.[0]).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ content: expect.stringContaining("oldest summary") }),
+      ]),
+    );
   });
 });
diff --git a/src/agents/compaction.ts b/src/agents/compaction.ts
@@ -413,11 +413,9 @@ export async function summarizeInStages(params: {
 
   const partialSummaries: string[] = [];
   let consecutiveGenericFallbacks = 0;
-  // Chunk 0 carries the oldest messages, which is where a caller puts context it needs
-  // redistilled into the new summary. Only its degradation means that context never
-  // reached the merge, so this — not "any chunk degraded" — is what the result kind
-  // reports; otherwise a caller restoring lost context duplicates what the merge has.
-  let firstChunkDegraded = false;
+  // Caller-owned leading context lives in the oldest split. Only losing that
+  // split requires restoration; later fallback placeholders remain in the merge.
+  let oldestChunkDegraded = false;
   for (const [index, chunk] of plan.chunks.entries()) {
     const result = await summarizeWithFallbackResult({
       ...params,
@@ -427,7 +425,7 @@ export async function summarizeInStages(params: {
     consecutiveGenericFallbacks =
       result.kind === "generic-fallback" ? consecutiveGenericFallbacks + 1 : 0;
     if (index === 0) {
-      firstChunkDegraded = result.kind === "generic-fallback";
+      oldestChunkDegraded = result.kind === "generic-fallback";
     }
 
     // Keep one placeholder to mark the missing split, but stop before repeated
@@ -451,7 +449,7 @@ export async function summarizeInStages(params: {
       throw new Error("Compaction summary plan produced no summary");
     }
     return {
-      kind: firstChunkDegraded ? "generic-fallback" : "summary",
+      kind: oldestChunkDegraded ? "generic-fallback" : "summary",
       text: summary,
     };
   }
@@ -492,7 +490,7 @@ export async function summarizeInStages(params: {
     messages: summaryMessages,
     customInstructions: mergeInstructions,
   });
-  return firstChunkDegraded && mergedResult.kind === "summary"
+  return oldestChunkDegraded && mergedResult.kind === "summary"
     ? { kind: "generic-fallback", text: mergedResult.text }
     : mergedResult;
 }
