@hayasaka7/haya-pet 0.3.7 → 0.3.8

package/CHANGELOG.md

@@ -7,6 +7,32 @@ 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.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 shares the same discovery shape and is
+  tracked as a known issue.
+- **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
@@ -624,6 +636,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 +944,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 +957,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,107 @@
 
 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: 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.8",
   "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;

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/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
+  );
+});

package/packages/platform-core/src/paths.js

@@ -30,6 +30,7 @@ function getWindowsPaths(env, homeDir) {
     statePath: joinWindows(localAppData, "haya-pet", "state.json"),
     configPath: joinWindows(appData, "haya-pet", "config.json"),
     logDir: joinWindows(localAppData, "haya-pet", "logs"),
+    sessionDir: joinWindows(localAppData, "haya-pet", "sessions"),
     petSearchPaths: [
       joinWindows(homeDir, ".codex", "pets"),
       joinWindows(localAppData, "haya-pet", "pets")
@@ -44,6 +45,7 @@ function getUnixPaths(homeDir) {
     statePath: joinUnix(homeDir, ".haya-pet", "state.json"),
     configPath: joinUnix(homeDir, ".haya-pet", "config.json"),
     logDir: joinUnix(homeDir, ".haya-pet", "logs"),
+    sessionDir: joinUnix(homeDir, ".haya-pet", "sessions"),
     petSearchPaths: [
       joinUnix(homeDir, ".codex", "pets"),
       joinUnix(homeDir, ".haya-pet", "pets")
@@ -58,6 +60,7 @@ function getUnsupportedPaths(homeDir) {
     statePath: joinUnix(homeDir, ".haya-pet", "state.json"),
     configPath: joinUnix(homeDir, ".haya-pet", "config.json"),
     logDir: joinUnix(homeDir, ".haya-pet", "logs"),
+    sessionDir: joinUnix(homeDir, ".haya-pet", "sessions"),
     petSearchPaths: [
       joinUnix(homeDir, ".codex", "pets"),
       joinUnix(homeDir, ".haya-pet", "pets")