fix(session): union fat-file facts and adopt dropped handoff spines

Iterative folds dropped fold-1 paths when the next region was only the
prior spine plus later turns, and a growing Evidence/Constraints line
fail-closed the completeness gate. Union the previous fat file, scan
tool_result evidence, and archive synthetic spines as user_message.

Author: TheGreatAxios

src/exec/runner.ts

@@ -137,6 +137,7 @@ import {
   resolveLiveSessionSources,
 } from "../session/assemble-runtime.js";
 import type { CompactionArchive } from "../session/compaction-archive.js";
+import { tryReadPriorHandoffFile } from "../session/compaction-handoff.js";
 import { emitPluginWarningSummary } from "../plugins/diagnostics.js";
 import { createModelSummarizer } from "../session/summarizer.js";
 import { ID_PREFIX, LOG_NAMESPACE_ROOT } from "../branding.js";
@@ -848,6 +849,10 @@ export async function runExec(config: Config): Promise<ExecResult> {
             const tools = activatedToolNames.list();
             return tools.length > 0 ? { activatedTools: tools } : undefined;
           },
+          readPriorHandoff: () =>
+            tryReadPriorHandoffFile(
+              currentStorage?.readBlob.bind(currentStorage),
+            ),
           telemetry: liveTelemetry,
           onFolded: () => {
             // Fold restarts the cached prefix, so catch promotions still

src/session/compaction-archive.test.ts

@@ -998,4 +998,150 @@ describe("wrapCompactorWithCompletenessGate", () => {
     expect(result.output).toHaveLength(1);
     expect(result.output[0]).not.toBe(turns[1]);
   });
+
+  test("second fold that grows the spine still compact-succeeds by adopting the prior handoff", async () => {
+    const { wrapCompactorWithCompletenessGate } =
+      await import("./compaction-archive.js");
+    const { createPruningCompactor } = await import("./compactor.js");
+    const { COMPACTED_PREFIX, buildHandoffFold } =
+      await import("./compaction-handoff.js");
+    const { archive } = memoryArchive();
+
+    const first = buildHandoffFold(
+      [
+        {
+          role: "user",
+          content: [{ type: "text", text: "Ship the widget." }],
+          timestamp: 1,
+        },
+      ],
+      "first narrative",
+    );
+    const priorSpine = first.spineText;
+    await archive.recordAuthorizedPayload({
+      kind: "user_message",
+      payload: "Must never write to /tmp. [[evidence:decision|op|no-tmp]]",
+    });
+    await archive.recordAuthorizedPayload({
+      kind: "assistant_text",
+      payload: "ok",
+    });
+    await archive.recordAuthorizedPayload({
+      kind: "assistant_text",
+      payload: "working",
+    });
+
+    const inner = createPruningCompactor({
+      keepRecentTurns: 2,
+      maxAnchorTurns: 0,
+      summaryMaxChars: 500,
+    });
+    const wrapped = wrapCompactorWithCompletenessGate(inner, archive);
+    const turns: import("@intx/types/runtime").ConversationTurn[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: priorSpine }],
+        timestamp: 1,
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "Continue the widget." }],
+        timestamp: 2,
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "working" }],
+        timestamp: 3,
+      },
+      {
+        role: "user",
+        content: [
+          {
+            type: "text",
+            text: "Must never write to /tmp. [[evidence:decision|op|no-tmp]]",
+          },
+        ],
+        timestamp: 4,
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "ok" }],
+        timestamp: 5,
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "keep one" }],
+        timestamp: 6,
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "keep two" }],
+        timestamp: 7,
+      },
+    ];
+    const result = await wrapped.apply(turns, ctx);
+    expect(result.record.reason).not.toBe("incomplete-evidence-archive");
+    const spine = result.output[0]?.content.find((b) => b.type === "text");
+    expect(spine?.type).toBe("text");
+    if (spine?.type !== "text") throw new Error("unreachable");
+    expect(spine.text.startsWith(COMPACTED_PREFIX)).toBe(true);
+    expect(spine.text).toContain("Must never write to /tmp.");
+    expect(spine.text).toContain("[[evidence:decision|op|no-tmp]]");
+  });
+
+  test("pre-format fat Compacted prior context summaries still compact", async () => {
+    const { wrapCompactorWithCompletenessGate } =
+      await import("./compaction-archive.js");
+    const { createPruningCompactor } = await import("./compactor.js");
+    const { COMPACTED_PREFIX } = await import("./compaction-handoff.js");
+    const { archive } = memoryArchive();
+    const fatSummary = `${COMPACTED_PREFIX}\nLong pre-format narrative about the auth migration and every file that was touched.`;
+    await archive.recordAuthorizedPayload({
+      kind: "user_message",
+      payload: "next ask after the old summary",
+    });
+    await archive.recordAuthorizedPayload({
+      kind: "assistant_text",
+      payload: "working",
+    });
+    const inner = createPruningCompactor({
+      keepRecentTurns: 2,
+      maxAnchorTurns: 0,
+      summaryMaxChars: 500,
+    });
+    const wrapped = wrapCompactorWithCompletenessGate(inner, archive);
+    const turns: import("@intx/types/runtime").ConversationTurn[] = [
+      {
+        role: "user",
+        content: [{ type: "text", text: fatSummary }],
+        timestamp: 1,
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "next ask after the old summary" }],
+        timestamp: 2,
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "working" }],
+        timestamp: 3,
+      },
+      {
+        role: "user",
+        content: [{ type: "text", text: "keep one" }],
+        timestamp: 4,
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text", text: "keep two" }],
+        timestamp: 5,
+      },
+    ];
+    const result = await wrapped.apply(turns, ctx);
+    expect(result.record.reason).not.toBe("incomplete-evidence-archive");
+    const spine = result.output[0]?.content.find((b) => b.type === "text");
+    expect(spine?.type).toBe("text");
+    if (spine?.type !== "text") throw new Error("unreachable");
+    expect(spine.text.startsWith(COMPACTED_PREFIX)).toBe(true);
+  });
 });

