@hayasaka7/haya-pet 0.3.4 → 0.3.6

package/CHANGELOG.md

@@ -7,6 +7,44 @@ 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.6]
+
+### Fixed
+- **The pet no longer gets stuck on "compacting" in Claude Code.** `PreCompact`
+  set the status to *compacting*, but nothing ever cleared it — Claude's `Stop`
+  does not fire for a `/compact`, so the pet sat on *compacting* until the next
+  prompt or the 30 s stale sweep. The Claude hook table now also subscribes
+  **`PostCompact`**, split by the documented `manual`/`auto` trigger matcher: a
+  **manual** `/compact` returns to *idle* (control is back at the prompt), while
+  an **auto** compaction (context filled mid-turn) resumes to *thinking* and the
+  next real event refines from there. Mirrors Codex, which already handled
+  `PostCompact`.
+- **Codex interrupts no longer get clobbered by stale working states.** The Codex
+  transcript watcher already detected `turn_aborted` and emitted
+  *interrupted*, but the daemon registry applied state by IPC arrival order. A
+  slower hook reporter could therefore deliver an older *thinking* / *running*
+  state after the interrupt and overwrite it. The registry now keeps a separate
+  per-session state timestamp and ignores state messages older than the latest
+  accepted state, while heartbeats still update liveness independently.
+- **Codex immediate interrupts in resumed sessions are detected.** In a resumed
+  Codex session, `session_meta.timestamp` stays at the original session start.
+  The prompt-start hook could still set the pet to *thinking*, but the transcript
+  watcher rejected the old rollout before it could see the immediately appended
+  `turn_aborted`. The watcher now also follows a fresh rollout from the wrapped
+  cwd, so resumed sessions can report interrupts while unrelated old sessions
+  remain filtered.
+- **Codex auto-review status works in resumed sessions too.** The guardian-review
+  watcher had the same old-`session_meta.timestamp` filter as the transcript
+  watcher, so a resumed main rollout could be rejected before the guardian trunk
+  was matched to it. The guardian watcher now uses the same fresh-mtime + wrapped
+  cwd rule for resumed main sessions before following the guardian review trunk.
+
+### Added
+- **`HAYA_PET_DAEMON_DEBUG` diagnostic.** When set to a file path, the companion
+  appends one JSONL line per incoming non-heartbeat message in daemon **arrival
+  order** (with `updatedAt`), making out-of-order state delivery observable. Added
+  to investigate state-order races such as the Codex interrupt issue.
+
 ## [0.3.4]
 
 ### Fixed

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

