@@ -675,7 +675,13 @@ export function assembleChatAgent(wiring: ChatAgentWiring): AssembledChatAgent {
     // Stamp last* only on success: a failed /clear factory would otherwise
     // make the retry look like the same session and inherit stale extras.
     if (!inheritFromPrev) stickyFromStore = undefined;
-    const { storage, audit } = await createSessionStores(workdir);
+    // The session id is the store's stable owner identity: a resumed session
+    // recognizes the on-disk ownership marker as its own, so its rewrites
+    // (compaction) stay canonical on the shared transcript instead of being
+    // diverted as foreign.
+    const { storage, audit } = await createSessionStores(workdir, {
+      ownerId: sessionId,
+    });
     // Primary-only: workers never pass evidenceArchiveHolder, so they keep
     // plain storage without admission / authorize recording wraps.
     const archiveHolder = wiring.evidenceArchiveHolder;
 
@@ -9,6 +9,7 @@ import {
   createOptimizedContextStore,
   createSessionStores,
   loadRecentTurns,
+  versionedBaseName,
 } from "./optimized-context-store.js";
 import { segmentFileName, listSegmentFiles } from "./incremental-jsonl.js";
 
@@ -597,6 +598,195 @@ describe("createSessionStores", () => {
   });
 });
 
+describe("concurrent sessions write disjoint transcripts (CL-10372)", () => {
+  test("a second session sharing the dir never overwrites the first session's turns", async () => {
+    const dir = tempDir();
+    const storeA = await createOptimizedContextStore(dir);
+    const storeB = await createOptimizedContextStore(dir);
+
+    // Session A lands a 107-record transcript (the ticket's verified size).
+    const turnsA = Array.from({ length: 107 }, (_, i) => turn(`a-${i}`));
+    await storeA.writeTurns([...turnsA]);
+    await storeA.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+    await storeA.commit({ message: "session A" });
+
+    // Session B starts concurrently on the same dir with its own transcript.
+    const turnsB = Array.from({ length: 7 }, (_, i) => turn(`b-${i}`));
+    await storeB.writeTurns([...turnsB]);
+    await storeB.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+    await storeB.commit({ message: "session B" });
+
+    // A's transcript must survive intact: no overwrite.
+    expect(turnTexts(readTurnsFromFile(path.join(dir, TURNS_FILE)))).toEqual(
+      turnTexts(turnsA),
+    );
+
+    // B's records must survive in a disjoint, versioned file: no lost records.
+    const versioned = versionedTurnsFiles(dir);
+    expect(versioned.length).toBeGreaterThan(0);
+    const bOnDisk = versioned.flatMap((name) =>
+      turnTexts(readTurnsFromFile(path.join(dir, name))),
+    );
+    expect(bOnDisk).toEqual(turnTexts(turnsB));
+
+    // Disjoint: every record from both sessions survives exactly once.
+    const all = [
+      ...turnTexts(readTurnsFromFile(path.join(dir, TURNS_FILE))),
+      ...bOnDisk,
+    ];
+    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(versionedTurnsFiles(dir)).toEqual([]);
+    expect(turnTexts(readTurnsFromFile(path.join(dir, TURNS_FILE)))).toEqual(
+      turnTexts(next),
+    );
+    expect(turnTexts((await resumed.load()).turns)).toEqual(turnTexts(next));
+  });
+
+  test("same-session compaction rewrite on resume is canonical, not diverted", async () => {
+    const dir = tempDir();
+    const owner = await createOptimizedContextStore(dir, {
+      ownerId: "session-S",
+    });
+    const original = [turn("a"), turn("b"), turn("c"), turn("d")];
+    await owner.writeTurns([...original]);
+    await owner.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+    await owner.commit({ message: "owner" });
+
+    // The same session resumes (same owner id) and its FIRST write is a
+    // compaction that replaces the head. Ownership is by marker, not content
+    // shape: this is the owner, so the rewrite is canonical on turns.jsonl.
+    const resumed = await createOptimizedContextStore(dir, {
+      ownerId: "session-S",
+    });
+    const compacted = [turn("[Compacted prior context]"), turn("c"), turn("d")];
+    await resumed.writeTurns([...compacted]);
+    await resumed.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+    await resumed.commit({ message: "resume compact" });
+
+    expect(versionedTurnsFiles(dir)).toEqual([]);
+    expect(turnTexts(readTurnsFromFile(path.join(dir, TURNS_FILE)))).toEqual(
+      turnTexts(compacted),
+    );
+    expect(turnTexts((await resumed.load()).turns)).toEqual(
+      turnTexts(compacted),
+    );
+  });
+
+  test("interleaved first writes cannot both claim the shared base", async () => {
+    const dir = tempDir();
+    const storeA = await createOptimizedContextStore(dir);
+    const storeB = await createOptimizedContextStore(dir);
+    const turnsA = Array.from({ length: 50 }, (_, i) => turn(`a-${i}`));
+    const turnsB = Array.from({ length: 50 }, (_, i) => turn(`b-${i}`));
+
+    await Promise.all([
+      (async () => {
+        await storeA.writeTurns([...turnsA]);
+        await storeA.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+        await storeA.commit({ message: "A" });
+      })(),
+      (async () => {
+        await storeB.writeTurns([...turnsB]);
+        await storeB.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+        await storeB.commit({ message: "B" });
+      })(),
+    ]);
+
+    // The dir lock serializes the first writes: exactly one store owns the
+    // shared base and the other lands in a single disjoint versioned file.
+    const shared = turnTexts(readTurnsFromFile(path.join(dir, TURNS_FILE)));
+    const versioned = versionedTurnsFiles(dir);
+    expect(versioned).toHaveLength(1);
+    const other = turnTexts(
+      readTurnsFromFile(path.join(dir, defined(versioned[0]))),
+    );
+    const sharedIsA =
+      JSON.stringify(shared) === JSON.stringify(turnTexts(turnsA));
+    const sharedIsB =
+      JSON.stringify(shared) === JSON.stringify(turnTexts(turnsB));
+    expect(sharedIsA || sharedIsB).toBe(true);
+    expect(other).toEqual(sharedIsA ? turnTexts(turnsB) : turnTexts(turnsA));
+    expect(new Set([...shared, ...other]).size).toBe(
+      turnsA.length + turnsB.length,
+    );
+  });
+
+  test("crash before the divert lands leaves no orphaned versioned file", async () => {
+    const dir = tempDir();
+    const owner = await createOptimizedContextStore(dir);
+    await owner.writeTurns([turn("a"), turn("b")]);
+    await owner.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+    await owner.commit({ message: "owner" });
+
+    const foreign = await createOptimizedContextStore(dir);
+    await foreign.writeTurns([turn("x"), turn("y")]);
+    // Simulated crash before commit: the divert is staged in memory only, so
+    // no versioned file may exist on disk yet.
+    expect(versionedTurnsFiles(dir)).toEqual([]);
+
+    // A later plain resume (prefix-extension, no stable id) sees no orphan
+    // and keeps the shared transcript canonical.
+    const resumed = await createOptimizedContextStore(dir);
+    await resumed.writeTurns([turn("a"), turn("b"), turn("c")]);
+    await resumed.writeMetadata(EMPTY_CHECKPOINT_METADATA);
+    await resumed.commit({ message: "resume" });
+    expect(versionedTurnsFiles(dir)).toEqual([]);
+    expect(turnTexts(readTurnsFromFile(path.join(dir, TURNS_FILE)))).toEqual([
+      "a",
+      "b",
+      "c",
+    ]);
+  });
+
+  test("versioned base names are unique even within the same millisecond", () => {
+    const names = Array.from({ length: 100 }, () =>
+      versionedBaseName(TURNS_FILE),
+    );
+    expect(new Set(names).size).toBe(100);
+    for (const name of names) {
+      expect(/^turns-\d+-[0-9a-f]+\.jsonl$/.test(name)).toBe(true);
+    }
+  });
+});
+
+function versionedTurnsFiles(dir: string): string[] {
+  return fs
+    .readdirSync(dir)
+    .filter((name) => /^turns-\d+-[0-9a-f]+\.jsonl$/.test(name));
+}
+
+function readTurnsFromFile(fullPath: string): ConversationTurn[] {
+  const text = fs.readFileSync(fullPath, "utf8");
+  return text
+    .split("\n")
+    .filter((line) => line.length > 0)
+    .map((line) => JSON.parse(line) as ConversationTurn);
+}
+
 async function gitLsTree(dir: string): Promise<string[]> {
   const proc = Bun.spawn(
     ["git", "-C", dir, "ls-tree", "-r", "--name-only", "HEAD"],