@hayasaka7/haya-pet 0.3.7 → 0.3.9

package/packages/cli-core/src/codex-guardian-watcher.js

@@ -14,6 +14,7 @@ import {
   parseGuardianTranscriptLines
 } from "../../adapters/src/codex-guardian.js";
 import { listJsonlFiles, readFirstLine, readRange, safeMtime, safeSize } from "./codex-rollout-fs.js";
+import { readSessionTranscriptLink } from "./session-transcript-link.js";
 
 const DEFAULT_POLL_MS = 700;
 const MTIME_SKEW_MS = 2000;
@@ -26,6 +27,8 @@ export function watchCodexGuardianReviews(options = {}) {
     onReviewEvent = () => {},
     pollIntervalMs = DEFAULT_POLL_MS,
     sessionsRoot,
+    sessionId,
+    sessionDir,
     setInterval: setIntervalFn = setInterval,
     clearInterval: clearIntervalFn = clearInterval
   } = options;
@@ -66,7 +69,33 @@ export function watchCodexGuardianReviews(options = {}) {
     return meta;
   };
 
+  // Authoritative main thread id from the session->transcript link (the linked
+  // rollout's session_meta.payload.id). Lets the guardian bind to OUR main thread
+  // even when another session's main rollout has a newer mtime.
+  const resolveLinkedMainThreadId = () => {
+    if (!sessionId || !sessionDir) {
+      return undefined;
+    }
+    const linked = readSessionTranscriptLink({ sessionDir, sessionId });
+    if (!linked) {
+      return undefined;
+    }
+    const firstLine = readFirstLine(linked);
+    if (firstLine === undefined) {
+      return undefined;
+    }
+    const meta = classifyCodexSessionMeta(firstLine);
+    return meta?.kind === "main" ? meta.threadId : undefined;
+  };
+
   const discoverTrunk = () => {
+    // Prefer the linked main thread id; fall back to the newest main rollout by
+    // mtime only when no link is available (older behavior, unsafe across
+    // concurrent same-cwd sessions).
+    if (!mainThreadId) {
+      mainThreadId = resolveLinkedMainThreadId();
+    }
+
     let newestMain;
     let newestTrunk;
 
@@ -83,8 +112,12 @@ export function watchCodexGuardianReviews(options = {}) {
       if (meta.kind === "main" && meta.threadId && (!newestMain || mtime > newestMain.mtime)) {
         newestMain = { threadId: meta.threadId, mtime };
       }
-      if (meta.kind === "guardian" && (!newestTrunk || mtime > newestTrunk.mtime)) {
-        newestTrunk = { file, parentThreadId: meta.parentThreadId, mtime };
+      if (meta.kind === "guardian" && meta.parentThreadId && (!newestTrunk || mtime > newestTrunk.mtime)) {
+        // Once our main thread id is known, only consider OUR trunk so a
+        // concurrent session's (or collab subagent's) newer trunk cannot win.
+        if (!mainThreadId || meta.parentThreadId === mainThreadId) {
+          newestTrunk = { file, parentThreadId: meta.parentThreadId, mtime };
+        }
       }
     }
 

package/packages/cli-core/src/codex-transcript-watcher.js

@@ -5,6 +5,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { parseCodexTranscriptLines } from "../../adapters/src/codex-transcript.js";
 import { listJsonlFiles, readFirstLine, readRange, safeMtime, safeSize } from "./codex-rollout-fs.js";
+import { readSessionTranscriptLink } from "./session-transcript-link.js";
 
 const DEFAULT_POLL_MS = 700;
 const MTIME_SKEW_MS = 2000;
@@ -17,6 +18,8 @@ export function watchCodexTranscript(options = {}) {
     onToolEvent = () => {},
     pollIntervalMs = DEFAULT_POLL_MS,
     sessionsRoot,
+    sessionId,
+    sessionDir,
     transcriptPath: fixedPath,
     setInterval: setIntervalFn = setInterval,
     clearInterval: clearIntervalFn = clearInterval
@@ -25,6 +28,13 @@ export function watchCodexTranscript(options = {}) {
   const root = sessionsRoot ?? (homeDir ? join(homeDir, ".codex", "sessions") : undefined);
   const minMtime = startedAt > 0 ? startedAt - MTIME_SKEW_MS : 0;
 
+  // Preferred resolution: pin to the exact rollout this session's hook reported
+  // (Codex puts `transcript_path` in every hook payload; the `haya-pet state`
+  // reporter records it as a session->transcript link). Without that link (e.g.
+  // the path was null early), fall back to the newest-by-mtime heuristic — unsafe
+  // with concurrent same-cwd sessions, which is the bug the link avoids.
+  const useLink = Boolean(sessionId && sessionDir);
+
   let transcriptPath = fixedPath;
   let offset = 0;
   let carry = "";
@@ -32,7 +42,9 @@ export function watchCodexTranscript(options = {}) {
   const tick = () => {
     try {
       if (!transcriptPath) {
-        transcriptPath = discoverCodexTranscript(root, minMtime, { cwd });
+        transcriptPath = useLink
+          ? resolveLinkedRollout(sessionDir, sessionId)
+          : discoverCodexTranscript(root, minMtime, { cwd });
         if (!transcriptPath) {
           return;
         }
@@ -79,6 +91,18 @@ export function watchCodexTranscript(options = {}) {
   };
 }
 
+// Resolve the rollout this session's hook bound itself to (via the
+// session->transcript link). Returns undefined until the link exists and points
+// at a real file, so before the first hook the watcher idles rather than guessing
+// a rollout that may belong to another concurrent session.
+function resolveLinkedRollout(sessionDir, sessionId) {
+  const linked = readSessionTranscriptLink({ sessionDir, sessionId });
+  if (!linked || !existsSync(linked)) {
+    return undefined;
+  }
+  return linked;
+}
+
 export function discoverCodexTranscript(root, minMtime = 0, options = {}) {
   if (!root || !existsSync(root)) {
     return undefined;

package/packages/cli-core/src/run-state.js

@@ -6,6 +6,7 @@ import { createIpcClient as defaultCreateIpcClient } from "../../daemon-core/src
 import { getDefaultPaths } from "../../platform-core/src/paths.js";
 import { isAiClientState } from "../../protocol/src/messages.js";
 import { DEADLINE, raceDeadline } from "./deadline.js";
+import { writeSessionTranscriptLink } from "./session-transcript-link.js";
 
 // Hard ceiling on the whole connect→send→close interaction. The reporter is a
 // child process of the wrapped AI client, and the client may wait for its hook
@@ -69,6 +70,13 @@ export async function runStateCommand(parsed, dependencies = {}) {
     return { command: "state", ok: false, reason: "invalid-state" };
   }
 
+  // Record this session's real transcript path (ground truth from the Claude hook
+  // payload, captured at the process entry and passed in via dependencies) so the
+  // wrapper's watcher tails THIS session's file rather than the newest in the
+  // project dir — which can bind it to a concurrent session and leak that
+  // session's interrupt/denial. Best-effort and synchronous; never blocks the hook.
+  recordTranscriptLink(sessionId, env, dependencies);
+
   const createIpcClient = dependencies.createIpcClient ?? defaultCreateIpcClient;
   const deadlineMs = dependencies.reportDeadlineMs ?? REPORT_DEADLINE_MS;
 
@@ -105,3 +113,105 @@ export async function runStateCommand(parsed, dependencies = {}) {
     return { command: "state", ok: false, reason: "no-daemon" };
   }
 }
+
+// Persist the session -> transcript binding for the wrapper's watcher. The
+// transcript path is supplied by the caller (read from the hook payload at the
+// process entry); when it's absent we simply skip — there is nothing to bind and
+// guessing is exactly the bug this avoids.
+function recordTranscriptLink(sessionId, env, dependencies) {
+  const transcriptPath = dependencies.transcriptPath;
+  if (typeof transcriptPath !== "string" || transcriptPath === "") {
+    return;
+  }
+  try {
+    const sessionDir =
+      dependencies.sessionDir ??
+      getDefaultPaths({
+        platform: dependencies.platform,
+        env,
+        homeDir: dependencies.homeDir
+      }).sessionDir;
+    writeSessionTranscriptLink({ sessionDir, sessionId, transcriptPath }, dependencies);
+  } catch {
+    // never break a hook over a best-effort binding write
+  }
+}
+
+// Pull `transcript_path` out of a Claude hook payload (JSON on stdin). Pure and
+// defensive: any non-JSON, missing-field, or wrong-type input yields undefined.
+export function extractTranscriptPath(raw) {
+  if (typeof raw !== "string" || raw.trim() === "") {
+    return undefined;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    const value = parsed?.transcript_path;
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// Read the Claude hook payload from stdin and return its transcript_path. Used by
+// the real `haya-pet state` process (a Claude hook child) — NOT by internal
+// callers, so tests and other commands never touch stdin. Bounded and best-effort:
+// a TTY (manual invocation) or a slow/absent payload resolves to undefined rather
+// than ever hanging the host client's hook.
+export function readHookTranscriptPathFromStdin(options = {}) {
+  const stdin = options.stdin ?? process.stdin;
+  const timeoutMs = options.timeoutMs ?? 400;
+  const maxBytes = options.maxBytes ?? 1_000_000;
+
+  return new Promise((resolve) => {
+    if (!stdin || stdin.isTTY) {
+      resolve(undefined);
+      return;
+    }
+
+    let data = "";
+    let settled = false;
+    let timer;
+
+    const finish = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      if (timer) {
+        clearTimeout(timer);
+      }
+      try {
+        stdin.removeListener("data", onData);
+        stdin.removeListener("end", onEnd);
+        stdin.removeListener("error", onError);
+        stdin.pause();
+      } catch {
+        // detaching is best-effort
+      }
+      resolve(value);
+    };
+
+    const onData = (chunk) => {
+      data += chunk;
+      if (data.length > maxBytes) {
+        finish(extractTranscriptPath(data));
+      }
+    };
+    const onEnd = () => finish(extractTranscriptPath(data));
+    const onError = () => finish(undefined);
+
+    try {
+      stdin.setEncoding("utf8");
+      stdin.on("data", onData);
+      stdin.on("end", onEnd);
+      stdin.on("error", onError);
+      stdin.resume();
+      timer = setTimeout(() => finish(extractTranscriptPath(data)), timeoutMs);
+      if (timer && typeof timer.unref === "function") {
+        timer.unref();
+      }
+    } catch {
+      finish(undefined);
+    }
+  });
+}

package/packages/cli-core/src/session-transcript-link.js

@@ -0,0 +1,72 @@
+// Records which transcript file belongs to which haya-pet session, so a wrapper's
+// transcript watcher can tail ITS OWN session's transcript instead of guessing
+// "the newest .jsonl in the project dir".
+//
+// Why this exists: two Claude Code sessions running in the same folder share one
+// project dir (~/.claude/projects/<sanitized-cwd>/), each with its own UUID file.
+// Picking newest-by-mtime can bind a watcher to a DIFFERENT concurrent session's
+// transcript — so an interrupt (or denial) in session A leaks onto idle session B.
+// The only ground-truth source of a session's transcript path is the Claude hook
+// payload (`transcript_path` on stdin), which the `haya-pet state` reporter sees.
+// The reporter writes the path here (keyed by HAYA_PET_SESSION_ID); the wrapper's
+// watcher reads it to pin to the exact file.
+//
+// Local-only and best-effort: every operation swallows errors so it can never
+// break a hook or the wrapped command, and nothing here is ever sent off-device.
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// Session ids are our own (`sess_<uuid>`), but sanitize defensively so the value
+// can never escape the sessions dir or produce an invalid filename.
+function sanitizeSessionId(sessionId) {
+  return String(sessionId).replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+export function sessionLinkPath(sessionDir, sessionId) {
+  return join(sessionDir, `${sanitizeSessionId(sessionId)}.json`);
+}
+
+export function writeSessionTranscriptLink(options = {}, dependencies = {}) {
+  const { sessionDir, sessionId, transcriptPath } = options;
+  if (!sessionDir || !sessionId || typeof transcriptPath !== "string" || transcriptPath === "") {
+    return false;
+  }
+  const mkdir = dependencies.mkdirSync ?? mkdirSync;
+  const write = dependencies.writeFileSync ?? writeFileSync;
+  try {
+    mkdir(sessionDir, { recursive: true });
+    write(sessionLinkPath(sessionDir, sessionId), JSON.stringify({ transcriptPath }), "utf8");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function readSessionTranscriptLink(options = {}, dependencies = {}) {
+  const { sessionDir, sessionId } = options;
+  if (!sessionDir || !sessionId) {
+    return undefined;
+  }
+  const read = dependencies.readFileSync ?? readFileSync;
+  try {
+    const parsed = JSON.parse(read(sessionLinkPath(sessionDir, sessionId), "utf8"));
+    return typeof parsed?.transcriptPath === "string" && parsed.transcriptPath !== ""
+      ? parsed.transcriptPath
+      : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export function removeSessionTranscriptLink(options = {}, dependencies = {}) {
+  const { sessionDir, sessionId } = options;
+  if (!sessionDir || !sessionId) {
+    return;
+  }
+  const rm = dependencies.rmSync ?? rmSync;
+  try {
+    rm(sessionLinkPath(sessionDir, sessionId), { force: true });
+  } catch {
+    // best-effort cleanup; a stale link is harmless (session ids are unique per run)
+  }
+}

package/packages/cli-core/test/claude-transcript-watcher.test.mjs

@@ -8,6 +8,7 @@ import {
   discoverTranscript,
   watchClaudeTranscript
 } from "../src/claude-transcript-watcher.js";
+import { writeSessionTranscriptLink } from "../src/session-transcript-link.js";
 
 const noopTimers = { setInterval: () => ({}), clearInterval: () => {} };
 
@@ -128,6 +129,78 @@ test("watchClaudeTranscript handles a line split across two appends", () => {
   watcher.stop();
 });
 
+test("watchClaudeTranscript pins to the session's linked transcript, not newest-by-mtime", () => {
+  // Two concurrent sessions share one project dir. Each has its own link.
+  const projectDir = mkdtempSync(join(tmpdir(), "proj-"));
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+  const fileA = join(projectDir, "a.jsonl");
+  const fileB = join(projectDir, "b.jsonl");
+  writeFileSync(fileA, "");
+  writeFileSync(fileB, "");
+  writeSessionTranscriptLink({ sessionDir, sessionId: "sess_a", transcriptPath: fileA });
+  writeSessionTranscriptLink({ sessionDir, sessionId: "sess_b", transcriptPath: fileB });
+
+  const interruptsA = [];
+  const interruptsB = [];
+  const watcherA = watchClaudeTranscript({
+    sessionId: "sess_a",
+    sessionDir,
+    onInterrupt: (e) => interruptsA.push(e),
+    ...noopTimers
+  });
+  const watcherB = watchClaudeTranscript({
+    sessionId: "sess_b",
+    sessionDir,
+    onInterrupt: (e) => interruptsB.push(e),
+    ...noopTimers
+  });
+
+  // Both pin to their own file, then skip to EOF.
+  watcherA._tick();
+  watcherB._tick();
+
+  // Interrupt happens in session A only.
+  appendFileSync(fileA, interrupt());
+  watcherA._tick();
+  watcherB._tick();
+
+  assert.deepEqual(interruptsA, [{ type: "interrupted" }], "session A sees its own interrupt");
+  assert.deepEqual(interruptsB, [], "session B (idle) is NOT contaminated by session A's interrupt");
+
+  watcherA.stop();
+  watcherB.stop();
+});
+
+test("watchClaudeTranscript with a session link idles until the link appears", () => {
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+  const projectDir = mkdtempSync(join(tmpdir(), "proj-"));
+  const file = join(projectDir, "s.jsonl");
+  writeFileSync(file, "");
+
+  const interrupts = [];
+  const watcher = watchClaudeTranscript({
+    sessionId: "sess_late",
+    sessionDir,
+    onInterrupt: (e) => interrupts.push(e),
+    ...noopTimers
+  });
+
+  // No link yet → nothing tailed, even if a marker is already present.
+  appendFileSync(file, interrupt());
+  watcher._tick();
+  assert.deepEqual(interrupts, [], "no guessing before the hook reports the path");
+
+  // The hook fires and records the binding; the watcher now pins (skipping to EOF,
+  // so the pre-existing marker is not replayed) and only catches NEW events.
+  writeSessionTranscriptLink({ sessionDir, sessionId: "sess_late", transcriptPath: file });
+  watcher._tick();
+  appendFileSync(file, interrupt());
+  watcher._tick();
+  assert.deepEqual(interrupts, [{ type: "interrupted" }]);
+
+  watcher.stop();
+});
+
 test("watchClaudeTranscript reports an interrupt appended after it starts tailing", () => {
   const dir = mkdtempSync(join(tmpdir(), "transcript-"));
   const path = join(dir, "session.jsonl");

package/packages/cli-core/test/codex-guardian-watcher.test.mjs

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "../../../test/harness.mjs";
 import { watchCodexGuardianReviews } from "../src/codex-guardian-watcher.js";
+import { writeSessionTranscriptLink } from "../src/session-transcript-link.js";
 
 const noopTimers = { setInterval: () => ({}), clearInterval: () => {} };
 
@@ -262,6 +263,53 @@ test("watchCodexGuardianReviews ignores guardian trunks of other parents", () =>
   watcher.stop();
 });
 
+test("watchCodexGuardianReviews binds to the LINKED main thread, not the newest main", () => {
+  const { root, dir } = makeSessionsRoot();
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+
+  // Our main rollout, and a DIFFERENT concurrent session's main rollout written
+  // afterwards (so it has the newer mtime — what the old heuristic would pick).
+  const ourMain = join(dir, "rollout-main-ours.jsonl");
+  writeFileSync(ourMain, metaLine({ id: "main-ours", parent_thread_id: null, source: "cli", thread_source: "user" }));
+  writeFileSync(
+    join(dir, "rollout-main-other.jsonl"),
+    metaLine({ id: "main-other", parent_thread_id: null, source: "cli", thread_source: "user" })
+  );
+
+  // A guardian trunk for OUR main, plus a decoy trunk for the OTHER main that is
+  // newer and already has a review turn.
+  const ourTrunk = join(dir, "rollout-guardian-ours.jsonl");
+  writeFileSync(
+    ourTrunk,
+    metaLine({ id: "g-ours", parent_thread_id: "main-ours", source: { subagent: { other: "guardian" } } })
+  );
+  writeFileSync(
+    join(dir, "rollout-guardian-other.jsonl"),
+    metaLine({ id: "g-other", parent_thread_id: "main-other", source: { subagent: { other: "guardian" } } }) +
+      reviewStarted("decoy")
+  );
+
+  writeSessionTranscriptLink({ sessionDir, sessionId: "sess_a", transcriptPath: ourMain });
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    sessionId: "sess_a",
+    sessionDir,
+    onReviewEvent: (e) => events.push(e),
+    ...noopTimers
+  });
+
+  watcher._tick();
+  assert.deepEqual(events, [], "the newer decoy trunk (another session) is ignored");
+
+  appendFileSync(ourTrunk, reviewStarted());
+  watcher._tick();
+  assert.deepEqual(events, [{ type: "review_started" }], "our trunk is the one tailed");
+
+  watcher.stop();
+});
+
 test("watchCodexGuardianReviews picks up a trunk created after watching began", () => {
   const { root, dir } = makeSessionsRoot();
   writeFileSync(

package/packages/cli-core/test/codex-transcript-watcher.test.mjs

@@ -4,6 +4,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "../../../test/harness.mjs";
 import { discoverCodexTranscript, watchCodexTranscript } from "../src/codex-transcript-watcher.js";
+import { writeSessionTranscriptLink } from "../src/session-transcript-link.js";
 
 const noopTimers = { setInterval: () => ({}), clearInterval: () => {} };
 
@@ -60,6 +61,55 @@ test("discoverCodexTranscript skips files older than session start", () => {
   assert.equal(discoverCodexTranscript(root, Date.now() - 1000), undefined);
 });
 
+test("watchCodexTranscript pins to the session's linked rollout, not newest-by-mtime", () => {
+  // Two concurrent Codex sessions, each with its own rollout and its own link.
+  const root = mkdtempSync(join(tmpdir(), "codex-sessions-"));
+  const dir = join(root, "2026", "06", "12");
+  mkdirSync(dir, { recursive: true });
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+
+  const fileA = join(dir, "rollout-a.jsonl");
+  const fileB = join(dir, "rollout-b.jsonl");
+  writeFileSync(fileA, sessionMeta("2026-06-12T01:00:00.000Z", "thread-a"));
+  writeFileSync(fileB, sessionMeta("2026-06-12T01:00:00.000Z", "thread-b"));
+  writeSessionTranscriptLink({ sessionDir, sessionId: "sess_a", transcriptPath: fileA });
+  writeSessionTranscriptLink({ sessionDir, sessionId: "sess_b", transcriptPath: fileB });
+
+  const eventsA = [];
+  const eventsB = [];
+  const watcherA = watchCodexTranscript({
+    sessionId: "sess_a",
+    sessionDir,
+    onToolEvent: (e) => eventsA.push(e),
+    ...noopTimers
+  });
+  const watcherB = watchCodexTranscript({
+    sessionId: "sess_b",
+    sessionDir,
+    onToolEvent: (e) => eventsB.push(e),
+    ...noopTimers
+  });
+
+  // Both pin to their own rollout and consume the session_meta line.
+  watcherA._tick();
+  watcherB._tick();
+
+  // Session A is interrupted.
+  appendFileSync(fileA, turnAborted());
+  watcherA._tick();
+  watcherB._tick();
+
+  assert.deepEqual(
+    eventsA,
+    [{ type: "turn_aborted", reason: "interrupted" }],
+    "session A sees its own interrupt"
+  );
+  assert.deepEqual(eventsB, [], "session B is NOT contaminated by session A's interrupt");
+
+  watcherA.stop();
+  watcherB.stop();
+});
+
 test("watchCodexTranscript reports appended tool events", () => {
   const dir = mkdtempSync(join(tmpdir(), "codex-transcript-"));
   const path = join(dir, "session.jsonl");

package/packages/cli-core/test/run-state.test.mjs

@@ -3,7 +3,8 @@ import { mkdtempSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "../../../test/harness.mjs";
-import { parseStateArgs, runStateCommand } from "../src/run-state.js";
+import { extractTranscriptPath, parseStateArgs, runStateCommand } from "../src/run-state.js";
+import { readSessionTranscriptLink } from "../src/session-transcript-link.js";
 
 test("runStateCommand appends a debug line when HAYA_PET_HOOK_DEBUG is set", async () => {
   const logPath = join(mkdtempSync(join(tmpdir(), "haya-dbg-")), "hooks.jsonl");
@@ -21,6 +22,51 @@ test("runStateCommand appends a debug line when HAYA_PET_HOOK_DEBUG is set", asy
   assert.deepEqual(line, { ts: 7, state: "waiting_approval", sessionId: "s1", summary: "approval" });
 });
 
+test("extractTranscriptPath pulls transcript_path out of a Claude hook payload", () => {
+  assert.equal(
+    extractTranscriptPath(JSON.stringify({ session_id: "x", transcript_path: "/p/a.jsonl", cwd: "/p" })),
+    "/p/a.jsonl"
+  );
+  // Defensive: junk, missing field, wrong type, and empty all yield undefined.
+  assert.equal(extractTranscriptPath("{not json"), undefined);
+  assert.equal(extractTranscriptPath(JSON.stringify({ session_id: "x" })), undefined);
+  assert.equal(extractTranscriptPath(JSON.stringify({ transcript_path: 42 })), undefined);
+  assert.equal(extractTranscriptPath(""), undefined);
+  assert.equal(extractTranscriptPath(undefined), undefined);
+});
+
+test("runStateCommand records the session->transcript link when given a transcript path", async () => {
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+  await runStateCommand(
+    { command: "state", state: "thinking", summary: undefined, session: "sess_link" },
+    {
+      now: () => 1,
+      sessionDir,
+      transcriptPath: "/p/.claude/projects/D--p/abc.jsonl",
+      createIpcClient: async () => ({ send: async () => {}, close: async () => {} })
+    }
+  );
+
+  assert.equal(
+    readSessionTranscriptLink({ sessionDir, sessionId: "sess_link" }),
+    "/p/.claude/projects/D--p/abc.jsonl"
+  );
+});
+
+test("runStateCommand writes no link when no transcript path is supplied", async () => {
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+  await runStateCommand(
+    { command: "state", state: "thinking", summary: undefined, session: "sess_nolink" },
+    {
+      now: () => 1,
+      sessionDir,
+      createIpcClient: async () => ({ send: async () => {}, close: async () => {} })
+    }
+  );
+
+  assert.equal(readSessionTranscriptLink({ sessionDir, sessionId: "sess_nolink" }), undefined);
+});
+
 test("parseStateArgs reads state, summary, and session", () => {
   assert.deepEqual(parseStateArgs(["thinking"]), {
     command: "state",

package/packages/cli-core/test/session-transcript-link.test.mjs

@@ -0,0 +1,67 @@
+import assert from "node:assert/strict";
+import { existsSync, mkdtempSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "../../../test/harness.mjs";
+import {
+  readSessionTranscriptLink,
+  removeSessionTranscriptLink,
+  sessionLinkPath,
+  writeSessionTranscriptLink
+} from "../src/session-transcript-link.js";
+
+test("write then read round-trips a session's transcript path", () => {
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+  const transcriptPath = "D:\\proj\\.claude\\projects\\D--proj\\abc.jsonl";
+
+  const wrote = writeSessionTranscriptLink({ sessionDir, sessionId: "sess_a", transcriptPath });
+  assert.equal(wrote, true);
+  assert.equal(readSessionTranscriptLink({ sessionDir, sessionId: "sess_a" }), transcriptPath);
+});
+
+test("two sessions in the same dir keep separate, independent links", () => {
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+  writeSessionTranscriptLink({ sessionDir, sessionId: "sess_a", transcriptPath: "/p/a.jsonl" });
+  writeSessionTranscriptLink({ sessionDir, sessionId: "sess_b", transcriptPath: "/p/b.jsonl" });
+
+  // The core of the bug fix: each session resolves ONLY its own transcript.
+  assert.equal(readSessionTranscriptLink({ sessionDir, sessionId: "sess_a" }), "/p/a.jsonl");
+  assert.equal(readSessionTranscriptLink({ sessionDir, sessionId: "sess_b" }), "/p/b.jsonl");
+});
+
+test("reading a session with no link returns undefined (no guessing)", () => {
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+  assert.equal(readSessionTranscriptLink({ sessionDir, sessionId: "missing" }), undefined);
+});
+
+test("write is a no-op without the required fields", () => {
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+  assert.equal(writeSessionTranscriptLink({ sessionDir, sessionId: "s" }), false);
+  assert.equal(writeSessionTranscriptLink({ sessionDir, transcriptPath: "/p/a.jsonl" }), false);
+  assert.equal(writeSessionTranscriptLink({ sessionId: "s", transcriptPath: "/p/a.jsonl" }), false);
+});
+
+test("remove deletes the link and is safe when it is already gone", () => {
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+  writeSessionTranscriptLink({ sessionDir, sessionId: "sess_a", transcriptPath: "/p/a.jsonl" });
+  const path = sessionLinkPath(sessionDir, "sess_a");
+  assert.equal(existsSync(path), true);
+
+  removeSessionTranscriptLink({ sessionDir, sessionId: "sess_a" });
+  assert.equal(existsSync(path), false);
+  // Second removal must not throw.
+  removeSessionTranscriptLink({ sessionDir, sessionId: "sess_a" });
+});
+
+test("a corrupt link file reads as undefined rather than throwing", () => {
+  const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
+  writeSessionTranscriptLink(
+    { sessionDir, sessionId: "sess_a", transcriptPath: "/p/a.jsonl" },
+    { writeFileSync: () => {} } // pretend write; nothing on disk
+  );
+  // Inject a reader returning junk to simulate a partially-written file.
+  assert.equal(
+    readSessionTranscriptLink({ sessionDir, sessionId: "sess_a" }, { readFileSync: () => "{not json" }),
+    undefined
+  );
+});