fix(session): keep prefix-sharing handoff facts distinct

Production iterative folds merge full prior-file text, so prefix unique
collapsed distinct constraints, decisions, and verification that only
shared a string start.

Author: TheGreatAxios

src/session/compaction-handoff.test.ts

@@ -62,6 +62,38 @@ function fileReadTurns(
   ];
 }
 
+function shellTurns(
+  id: string,
+  command: string,
+  result: string,
+  isError = false,
+): ConversationTurn[] {
+  return [
+    makeTurn({
+      role: "assistant",
+      content: [
+        {
+          type: "tool_call",
+          id,
+          name: "run_shell",
+          arguments: { command },
+        },
+      ],
+    }),
+    makeTurn({
+      role: "user",
+      content: [
+        {
+          type: "tool_result",
+          callId: id,
+          isError,
+          content: [{ type: "text", text: result }],
+        },
+      ],
+    }),
+  ];
+}
+
 function userTurn(text: string): ConversationTurn {
   return makeTurn({ role: "user", content: [{ type: "text", text }] });
 }
@@ -550,6 +582,83 @@ describe("iterative folding", () => {
     );
   });
 
+  test("iterative union keeps prefix-sharing constraints distinct", () => {
+    const first = buildHandoffFold(
+      [
+        userTurn(
+          "Ship the widget.\nMust never write to /tmp\nNever touch src/auth",
+        ),
+      ],
+      "narrative",
+    );
+    const second = buildHandoffFold(
+      [
+        spineTurn(first.spineText),
+        userTurn(
+          "Continue.\nMust never write to /tmp/cache\nNever touch src/auth.ts",
+        ),
+      ],
+      "narrative",
+      { priorFileText: new TextDecoder().decode(first.blob.bytes) },
+    );
+    expect(second.artifact.constraints).toEqual(
+      expect.arrayContaining([
+        "Must never write to /tmp",
+        "Must never write to /tmp/cache",
+        "Never touch src/auth",
+        "Never touch src/auth.ts",
+      ]),
+    );
+  });
+
+  test("iterative union keeps prefix-sharing decisions distinct", () => {
+    const first = buildHandoffFold(
+      [
+        userTurn("Ship the widget."),
+        userTurn("Use src/auth"),
+        userTurn("Keep going."),
+      ],
+      "narrative",
+    );
+    const second = buildHandoffFold(
+      [
+        spineTurn(first.spineText),
+        userTurn("Use src/auth.ts"),
+        userTurn("Keep going."),
+      ],
+      "narrative",
+      { priorFileText: new TextDecoder().decode(first.blob.bytes) },
+    );
+    expect(second.artifact.decisions).toEqual(
+      expect.arrayContaining(["Use src/auth", "Use src/auth.ts"]),
+    );
+  });
+
+  test("iterative union keeps prefix-sharing verification distinct", () => {
+    const first = buildHandoffFold(
+      [
+        userTurn("Run the suite."),
+        ...shellTurns("c1", "bun test", "1 pass, 0 fail"),
+      ],
+      "narrative",
+    );
+    const second = buildHandoffFold(
+      [
+        spineTurn(first.spineText),
+        userTurn("Run the module tests."),
+        ...shellTurns("c2", "bun test src/foo.test.ts", "1 pass, 0 fail"),
+      ],
+      "narrative",
+      { priorFileText: new TextDecoder().decode(first.blob.bytes) },
+    );
+    expect(second.artifact.verification).toEqual(
+      expect.arrayContaining([
+        "PASS: bun test",
+        "PASS: bun test src/foo.test.ts",
+      ]),
+    );
+  });
+
   test("narrative ## Goal/Files in the prior summary do not overwrite schema", () => {
     const first = buildHandoffFold(foldedRegion(), "First fold narrative.");
     const poisoned = renderHandoffFile(
@@ -590,6 +699,38 @@ describe("iterative folding", () => {
       "Never touch src/legacy.",
     );
   });
+
+  test("partial prior-file constraints do not drop extra carried spine constraints", () => {
+    const first = buildHandoffFold(
+      [
+        userTurn(
+          "Ship the widget.\nMust never write to /tmp\nNever touch src/auth",
+        ),
+      ],
+      "narrative",
+    );
+    const kept = first.artifact.constraints.filter((constraint) =>
+      constraint.includes("/tmp"),
+    );
+    expect(kept.length).toBeGreaterThan(0);
+    expect(first.artifact.constraints.length).toBeGreaterThan(kept.length);
+    const partial = renderHandoffFile(
+      { ...first.artifact, constraints: kept },
+      "narrative",
+      handoffBlobUri(HANDOFF_LATEST_KEY),
+    );
+    const second = buildHandoffFold(
+      [spineTurn(first.spineText), userTurn("Continue.")],
+      "narrative",
+      { priorFileText: partial },
+    );
+    expect(second.artifact.constraints).toEqual(
+      expect.arrayContaining([
+        "Must never write to /tmp",
+        "Never touch src/auth",
+      ]),
+    );
+  });
 });
 
 describe("tool-body dumps", () => {

src/session/compaction-handoff.ts

@@ -323,15 +323,24 @@ function parseHandoffFile(text: string): Partial<HandoffArtifact> {
 }
 
 // Prefer the full prior-file text over a spine-truncated prefix of the same
-// fact. Distinct facts append until the cap. Prefix collapse is only for
-// known truncated spine fragments (80-char cuts); paths and commands use
-// exact equality so `src/auth` and `src/auth.ts` stay distinct.
+// fact. Distinct facts append until the cap. Production prior-file text is
+// full, so union is exact: `Must never write to /tmp` and `.../tmp/cache`
+// stay distinct. Prefix collapse is only for known 80-char spine cuts when
+// merging carried spine fragments into the fat file.
+function isSpineTruncationOf(fragment: string, full: string): boolean {
+  return (
+    fragment.length === MAX_SPINE_ITEM_CHARS &&
+    full.length > fragment.length &&
+    full.startsWith(fragment)
+  );
+}
+
 function mergeUnique(
   primary: readonly string[],
   extra: readonly string[],
   cap: number,
   maxChars = MAX_ITEM_CHARS,
-  mode: "prefix" | "exact" = "prefix",
+  mode: "prefix" | "exact" = "exact",
 ): string[] {
   const merged: string[] = [];
   const consider = (raw: string): void => {
@@ -342,7 +351,9 @@ function mergeUnique(
     const related = merged.findIndex((entry) =>
       mode === "exact"
         ? entry === item
-        : entry === item || entry.startsWith(item) || item.startsWith(entry),
+        : entry === item ||
+          isSpineTruncationOf(item, entry) ||
+          isSpineTruncationOf(entry, item),
     );
     if (related >= 0) {
       const existing = merged[related];
@@ -546,12 +557,24 @@ export function extractHandoffArtifact(
     );
 
   const mergedConstraints = mergeUnique(
-    priorFile.constraints ?? carried.constraints,
+    mergeUnique(
+      priorFile.constraints ?? [],
+      carried.constraints,
+      MAX_CONSTRAINTS,
+      MAX_ITEM_CHARS,
+      "prefix",
+    ),
     freshConstraints,
     MAX_CONSTRAINTS,
   );
   const mergedDecisions = mergeUnique(
-    priorFile.decisions ?? carried.decisions,
+    mergeUnique(
+      priorFile.decisions ?? [],
+      carried.decisions,
+      MAX_DECISIONS,
+      MAX_ITEM_CHARS,
+      "prefix",
+    ),
     freshDecisions,
     MAX_DECISIONS,
   );