@hayasaka7/haya-pet 0.3.8 → 0.3.9

package/CHANGELOG.md

@@ -7,6 +7,23 @@ All notable changes to HAYA Pet are documented here. This project adheres to
 > 0.2.0 npm publish; they are listed under 0.2.1, which is the first version that
 > ships them.
 
+## [0.3.9]
+
+### Fixed
+- **The cross-session contamination fix now covers Codex too.** Codex had the same
+  flaw fixed for Claude in 0.3.8: its transcript watcher chose the rollout by
+  newest mtime + cwd, and the guardian-review watcher derived the main thread id
+  from the newest main rollout — so two Codex sessions in the same folder could
+  cross-report each other's `turn_aborted` (interrupt) or tool activity, with the
+  idle session showing the busy one's state. Codex's command-hook payload also
+  carries `transcript_path`, so the `haya-pet state` reporter's per-session
+  `session → transcript` link (already written for every client) now pins the Codex
+  transcript watcher to its own rollout, and the guardian watcher binds the main
+  thread id from the linked rollout's `payload.id` (and only follows a trunk whose
+  `parent_thread_id` matches it). Both fall back to the previous mtime+cwd heuristic
+  when no link is available (e.g. `transcript_path` null early), so there is no
+  regression. No timer involved.
+
 ## [0.3.8]
 
 ### Fixed
@@ -19,8 +36,8 @@ All notable changes to HAYA Pet are documented here. This project adheres to
   session's watcher now pins to its own transcript via the `transcript_path` Claude
   includes in every hook payload (recorded as a per-session link by the `haya-pet
   state` reporter) instead of guessing; until that link exists it idles rather than
-  locking onto another session's file. Codex shares the same discovery shape and is
-  tracked as a known issue.
+  locking onto another session's file. (Codex had the same discovery shape — fixed
+  in 0.3.9.)
 - **The pet no longer disappears when the display layout changes.** The overlay
   window's bounds were set once at creation to span one display's work area and
   never re-homed, so unplugging a monitor, changing resolution/DPI, docking or

package/apps/cli/src/haya-pet.js

@@ -434,12 +434,20 @@ async function runRunCommand(parsed, dependencies) {
       };
       cleanup = injected.cleanup;
 
