fix(session): only divert foreign stores, not same-session resumes (CL-10372)

Review found the writePrompt divert over-fired: on a normal same-session
resume the reactor writes the materialized prompt in pre-inference before any
writeTurns, and the prompt legitimately differs from on-disk turns (context
transforms, ephemeral turns, summaries). The prompt-only signal marked the
owner store as foreign, froze turns.jsonl, and hid new turns from load().

Rework: ownership is decided solely by writeTurns. Only a fresh store whose
first writeTurns diverges from the on-disk history (a genuinely foreign
concurrent session) diverts to versioned bases; writePromptSegmented is
rebound with it. A differing prompt alone never diverts, so resumes keep
writing turns.jsonl/prompt.jsonl as before.

Adds a regression test: same-session resume with a differing first prompt
must keep updating turns.jsonl and be visible to load(), with no versioned
file. The concurrent-clobber repro still passes.

Author: TheGreatAxios

src/session/optimized-context-store.test.ts

@@ -637,6 +637,39 @@ describe("concurrent sessions write disjoint transcripts (CL-10372)", () => {
     ];
     expect(new Set(all).size).toBe(turnsA.length + turnsB.length);
   });
+
+  test("same-session resume with a differing first prompt keeps writing turns.jsonl (CL-10372 regression)", async () => {
+    const dir = tempDir();
+
+    // Owner session lands a committed transcript, then is resumed by a fresh
+    // store in a new process (the reactor writes the materialized prompt in
+    // pre-inference BEFORE any writeTurns; the prompt legitimately differs
+    // from the on-disk turns when context transforms / ephemeral turns apply).
+    const owner = await createOptimizedContextStore(dir);
+    const live = [turn("a"), turn("b")];
+    await owner.writeTurns([...live]);
+    await owner.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+    await owner.commit({ message: "owner" });
+
+    const resumed = await createOptimizedContextStore(dir);
+    await resumed.writePrompt([turn("a"), turn("b"), turn("ephemeral")]);
+    const next = [...live, turn("c")];
+    await resumed.writeTurns([...next]);
+    await resumed.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+    await resumed.commit({ message: "resume append" });
+
+    // No versioned base: this store is the session owner resuming, so it
+    // keeps owning turns.jsonl and the new turn is visible to load().
+    expect(
+      fs
+        .readdirSync(dir)
+        .filter((name) => /^turns-\d+-[0-9a-f]+\.jsonl$/.test(name)),
+    ).toEqual([]);
+    expect(turnTexts(readTurnsFromFile(path.join(dir, TURNS_FILE)))).toEqual(
+      turnTexts(next),
+    );
+    expect(turnTexts((await resumed.load()).turns)).toEqual(turnTexts(next));
+  });
 });
 
 function readTurnsFromFile(fullPath: string): ConversationTurn[] {

src/session/optimized-context-store.ts

@@ -606,13 +606,6 @@ export async function createSessionStores(
       liveTurnRefs = [...turns];
       return;
     }
-    if (versionedBase !== null) {
-      // Already diverted (e.g. a colliding prompt wrote first): this store's
-      // transcript owns a disjoint versioned base; write turns there too.
-      await writeSegmented(writeTurnsSegmented, turns);
-      liveTurnRefs = [...turns];
-      return;
-    }
     const extraTexts = await readExtraSegmentTexts(dir, TURNS_FILE);
     let baseTurns: ConversationTurn[];
     try {
@@ -692,17 +685,13 @@ export async function createSessionStores(
       }
     }
     if (live === null || !promptEqualsLiveTurns(live, turns)) {
-      // A fresh instance whose on-disk live turns came from another session
-      // (CL-10372) must not clobber that session's prompt snapshot either;
-      // divert this store's prompt to its own disjoint versioned base.
-      if (
-        versionedBase === null &&
-        liveTurnRefs === null &&
-        live !== null &&
-        live.length > 0
-      ) {
-        divertToVersionedBases();
-      }
+      // The prompt is a materialized snapshot and legitimately differs from
+      // the live turns on a normal resume (context transforms, ephemeral
+      // turns, summaries), so a differing prompt alone never proves a foreign
+      // store. Ownership is decided by writeTurns: only its fresh-store
+      // divergence diverts to versioned bases, and writePromptSegmented is
+      // rebound with it. Prompt writes therefore stay on the shared base
+      // unless that divert already happened.
       await writeSegmented(writePromptSegmented, turns);
       return;
     }