fix(session): order compaction repair lines critical-first

A tight cap used to slice exact names off the repair tail. Put goal,
next action, and exact names first so truncation keeps the facts the
next agent needs, and restore real verify coverage on the truncation
path.

Author: TheGreatAxios

src/context-compactor.test.ts

@@ -7,6 +7,7 @@ import {
   formatPlan,
   classifyTaskBoundary,
   buildLLMTurnSummary,
+  buildTurnSummary,
   COMPACTED_PREFIX,
   COMPACT_SPACER_TEXT,
   LEGACY_COMPACT_SPACER_TEXT,
@@ -1211,7 +1212,26 @@ describe("buildTurnSummary via createPruningCompactor", () => {
     expect(summaryText).toContain("Total tool calls: 1");
   });
 
-  test("truncates summary when it exceeds maxChars", async () => {
+  test("buildTurnSummary truncates with ellipsis when over maxChars", () => {
+    const maxChars = 20;
+    const turns: ConversationTurn[] = [
+      makeTurn({
+        role: "user",
+        content: [{ type: "text", text: "migrate opaque tokens ".repeat(40) }],
+      }),
+      makeTurn({
+        role: "assistant",
+        content: [
+          { type: "text", text: "patch the refresh handler ".repeat(40) },
+        ],
+      }),
+    ];
+    const summary = buildTurnSummary(turns, maxChars);
+    expect(summary.endsWith("...")).toBe(true);
+    expect(summary.length).toBe(maxChars);
+  });
+
+  test("a truncated lying spine aborts instead of shipping", async () => {
     const maxChars = 20;
     const compactor = createPruningCompactor({
       keepRecentTurns: 1,
@@ -1220,28 +1240,20 @@ describe("buildTurnSummary via createPruningCompactor", () => {
     const turns: ConversationTurn[] = [
       makeTurn({
         role: "user",
-        // Short tokens so the verify pass is vacuous; length still overflows.
-        content: [{ type: "text", text: "yes ".repeat(200) }],
+        content: [{ type: "text", text: "migrate opaque tokens ".repeat(40) }],
       }),
       makeTurn({
         role: "assistant",
-        content: [{ type: "text", text: "ok ".repeat(200) }],
+        content: [
+          { type: "text", text: "patch the refresh handler ".repeat(40) },
+        ],
       }),
       makeTurn({ role: "user", content: [{ type: "text", text: "recent" }] }),
     ];
 
     const result = await compactor.apply(turns, mockStrategyCtx);
-    const summaryBlock = defined(defined(result.output[0]).content[0]) as {
-      text: string;
-    };
-    // The summary portion of the block is extracted from after the header line.
-    // The header itself is "---..." so we look at the full block text — the
-    // embedded buildTurnSummary output must end with "..." when truncated.
-    expect(summaryBlock.text).toContain("...");
-    // And the truncated summary must not exceed maxChars + 3 (for the "..." suffix)
-    const summaryStart = summaryBlock.text.indexOf("[Compacted prior context]");
-    const rawSummary = summaryBlock.text.slice(summaryStart);
-    // The raw summary lines are bounded by maxChars
-    expect(rawSummary.length).toBeLessThan(maxChars + 200); // header text + bounded summary
+    expect(result.output).toBe(turns);
+    expect(result.record.reason).toBe("verify failed — keeping prior context");
+    expect(result.record.decisions).toMatchObject({ verifyAborted: 1 });
   });
 });

src/session/compaction-verify.test.ts

@@ -1,6 +1,13 @@
 import { describe, test, expect } from "bun:test";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { createPruningCompactor } from "./compactor.js";
 import { condenseTurns } from "./summarizer.js";
+import {
+  createCompactionArchive,
+  wrapCompactorWithCompletenessGate,
+} from "./compaction-archive.js";
 import {
   extractContinuationFacts,
   repairSummary,
@@ -221,6 +228,37 @@ describe("verifyOrRepair", () => {
     );
     expect(repaired).toContain(VERIFY_REPAIR_HEADING);
   });
+
+  test("repair lines are goal, next, exact names, then the rest", () => {
+    const facts = extractContinuationFacts(droppedTurns());
+    const misses = verifyCompactionSummary("Work continues.", facts).misses;
+    const repaired = repairSummary("Work continues.", facts, misses);
+    const goalAt = repaired.indexOf("Goal:");
+    const nextAt = repaired.indexOf("Next:");
+    const exactAt = repaired.indexOf("Exact references:");
+    const blockersAt = repaired.indexOf("Open blockers:");
+    const ranAt = repaired.indexOf("Ran:");
+    expect(goalAt).toBeGreaterThan(-1);
+    expect(nextAt).toBeGreaterThan(goalAt);
+    expect(exactAt).toBeGreaterThan(nextAt);
+    expect(blockersAt).toBeGreaterThan(exactAt);
+    expect(ranAt).toBeGreaterThan(blockersAt);
+  });
+
+  test("a tight cap keeps goal, next, and names before aborting on the tail", () => {
+    const facts = extractContinuationFacts(droppedTurns());
+    const misses = verifyCompactionSummary("Work continues.", facts).misses;
+    const full = repairSummary("Work continues.", facts, misses);
+    const cap = full.indexOf("Open blockers:");
+    expect(cap).toBeGreaterThan(0);
+    const outcome = verifyOrRepair("Work continues.", facts, cap);
+    expect(outcome.aborted).toBe(true);
+    const kinds = outcome.misses.map((m) => m.kind);
+    expect(kinds).not.toContain("goal");
+    expect(kinds).not.toContain("nextAction");
+    expect(kinds).not.toContain("exactName");
+    expect(kinds).toContain("verification");
+  });
 });
 
 describe("pruning compactor verify pass", () => {
@@ -309,6 +347,104 @@ describe("continuation facts survive many folds", () => {
   });
 });
 
+describe("completeness gate plus verify repair", () => {
+  function memoryArchive() {
+    const dir = fs.mkdtempSync(
+      path.join(os.tmpdir(), "compaction-verify-gate-"),
+    );
+    const blobs = new Map<string, Uint8Array>();
+    const archive = createCompactionArchive({
+      sessionId: "sess-verify-gate",
+      contextDir: dir,
+      writeBlob: async (key, bytes) => {
+        blobs.set(key, bytes);
+      },
+      readBlob: async (key) => {
+        const bytes = blobs.get(key);
+        if (bytes === undefined) throw new Error(`missing ${key}`);
+        return bytes;
+      },
+    });
+    return archive;
+  }
+
+  async function archiveTurns(
+    archive: ReturnType<typeof createCompactionArchive>,
+    turns: readonly ConversationTurn[],
+  ): Promise<void> {
+    for (const turn of turns) {
+      for (const block of turn.content) {
+        if (block.type === "text" && block.text.length > 0) {
+          await archive.recordAuthorizedPayload({
+            kind: turn.role === "assistant" ? "assistant_text" : "user_message",
+            payload: block.text,
+          });
+        } else if (block.type === "tool_call") {
+          await archive.recordAuthorizedPayload({
+            kind: "tool_args",
+            payload: { name: block.name, arguments: block.arguments },
+            callId: block.id,
+          });
+        } else if (block.type === "tool_result") {
+          const text = block.content
+            .flatMap((c) => (c.type === "text" ? [c.text] : []))
+            .join("");
+          await archive.recordAuthorizedPayload({
+            kind: "tool_result",
+            payload: text,
+            callId: block.callId,
+          });
+        }
+      }
+    }
+  }
+
+  test("two lossy folds through the gate keep facts via adopted handoffs", async () => {
+    const archive = memoryArchive();
+    const inner = createPruningCompactor({
+      keepRecentTurns: 2,
+      summaryMaxChars: 4000,
+      summarize: async () => "Work continues. Next: fix tests.",
+    });
+    const wrapped = wrapCompactorWithCompletenessGate(inner, archive);
+    let turns: ConversationTurn[] = [
+      ...droppedTurns(),
+      textTurn("user", "recent ask"),
+      textTurn("assistant", "recent reply"),
+    ];
+    await archiveTurns(archive, turns);
+
+    const first = await wrapped.apply(turns, mockStrategyCtx);
+    expect(first.record.reason).not.toBe("incomplete-evidence-archive");
+    expect(first.record.reason).not.toBe(
+      "verify failed — keeping prior context",
+    );
+    expect(first.record.decisions).toMatchObject({ verifyRepaired: 1 });
+    const handoffs = (await archive.listOccurrences()).filter(
+      (occurrence) => occurrence.provenance === "compaction-handoff",
+    );
+    expect(handoffs.length).toBeGreaterThan(0);
+    expect(allText(first.output)).toContain("opaque tokens");
+    expect(allText(first.output)).toContain("auth.ts");
+
+    const followUp = [
+      textTurn("user", "follow-up after first fold"),
+      textTurn("assistant", "progress note after first fold"),
+    ];
+    await archiveTurns(archive, followUp);
+    turns = [...first.output, ...followUp];
+
+    const second = await wrapped.apply(turns, mockStrategyCtx);
+    expect(second.record.reason).not.toBe("incomplete-evidence-archive");
+    expect(second.record.reason).not.toBe(
+      "verify failed — keeping prior context",
+    );
+    expect(allText(second.output)).toContain("opaque tokens");
+    expect(allText(second.output)).toContain("auth.ts");
+    expect(allText(second.output)).toContain("refresh assertion");
+  });
+});
+
 describe("condenseTurns keep-set", () => {
   test("pins the standing goal ahead of the recency window", () => {
     const turns: ConversationTurn[] = [

src/session/compaction-verify.ts

@@ -160,22 +160,13 @@ function tokensSupported(fact: string, summary: string): boolean {
   return hits >= needed;
 }
 
-function userTexts(turns: readonly ConversationTurn[]): string[] {
-  const out: string[] = [];
-  for (const turn of turns) {
-    if (turn.role !== "user") continue;
-    for (const block of turn.content) {
-      if (block.type === "text" && block.text.trim().length > 0)
-        out.push(block.text);
-    }
-  }
-  return out;
-}
-
-function assistantTexts(turns: readonly ConversationTurn[]): string[] {
+function textsForRole(
+  turns: readonly ConversationTurn[],
+  role: "user" | "assistant",
+): string[] {
   const out: string[] = [];
   for (const turn of turns) {
-    if (turn.role !== "assistant") continue;
+    if (turn.role !== role) continue;
     for (const block of turn.content) {
       if (block.type === "text" && block.text.trim().length > 0)
         out.push(block.text);
@@ -254,8 +245,8 @@ function hostnameOf(url: string): string | undefined {
 export function extractContinuationFacts(
   turns: readonly ConversationTurn[],
 ): ContinuationFacts {
-  const users = userTexts(turns);
-  const assistants = assistantTexts(turns);
+  const users = textsForRole(turns, "user");
+  const assistants = textsForRole(turns, "assistant");
   const calls = toolCallArgs(turns);
   const blockers = erroredResultTexts(turns);
 
@@ -394,6 +385,14 @@ export function repairSummary(
   if (goalMiss !== undefined) lines.push(`Goal: ${facts.goal}`);
   const nextMiss = misses.find((m) => m.kind === "nextAction");
   if (nextMiss !== undefined) lines.push(`Next: ${facts.nextAction}`);
+  // Critical-first: goal, next action, exact names, then the rest. A cap
+  // that slices the tail still prefers the facts the next agent needs.
+  if (kinds.has("exactName")) {
+    const missing = misses
+      .filter((m) => m.kind === "exactName")
+      .map((m) => m.detail);
+    lines.push(`Exact references: ${missing.join(", ")}`);
+  }
   // The state line carries where the work stood when it is neither the next
   // action nor an already-listed blocker.
   const stateCovered =
@@ -412,12 +411,6 @@ export function repairSummary(
       `Open blockers:\n${facts.blockers.map((b) => `- ${b}`).join("\n")}`,
     );
   }
-  if (kinds.has("exactName")) {
-    const missing = misses
-      .filter((m) => m.kind === "exactName")
-      .map((m) => m.detail);
-    lines.push(`Exact references: ${missing.join(", ")}`);
-  }
   if (kinds.has("verification")) {
     lines.push(`Ran: ${facts.verification.join("; ")}`);
   }