+      // Pin both Codex watchers to THIS session's rollout via the
+      // session->transcript link the `haya-pet state` reporter records from the
+      // hook payload's transcript_path, instead of guessing newest-by-mtime (which
+      // leaks a concurrent same-cwd session's activity/interrupts).
+      const sessionDir = resolveSessionDir(dependencies, env);
+
       const activeToolCalls = new Set();
       const watcher = watchCodexTranscript({
         homeDir: dependencies.homeDir,
         sessionsRoot: dependencies.codexSessionsRoot,
         cwd,
         startedAt: now(),
+        sessionId,
+        sessionDir,
         onToolEvent: (event) => {
           hookDebugLog(env, now, {
             source: "codex_transcript",
@@ -522,6 +530,8 @@ async function runRunCommand(parsed, dependencies) {
         sessionsRoot: dependencies.codexSessionsRoot,
         cwd,
         startedAt: now(),
+        sessionId,
+        sessionDir,
         onReviewEvent: (event) => {
           hookDebugLog(env, now, {
             source: "codex_guardian",
@@ -550,6 +560,7 @@ async function runRunCommand(parsed, dependencies) {
       stopWatcher = () => {
         guardianWatcher.stop();
         stopWithoutGuardian();
+        removeSessionTranscriptLink({ sessionDir, sessionId });
       };
     }
   }

package/docs/known-issues.md

@@ -2,38 +2,34 @@
 
 Issues found in live use, with their current status.
 
-## 🔲 Open: cross-session status contamination on Codex
-
-- **Symptom (same class as the resolved Claude entry below):** interrupting one
-  Codex session can flip a **different, concurrent** Codex session's pet to
-  *interrupted* (and more generally mirror another session's tool/working
-  states). Most likely when two Codex sessions run in the **same folder** and one
-  is busy while the other is idle. Not yet fixed.
-- **Root cause:** `discoverCodexTranscript` (`codex-transcript-watcher.js`) picks
-  the rollout by **newest `.jsonl` by mtime**, filtered only by
-  `session_meta.cwd` / freshness — it does **not** bind to a specific session, so
-  an idle session's watcher can lock onto a busy session's rollout and then read
-  that session's `turn_aborted` (Codex's interrupt signal) as its own. The rollout
-  *does* identify itself (`session_meta.payload.id` = the Codex thread id, plus a
-  unique per-session filename), but (1) we never learn **which** thread id belongs
-  to the session our wrapper launched — the Codex hooks pass only
-  `HAYA_PET_SESSION_ID` via env and the reporter currently **discards Codex's hook
-  stdin** — and (2) the watcher matches on mtime+cwd, not on that id. The
-  `isFreshSession` branch even admits recently-started rollouts from **other
-  cwds**, so the exposure is slightly *wider* than Claude's (which is scoped to one
-  project dir). This is the residual same-session-folder case the earlier
-  "Codex pet looked busy immediately after startup" fix narrowed but did not
-  eliminate.
-- **Plan (handle later):** port the Claude binding to Codex. Verify against the
-  live Codex CLI whether the hook **stdin payload** carries the rollout path or
-  the thread id (`session_id`); if so, have the `haya-pet state` reporter record a
-  per-session session→rollout link (reusing `session-transcript-link.js`) and pin
-  the watcher to it — or, failing that, match `session_meta.payload.id` once we
-  can learn our session's id. Fall back to current behavior when no identifier is
-  available. No timer, consistent with the rest of the status model.
-- **Status:** unfixed. The binding fix shipped this session is **Claude-only** and
-  does not touch the Codex watcher or the guardian-review watcher (which shares the
-  same discovery shape and should be checked alongside it).
+## ✅ Resolved: cross-session status contamination on Codex
+
+- **Symptom (same class as the Claude entry below):** interrupting one Codex
+  session could flip a **different, concurrent** Codex session's pet to
+  *interrupted* (and more generally mirror another session's tool/working states).
+  Most likely when two Codex sessions ran in the **same folder** and one was busy
+  while the other was idle.
+- **Root cause:** `discoverCodexTranscript` (`codex-transcript-watcher.js`) picked
+  the rollout by **newest `.jsonl` by mtime**, filtered only by `session_meta.cwd`
+  / freshness — it did **not** bind to a specific session, so an idle session's
+  watcher could lock onto a busy session's rollout and read that session's
+  `turn_aborted` (Codex's interrupt signal) as its own. The `isFreshSession` branch
+  even admitted recently-started rollouts from **other cwds**, so the exposure was
+  slightly *wider* than Claude's (scoped to one project dir). The guardian-review
+  watcher had the same flaw: it derived the main thread id from the newest main
+  rollout by mtime, so a concurrent session's review status could be misattributed.
+- **Fix:** the same per-session binding used for Claude. Verified against the
+  OpenAI Codex docs that the command-hook stdin payload carries **`transcript_path`**
+  (and `session_id`, the conversation/rollout id — which I also confirmed on disk
+  equals `session_meta.payload.id` and the rollout filename uuid). The
+  `haya-pet state` reporter already records a per-session `session→transcript` link
+  from that `transcript_path` (the capture is client-agnostic), so the Codex
+  transcript watcher now pins to its own rollout via the link
+  (`session-transcript-link.js`) instead of guessing newest-by-mtime, and the
+  guardian watcher derives the main thread id from the **linked** rollout's
+  `payload.id` (and only considers a trunk whose `parent_thread_id` matches it).
+  Both fall back to the old heuristic when no link is available (e.g. `transcript_path`
+  null early), so there is no regression. No timer involved.
 
 ## ✅ Resolved: Claude interrupt/denial leaked into a concurrent idle session
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hayasaka7/haya-pet",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "type": "module",
   "description": "Generic AI CLI pet runtime foundation.",
   "keywords": [

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/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");