@hayasaka7/haya-pet 0.3.7 → 0.3.9

package/CHANGELOG.md

@@ -7,6 +7,49 @@ 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
+- **An interrupt or denial in one Claude Code session no longer leaks into a
+  concurrent, idle one.** The transcript watcher discovered its file by "newest
+  `.jsonl` by mtime in the project dir", so two Claude sessions in the same folder
+  (one project dir, one transcript each) could make an idle session's watcher lock
+  onto a *busy* session's transcript — then read its `[Request interrupted by
+  user]` marker (or a denial) and report the wrong pet as *interrupted*. Each
+  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 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
+  undocking, or waking from sleep could strand it off-screen (or on a display that
+  no longer exists) — the pet vanished while the process kept running, and neither
+  **Show/Hide Pet** (which only flips visibility) nor **Reset Position** (which only
+  moved the sprite *inside* the window) brought it back. The companion now re-homes
+  the overlay onto a valid display on `screen` display add/remove/metrics-change and
+  on resume from sleep, and **Reset Position** / **Show Pet** / relaunch re-home the
+  window itself. Automatic re-homes preserve the preferred display, so the pet
+  returns there when the monitor comes back.
+
 ## [0.3.7]
 
 ### Changed

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

@@ -5,7 +5,8 @@ import { randomUUID } from "node:crypto";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { runGenericCommand as defaultRunGenericCommand } from "../../../packages/cli-core/src/run-command.js";
-import { parseStateArgs, runStateCommand } from "../../../packages/cli-core/src/run-state.js";
+import { parseStateArgs, runStateCommand, readHookTranscriptPathFromStdin } from "../../../packages/cli-core/src/run-state.js";
+import { removeSessionTranscriptLink } from "../../../packages/cli-core/src/session-transcript-link.js";
 import { injectClaudeHooks as defaultInjectClaudeHooks } from "../../../packages/cli-core/src/claude-hook-injection.js";
 import { injectCodexHooks as defaultInjectCodexHooks } from "../../../packages/cli-core/src/codex-hook-injection.js";
 import { watchClaudeTranscript as defaultWatchClaudeTranscript } from "../../../packages/cli-core/src/claude-transcript-watcher.js";
@@ -353,6 +354,12 @@ async function runRunCommand(parsed, dependencies) {
     childEnv = { ...env, HAYA_PET_SESSION_ID: sessionId };
     cleanup = injected.cleanup;
 
+    // The transcript watcher pins to THIS session's transcript via the
+    // session->transcript link the `haya-pet state` reporter writes from the hook
+    // payload. sessionDir is where that link lives; resolve it defensively so a
+    // missing home dir (tests) never breaks the run.
+    const sessionDir = resolveSessionDir(dependencies, env);
+
     // Claude fires NO hook when the user manually denies a permission, so the
     // pet would stay stuck on "waiting for approval". Tail the session transcript
     // (ground truth) and clear to idle the moment a denial is recorded — never on
@@ -361,6 +368,8 @@ async function runRunCommand(parsed, dependencies) {
       cwd,
       homeDir: dependencies.homeDir,
       startedAt: now(),
+      sessionId,
+      sessionDir,
       onDenial: (event) => {
         hookDebugLog(env, now, { source: "transcript", event: "denied", state: "idle", toolUseId: event?.toolUseId });
         messageSender
@@ -392,7 +401,10 @@ async function runRunCommand(parsed, dependencies) {
           .catch(() => {});
       }
     });
-    stopWatcher = watcher.stop;
+    stopWatcher = () => {
+      watcher.stop();
+      removeSessionTranscriptLink({ sessionDir, sessionId });
+    };
   }
 
   // Codex: no `--settings` equivalent, so inject a stable profile and add
@@ -422,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",
@@ -510,6 +530,8 @@ async function runRunCommand(parsed, dependencies) {
         sessionsRoot: dependencies.codexSessionsRoot,
         cwd,
         startedAt: now(),
+        sessionId,
+        sessionDir,
         onReviewEvent: (event) => {
           hookDebugLog(env, now, {
             source: "codex_guardian",
@@ -538,6 +560,7 @@ async function runRunCommand(parsed, dependencies) {
       stopWatcher = () => {
         guardianWatcher.stop();
         stopWithoutGuardian();
+        removeSessionTranscriptLink({ sessionDir, sessionId });
       };
     }
   }
@@ -624,6 +647,21 @@ function createConfigStateFile(dependencies) {
   return createStateFile({ statePath: paths.statePath });
 }
 
+// Where per-session transcript links live. Resolved defensively: if no home dir
+// is available (some tests), return undefined and the watcher falls back to its
+// legacy discovery instead of crashing the run.
+function resolveSessionDir(dependencies, env) {
+  try {
+    return getDefaultPaths({
+      platform: dependencies.platform,
+      env,
+      homeDir: dependencies.homeDir
+    }).sessionDir;
+  } catch {
+    return undefined;
+  }
+}
+
 // Best-effort: mirror the reporter's HAYA_PET_HOOK_DEBUG log so transcript-driven
 // events (which don't go through `haya-pet state`) show up in the same trace.
 function hookDebugLog(env, now, entry) {
@@ -917,7 +955,7 @@ async function noopSend() {}
 async function noopClose() {}
 
 if (isDirectRun(import.meta.url, process.argv[1])) {
-  main()
+  bootstrap()
     .catch((error) => {
       console.error(error.message);
       process.exitCode = 1;
@@ -930,6 +968,28 @@ if (isDirectRun(import.meta.url, process.argv[1])) {
     });
 }
 
+// Real-process entry. For a `haya-pet state` invocation — which is ALWAYS a client
+// hook child — read the hook payload from stdin once to learn this session's real
+// transcript path, and hand it to the reporter so it can record the
+// session->transcript link. Done here (not inside main/runStateCommand) so unit
+// tests, and every other command that needs stdin passed through to its child
+// (e.g. `run`), never touch stdin.
+async function bootstrap() {
+  const argv = process.argv.slice(2);
+  const dependencies = {};
+  if (argv[0] === "state") {
+    try {
+      const transcriptPath = await readHookTranscriptPathFromStdin();
+      if (transcriptPath) {
+        dependencies.transcriptPath = transcriptPath;
+      }
+    } catch {
+      // a missing/garbled payload just means no binding this time — never fatal
+    }
+  }
+  return main(argv, dependencies);
+}
+
 function isDirectRun(moduleUrl, scriptPath) {
   if (!scriptPath) {
     return false;

package/apps/companion/src/main/display-manager.js

@@ -22,6 +22,41 @@ export function resolveSavedPosition(savedPosition, displays, size = DEFAULT_SIZ
   };
 }
 
+// Resolve where the overlay window should sit RIGHT NOW: which display's work
+// area it spans, plus where the pet sprite sits inside it (work-area-relative).
+// Shared by initial placement and by re-homing after a display change (monitor
+// unplugged, resolution/DPI change, dock/undock, sleep→resume). Re-homing is what
+// stops the overlay from being stranded off-screen on a display that no longer
+// exists — the bug where the pet "vanishes" but the process is alive and neither
+// Show/Hide nor Reset (which only move the sprite inside the window) recover it.
+export function resolveOverlayPlacement({ savedPosition, displays, petSize = DEFAULT_SIZE } = {}) {
+  const saved = resolveSavedPosition(savedPosition, displays, petSize);
+  // saved.displayId always names a display that currently exists (resolveSavedPosition
+  // falls back to primary/first when the saved one is gone), so this re-homes a
+  // stranded position onto a valid display.
+  const display = findDisplayForSavedPosition({ displayId: saved.displayId }, displays);
+  const workArea = display.workArea ?? display.bounds;
+  const petLocal = clampLocalToWorkArea(
+    { x: saved.x - workArea.x, y: saved.y - workArea.y },
+    workArea,
+    petSize
+  );
+
+  return { workArea, displayId: display.id, petLocal };
+}
+
+// Keep a pet's work-area-relative position inside the work area for a given pet
+// size. Pure mirror of the companion's in-window clamp, so placement resolution
+// can be unit-tested without Electron.
+export function clampLocalToWorkArea(local, workArea, petSize = DEFAULT_SIZE) {
+  const maxX = Math.max(0, (workArea?.width ?? petSize.width) - petSize.width);
+  const maxY = Math.max(0, (workArea?.height ?? petSize.height) - petSize.height);
+  return {
+    x: clamp(local?.x ?? 0, 0, maxX),
+    y: clamp(local?.y ?? 0, 0, maxY)
+  };
+}
+
 export function clampWindowBounds(bounds, display) {
   const workArea = display.workArea ?? display.bounds;
   const width = bounds.width ?? DEFAULT_SIZE.width;

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

@@ -1,4 +1,4 @@
-import { app, BrowserWindow, ipcMain, Menu, nativeImage, screen, shell, Tray } from "electron";
+import { app, BrowserWindow, ipcMain, Menu, nativeImage, powerMonitor, screen, shell, Tray } from "electron";
 import { fileURLToPath } from "node:url";
 import { appendFileSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
@@ -14,7 +14,7 @@ import { getPlatformCapabilities } from "../../../../packages/platform-core/src/
 import { buildBubbleViews } from "../../../../packages/session-core/src/bubble-view.js";
 import { clampScale } from "../../../../packages/pet-core/src/pet-scale.js";
 import { buildPetWindowOptions, PET_SIZE } from "./window-options.js";
-import { resolveSavedPosition } from "./display-manager.js";
+import { clampLocalToWorkArea, resolveOverlayPlacement } from "./display-manager.js";
 import { getPetScale, setPetScale, setSelectedPet, updateGlobalPetPosition } from "./position-store.js";
 import { buildTrayMenu, buildTrayTooltip } from "./tray-menu.js";
 import { createStateFile } from "./state-file.js";
@@ -151,6 +151,7 @@ async function bootstrap() {
   createPetWindow();
   createTray();
   registerRendererHandlers();
+  registerDisplayWatchers();
   // Best-effort and cached in state.json (shared with the CLI's check, so at
   // most one registry request per day between them); never blocks startup.
   void detectUpdate();
@@ -171,16 +172,9 @@ async function bootstrap() {
 }
 
 function createPetWindow() {
-  const displays = listDisplays();
-  // Resolve the pet's saved on-screen position (pet-sized), which also tells us
-  // which display it belongs on. The window then spans that display's work area.
-  const saved = resolveSavedPosition(positionState.globalPet, displays);
-  const display = displays.find((d) => d.id === saved.displayId)
-    ?? displays.find((d) => d.primary)
-    ?? displays[0];
-  currentWorkArea = display.workArea ?? display.bounds;
-  currentDisplayId = display.id;
-  petLocal = clampPetLocal({ x: saved.x - currentWorkArea.x, y: saved.y - currentWorkArea.y });
+  // Resolve which display the pet belongs on and where it sits inside that
+  // display's work area; the window then spans that work area.
+  applyOverlayPlacement(resolveCurrentPlacement());
 
   const { browserWindow } = buildPetWindowOptions({ capabilities, bounds: currentWorkArea });
 
@@ -214,13 +208,69 @@ function scaledPetSize() {
 }
 
 function clampPetLocal(local) {
+  return clampLocalToWorkArea(local ?? petLocal, currentWorkArea, scaledPetSize());
+}
+
+// Resolve where the overlay should sit right now, given the saved position and the
+// CURRENT set of displays. Used at startup and on every re-home.
+function resolveCurrentPlacement() {
+  return resolveOverlayPlacement({
+    savedPosition: positionState.globalPet,
+    displays: listDisplays(),
+    petSize: scaledPetSize()
+  });
+}
+
+// Adopt a resolved placement into the module's window/pet state (does NOT move the
+// BrowserWindow — callers decide whether to create or setBounds).
+function applyOverlayPlacement(placement) {
+  currentWorkArea = placement.workArea;
+  currentDisplayId = placement.displayId;
+  petLocal = placement.petLocal;
+}
+
+// Re-home the overlay onto a currently-valid display and re-assert its bounds.
+// A display change (monitor unplugged, resolution/DPI change, dock/undock,
+// sleep→resume) can strand the window off-screen on a display that no longer
+// exists: the pet "vanishes" while the process is alive, and neither Show/Hide
+// nor Reset (which only move the sprite INSIDE the window) bring it back. This is
+// the one operation that puts the window itself back on screen.
+function rehomeOverlay({ recenter = false, persist = true } = {}) {
+  if (!petWindow || petWindow.isDestroyed()) {
+    return;
+  }
+
+  applyOverlayPlacement(resolveCurrentPlacement());
+  if (recenter) {
+    petLocal = cornerPetLocal();
+  }
+
+  try {
+    petWindow.setBounds(currentWorkArea);
+  } catch (error) {
+    // Setting bounds must never crash the overlay; the next display event retries.
+    console.error("overlay re-home failed:", error.message);
+  }
+  if (!petWindow.isVisible()) {
+    petWindow.show();
+  }
+  sendPetPosition();
+  // Automatic re-homes (display change / resume) deliberately do NOT persist, so
+  // the user's preferred display is preserved and the pet returns there once that
+  // display comes back. User-initiated re-homes (reset/show) persist as usual.
+  if (persist) {
+    persistPetPosition();
+  }
+}
+
+// Bottom-right corner of the current work area (the Reset target).
+function cornerPetLocal() {
+  const margin = 24;
   const size = scaledPetSize();
-  const maxX = Math.max(0, (currentWorkArea?.width ?? size.width) - size.width);
-  const maxY = Math.max(0, (currentWorkArea?.height ?? size.height) - size.height);
-  return {
-    x: Math.min(Math.max(local.x ?? 0, 0), maxX),
-    y: Math.min(Math.max(local.y ?? 0, 0), maxY)
-  };
+  return clampPetLocal({
+    x: (currentWorkArea?.width ?? size.width) - size.width - margin,
+    y: (currentWorkArea?.height ?? size.height) - size.height - margin
+  });
 }
 
 function createTray() {
@@ -348,6 +398,22 @@ function handleTrayClick(item) {
   }
 }
 
+// The overlay window is positioned once at creation; without these it would never
+// react to the display layout changing under it. Re-home on any display add/remove/
+// metrics change, and on resume from sleep (which commonly fires a metrics change
+// and, on Windows, can blank a transparent surface — re-asserting bounds repaints).
+function registerDisplayWatchers() {
+  const onDisplayChange = () => rehomeOverlay({ persist: false });
+  screen.on("display-metrics-changed", onDisplayChange);
+  screen.on("display-added", onDisplayChange);
+  screen.on("display-removed", onDisplayChange);
+  try {
+    powerMonitor.on("resume", onDisplayChange);
+  } catch {
+    // powerMonitor is unavailable on some platforms/headless; never fatal.
+  }
+}
+
 function registerRendererHandlers() {
   ipcMain.handle("haya-pet:list-sessions", () => buildSessionPayload());
 
@@ -441,24 +507,27 @@ function togglePet() {
   if (!petWindow) {
     return;
   }
-  petWindow.isVisible() ? petWindow.hide() : petWindow.show();
+  if (petWindow.isVisible()) {
+    petWindow.hide();
+  } else {
+    // Re-home on show: a stranded (off-screen) window still reports isVisible()
+    // === true, so the user's first click hides it and this second click must put
+    // it back on a valid display, not just show it at the same bad bounds.
+    rehomeOverlay();
+  }
   refreshTrayMenu();
 }
 
 function focusPet() {
-  petWindow?.show();
+  // Relaunching `haya-pet` (second-instance) is also a "bring it back" gesture, so
+  // re-home rather than show at possibly-stale bounds.
+  rehomeOverlay();
 }
 
 function resetPosition() {
-  // Drop the pet back to the bottom-right corner of its work area.
-  const margin = 24;
-  const size = scaledPetSize();
-  petLocal = clampPetLocal({
-    x: (currentWorkArea?.width ?? size.width) - size.width - margin,
-    y: (currentWorkArea?.height ?? size.height) - size.height - margin
-  });
-  sendPetPosition();
-  persistPetPosition();
+  // Re-home onto a valid display FIRST (a stale display layout is exactly when
+  // users reach for Reset), then drop the pet to the bottom-right corner.
+  rehomeOverlay({ recenter: true });
 }
 
 function setDisplayMode(displayMode) {

package/apps/companion/test/display-manager.test.mjs

@@ -1,6 +1,11 @@
 import assert from "node:assert/strict";
 import { test } from "../../../test/harness.mjs";
-import { clampWindowBounds, resolveSavedPosition } from "../src/main/display-manager.js";
+import {
+  clampLocalToWorkArea,
+  clampWindowBounds,
+  resolveOverlayPlacement,
+  resolveSavedPosition
+} from "../src/main/display-manager.js";
 
 const displays = [
   {
@@ -46,3 +51,48 @@ test("uses primary display when no saved position exists", () => {
     { x: 416, y: 144, width: 384, height: 416, displayId: "primary", scaleFactor: 1.25 }
   );
 });
+
+test("resolveOverlayPlacement spans the saved display and places the sprite inside it", () => {
+  assert.deepEqual(
+    resolveOverlayPlacement({
+      savedPosition: { x: 900, y: 120, width: 192, height: 208, displayId: "secondary" },
+      displays,
+      petSize: { width: 192, height: 208 }
+    }),
+    {
+      workArea: { x: 820, y: 20, width: 1160, height: 840 },
+      displayId: "secondary",
+      petLocal: { x: 80, y: 100 } // 900-820, 120-20
+    }
+  );
+});
+
+test("resolveOverlayPlacement re-homes a stranded position onto a valid display", () => {
+  // The pet was last on a display that is now gone (monitor unplugged). It must
+  // come back on the primary display, fully inside its work area — this is the
+  // recovery the disappear-and-can't-restore bug needed.
+  assert.deepEqual(
+    resolveOverlayPlacement({
+      savedPosition: { x: 4000, y: 4000, width: 192, height: 208, displayId: "gone" },
+      displays,
+      petSize: { width: 192, height: 208 }
+    }),
+    {
+      workArea: { x: 0, y: 0, width: 800, height: 560 },
+      displayId: "primary",
+      petLocal: { x: 608, y: 352 } // clamped to primary work area (800-192, 560-208)
+    }
+  );
+});
+
+test("clampLocalToWorkArea keeps the sprite within the work area for its size", () => {
+  const workArea = { x: 0, y: 0, width: 800, height: 560 };
+  assert.deepEqual(
+    clampLocalToWorkArea({ x: 5000, y: 5000 }, workArea, { width: 192, height: 208 }),
+    { x: 608, y: 352 }
+  );
+  assert.deepEqual(
+    clampLocalToWorkArea({ x: -50, y: -50 }, workArea, { width: 192, height: 208 }),
+    { x: 0, y: 0 }
+  );
+});

package/docs/known-issues.md

@@ -2,6 +2,103 @@
 
 Issues found in live use, with their current status.
 
+## ✅ 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
+
+- **Symptom:** With Claude Code hooks enabled, interrupting (Esc) one Claude
+  session could also flip a **different, idle** Claude session's pet to
+  *interrupted* (and mirror its working states). Intermittent — most visible when
+  the two ran in the **same folder** and one was busy while the other sat idle.
+- **Root cause:** the L3 transcript watcher had **no binding to a specific
+  session's transcript**. It discovered the file by "newest `.jsonl` by mtime in
+  the project dir" (`claude-transcript-watcher.js` `discoverTranscript`). Two
+  Claude sessions in one folder share a project dir
+  (`~/.claude/projects/<sanitized-cwd>/`), each with its own UUID file, so an idle
+  session's watcher could lock onto a **busy** session's transcript and then read
+  that session's `[Request interrupted by user]` marker (or a denial) and report
+  it for itself. `HAYA_PET_SESSION_ID` identified the session to the daemon, but
+  nothing tied the watched **file** to the session.
+- **Fix:** bind each watcher to its own transcript via the **`transcript_path`
+  Claude includes in every hook payload** (ground truth). The `haya-pet state`
+  reporter — already a hook child that knows `HAYA_PET_SESSION_ID` — reads the hook
+  payload from stdin (only in the real process entry, never in tests/other
+  commands) and records a per-session **session→transcript link**
+  (`packages/cli-core/src/session-transcript-link.js`, stored under
+  `…/haya-pet/sessions/<id>.json`). The watcher pins to that exact file instead of
+  guessing; until the link exists it simply idles (nothing to interrupt yet)
+  rather than locking onto another session's file. Newest-by-mtime remains only as
+  a fallback for the no-session case (never hit in production, where the watcher
+  only runs with hooks on). The link is removed on wrapper exit. Local-only and
+  best-effort; **no timer** is involved.
+- **Tests:** `session-transcript-link.test.mjs` (write/read round-trip + per-session
+  isolation) and a `claude-transcript-watcher.test.mjs` case proving an interrupt
+  in session A is **not** reported for idle session B, plus a case that the watcher
+  idles until its link appears.
+- **How to diagnose if it recurs:** with `HAYA_PET_HOOK_DEBUG=<path>` set, the
+  transcript-sourced `interrupted` line is logged with its `sessionId`; if it
+  appears under a session that was idle, the binding (the
+  `…/haya-pet/sessions/<id>.json` link) resolved to the wrong file.
+
+## ✅ Resolved: pet disappeared (and could not be restored) after a display change
+
+- **Symptom:** the pet sometimes vanished from the screen while the companion was
+  still running — and once gone, **Show/Hide Pet** and **Reset Position** both
+  failed to bring it back. Intermittent.
+- **Root cause:** the overlay is a single full-work-area `BrowserWindow` whose
+  bounds are computed **once**, at creation, for whichever display it resolved to
+  then. The companion subscribed to **no** `screen` events and never called
+  `setBounds` again, so a display-layout change underneath it — monitor unplugged,
+  resolution/DPI change, dock/undock, or sleep→resume — left the window at
+  coordinates that were now **off-screen or on a display that no longer exists**.
+  The window stayed alive and `isVisible() === true`; it was just painting where no
+  monitor covered. The two recovery actions failed for the same reason: *Show/Hide*
+  only flips `isVisible()` (an off-screen window is already "visible", so it
+  toggled between hidden and shown-at-the-same-bad-bounds), and *Reset Position*
+  only moved the **sprite's CSS position inside** the overlay (against a stale work
+  area), never the window's bounds.
+- **Fix:** the companion now re-homes the overlay onto a currently-valid display.
+  It listens for `screen` `display-metrics-changed` / `display-added` /
+  `display-removed` and `powerMonitor` `resume`, re-resolving the target display
+  and calling `setBounds` (decision logic in the pure, tested
+  `display-manager.js` `resolveOverlayPlacement`). **Reset Position**, **Show
+  Pet**, and relaunch now re-home the window itself, not just the sprite.
+  Automatic re-homes do **not** persist the position, so the user's preferred
+  display is remembered and the pet returns there when that monitor comes back. No
+  timer is involved — every re-home is driven by a real display/power event or a
+  user action.
+- **Known residual (Windows):** a transparent surface can still occasionally go
+  blank after resume even with correct bounds (an Electron compositor issue);
+  re-asserting bounds repaints it in the common case, and a hide/show repaint nudge
+  is the fallback if it recurs.
+
 ## ✅ Resolved: Codex interrupt sometimes left the pet "working"
 
 - **Symptom:** Pressing Esc to interrupt a Codex turn occasionally does **not**

package/package.json

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

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

@@ -15,6 +15,7 @@ import {
 } from "node:fs";
 import { basename, join } from "node:path";
 import { parseTranscriptLines } from "../../adapters/src/claude-transcript.js";
+import { readSessionTranscriptLink } from "./session-transcript-link.js";
 
 const DEFAULT_POLL_MS = 700;
 
@@ -37,6 +38,8 @@ export function watchClaudeTranscript(options = {}) {
     onInterrupt = () => {},
     pollIntervalMs = DEFAULT_POLL_MS,
     projectsRoot,
+    sessionId,
+    sessionDir,
     transcriptPath: fixedPath,
     setInterval: setIntervalFn = setInterval,
     clearInterval: clearIntervalFn = clearInterval
@@ -47,6 +50,13 @@ export function watchClaudeTranscript(options = {}) {
   // before Claude has created THIS session's transcript.
   const minMtime = startedAt > 0 ? startedAt - MTIME_SKEW_MS : 0;
 
+  // Preferred resolution: pin to the exact transcript this session's hook reported
+  // (via the session->transcript link). Only when no session identity is available
+  // (e.g. hooks off, or older tests) do we fall back to the newest-by-mtime guess —
+  // which is unsafe with multiple concurrent sessions in one folder. In production
+  // the watcher only runs with hooks on, so the link path is always used.
+  const useLink = Boolean(sessionId && sessionDir);
+
   let transcriptPath = fixedPath;
   let offset = 0;
   let carry = "";
@@ -54,7 +64,9 @@ export function watchClaudeTranscript(options = {}) {
   const tick = () => {
     try {
       if (!transcriptPath) {
-        transcriptPath = discoverTranscript(root, cwd, minMtime);
+        transcriptPath = useLink
+          ? resolveLinkedTranscript(sessionDir, sessionId)
+          : discoverTranscript(root, cwd, minMtime);
         if (!transcriptPath) {
           return;
         }
@@ -106,6 +118,18 @@ export function watchClaudeTranscript(options = {}) {
   };
 }
 
+// Resolve the transcript this session's hook bound itself to. Returns undefined
+// until the link exists and points at a real file, so before the first hook fires
+// the watcher simply idles (there is nothing to interrupt yet) rather than
+// guessing a file that might belong to another session.
+function resolveLinkedTranscript(sessionDir, sessionId) {
+  const linked = readSessionTranscriptLink({ sessionDir, sessionId });
+  if (!linked || !existsSync(linked)) {
+    return undefined;
+  }
+  return linked;
+}
+
 export function discoverTranscript(root, cwd, minMtime = 0) {
   if (!root || !existsSync(root)) {
     return undefined;