@@ -426,6 +426,7 @@ async function runRunCommand(parsed, dependencies) {
       const watcher = watchCodexTranscript({
         homeDir: dependencies.homeDir,
         sessionsRoot: dependencies.codexSessionsRoot,
+        cwd,
         startedAt: now(),
         onToolEvent: (event) => {
           hookDebugLog(env, now, {
@@ -507,6 +508,7 @@ async function runRunCommand(parsed, dependencies) {
       const guardianWatcher = watchCodexGuardianReviews({
         homeDir: dependencies.homeDir,
         sessionsRoot: dependencies.codexSessionsRoot,
+        cwd,
         startedAt: now(),
         onReviewEvent: (event) => {
           hookDebugLog(env, now, {

package/apps/companion/src/main/index.js

@@ -1,6 +1,6 @@
 import { app, BrowserWindow, ipcMain, Menu, nativeImage, screen, shell, Tray } from "electron";
 import { fileURLToPath } from "node:url";
-import { readFileSync } from "node:fs";
+import { appendFileSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { createDaemonRuntime } from "../../../../packages/daemon-core/src/daemon-runtime.js";
 import { createIpcServer } from "../../../../packages/daemon-core/src/ipc-server.js";
@@ -30,6 +30,35 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const TRAY_ICON_DATA_URL =
   "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAANElEQVR4nGNgoAXIW/HvPzZMtkaiDCJWM05DKDKAVM0YhowaQAUDBj4dUCUpE2MQQY3kAACyf/g8DHVl5wAAAABJRU5ErkJggg==";
 
+// Best-effort daemon-side diagnostic, mirroring the wrapper's HAYA_PET_HOOK_DEBUG.
+// When HAYA_PET_DAEMON_DEBUG points at a file, append one JSONL line per incoming
+// non-heartbeat message in DAEMON ARRIVAL ORDER, with its updatedAt. This is the
+// only place the true apply order is visible: the registry is last-writer-wins by
+// arrival and ignores updatedAt, so a stale "working" message that arrives after
+// "interrupted" would surface here as the clobber. Never throws.
+function debugLogDaemonMessage(message) {
+  const target = process.env.HAYA_PET_DAEMON_DEBUG;
+  if (!target || !message || message.type === "heartbeat") {
+    return;
+  }
+  try {
+    appendFileSync(
+      target,
+      `${JSON.stringify({
+        ts: Date.now(),
+        type: message.type,
+        sessionId: message.sessionId,
+        state: message.state,
+        source: message.source,
+        updatedAt: message.updatedAt,
+        summary: message.summary
+      })}\n`
+    );
+  } catch {
+    // diagnostics must never break the daemon
+  }
+}
+
 const paths = getDefaultPaths();
 const capabilities = getPlatformCapabilities();
 const stateFile = createStateFile({ statePath: paths.statePath });
@@ -113,6 +142,7 @@ async function bootstrap() {
         app.quit();
         return;
       }
+      debugLogDaemonMessage(message);
       return runtime.handleMessage(message);
     },
     onProtocolError: (error) => console.error("protocol error:", error.message)

package/docs/known-issues.md

@@ -2,6 +2,57 @@
 
 Issues found in live use, with their current status.
 
+## ✅ Resolved: Codex interrupt sometimes left the pet "working"
+
+- **Symptom:** Pressing Esc to interrupt a Codex turn occasionally does **not**
+  flip the pet to *interrupted* — it keeps showing a working state (*thinking* /
+  *running*) even though the turn was cut short. Intermittent ("some occasions").
+- **Investigation so far:** The "a late `function_call_output` resets the state to
+  *thinking*" theory was **ruled out** — across 257 real `turn_aborted` events in
+  live `~/.codex/sessions`, **zero** had a tool result after the abort. Codex
+  fires no hook on an abort, and the L3 transcript watcher does record
+  `turn_aborted` and emit `interrupted`.
+- **Root cause:** The daemon registry applied session state **last-writer-wins by
+  IPC arrival order** (`registry.js` `applyState` ignored state ordering). Hooks
+  (separate `haya-pet state` subprocesses) and the interrupt watcher use different
+  IPC connections, so a stale "working" message could arrive *after*
+  `interrupted` and clobber it.
+- **Fix:** The registry now keeps a separate per-session state timestamp and ignores
+  state messages older than the latest accepted state. Heartbeats still update
+  liveness independently, so a newer heartbeat cannot block a legitimate
+  later-delivered state message.
+- **Follow-up root cause:** Immediate Esc after prompt submit still failed in
+  **resumed** Codex sessions. `UserPromptSubmit` fired and set *thinking*, and
+  Codex wrote a normal `turn_aborted` record, but the watcher rejected the rollout
+  because `session_meta.timestamp` was from the original session start, before the
+  HAYA wrapper launch. The transcript watcher now allows a fresh rollout from the
+  wrapped cwd, preserving the old guard against unrelated stale sessions while
+  covering resumed sessions.
+- **Other affected case checked:** The Codex guardian-review watcher had the same
+  resumed-session shape. It matched guardian trunks by the main thread id, but the
+  old resumed main rollout could be rejected before that id was accepted. It now
+  uses the same fresh-mtime + wrapped-cwd rule for resumed main sessions, so
+  "Approve for me" review status is not lost after a Codex resume.
+- **How to diagnose if it recurs:** Set `HAYA_PET_DAEMON_DEBUG=<path>` before
+  launching the companion. The companion writes daemon-arrival JSONL for
+  non-heartbeat messages. If `interrupted` never appears, the issue is in
+  transcript discovery/watching; if `interrupted` appears before a stale
+  hook-sourced working state, it is an ordering regression.
+
+## ✅ Resolved: Claude pet stuck on "compacting" after a compaction
+
+- **Symptom:** With Claude Code hooks enabled, the pet entered *compacting* on
+  `PreCompact` and never left — it sat there until the 30 s stale sweep or the
+  next prompt. Most visible after a manual `/compact`.
+- **Root cause:** The Claude hook table subscribed `PreCompact` → *compacting* but
+  had **no completion event**. Claude's `Stop` does not fire for a compaction, so
+  nothing cleared the state. (Codex already subscribed `PostCompact`.)
+- **Fix:** The Claude hook table now also subscribes **`PostCompact`**, split by
+  the documented `manual`/`auto` trigger matcher: a **manual** `/compact` returns
+  to *idle* (control is back at the prompt), while an **auto** compaction resumes
+  to *thinking* (the agent continues the turn) and the next real event refines it.
+  Verified live on the manual path; auto uses the identical matcher mechanism.
+
 ## ✅ Resolved: Claude Code subagent completion changed the main session status
 
 - **Symptom:** In Claude Code multi-agent runs, the main agent could already be
@@ -75,9 +126,11 @@ Issues found in live use, with their current status.
   Another already-running Codex session could keep writing fresh records after
   HAYA Pet started, making its rollout look like the wrapped session even though
   it began earlier.
-- **Fix:** Both watchers now inspect the first `session_meta` line and require
-  its timestamp to belong to this wrapper launch. Old-but-active Codex sessions
-  are ignored even if their files continue to receive fresh writes.
+- **Fix:** Both watchers inspect the first `session_meta` line and require either
+  a timestamp that belongs to this wrapper launch, or a fresh rollout whose cwd
+  matches the wrapped Codex cwd for resumed sessions. Old-but-active Codex
+  sessions from unrelated projects are ignored even if their files continue to
+  receive fresh writes.
 
 ## ✅ Resolved: Codex `/quit` hung on its goodbye (and the pet kept showing "working")
 
@@ -259,8 +312,10 @@ observation (`--observe`) or L1 lifecycle as the fallback. Current state:
   lifecycle status). Live in-session status is **opt-in** via `HAYA_PET_HOOKS=1`,
   which injects a settings file (`claude --settings <stable-file>`, no change to
   your global config) wiring Claude's `UserPromptSubmit`/`PreToolUse`/`PostToolUse`/
-  `Notification`/`PreCompact`/`Stop` events to `haya-pet state <state>`, reported
-  to the daemon over the IPC pipe. `SubagentStop` is intentionally ignored because
+  `Notification`/`PreCompact`/`PostCompact`/`Stop` events to `haya-pet state <state>`,
+  reported to the daemon over the IPC pipe. `PostCompact` is split by its
+  `manual`/`auto` trigger matcher (manual `/compact` → *idle*, auto compaction →
+  *thinking*) so the pet never sticks on *compacting*. `SubagentStop` is intentionally ignored because
   it is not a main-turn idle signal. `PreToolUse` distinguishes
   file-editing tools (`Edit`/`Write`/`MultiEdit`/`NotebookEdit` → *editing files*)
   from other tools (→ *running tools*) via the hook `matcher`. **Why opt-in:**

package/package.json

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

package/packages/adapters/src/claude-hooks.js

@@ -33,6 +33,14 @@ const HOOK_TABLE = Object.freeze([
   { event: "Notification", matcher: "idle_prompt", state: "idle", summary: "idle" },
   { event: "PermissionDenied", state: "idle", summary: "denied" },
   { event: "PreCompact", state: "compacting" },
+  // PostCompact is the authoritative "compaction finished" signal (verified in
+  // the Claude hooks docs). Without it the pet stays stuck on `compacting` until
+  // the 30s stale sweep. The `trigger` matcher splits the two outcomes: a manual
+  // /compact hands control back to an idle prompt, while an AUTO compaction fires
+  // mid-turn and the agent immediately resumes working (thinking) — the next real
+  // event (PreToolUse/Stop) refines from there. Mirrors codex-hooks' PostCompact.
+  { event: "PostCompact", matcher: "manual", state: "idle", summary: "compacted" },
+  { event: "PostCompact", matcher: "auto", state: "thinking", summary: "compacted" },
   { event: "Stop", state: "idle" },
   { event: "StopFailure", state: "idle", summary: "stopped" }
 ]);
@@ -49,6 +57,11 @@ export function mapClaudeEventToState(event, detail) {
     if (detail === "idle_prompt") return "idle";
     return undefined;
   }
+  if (event === "PostCompact") {
+    // `detail` is the compaction trigger ("manual" | "auto"). A manual /compact
+    // ends at an idle prompt; an auto compaction resumes the turn (thinking).
+    return detail === "manual" ? "idle" : "thinking";
+  }
   const entry = HOOK_TABLE.find((row) => row.event === event && row.matcher === undefined);
   return entry?.state;
 }

package/packages/adapters/src/codex-hooks.js

@@ -43,8 +43,11 @@
 //    while manual/unknown reviewer config reports waiting_approval. The guardian
 //    fires NO hooks itself (SubAgentSource::Other is excluded from Subagent
 //    hooks), so the wrapper also tails the guardian rollout directly.
-//  - UNTESTED: PreCompact / SubagentStart|Stop (no compaction / subagent
-//    occurred in the probe).
+//  - PreCompact / PostCompact trigger split follows the same manual/auto matcher
+//    shape as Claude. A manual `/compact` returns to a prompt, while auto compact
+//    happens mid-turn and should resume the pet's working state.
+//  - UNTESTED: PreCompact / SubagentStart|Stop live firing (no compaction /
+//    subagent occurred in the probe).
 //
 // OPEN QUESTION (injection): unlike `claude --settings <file>`, Codex has no
 // per-invocation settings-file flag. Candidate non-mutating paths, best first:
@@ -70,8 +73,9 @@ const EDIT_TOOLS_MATCHER = EDIT_TOOLS.join("|");
 const COMMAND_TOOLS_MATCHER = "shell_command";
 
 // The hook table. Each entry → one Codex hook that reports a fixed pet state.
-// `matcher` (when present) filters PreToolUse by tool name. `summary` is an
-// optional short label shown in the bubble and in HAYA_PET_HOOK_DEBUG logs.
+// `matcher` (when present) filters PreToolUse by tool name or PostCompact by
+// compaction trigger. `summary` is an optional short label shown in the bubble and
+// in HAYA_PET_HOOK_DEBUG logs.
 const HOOK_TABLE = Object.freeze([
   { event: "UserPromptSubmit", state: "thinking" },
   { event: "PreToolUse", matcher: EDIT_TOOLS_MATCHER, state: "editing_files" },
@@ -79,7 +83,8 @@ const HOOK_TABLE = Object.freeze([
   { event: "PostToolUse", state: "thinking" },
   { event: "PermissionRequest", command: "codex-permission-request" },
   { event: "PreCompact", state: "compacting" },
-  { event: "PostCompact", state: "thinking", summary: "compacted" },
+  { event: "PostCompact", matcher: "manual", state: "idle", summary: "compacted" },
+  { event: "PostCompact", matcher: "auto", state: "thinking", summary: "compacted" },
   // A subagent finishing is mid-turn — the main agent keeps working, so this is
   // NOT idle. Turn-end is the dedicated `Stop` event below.
   { event: "SubagentStart", state: "running_tool", summary: "subagent" },
@@ -87,11 +92,15 @@ const HOOK_TABLE = Object.freeze([
   { event: "Stop", state: "idle" }
 ]);
 
-// Resolve the pet state for a Codex event. `toolName` is the tool for PreToolUse.
-// Exposed for testing and to keep the mapping in one place.
-export function mapCodexEventToState(event, toolName) {
+// Resolve the pet state for a Codex event. `detail` is the tool for PreToolUse or
+// the compaction trigger for PostCompact. Exposed for testing and to keep the
+// mapping in one place.
+export function mapCodexEventToState(event, detail) {
   if (event === "PreToolUse") {
-    return EDIT_TOOLS.includes(toolName) ? "editing_files" : "running_tool";
+    return EDIT_TOOLS.includes(detail) ? "editing_files" : "running_tool";
+  }
+  if (event === "PostCompact") {
+    return detail === "manual" ? "idle" : "thinking";
   }
   const entry = HOOK_TABLE.find((row) => row.event === event && row.matcher === undefined);
   return entry?.state;

package/packages/adapters/test/claude-hooks.test.mjs

@@ -31,6 +31,15 @@ test("mapClaudeEventToState branches Notification on type (approval vs idle)", (
   assert.equal(mapClaudeEventToState("Notification", "auth_success"), undefined);
 });
 
+test("mapClaudeEventToState branches PostCompact on compaction trigger", () => {
+  // Manual /compact returns to an idle prompt; auto compaction resumes the turn.
+  assert.equal(mapClaudeEventToState("PostCompact", "manual"), "idle");
+  assert.equal(mapClaudeEventToState("PostCompact", "auto"), "thinking");
+  // Unknown/missing trigger defaults to the "still working" assumption, which the
+  // next real event corrects — never leaving the pet stuck on `compacting`.
+  assert.equal(mapClaudeEventToState("PostCompact"), "thinking");
+});
+
 test("buildClaudeHookSettings bakes node + cli, no volatile session id", () => {
   const settings = buildClaudeHookSettings({
     nodePath: "/usr/bin/node",
@@ -62,6 +71,15 @@ test("buildClaudeHookSettings splits Notification into approval + idle matchers"
   assert.match(idle.hooks[0].command, /state idle --summary idle$/);
 });
 
+test("buildClaudeHookSettings splits PostCompact into manual + auto triggers", () => {
+  const post = buildClaudeHookSettings({ nodePath: "n", cliPath: "c" }).hooks.PostCompact;
+  assert.equal(post.length, 2);
+  const manual = post.find((e) => e.matcher === "manual");
+  const auto = post.find((e) => e.matcher === "auto");
+  assert.match(manual.hooks[0].command, /state idle --summary compacted$/);
+  assert.match(auto.hooks[0].command, /state thinking --summary compacted$/);
+});
+
 test("buildClaudeHookSettings keeps two non-overlapping PreToolUse matchers", () => {
   const pre = buildClaudeHookSettings({ nodePath: "n", cliPath: "c" }).hooks.PreToolUse;
   assert.equal(pre.length, 2);
@@ -83,7 +101,7 @@ test("buildClaudeHookSettings includes all subscribed events", () => {
   for (const event of [
     "UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure",
     "PermissionRequest", "Notification", "PermissionDenied", "PreCompact",
-    "Stop", "StopFailure"
+    "PostCompact", "Stop", "StopFailure"
   ]) {
     assert.ok(settings.hooks[event], `missing hook event ${event}`);
   }

package/packages/adapters/test/codex-hooks.test.mjs

@@ -25,6 +25,12 @@ test("mapCodexEventToState branches PreToolUse on tool name (apply_patch vs comm
   assert.equal(mapCodexEventToState("PreToolUse", "read_file"), "running_tool");
 });
 
+test("mapCodexEventToState branches PostCompact on compaction trigger", () => {
+  assert.equal(mapCodexEventToState("PostCompact", "manual"), "idle");
+  assert.equal(mapCodexEventToState("PostCompact", "auto"), "thinking");
+  assert.equal(mapCodexEventToState("PostCompact"), "thinking");
+});
+
 test("Stop is the only idle signal — SubagentStop stays working", () => {
   // Regression guard for the key Codex-vs-Claude difference: a subagent finishing
   // mid-turn must NOT flip the pet to idle.
@@ -64,6 +70,15 @@ test("buildCodexHookSettings splits PreToolUse into edit + command matchers", ()
   assert.equal(other.matcher, "shell_command");
 });
 
+test("buildCodexHookSettings splits PostCompact into manual + auto triggers", () => {
+  const post = buildCodexHookSettings({ nodePath: "n", cliPath: "c" }).hooks.PostCompact;
+  assert.equal(post.length, 2);
+  const manual = post.find((e) => e.matcher === "manual");
+  const auto = post.find((e) => e.matcher === "auto");
+  assert.match(manual.hooks[0].command, /state idle --summary compacted$/);
+  assert.match(auto.hooks[0].command, /state thinking --summary compacted$/);
+});
+
 test("buildCodexHookSettings routes PermissionRequest through the Codex reporter", () => {
   const permission = buildCodexHookSettings({ nodePath: "n", cliPath: "c" }).hooks.PermissionRequest;
   assert.equal(permission.length, 1);

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

@@ -21,6 +21,7 @@ const MTIME_SKEW_MS = 2000;
 export function watchCodexGuardianReviews(options = {}) {
   const {
     homeDir = process.env.USERPROFILE || process.env.HOME,
+    cwd,
     startedAt = 0,
     onReviewEvent = () => {},
     pollIntervalMs = DEFAULT_POLL_MS,
@@ -31,6 +32,7 @@ export function watchCodexGuardianReviews(options = {}) {
 
   const root = sessionsRoot ?? (homeDir ? join(homeDir, ".codex", "sessions") : undefined);
   const minMtime = startedAt > 0 ? startedAt - MTIME_SKEW_MS : 0;
+  const expectedCwd = normalizePathForCompare(cwd);
 
   // session_meta classifications are immutable once written, so cache them by
   // path. A file with no complete first line yet is NOT cached — it is retried
@@ -50,8 +52,13 @@ export function watchCodexGuardianReviews(options = {}) {
       return undefined;
     }
     const meta = classifyCodexSessionMeta(firstLine) ?? null;
-    const sessionStartedAt = readSessionMetaTimestamp(firstLine);
-    if (meta && minMtime > 0 && (!Number.isFinite(sessionStartedAt) || sessionStartedAt < minMtime)) {
+    const sessionMeta = readSessionMeta(firstLine);
+    const isFreshSession = sessionMeta && sessionMeta.startedAt >= minMtime;
+    const isFreshResume =
+      meta?.kind === "main" &&
+      expectedCwd !== undefined &&
+      normalizePathForCompare(sessionMeta?.cwd) === expectedCwd;
+    if (meta && minMtime > 0 && !isFreshSession && !isFreshResume) {
       metaByPath.set(file, null);
       return null;
     }
@@ -140,7 +147,7 @@ export function watchCodexGuardianReviews(options = {}) {
   };
 }
 
-function readSessionMetaTimestamp(line) {
+function readSessionMeta(line) {
   let entry;
   try {
     entry = JSON.parse(line);
@@ -153,5 +160,19 @@ function readSessionMetaTimestamp(line) {
   }
 
   const timestampMs = Date.parse(entry.timestamp);
-  return Number.isFinite(timestampMs) ? timestampMs : undefined;
+  if (!Number.isFinite(timestampMs)) {
+    return undefined;
+  }
+
+  return {
+    startedAt: timestampMs,
+    cwd: typeof entry.payload?.cwd === "string" ? entry.payload.cwd : undefined
+  };
+}
+
+function normalizePathForCompare(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    return undefined;
+  }
+  return value.trim().replace(/\\/g, "/").replace(/\/+$/g, "").toLowerCase();
 }

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

@@ -12,6 +12,7 @@ const MTIME_SKEW_MS = 2000;
 export function watchCodexTranscript(options = {}) {
   const {
     homeDir = process.env.USERPROFILE || process.env.HOME,
+    cwd,
     startedAt = 0,
     onToolEvent = () => {},
     pollIntervalMs = DEFAULT_POLL_MS,
@@ -31,7 +32,7 @@ export function watchCodexTranscript(options = {}) {
   const tick = () => {
     try {
       if (!transcriptPath) {
-        transcriptPath = discoverCodexTranscript(root, minMtime);
+        transcriptPath = discoverCodexTranscript(root, minMtime, { cwd });
         if (!transcriptPath) {
           return;
         }
@@ -78,21 +79,29 @@ export function watchCodexTranscript(options = {}) {
   };
 }
 
-export function discoverCodexTranscript(root, minMtime = 0) {
+export function discoverCodexTranscript(root, minMtime = 0, options = {}) {
   if (!root || !existsSync(root)) {
     return undefined;
   }
 
+  const expectedCwd = normalizePathForCompare(options.cwd);
   let newest;
   for (const file of listJsonlFiles(root)) {
     const mtime = safeMtime(file);
     if (mtime < minMtime) {
       continue;
     }
-    const sessionStartedAt = readCodexSessionStartedAt(file);
-    if (!Number.isFinite(sessionStartedAt) || sessionStartedAt < minMtime) {
+    const meta = readCodexSessionMeta(file);
+    if (!meta) {
       continue;
     }
+
+    const isFreshSession = meta.startedAt >= minMtime;
+    const isFreshResume = expectedCwd !== undefined && normalizePathForCompare(meta.cwd) === expectedCwd;
+    if (!isFreshSession && !isFreshResume) {
+      continue;
+    }
+
     if (!newest || mtime > newest.mtime) {
       newest = { file, mtime };
     }
@@ -100,7 +109,7 @@ export function discoverCodexTranscript(root, minMtime = 0) {
   return newest?.file;
 }
 
-function readCodexSessionStartedAt(file) {
+function readCodexSessionMeta(file) {
   const line = readFirstLine(file);
   if (line === undefined) {
     return undefined;
@@ -118,5 +127,19 @@ function readCodexSessionStartedAt(file) {
   }
 
   const timestampMs = Date.parse(entry.timestamp);
-  return Number.isFinite(timestampMs) ? timestampMs : undefined;
+  if (!Number.isFinite(timestampMs)) {
+    return undefined;
+  }
+
+  return {
+    startedAt: timestampMs,
+    cwd: typeof entry.payload?.cwd === "string" ? entry.payload.cwd : undefined
+  };
+}
+
+function normalizePathForCompare(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    return undefined;
+  }
+  return value.trim().replace(/\\/g, "/").replace(/\/+$/g, "").toLowerCase();
 }

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

@@ -175,6 +175,43 @@ test("watchCodexGuardianReviews ignores guardian trunks for sessions that starte
   watcher.stop();
 });
 
+test("watchCodexGuardianReviews follows a resumed main session in the same cwd", () => {
+  const { root, dir } = makeSessionsRoot();
+  writeFileSync(
+    join(dir, "rollout-main-resumed.jsonl"),
+    metaLineAt("2026-06-12T00:00:00.000Z", {
+      id: "main-1",
+      parent_thread_id: null,
+      source: "cli",
+      thread_source: "user",
+      cwd: "D:\\Work\\project"
+    })
+  );
+  writeFileSync(
+    join(dir, "rollout-guardian.jsonl"),
+    metaLineAt("2026-06-12T01:01:00.000Z", {
+      id: "guardian-1",
+      parent_thread_id: "main-1",
+      source: { subagent: { other: "guardian" } }
+    }) + reviewStarted("turn-new", "2026-06-12T01:02:00.000Z")
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    cwd: "D:\\Work\\project",
+    startedAt: Date.parse("2026-06-12T01:00:00.000Z"),
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+
+  assert.deepEqual(events, [{ type: "review_started" }]);
+
+  watcher.stop();
+});
+
 test("watchCodexGuardianReviews emits nothing without a classifiable main session", () => {
   const { root, dir } = makeSessionsRoot();
   // Guardian trunk exists but there is no main rollout to bind its parent to.

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

@@ -7,11 +7,11 @@ import { discoverCodexTranscript, watchCodexTranscript } from "../src/codex-tran
 
 const noopTimers = { setInterval: () => ({}), clearInterval: () => {} };
 
-function sessionMeta(timestamp, id = "thread-1") {
+function sessionMeta(timestamp, id = "thread-1", cwd) {
   return `${JSON.stringify({
     timestamp,
     type: "session_meta",
-    payload: { id, parent_thread_id: null, source: "cli", thread_source: "user" }
+    payload: { id, parent_thread_id: null, source: "cli", thread_source: "user", ...(cwd ? { cwd } : {}) }
   })}\n`;
 }
 
@@ -152,6 +152,37 @@ test("watchCodexTranscript ignores fresh writes to sessions that started before
   watcher.stop();
 });
 
+test("watchCodexTranscript follows a fresh resumed session in the same cwd", () => {
+  const root = mkdtempSync(join(tmpdir(), "codex-sessions-"));
+  const dir = join(root, "2026", "06", "08");
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, "rollout-resumed.jsonl");
+  writeFileSync(
+    path,
+    [
+      sessionMeta("2026-06-08T10:00:00.000Z", "resumed-thread", "D:\\Work\\project"),
+      turnAborted("2026-06-08T11:00:01.000Z")
+    ].join("")
+  );
+  const fresh = new Date("2026-06-08T11:00:01.500Z");
+  utimesSync(path, fresh, fresh);
+
+  const events = [];
+  const watcher = watchCodexTranscript({
+    sessionsRoot: root,
+    cwd: "D:\\Work\\project",
+    startedAt: Date.parse("2026-06-08T11:00:00.000Z"),
+    onToolEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+
+  assert.deepEqual(events, [{ type: "turn_aborted", reason: "interrupted" }]);
+
+  watcher.stop();
+});
+
 test("watchCodexTranscript forwards a turn_aborted interrupt event", () => {
   const dir = mkdtempSync(join(tmpdir(), "codex-transcript-"));
   const path = join(dir, "session.jsonl");

package/packages/session-core/src/registry.js

@@ -11,6 +11,7 @@ export function createSessionRegistry(options = {}) {
 class SessionRegistry {
   constructor(options) {
     this.sessions = new Map();
+    this.lastStateUpdatedAt = new Map();
     this.staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
     this.dropAfterMs = options.dropAfterMs ?? DEFAULT_DROP_AFTER_MS;
   }
@@ -58,6 +59,7 @@ class SessionRegistry {
       // real update — marking stale must NOT bump updatedAt, or it never elapses.
       if (now - session.updatedAt > this.dropAfterMs) {
         this.sessions.delete(sessionId);
+        this.lastStateUpdatedAt.delete(sessionId);
         continue;
       }
 
@@ -70,6 +72,7 @@ class SessionRegistry {
         session.source = "wrapper";
         session.confidence = 0.3;
         session.summary = "heartbeat stale";
+        this.lastStateUpdatedAt.set(sessionId, now);
         staleSessions.push(snapshotSession(session));
       }
     }
@@ -93,6 +96,7 @@ class SessionRegistry {
     };
 
     this.sessions.set(message.sessionId, session);
+    this.lastStateUpdatedAt.set(message.sessionId, message.startedAt);
     return snapshotSession(session);
   }
 
@@ -104,10 +108,17 @@ class SessionRegistry {
 
   applyState(message) {
     const session = this.requireSession(message.sessionId);
+    const lastStateUpdatedAt = this.lastStateUpdatedAt.get(message.sessionId) ?? session.startedAt;
+
+    if (message.updatedAt < lastStateUpdatedAt) {
+      return snapshotSession(session);
+    }
+
+    this.lastStateUpdatedAt.set(message.sessionId, message.updatedAt);
     session.state = message.state;
     session.confidence = message.confidence;
     session.source = message.source;
-    session.updatedAt = message.updatedAt;
+    session.updatedAt = Math.max(session.updatedAt, message.updatedAt);
 
     if (Object.prototype.hasOwnProperty.call(message, "summary")) {
       session.summary = message.summary;
@@ -126,6 +137,7 @@ class SessionRegistry {
     session.exitCode = message.exitCode;
     session.finishedAt = message.finishedAt;
     session.updatedAt = message.finishedAt;
+    this.lastStateUpdatedAt.set(message.sessionId, message.finishedAt);
     return snapshotSession(session);
   }
 

package/packages/session-core/test/registry.test.mjs

@@ -65,6 +65,60 @@ test("applies state and heartbeat messages without losing session metadata", ()
   assert.equal(session.projectName, "project");
 });
 
+test("ignores late state messages older than the latest accepted state", () => {
+  const registry = createSessionRegistry();
+
+  registry.applyMessage(registerMessage("sess_a"));
+  registry.applyMessage({
+    type: "state",
+    sessionId: "sess_a",
+    state: "interrupted",
+    summary: "interrupted",
+    confidence: 0.9,
+    source: "client_log",
+    updatedAt: 2000
+  });
+  registry.applyMessage({
+    type: "state",
+    sessionId: "sess_a",
+    state: "thinking",
+    confidence: 0.9,
+    source: "official_plugin",
+    updatedAt: 1500
+  });
+
+  const session = registry.getSession("sess_a");
+  assert.equal(session.state, "interrupted");
+  assert.equal(session.summary, "interrupted");
+  assert.equal(session.source, "client_log");
+  assert.equal(session.updatedAt, 2000);
+});
+
+test("heartbeats do not block later-delivered state messages", () => {
+  const registry = createSessionRegistry();
+
+  registry.applyMessage(registerMessage("sess_a"));
+  registry.applyMessage({
+    type: "heartbeat",
+    sessionId: "sess_a",
+    updatedAt: 3000
+  });
+  registry.applyMessage({
+    type: "state",
+    sessionId: "sess_a",
+    state: "running_tool",
+    summary: "shell_command",
+    confidence: 0.85,
+    source: "client_log",
+    updatedAt: 2000
+  });
+
+  const session = registry.getSession("sess_a");
+  assert.equal(session.state, "running_tool");
+  assert.equal(session.summary, "shell_command");
+  assert.equal(session.updatedAt, 3000);
+});
+
 test("unregister marks sessions as exited and preserves exit details", () => {
   const registry = createSessionRegistry();