Replace accumulating compaction with one evidence-backed handoff

Failed summaries used to write a stats stub into history, and later
folds stacked frozen prefixes. The primary session now keeps the prior
context on summary failure and replaces the dropped prefix with a
single archive-backed handoff.

Author: TheGreatAxios

docs/IMPLEMENTATION.md

@@ -79,7 +79,8 @@ src/
     index.ts              Session lifecycle
     state.ts              RunState JSON save/load
     compactor.ts          Context compactor
-    summarizer.ts         Model-backed structured compaction summary (+ deterministic fallback)
+    summarizer.ts         Model-backed structured compaction summary (fails closed)
+    summary-excerpt.ts    Token-budgeted archive excerpt for the summary call
     compaction-archive.ts Primary-only authorized evidence archive (post-policy capture)
     compaction-archive-schema.ts Archive occurrence / completeness certificate schemas
     run-sink.ts           Run-level event sink

src/config/settings.ts

@@ -117,9 +117,9 @@ export interface Settings {
   // interactive install). Upgrade stamps only after notes are actually shown
   // so a missing surface cannot silently swallow them (CL-5475).
   lastChangelogVersion?: string;
-  // Controls the context-compaction strategy used when the context window fills.
-  // "llm" (default) generates a structured handoff summary via LLM call.
-  // "pruning" uses fast deterministic pruning with no LLM call.
+  // Deprecated: summarize vs drop is no longer operator-selectable. Primary
+  // compaction is always the evidence-backed LLM handoff. Legacy values may
+  // still appear in on-disk settings and are ignored; new writes omit this field.
   compactionMode?: "llm" | "pruning";
   // Deprecated (CL-5814): orchestrator is the only product path. Legacy values
   // may still appear in on-disk settings and are ignored at resolve time; new

src/context-compactor.test.ts

@@ -7,7 +7,6 @@ import {
   classifyTaskBoundary,
   buildLLMTurnSummary,
   COMPACTED_PREFIX,
-  COMPACT_SPACER_TEXT,
   type SessionMetadata,
 } from "./session/compactor.js";
 import { createModelSummarizer } from "./session/summarizer.js";
@@ -585,7 +584,7 @@ describe("createPruningCompactor — summarize receives the workflow context (CL
   });
 });
 