src/session/compaction-archive.ts

@@ -29,6 +29,7 @@ import {
   type ToolRecordingLifecycle,
 } from "./compaction-archive-schema.js";
 import { parseAgedImageMarker } from "./attachment-uri.js";
+import { COMPACTED_PREFIX } from "./compaction-handoff.js";
 
 const INDEX_DIR = "evidence-archive";
 const INDEX_FILE = "index.jsonl";
@@ -892,9 +893,30 @@ function incompleteIdentity(inner: Compactor, turns: ConversationTurn[]) {
   };
 }
 
+/**
+ * Archive a synthetic `[Compacted prior context]` turn as a user_message so
+ * the completeness gate can certify dropping it when the next spine grows.
+ */
+export async function recordAdoptedHandoff(
+  archive: CompactionArchive,
+  text: string,
+): Promise<ArchiveOccurrence> {
+  return archive.recordAuthorizedPayload({
+    kind: "user_message",
+    payload: text,
+    provenance: "adopted-handoff",
+  });
+}
+
+function isSyntheticHandoffText(text: string): boolean {
+  return text.startsWith(COMPACTED_PREFIX);
+}
+
 /**
  * Refuse a destructive compact when the evidence archive cannot certify the
  * dropped prefix. Historical gap:true rows are not part of the expected set.
+ * Synthetic handoff spines (and pre-format fat summaries) are adopted into
+ * the archive as user_message so a later fold may change the live spine.
  */
 export function wrapCompactorWithCompletenessGate(
   inner: Compactor,
@@ -908,6 +930,15 @@ export function wrapCompactorWithCompletenessGate(
       const proposed = await inner.apply(turns, ctx);
       const units = uncoveredContentUnits(turns, proposed.output);
       if (units.length === 0) return proposed;
+      for (const unit of units) {
+        if (
+          unit.kind === "text" &&
+          unit.role === "user" &&
+          unit.text !== undefined &&
+          isSyntheticHandoffText(unit.text)
+        )
+          await recordAdoptedHandoff(archive, unit.text);
+      }
       const occurrences = await archive.listOccurrences();
       const covering = coveringOccurrence(
         units,