-describe("createPruningCompactor — prefix-stable summaries (CL-6914)", () => {
+describe("createPruningCompactor — consolidated handoff (CL-7521)", () => {
   function firstText(turn: ConversationTurn): string {
     const block = turn.content.find((b) => b.type === "text");
     return block !== undefined && block.type === "text" ? block.text : "";
@@ -608,23 +607,55 @@ describe("createPruningCompactor — prefix-stable summaries (CL-6914)", () => {
     return [...base, ...extra];
   }
 
-  test("second apply leaves output[0] bytes identical and appends a later summary", async () => {
+  test("second apply replaces the prior summary instead of accumulating", async () => {
     const compactor = createPruningCompactor({ keepRecentTurns: 2, summaryMaxChars: 500 });
     const turns = grow([], 16, "round1");
     const output1 = (await compactor.apply(turns, mockStrategyCtx)).output;
     expect(firstText(output1[0]!)).toContain(COMPACTED_PREFIX);
 
     const output2 = (await compactor.apply(grow(output1, 16, "round2"), mockStrategyCtx)).output;
 
-    expect(firstText(output2[0]!)).toBe(firstText(output1[0]!));
-    expect(output2[0]).toBe(output1[0]);
-    const summaries = compactedTurns(output2);
-    expect(summaries.length).toBeGreaterThanOrEqual(2);
-    expect(output2.indexOf(summaries[1]!)).toBeGreaterThan(0);
+    expect(output2[0]).not.toBe(output1[0]);
+    expect(compactedTurns(output2)).toHaveLength(1);
+    expect(firstText(output2[0]!)).toContain(COMPACTED_PREFIX);
     expect(hasConsecutiveSameRole(output2)).toBe(false);
+    expect(allText(output2)).toContain("round1 0");
+  });
+
+  test("second apply keeps the initiating task as its own user turn", async () => {
+    const compactor = createPruningCompactor({
+      keepRecentTurns: 2,
+      maxAnchorTurns: 1,
+      summaryMaxChars: 500,
+    });
+    const goal = "GOAL: migrate the auth module to opaque tokens";
+    const turns: ConversationTurn[] = [
+      makeTurn({ role: "user", content: [{ type: "text", text: goal }] }),
+    ];
+    for (let i = 0; i < 8; i++) {
+      turns.push(makeTurn({ role: "assistant", content: [{ type: "text", text: `step ${i}` }] }));
+    }
+    turns.push(
+      makeTurn({ role: "user", content: [{ type: "text", text: "also handle refresh" }] }),
+    );
+    turns.push(makeTurn({ role: "assistant", content: [{ type: "text", text: "recent reply" }] }));
+    turns.push(makeTurn({ role: "user", content: [{ type: "text", text: "recent ask" }] }));
+
+    const output1 = (await compactor.apply(turns, mockStrategyCtx)).output;
     expect(
-      output2.some((t) => t.role === "assistant" && firstText(t) === COMPACT_SPACER_TEXT),
+      output1.some(
+        (t) => t.role === "user" && t.content.some((b) => b.type === "text" && b.text === goal),
+      ),
     ).toBe(true);
+
+    const output2 = (await compactor.apply(grow(output1, 16, "round2"), mockStrategyCtx)).output;
+    expect(compactedTurns(output2)).toHaveLength(1);
+    expect(
+      output2.some(
+        (t) => t.role === "user" && t.content.some((b) => b.type === "text" && b.text === goal),
+      ),
+    ).toBe(true);
+    expect(hasConsecutiveSameRole(output2)).toBe(false);
   });
 
   test("empty-fold keep-set returns the input unchanged", async () => {
@@ -648,7 +679,7 @@ describe("createPruningCompactor — prefix-stable summaries (CL-6914)", () => {
     expect(result.record.reason).toBe("no compaction needed");
   });
 
-  test("failing then succeeding summarizer does not rewrite output[0]", async () => {
+  test("failing summarizer keeps prior context; a later success writes one handoff", async () => {
     const source: InferenceSource = {
       id: "test",
       provider: "openai",
@@ -671,15 +702,15 @@ describe("createPruningCompactor — prefix-stable summaries (CL-6914)", () => {
       summarize,
     });
     const turns = grow([], 16, "fail");
-    const output1 = (await compactor.apply(turns, mockStrategyCtx)).output;
-    expect(firstText(output1[0]!)).toContain("Turns compacted:");
-    expect(firstText(output1[0]!)).not.toContain("UNIQUE_SUCCESS_SUMMARY");
-    expect(firstText(output1[0]!)).toContain("Model summary unavailable");
-
-    const output2 = (await compactor.apply(grow(output1, 16, "ok"), mockStrategyCtx)).output;
-    expect(firstText(output2[0]!)).toBe(firstText(output1[0]!));
-    expect(allText(output2)).toContain("UNIQUE_SUCCESS_SUMMARY");
-    expect(hasConsecutiveSameRole(output2)).toBe(false);
+    const result1 = await compactor.apply(turns, mockStrategyCtx);
+    expect(result1.output).toBe(turns);
+    expect(result1.record.reason).toBe("summarize failed");
+    expect(firstText(result1.output[0]!)).not.toContain(COMPACTED_PREFIX);
+
+    const result2 = await compactor.apply(grow(result1.output, 16, "ok"), mockStrategyCtx);
+    expect(compactedTurns(result2.output)).toHaveLength(1);
+    expect(allText(result2.output)).toContain("UNIQUE_SUCCESS_SUMMARY");
+    expect(hasConsecutiveSameRole(result2.output)).toBe(false);
   });
 });
 

src/exec/runner.ts

@@ -537,8 +537,8 @@ export async function runExec(config: Config): Promise<ExecResult> {
     const summarizeForCompaction = createModelSummarizer({
       getSource: () => liveSource,
       deps: inferenceDeps,
+      getArchive: () => evidenceArchiveHolder.current,
     });
-    const liveCompactionMode = config.settings?.compactionMode ?? "llm";
 
     const { activated: activatedToolNames, computeAdvertised } = createAdvertisedToolset({
       sessionMode,
@@ -582,7 +582,6 @@ export async function runExec(config: Config): Promise<ExecResult> {
       getDefaultSource: () => (liveDefaultSource.length > 0 ? liveDefaultSource : liveSource.id),
       getCompactor: () =>
         createSessionPruningCompactor({
-          compactionMode: liveCompactionMode,
           summarize: summarizeForCompaction,
           telemetry: liveTelemetry,
         }),