@hayasaka7/haya-pet 0.2.6 → 0.2.7

package/CHANGELOG.md

@@ -7,6 +7,40 @@ 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.2.7]
+
+### Fixed
+- **Codex `/quit` no longer hangs after its goodbye.** The `haya-pet state`
+  hook reporter could hang forever on a never-settling IPC await (pipe connect,
+  write drain, or close) — and Codex awaits each hook child with a default
+  **600 s** timeout, so a hung turn-end `state idle` reporter both froze the
+  pet on "working" and made `/quit` sit on its token-usage goodbye for up to
+  10 minutes (Ctrl+C worked because it kills Codex without the wait, orphaning
+  the reporter — observed live). The reporter now races its whole IPC
+  interaction against a 2 s deadline and always exits; the wrapper's own
+  companion connection gets the same guard (5 s) so a wedged companion can
+  never hold the terminal after the wrapped CLI exits.
+
+### Added
+- **Update notice.** HAYA Pet now checks npm (at most once a day, cached in
+  `state.json`, shared between the CLI and the overlay) for a newer published
+  version. The CLI prints a one-line notice after a wrapped command exits (and
+  after `haya-pet start`), and the tray gains an **Update Available (x.y.z)**
+  item that opens the package page — the app never runs npm itself. The check
+  is best-effort (3 s timeout, silent on any failure, never blocks a run),
+  skipped when stdout isn't a terminal, and can be disabled with
+  `HAYA_PET_NO_UPDATE_CHECK=1`.
+
+### Changed
+- **The bubble panel shows at most three sessions at once.** Beyond the existing
+  height budget (the room between the folder button and the screen edge), the
+  list now also caps its viewport at the bottom of the third bubble — more
+  sessions are reached by scrolling, so a busy machine no longer grows a
+  screen-tall stack. The list surface itself (gaps between bubbles and the
+  scrollbar) is now pointer-active so wheel scrolling and scrollbar dragging
+  work anywhere on the open panel, and the scrollbar is a slim dark-theme thumb
+  instead of the stock bar.
+
 ## [0.2.6]
 
 ### Fixed

package/README.md

@@ -248,6 +248,21 @@ exit code. Disable auto-start with `HAYA_PET_NO_AUTOSTART=1`.
 | Electron | Installed as a runtime dependency. |
 | node-pty | Optional; used only for `--observe`. |
 
+## Updates
+
+HAYA Pet checks npm for a newer published version at most once a day (cached in
+`state.json`). When one exists, the CLI prints a one-line notice after your
+wrapped command exits, and the tray shows **Update Available (x.y.z)** — clicking
+it opens the package page. Updating is always your action:
+
+```bash
+npm install -g @hayasaka7/haya-pet
+```
+
+The check is best-effort (3s timeout, silent on failure, never blocks a run),
+skipped when output is piped, and fully disabled with
+`HAYA_PET_NO_UPDATE_CHECK=1`.
+
 ## Troubleshooting
 
 | Symptom | Fix |
@@ -265,7 +280,10 @@ repairing a broken Electron install.
 
 HAYA Pet is local-only by default. It does not upload prompts, files,
 screenshots, or session logs. The overlay stores only local state needed for
-pet selection, position, size, and short derived status summaries.
+pet selection, position, size, and short derived status summaries. The single
+outbound request it ever makes is the daily npm version check (a standard
+HTTPS request to `registry.npmjs.org` that sends no session data); disable it
+with `HAYA_PET_NO_UPDATE_CHECK=1`.
 
 ## Documentation
 

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

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
-import { realpathSync, appendFileSync } from "node:fs";
+import { realpathSync, appendFileSync, readFileSync } from "node:fs";
 import { spawn } from "node:child_process";
 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";
@@ -16,6 +17,11 @@ import { getDefaultPaths } from "../../../packages/platform-core/src/paths.js";
 import { discoverPets as defaultDiscoverPets } from "../../../packages/pet-core/src/discovery.js";
 import { createStateFile as defaultCreateStateFile } from "../../../packages/app-state/src/state-file.js";
 import { getSelectedPetId, setSelectedPet, getHooksEnabled, setHooksEnabled } from "../../../packages/app-state/src/state.js";
+import { checkForUpdate, UPDATE_COMMAND } from "../../../packages/app-state/src/update-check.js";
+import { raceDeadline } from "../../../packages/cli-core/src/deadline.js";
+
+// Ceiling for wrapper→companion IPC awaits (see createMessageSender).
+const SENDER_DEADLINE_MS = 5000;
 import { getAdapterInfo } from "../../../packages/adapters/src/adapter-info.js";
 
 const CLIENT_DISPLAY_NAMES = Object.freeze({
@@ -105,6 +111,13 @@ export async function runStopCommand(_parsed, dependencies = {}) {
 // Explicitly start the companion overlay (so users never need `npm start`).
 export async function runStartCommand(_parsed, dependencies = {}) {
   const print = dependencies.print ?? defaultPrint;
+  const updateCheck = startUpdateCheck(dependencies);
+  const result = await startCompanionAndReport(dependencies, print);
+  await reportUpdateNotice(updateCheck, print);
+  return result;
+}
+
+async function startCompanionAndReport(dependencies, print) {
   const { client, started, error, timedOut } = await connectCompanion(dependencies, true);
 
   if (client) {
@@ -123,6 +136,51 @@ export async function runStartCommand(_parsed, dependencies = {}) {
   return { command: "start", ok: false, started: false };
 }
 
+// Kick off the (cached, best-effort) npm update check without blocking the
+// actual work; callers await the promise only when they are about to print.
+// Nothing here may ever break the run — even resolving the state path can
+// throw (no HOME/USERPROFILE), which simply means "no check".
+function startUpdateCheck(dependencies) {
+  try {
+    const check = dependencies.checkForUpdate ?? defaultCheckForUpdate;
+    return check({
+      currentVersion: dependencies.currentVersion ?? readOwnVersion(),
+      stateFile: createConfigStateFile(dependencies),
+      env: dependencies.env ?? process.env,
+      now: dependencies.now ?? Date.now
+    });
+  } catch {
+    return Promise.resolve(undefined);
+  }
+}
+
+// Default update check runs only on an interactive terminal: piped/CI output
+// should not be nagged (and nothing non-interactive should touch the network).
+function defaultCheckForUpdate(options) {
+  if (!process.stdout.isTTY) {
+    return Promise.resolve(undefined);
+  }
+  return checkForUpdate(options);
+}
+
+async function reportUpdateNotice(updateCheck, print) {
+  const update = await updateCheck;
+  if (update) {
+    print(
+      `haya-pet: update available — ${update.currentVersion} → ${update.latestVersion}. Run: ${UPDATE_COMMAND}`
+    );
+  }
+}
+
+function readOwnVersion() {
+  try {
+    const packagePath = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "..", "package.json");
+    return JSON.parse(readFileSync(packagePath, "utf8")).version;
+  } catch {
+    return undefined;
+  }
+}
+
 async function runRunCommand(parsed, dependencies) {
   const runGenericCommand = dependencies.runGenericCommand ?? defaultRunGenericCommand;
   const injectClaudeHooks = dependencies.injectClaudeHooks ?? defaultInjectClaudeHooks;
@@ -136,6 +194,9 @@ async function runRunCommand(parsed, dependencies) {
   const now = dependencies.now ?? Date.now;
   const cwd = dependencies.cwd ?? process.cwd();
   const messageSender = await createMessageSender(dependencies);
+  // Concurrent with the wrapped command; the result is printed after it exits
+  // (interactive TUIs clear the screen, so a pre-launch notice would be lost).
+  const updateCheck = startUpdateCheck(dependencies);
 
   const sessionId = dependencies.sessionId ?? `sess_${randomUUID()}`;
   let childArgs = parsed.childArgs;
@@ -302,7 +363,7 @@ async function runRunCommand(parsed, dependencies) {
   }
 
   try {
-    return await runGenericCommand({
+    const result = await runGenericCommand({
       command: parsed.childCommand,
       args: childArgs,
       cwd,
@@ -316,6 +377,8 @@ async function runRunCommand(parsed, dependencies) {
       stdio: dependencies.stdio,
       send: messageSender.send
     });
+    await reportUpdateNotice(updateCheck, print);
+    return result;
   } finally {
     stopWatcher();
     cleanup();
@@ -609,9 +672,14 @@ async function createMessageSender(dependencies) {
     process.stderr.write("haya-pet: started the companion overlay.\n");
   }
 
+  // Deadline every IPC await: if the companion wedges, a hanging send/close
+  // would keep THIS process alive after the wrapped CLI exits — leaving the
+  // user's terminal without a prompt. Losing a status message to the deadline
+  // is fine (the registry stales-out dead sessions); losing the terminal isn't.
+  const deadlineMs = dependencies.senderDeadlineMs ?? SENDER_DEADLINE_MS;
   return {
-    send: (message) => client.send(message),
-    close: () => client.close()
+    send: (message) => raceDeadline(client.send(message), deadlineMs),
+    close: () => raceDeadline(client.close(), deadlineMs)
   };
 }
 

package/apps/cli/test/haya-pet.test.mjs

@@ -275,6 +275,74 @@ test("HAYA_PET_NO_AUTOSTART disables auto-starting the companion", async () => {
   assert.equal(launched, 0);
 });
 
+test("run prints an update notice only after the wrapped command exits", async () => {
+  const order = [];
+
+  await runAiPet(["run", "--client", "generic", "--", "node", "-v"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    send: async () => {},
+    print: (line) => order.push(line),
+    checkForUpdate: async () => ({ currentVersion: "0.2.7", latestVersion: "9.9.9" }),
+    runGenericCommand: async (options) => {
+      order.push("child-finished");
+      return { sessionId: options.sessionId, pid: 1, exitCode: 0 };
+    }
+  });
+
+  const noticeIndex = order.findIndex((entry) => entry.includes("update available"));
+  assert.ok(noticeIndex !== -1, "notice printed");
+  assert.ok(order[noticeIndex].includes("0.2.7 → 9.9.9"), "notice names both versions");
+  assert.ok(order[noticeIndex].includes("npm install -g @hayasaka7/haya-pet"), "notice gives the command");
+  assert.ok(noticeIndex > order.indexOf("child-finished"), "notice comes after the child exits");
+});
+
+test("run prints no update notice when the check finds nothing", async () => {
+  const lines = [];
+
+  await runAiPet(["run", "--client", "generic", "--", "node", "-v"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    send: async () => {},
+    print: (line) => lines.push(line),
+    checkForUpdate: async () => undefined,
+    runGenericCommand: async (options) => ({ sessionId: options.sessionId, pid: 1, exitCode: 0 })
+  });
+
+  assert.ok(!lines.some((line) => line.includes("update available")));
+});
+
+test("start prints an update notice after its status line", async () => {
+  const lines = [];
+
+  await runAiPet(["start"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    createIpcClient: async () => ({ send: async () => {}, close: async () => {} }),
+    launchCompanion: async () => {},
+    print: (line) => lines.push(line),
+    checkForUpdate: async () => ({ currentVersion: "0.2.7", latestVersion: "9.9.9" })
+  });
+
+  const noticeIndex = lines.findIndex((line) => line.includes("update available"));
+  assert.ok(noticeIndex !== -1, "notice printed");
+  assert.ok(noticeIndex > lines.findIndex((line) => line.includes("already running")));
+});
+
+test("run returns even when the companion connection hangs on close", async () => {
+  const result = await runAiPet(["run", "--client", "generic", "--", "node", "-v"], {
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    senderDeadlineMs: 20,
+    createIpcClient: async () => ({
+      send: async () => {},
+      close: () => new Promise(() => {})
+    }),
+    runGenericCommand: async (options) => ({ sessionId: options.sessionId, pid: 1, exitCode: 0 })
+  });
+
+  assert.equal(result.exitCode, 0);
+});
+
 test("parses the start command and reports when already running", async () => {
   assert.deepEqual(parseAiPetArgs(["start"]), { command: "start" });
 

package/apps/companion/src/main/bubble-list-viewport.js

@@ -0,0 +1,26 @@
+// Caps the bubble list's visible height. Two budgets apply, and the tighter one
+// wins: the HEIGHT budget (the pixel room between the folder button and the
+// screen edge on the side the list opens toward) and a COUNT budget — at most
+// MAX_VISIBLE_BUBBLES bubbles are visible at once, so a long session list stays
+// a compact panel and the rest is reached by scrolling (.bubble-list has
+// overflow-y: auto). The floor keeps the list usable even when the button sits
+// against a screen edge.
+const DEFAULT_MAX_VISIBLE_BUBBLES = 3;
+const DEFAULT_MIN_HEIGHT = 96;
+
+// `bubbleBottoms` are the layout bottoms (offsetTop + offsetHeight) of each
+// bubble in list order; the count cap is the bottom of the last bubble allowed
+// to be visible, so exactly that many show before scrolling.
+export function resolveBubbleListMaxHeight({
+  room,
+  bubbleBottoms = [],
+  maxVisible = DEFAULT_MAX_VISIBLE_BUBBLES,
+  minHeight = DEFAULT_MIN_HEIGHT
+} = {}) {
+  const heightBudget = Number.isFinite(room) ? Math.round(room) : 0;
+
+  const capBottom = bubbleBottoms.length > maxVisible ? bubbleBottoms[maxVisible - 1] : undefined;
+  const countBudget = Number.isFinite(capBottom) ? Math.round(capBottom) : Infinity;
+
+  return Math.max(minHeight, Math.min(heightBudget, countBudget));
+}

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

@@ -1,5 +1,6 @@
-import { app, BrowserWindow, ipcMain, Menu, nativeImage, screen, Tray } from "electron";
+import { app, BrowserWindow, ipcMain, Menu, nativeImage, screen, shell, Tray } from "electron";
 import { fileURLToPath } from "node:url";
+import { 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";
@@ -18,6 +19,7 @@ import { getPetScale, setPetScale, setSelectedPet, updateGlobalPetPosition } fro
 import { buildTrayMenu, buildTrayTooltip } from "./tray-menu.js";
 import { createStateFile } from "./state-file.js";
 import { discoverPets } from "./pet-loader.js";
+import { checkForUpdate, UPDATE_PAGE_URL } from "../../../../packages/app-state/src/update-check.js";
 
 const STALE_SWEEP_INTERVAL_MS = 10_000;
 const __dirname = dirname(fileURLToPath(import.meta.url));
@@ -47,6 +49,9 @@ let petLocal = { x: 0, y: 0 };
 // User-chosen pet scale (resize grip); the pet occupies PET_SIZE × petScale.
 let petScale = 1;
 let approvalWatch;
+// Set once the daily npm update check finds a newer version; surfaces as a
+// tray item (see tray-menu.js).
+let updateAvailable;
 
 // Electron singleton: a second launch forwards to the running instance.
 if (!app.requestSingleInstanceLock()) {
@@ -116,6 +121,9 @@ async function bootstrap() {
   createPetWindow();
   createTray();
   registerRendererHandlers();
+  // 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();
 
   const sweep = setInterval(() => {
     runtime.markStaleSessions(Date.now());
@@ -219,7 +227,8 @@ function refreshTrayMenu() {
     attachBubblesToTerminals: positionState.settings.attachBubblesToTerminals,
     selectedPetId: positionState.globalPet.selectedPetId,
     sessions,
-    pets: pets.map((pet) => ({ id: pet.manifest.id, name: pet.manifest.name }))
+    pets: pets.map((pet) => ({ id: pet.manifest.id, name: pet.manifest.name })),
+    updateAvailable
   }).map(toElectronMenuItem);
 
   tray.setContextMenu(Menu.buildFromTemplate(template));
@@ -246,6 +255,42 @@ function toElectronMenuItem(item) {
   return electronItem;
 }
 
+// Daily npm update check (shared cache with the CLI in state.json). On a hit,
+// the tray gains an "Update Available (x.y.z)" item; checkForUpdate itself
+// never throws, so this can run unawaited from bootstrap.
+async function detectUpdate() {
+  const update = await checkForUpdate({
+    currentVersion: readPackageVersion(),
+    // Every companion write flows through the in-memory positionState (load →
+    // mutate → save). Mirror that here: read the live copy, and on save merge
+    // only the cache key into whatever positionState is by then — a direct
+    // stateFile.save of the load-time snapshot could clobber a pet move made
+    // while the registry fetch was in flight.
+    stateFile: {
+      load: async () => positionState,
+      save: async (next) => {
+        positionState = { ...positionState, updateCheck: next.updateCheck };
+        return stateFile.save(positionState);
+      }
+    }
+  });
+  if (update) {
+    updateAvailable = update;
+    refreshTrayMenu();
+  }
+}
+
+// The published version lives in the ROOT package.json (the companion workspace
+// has its own, unpublished version number).
+function readPackageVersion() {
+  try {
+    const packagePath = join(__dirname, "..", "..", "..", "..", "package.json");
+    return JSON.parse(readFileSync(packagePath, "utf8")).version;
+  } catch {
+    return undefined;
+  }
+}
+
 function handleTrayClick(item) {
   switch (item.id) {
     case "toggle_pet":
@@ -257,6 +302,11 @@ function handleTrayClick(item) {
     case "quit":
       app.quit();
       break;
+    case "update":
+      // Open the package page rather than running npm ourselves — installing
+      // is the user's call (and may need their node manager / sudo setup).
+      shell.openExternal(UPDATE_PAGE_URL);
+      break;
     default:
       if (item.id?.startsWith("display_mode:")) {
         setDisplayMode(item.value);

package/apps/companion/src/main/tray-menu.js

@@ -55,6 +55,11 @@ export function buildTrayMenu(state = {}) {
     // item would be a dead button. Re-enable once settings outgrow the tray
     // (e.g. bubble text size, linger duration) and a handler is wired up.
     // { id: "settings", label: "Open Settings" },
+    // Only present when the daily npm update check found a newer version;
+    // clicking it opens the package page (the app never runs npm itself).
+    ...(state.updateAvailable?.latestVersion
+      ? [{ id: "update", label: `Update Available (${state.updateAvailable.latestVersion})` }]
+      : []),
     { id: "separator", type: "separator" },
     { id: "quit", label: "Quit" }
   ];

package/apps/companion/src/renderer/pet-window.js

@@ -16,6 +16,7 @@ import {
 import { resolveCompanionPetState } from "../../../../packages/session-core/src/pet-state.js";
 import { resolveVisibleBubbles } from "../../../../packages/session-core/src/bubble-linger.js";
 import { resolvePanelPlacement } from "../main/panel-placement.js";
+import { resolveBubbleListMaxHeight } from "../main/bubble-list-viewport.js";
 import { createInteractionController } from "./interaction-controller.js";
 import { createBubbleList } from "./session-bubbles.js";
 
@@ -137,9 +138,11 @@ function placePanel() {
     const alignRight = placement.x + rect.width / 2 > workArea.width / 2;
     list.dataset.openDirection = openUp ? "up" : "down";
     list.dataset.openAlign = alignRight ? "right" : "left";
-    // Cap the height to the room actually available on the chosen side.
+    // Cap the height to the room actually available on the chosen side AND to
+    // three visible bubbles — more sessions are reached by scrolling the list.
     const room = openUp ? placement.y - margin : workArea.height - (placement.y + rect.height) - margin;
-    list.style.maxHeight = `${Math.max(96, Math.round(room))}px`;
+    const bubbleBottoms = Array.from(list.children, (child) => child.offsetTop + child.offsetHeight);
+    list.style.maxHeight = `${resolveBubbleListMaxHeight({ room, bubbleBottoms })}px`;
   }
 }
 

package/apps/companion/src/renderer/session-bubbles.js

@@ -32,7 +32,11 @@ export function createBubbleList(container, { collapsed = false, onRender } = {}
 
       if (!isCollapsed) {
         const list = document.createElement("div");
-        list.className = "bubble-list";
+        // The list itself must be pointer-active (not just the bubbles): with
+        // more than three sessions it scrolls, and the scrollbar + the gaps
+        // between bubbles belong to the list element — if it stayed
+        // click-through, wheel/drag there would fall through to the desktop.
+        list.className = "bubble-list interactive";
         for (const bubble of lastBubbles) {
           list.appendChild(renderBubble(bubble));
         }

package/apps/companion/src/renderer/styles.css

@@ -149,6 +149,25 @@ body {
   pointer-events: auto;
 }
 
+/* Scrolling is by design (at most three bubbles are visible at once), so give
+   the list a slim thumb that fits the dark pills instead of the stock bar. */
+.bubble-list::-webkit-scrollbar {
+  width: 6px;
+}
+
+.bubble-list::-webkit-scrollbar-track {
+  background: transparent;
+}
+
+.bubble-list::-webkit-scrollbar-thumb {
+  background: rgba(255, 255, 255, 0.25);
+  border-radius: 3px;
+}
+
+.bubble-list::-webkit-scrollbar-thumb:hover {
+  background: rgba(255, 255, 255, 0.4);
+}
+
 .bubble-list[data-open-direction="down"] { top: calc(100% + 6px); }
 .bubble-list[data-open-direction="up"] { bottom: calc(100% + 6px); }
 .bubble-list[data-open-align="left"] { left: 0; right: auto; }

package/apps/companion/test/bubble-list-viewport.test.mjs

@@ -0,0 +1,50 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { resolveBubbleListMaxHeight } from "../src/main/bubble-list-viewport.js";
+
+// Layout bottoms for bubbles ~48px tall with a 6px gap.
+const FOUR_BUBBLES = [48, 102, 156, 210];
+
+test("three or fewer bubbles use the height budget alone", () => {
+  assert.equal(resolveBubbleListMaxHeight({ room: 400, bubbleBottoms: [48, 102, 156] }), 400);
+  assert.equal(resolveBubbleListMaxHeight({ room: 400, bubbleBottoms: [48] }), 400);
+  assert.equal(resolveBubbleListMaxHeight({ room: 400, bubbleBottoms: [] }), 400);
+});
+
+test("more than three bubbles cap the viewport at the third bubble's bottom", () => {
+  assert.equal(resolveBubbleListMaxHeight({ room: 400, bubbleBottoms: FOUR_BUBBLES }), 156);
+});
+
+test("the height budget still wins when it is tighter than the count cap", () => {
+  assert.equal(resolveBubbleListMaxHeight({ room: 120, bubbleBottoms: FOUR_BUBBLES }), 120);
+});
+
+test("the minimum height floor applies to both budgets", () => {
+  assert.equal(resolveBubbleListMaxHeight({ room: 40, bubbleBottoms: FOUR_BUBBLES }), 96);
+  assert.equal(resolveBubbleListMaxHeight({ room: 40, bubbleBottoms: [48] }), 96);
+});
+
+test("the room is rounded to whole pixels", () => {
+  assert.equal(resolveBubbleListMaxHeight({ room: 150.6, bubbleBottoms: [48] }), 151);
+});
+
+test("maxVisible and minHeight are configurable", () => {
+  assert.equal(
+    resolveBubbleListMaxHeight({ room: 400, bubbleBottoms: FOUR_BUBBLES, maxVisible: 2 }),
+    102
+  );
+  assert.equal(
+    resolveBubbleListMaxHeight({ room: 40, bubbleBottoms: [48], minHeight: 32 }),
+    40
+  );
+});
+
+test("garbage measurements fall back safely", () => {
+  // Unusable room → the floor keeps the list usable.
+  assert.equal(resolveBubbleListMaxHeight({ room: Number.NaN, bubbleBottoms: [48] }), 96);
+  // Unusable bottom at the cap index → no count cap, height budget alone.
+  assert.equal(
+    resolveBubbleListMaxHeight({ room: 400, bubbleBottoms: [48, 102, Number.NaN, 210] }),
+    400
+  );
+});

package/apps/companion/test/tray-menu.test.mjs

@@ -47,6 +47,16 @@ test("reflects the attach-bubbles checkbox state", () => {
   assert.equal(buildTrayMenu({ ...baseState, attachBubblesToTerminals: false }).find((i) => i.id === "attach_bubbles").checked, false);
 });
 
+test("shows the update item only when a newer version is known", () => {
+  const withoutUpdate = buildTrayMenu(baseState);
+  assert.ok(!withoutUpdate.some((i) => i.id === "update"), "no update item by default");
+
+  const withUpdate = buildTrayMenu({ ...baseState, updateAvailable: { latestVersion: "9.9.9" } });
+  const item = withUpdate.find((i) => i.id === "update");
+  assert.ok(item, "update item appears when an update is known");
+  assert.ok(item.label.includes("9.9.9"), "label names the new version");
+});
+
 test("uses the HAYA Pet brand in the tray hover text", () => {
   assert.equal(buildTrayTooltip(), "HAYA Pet");
 });

package/docs/known-issues.md

@@ -48,6 +48,39 @@ Issues found in live use, with their current status.
   surfaces as turn-end *idle*). The TUI's passive `/approve` denial-override
   picker is not a blocking prompt.
 
+## ✅ Resolved: Codex `/quit` hung on its goodbye (and the pet kept showing "working")
+
+- **Symptom:** Exiting Codex with `/quit` printed the token-usage goodbye and the
+  `codex resume` hint, but the terminal never returned to a prompt and the pet
+  kept showing the session as ongoing. Ctrl+C exited fine. Only happened under
+  `haya-pet run`.
+- **Root cause (verified against codex-rs 0.139.0 source + a live orphaned
+  process):** the `haya-pet state` hook reporter had three **unbounded awaits**
+  in its IPC path — pipe connect, write drain, and `socket.end()` → `close` —
+  and the CLI entry's `process.exit()` only runs after the command resolves, so
+  one never-settling await made a reporter hang forever. Codex awaits every
+  hook child with a **default 600 s timeout**
+  (`hooks/engine/discovery.rs` `timeout_sec.unwrap_or(600)`;
+  `command_runner.rs` `timeout(…, child.wait_with_output())`), and `Stop` hooks
+  are awaited in turn completion (`core/hook_runtime.rs run_turn_stop_hooks`)
+  with the TUI exiting only after `ShutdownComplete`. So one hung turn-end
+  `state idle` reporter produced BOTH symptoms: the idle report never arrived
+  (pet stuck on "working"), and `/quit` waited up to 10 minutes on the hook
+  child after printing its goodbye. Ctrl+C kills Codex without that wait and
+  orphans the reporter — exactly what live process-tree monitoring showed (a
+  parentless reporter under the hook node version).
+- **Fix:** every IPC await now has a hard deadline (`cli-core/deadline.js`).
+  The reporter races its whole connect→send→close against **2 s** and exits
+  with `{ ok:false, reason:"timeout" }` on the deadline (one best-effort status
+  update lost; `HAYA_PET_HOOK_DEBUG` logs a `timeout: true` line for evidence).
+  The wrapper's companion connection gets the same guard (**5 s** per
+  send/close) so a wedged companion can never keep the wrapper — and the user's
+  terminal — alive after the wrapped CLI exits. Dead sessions still resolve via
+  the registry's stale/drop sweep, so a lost message self-heals.
+- **Note:** why a pipe await occasionally never settles (companion busy/wedged
+  at that moment) is not yet pinned down; the deadline makes it harmless and
+  the debug log will show `timeout: true` entries if it recurs.
+
 ## ✅ Resolved: pet stuck on "waiting for approval" after a manual denial
 
 - **Symptom:** With Claude Code hooks enabled, denying a permission prompt left the

package/docs/troubleshooting.md

@@ -25,7 +25,9 @@ deferred problems with known root causes.
 | Pet stayed on **waiting for approval** after I denied a tool | Fixed — Claude fires no hook on a manual denial, so the wrapper tails the session transcript and clears to **idle** when the denial is recorded. A genuinely-pending approval (you haven't decided yet) correctly keeps alerting — there's no timer. |
 | Pet stayed on **waiting for approval** after I *approved* a command | Fixed — Claude also fires no hook at the accept moment, so the companion watches the client's process tree while a session waits: when the approved command verifiably starts (a new persistent process under the client), the pet flips to **working**. Expect a ~2–3s lag after your click. File-edit approvals (no process) resolve at completion, which is near-instant. |
 | Want to see which status events fire | Set `HAYA_PET_HOOK_DEBUG=<file.jsonl>` before `haya-pet run`; each hook- and transcript-sourced status appends one JSON line (timestamp, state, and source/event). |
+| Don't want the update check / notice | Set `HAYA_PET_NO_UPDATE_CHECK=1`. The check is a daily, cached HTTPS request to the npm registry (no session data); it is already skipped automatically when output is piped. |
 | Pet stays **idle** after force-quitting a CLI | The wrapper marks the session stale ~15s after the heartbeat stops, then drops it. Exiting normally (incl. Ctrl+C) reports **exited** immediately. |
+| **Codex `/quit`** printed its goodbye but the terminal hung (pet stuck on "working") | Fixed — a hook reporter could hang on a pipe await and Codex waits up to 600s for hook children at shutdown. Reporters now hard-deadline at 2s. Update to the latest version. |
 | Ctrl+C doesn't exit the CLI cleanly under `haya-pet run` | Fixed — the wrapper no longer dies on Ctrl+C; the signal reaches the CLI, which exits, and the pet shows the result. |
 | `ENOENT … electron\path.txt` | Electron's install extraction was interrupted — see below. |
 

package/package.json

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

package/packages/app-state/src/state.js

@@ -105,7 +105,10 @@ export function parsePositionState(text) {
       settings: {
         ...defaults.settings,
         ...(isPlainObject(parsed.settings) ? parsed.settings : {})
-      }
+      },
+      // Cached npm update-check result (see update-check.js) — must survive a
+      // load/save round-trip or every run would re-fetch from the registry.
+      ...(isPlainObject(parsed.updateCheck) ? { updateCheck: parsed.updateCheck } : {})
     };
   } catch {
     return defaults;

package/packages/app-state/src/update-check.js

@@ -0,0 +1,173 @@
+// Best-effort npm update check shared by the CLI (one-line notice) and the
+// companion (tray item). One small registry request per TTL window, cached in
+// state.json so the CLI and companion share it; every failure path resolves to
+// undefined — an update notice must never block or break a run. Opt out with
+// HAYA_PET_NO_UPDATE_CHECK=1.
+
+export const UPDATE_PACKAGE_NAME = "@hayasaka7/haya-pet";
+export const UPDATE_COMMAND = `npm install -g ${UPDATE_PACKAGE_NAME}`;
+export const UPDATE_PAGE_URL = `https://www.npmjs.com/package/${UPDATE_PACKAGE_NAME}`;
+
+// The version-specific manifest (a few KB) — not the full packument.
+const REGISTRY_LATEST_URL = "https://registry.npmjs.org/@hayasaka7%2fhaya-pet/latest";
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_TIMEOUT_MS = 3000;
+
+// Strictly-numeric dotted compare ("v" prefix tolerated). Anything else —
+// prerelease tags, garbage, missing values — is conservatively "not newer",
+// so a weird registry response can never produce a false update nag.
+export function isNewerVersion(candidate, current) {
+  const a = parseVersion(candidate);
+  const b = parseVersion(current);
+  if (!a || !b) {
+    return false;
+  }
+
+  for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+    const x = a[i] ?? 0;
+    const y = b[i] ?? 0;
+    if (x !== y) {
+      return x > y;
+    }
+  }
+  return false;
+}
+
+function parseVersion(value) {
+  if (typeof value !== "string" || value.trim() === "") {
+    return undefined;
+  }
+  const parts = value.trim().replace(/^v/, "").split(".");
+  if (!parts.every((part) => /^\d+$/.test(part))) {
+    return undefined;
+  }
+  return parts.map((part) => Number.parseInt(part, 10));
+}
+
+export function getLastUpdateCheck(state) {
+  const entry = state?.updateCheck;
+  if (!entry || typeof entry !== "object") {
+    return undefined;
+  }
+  return entry;
+}
+
+export function setUpdateCheck(state, { checkedAt, latestVersion }) {
+  return {
+    ...state,
+    updateCheck: { checkedAt, latestVersion }
+  };
+}
+
+// Resolve the latest published version from the npm registry. The outer timer
+// (not request.setTimeout) also covers DNS stalls, which happen before any
+// socket exists. Always resolves — undefined on any failure.
+export function fetchLatestVersion({
+  url = REGISTRY_LATEST_URL,
+  timeoutMs = DEFAULT_TIMEOUT_MS,
+  get
+} = {}) {
+  return new Promise((resolve) => {
+    let request;
+    let settled = false;
+    const settle = (value) => {
+      if (settled) {
+        return;
+      }
+      settled = true;
+      clearTimeout(timer);
+      try {
+        request?.destroy?.();
+      } catch {
+        // already closed
+      }
+      resolve(value);
+    };
+
+    // Deliberately ref'd: this timer is what guarantees the promise settles
+    // (and an awaiting caller terminates) even when the request never responds
+    // — e.g. a DNS stall. It is cleared the moment anything else settles, so it
+    // never holds the process open after a normal success or failure.
+    const timer = setTimeout(() => settle(undefined), timeoutMs);
+
+    resolveGet(get)
+      .then((getFn) => {
+        if (settled) {
+          return;
+        }
+        request = getFn(url, { headers: { accept: "application/json" } }, (response) => {
+          if (response.statusCode !== 200) {
+            response.resume();
+            settle(undefined);
+            return;
+          }
+          let body = "";
+          response.setEncoding("utf8");
+          response.on("data", (chunk) => {
+            body += chunk;
+          });
+          response.on("end", () => {
+            try {
+              const version = JSON.parse(body)?.version;
+              settle(typeof version === "string" ? version : undefined);
+            } catch {
+              settle(undefined);
+            }
+          });
+        });
+        request.on("error", () => settle(undefined));
+      })
+      .catch(() => settle(undefined));
+  });
+}
+
+// node:https is imported lazily so merely loading this module (e.g. from the
+// renderer-adjacent companion code or tests) never touches the network stack.
+async function resolveGet(get) {
+  if (get) {
+    return get;
+  }
+  const https = await import("node:https");
+  return https.get;
+}
+
+// The single entry point: load the cached result (or fetch + cache it), and
+// report `{ currentVersion, latestVersion }` only when an update exists.
+// Never throws and never rejects.
+export async function checkForUpdate(options = {}) {
+  const {
+    currentVersion,
+    stateFile,
+    env = process.env,
+    now = Date.now,
+    ttlMs = DEFAULT_TTL_MS,
+    fetchLatest = fetchLatestVersion
+  } = options;
+
+  try {
+    if (env.HAYA_PET_NO_UPDATE_CHECK === "1" || env.HAYA_PET_NO_UPDATE_CHECK === "true") {
+      return undefined;
+    }
+    if (typeof currentVersion !== "string" || currentVersion === "" || !stateFile) {
+      return undefined;
+    }
+
+    const state = await stateFile.load();
+    const cached = getLastUpdateCheck(state);
+
+    let latestVersion;
+    if (cached && Number.isFinite(cached.checkedAt) && now() - cached.checkedAt < ttlMs) {
+      latestVersion = cached.latestVersion;
+    } else {
+      latestVersion = await fetchLatest();
+      if (typeof latestVersion !== "string" || latestVersion === "") {
+        return undefined;
+      }
+      await stateFile.save(setUpdateCheck(state, { checkedAt: now(), latestVersion }));
+    }
+
+    return isNewerVersion(latestVersion, currentVersion) ? { currentVersion, latestVersion } : undefined;
+  } catch {
+    return undefined;
+  }
+}

package/packages/app-state/test/update-check.test.mjs

@@ -0,0 +1,227 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { parsePositionState, serializePositionState } from "../src/state.js";
+import {
+  checkForUpdate,
+  fetchLatestVersion,
+  getLastUpdateCheck,
+  isNewerVersion,
+  setUpdateCheck
+} from "../src/update-check.js";
+
+test("isNewerVersion compares dotted numeric versions", () => {
+  assert.equal(isNewerVersion("0.2.8", "0.2.7"), true);
+  assert.equal(isNewerVersion("0.3.0", "0.2.7"), true);
+  assert.equal(isNewerVersion("1.0.0", "0.9.9"), true);
+  assert.equal(isNewerVersion("0.2.10", "0.2.9"), true);
+  assert.equal(isNewerVersion("v0.2.8", "0.2.7"), true);
+
+  assert.equal(isNewerVersion("0.2.7", "0.2.7"), false);
+  assert.equal(isNewerVersion("0.2.6", "0.2.7"), false);
+  assert.equal(isNewerVersion("0.2", "0.2.0"), false);
+});
+
+test("isNewerVersion is conservative about unparseable versions", () => {
+  assert.equal(isNewerVersion(undefined, "0.2.7"), false);
+  assert.equal(isNewerVersion("0.3.0", undefined), false);
+  assert.equal(isNewerVersion("not-a-version", "0.2.7"), false);
+  assert.equal(isNewerVersion("0.3.0-beta.1", "0.2.7"), false);
+});
+
+test("setUpdateCheck stores the cache immutably and survives (de)serialization", () => {
+  const original = parsePositionState("{}");
+  const updated = setUpdateCheck(original, { checkedAt: 123, latestVersion: "0.3.0" });
+
+  assert.equal(getLastUpdateCheck(original), undefined, "original state untouched");
+  assert.deepEqual(getLastUpdateCheck(updated), { checkedAt: 123, latestVersion: "0.3.0" });
+
+  const reloaded = parsePositionState(serializePositionState(updated));
+  assert.deepEqual(getLastUpdateCheck(reloaded), { checkedAt: 123, latestVersion: "0.3.0" });
+});
+
+function memoryStateFile(initial = parsePositionState("{}")) {
+  let state = initial;
+  const saves = [];
+  return {
+    load: async () => state,
+    save: async (next) => {
+      state = next;
+      saves.push(next);
+      return next;
+    },
+    saves
+  };
+}
+
+test("checkForUpdate fetches, caches, and reports a newer version", async () => {
+  const stateFile = memoryStateFile();
+  let fetches = 0;
+
+  const result = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile,
+    env: {},
+    now: () => 1000,
+    fetchLatest: async () => {
+      fetches += 1;
+      return "0.3.0";
+    }
+  });
+
+  assert.deepEqual(result, { currentVersion: "0.2.7", latestVersion: "0.3.0" });
+  assert.equal(fetches, 1);
+  assert.deepEqual(getLastUpdateCheck(stateFile.saves[0]), { checkedAt: 1000, latestVersion: "0.3.0" });
+});
+
+test("checkForUpdate uses a fresh cache without fetching", async () => {
+  const cached = setUpdateCheck(parsePositionState("{}"), { checkedAt: 1000, latestVersion: "0.3.0" });
+  const stateFile = memoryStateFile(cached);
+
+  const result = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile,
+    env: {},
+    now: () => 1000 + 60_000,
+    fetchLatest: async () => {
+      throw new Error("must not fetch while the cache is fresh");
+    }
+  });
+
+  assert.deepEqual(result, { currentVersion: "0.2.7", latestVersion: "0.3.0" });
+  assert.equal(stateFile.saves.length, 0, "fresh cache is not re-saved");
+});
+
+test("checkForUpdate refetches once the cache expires", async () => {
+  const cached = setUpdateCheck(parsePositionState("{}"), { checkedAt: 0, latestVersion: "0.2.8" });
+  const stateFile = memoryStateFile(cached);
+
+  const result = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile,
+    env: {},
+    now: () => 25 * 60 * 60 * 1000,
+    ttlMs: 24 * 60 * 60 * 1000,
+    fetchLatest: async () => "0.4.0"
+  });
+
+  assert.equal(result.latestVersion, "0.4.0");
+  assert.equal(stateFile.saves.length, 1);
+});
+
+test("checkForUpdate reports nothing when already up to date", async () => {
+  const result = await checkForUpdate({
+    currentVersion: "0.3.0",
+    stateFile: memoryStateFile(),
+    env: {},
+    now: () => 1000,
+    fetchLatest: async () => "0.3.0"
+  });
+
+  assert.equal(result, undefined);
+});
+
+test("checkForUpdate is silent on opt-out, failure, and bad input", async () => {
+  const optedOut = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile: memoryStateFile(),
+    env: { HAYA_PET_NO_UPDATE_CHECK: "1" },
+    fetchLatest: async () => "9.9.9"
+  });
+  assert.equal(optedOut, undefined);
+
+  const fetchFailed = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile: memoryStateFile(),
+    env: {},
+    fetchLatest: async () => undefined
+  });
+  assert.equal(fetchFailed, undefined);
+
+  const loadFailed = await checkForUpdate({
+    currentVersion: "0.2.7",
+    stateFile: { load: async () => { throw new Error("disk"); }, save: async () => {} },
+    env: {},
+    fetchLatest: async () => "9.9.9"
+  });
+  assert.equal(loadFailed, undefined);
+
+  const noVersion = await checkForUpdate({
+    currentVersion: undefined,
+    stateFile: memoryStateFile(),
+    env: {},
+    fetchLatest: async () => "9.9.9"
+  });
+  assert.equal(noVersion, undefined);
+});
+
+function fakeResponse({ statusCode = 200, body = "" } = {}) {
+  const handlers = {};
+  return {
+    statusCode,
+    setEncoding() {},
+    resume() {},
+    on(event, handler) {
+      handlers[event] = handler;
+      return this;
+    },
+    emit(event, payload) {
+      handlers[event]?.(payload);
+    },
+    body
+  };
+}
+
+function fakeGet({ response, requestError } = {}) {
+  return (url, options, onResponse) => {
+    const handlers = {};
+    const request = {
+      on(event, handler) {
+        handlers[event] = handler;
+        return this;
+      },
+      destroy() {
+        this.destroyed = true;
+      }
+    };
+    queueMicrotask(() => {
+      if (requestError) {
+        handlers.error?.(requestError);
+        return;
+      }
+      onResponse(response);
+      response.emit("data", response.body);
+      response.emit("end");
+    });
+    return request;
+  };
+}
+
+test("fetchLatestVersion extracts the version from the registry response", async () => {
+  const version = await fetchLatestVersion({
+    get: fakeGet({ response: fakeResponse({ body: '{"name":"x","version":"0.3.0"}' }) })
+  });
+  assert.equal(version, "0.3.0");
+});
+
+test("fetchLatestVersion resolves undefined on bad status, bad JSON, and errors", async () => {
+  assert.equal(
+    await fetchLatestVersion({ get: fakeGet({ response: fakeResponse({ statusCode: 404, body: "{}" }) }) }),
+    undefined
+  );
+  assert.equal(
+    await fetchLatestVersion({ get: fakeGet({ response: fakeResponse({ body: "not json" }) }) }),
+    undefined
+  );
+  assert.equal(
+    await fetchLatestVersion({ get: fakeGet({ requestError: new Error("offline") }) }),
+    undefined
+  );
+});
+
+test("fetchLatestVersion times out instead of hanging", async () => {
+  const version = await fetchLatestVersion({
+    timeoutMs: 5,
+    get: () => ({ on() { return this; }, destroy() {} }) // never responds
+  });
+  assert.equal(version, undefined);
+});

package/packages/cli-core/src/deadline.js

@@ -0,0 +1,23 @@
+// Hard deadline for IPC awaits in processes that something else waits on.
+// A hook reporter is a child process of the wrapped AI client, and the client
+// may wait for its hook children at shutdown (observed: Codex /quit hanging on
+// its goodbye while an orphaned reporter sat on a never-settling pipe await).
+// Racing the interaction against a deadline guarantees the await terminates,
+// which in turn guarantees the process can exit.
+
+export const DEADLINE = Symbol("deadline");
+
+// Resolves to the promise's value, or to DEADLINE after `ms` if the promise
+// hasn't settled by then. The promise keeps running if it loses the race —
+// callers are expected to exit (or proceed) regardless; its eventual rejection
+// is swallowed so a late failure can't become an unhandled rejection.
+export function raceDeadline(promise, ms) {
+  promise.catch(() => {});
+
+  let timer;
+  const timeout = new Promise((resolve) => {
+    timer = setTimeout(() => resolve(DEADLINE), ms);
+  });
+
+  return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
+}

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

@@ -5,6 +5,14 @@ import { appendFileSync } from "node:fs";
 import { createIpcClient as defaultCreateIpcClient } from "../../daemon-core/src/ipc-server.js";
 import { getDefaultPaths } from "../../platform-core/src/paths.js";
 import { isAiClientState } from "../../protocol/src/messages.js";
+import { DEADLINE, raceDeadline } from "./deadline.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
+// children at shutdown (observed: Codex /quit stuck on its goodbye while an
+// orphaned reporter hung forever on a pipe await). Hitting the deadline only
+// loses one best-effort status update; hanging loses the user's terminal.
+const REPORT_DEADLINE_MS = 2000;
 
 // Best-effort diagnostic: when HAYA_PET_HOOK_DEBUG points at a file, append one
 // JSONL line per reporter invocation so we can see the exact sequence of states
@@ -62,6 +70,7 @@ export async function runStateCommand(parsed, dependencies = {}) {
   }
 
   const createIpcClient = dependencies.createIpcClient ?? defaultCreateIpcClient;
+  const deadlineMs = dependencies.reportDeadlineMs ?? REPORT_DEADLINE_MS;
 
   try {
     const endpoint = dependencies.ipcEndpoint ?? getDefaultPaths({
@@ -69,17 +78,28 @@ export async function runStateCommand(parsed, dependencies = {}) {
       env,
       homeDir: dependencies.homeDir
     }).ipcEndpoint;
-    const client = await createIpcClient({ endpoint });
-    await client.send({
-      type: "state",
-      sessionId,
-      state: parsed.state,
-      summary: parsed.summary,
-      confidence: 0.9,
-      source: "official_plugin",
-      updatedAt: now()
-    });
-    await client.close();
+
+    const outcome = await raceDeadline(
+      (async () => {
+        const client = await createIpcClient({ endpoint });
+        await client.send({
+          type: "state",
+          sessionId,
+          state: parsed.state,
+          summary: parsed.summary,
+          confidence: 0.9,
+          source: "official_plugin",
+          updatedAt: now()
+        });
+        await client.close();
+      })(),
+      deadlineMs
+    );
+
+    if (outcome === DEADLINE) {
+      debugLog(env, now, { state: parsed.state, sessionId, timeout: true });
+      return { command: "state", ok: false, reason: "timeout" };
+    }
     return { command: "state", ok: true };
   } catch {
     return { command: "state", ok: false, reason: "no-daemon" };

package/packages/cli-core/test/deadline.test.mjs

@@ -0,0 +1,29 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import { DEADLINE, raceDeadline } from "../src/deadline.js";
+
+test("raceDeadline passes through a value that settles in time", async () => {
+  assert.equal(await raceDeadline(Promise.resolve("done"), 50), "done");
+});
+
+test("raceDeadline resolves to DEADLINE when the promise hangs", async () => {
+  const hang = new Promise(() => {});
+  assert.equal(await raceDeadline(hang, 10), DEADLINE);
+});
+
+test("raceDeadline propagates a rejection that settles in time", async () => {
+  await assert.rejects(() => raceDeadline(Promise.reject(new Error("boom")), 50), /boom/);
+});
+
+test("raceDeadline swallows a rejection that loses the race", async () => {
+  let rejectLater;
+  const losing = new Promise((_resolve, reject) => {
+    rejectLater = reject;
+  });
+
+  assert.equal(await raceDeadline(losing, 10), DEADLINE);
+
+  // The late rejection must not surface as an unhandled rejection.
+  rejectLater(new Error("late failure"));
+  await new Promise((resolve) => setImmediate(resolve));
+});

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

@@ -111,3 +111,44 @@ test("runStateCommand never throws when the daemon is unreachable", async () =>
   assert.equal(result.ok, false);
   assert.equal(result.reason, "no-daemon");
 });
+
+// The reporter is a child process the wrapped AI client may WAIT on at its own
+// shutdown (Codex /quit hung on its goodbye because a reporter sat forever on
+// a pipe await). Every IPC phase must therefore hit a hard deadline.
+test("runStateCommand times out instead of hanging when the connect never settles", async () => {
+  const result = await runStateCommand(
+    { command: "state", state: "thinking", summary: undefined, session: "s1" },
+    {
+      env: {},
+      ipcEndpoint: "test-endpoint",
+      reportDeadlineMs: 20,
+      createIpcClient: () => new Promise(() => {})
+    }
+  );
+  assert.equal(result.ok, false);
+  assert.equal(result.reason, "timeout");
+});
+
+test("runStateCommand times out instead of hanging when send or close never settle", async () => {
+  const hangingSend = await runStateCommand(
+    { command: "state", state: "thinking", summary: undefined, session: "s1" },
+    {
+      env: {},
+      ipcEndpoint: "test-endpoint",
+      reportDeadlineMs: 20,
+      createIpcClient: async () => ({ send: () => new Promise(() => {}), close: async () => {} })
+    }
+  );
+  assert.equal(hangingSend.reason, "timeout");
+
+  const hangingClose = await runStateCommand(
+    { command: "state", state: "thinking", summary: undefined, session: "s1" },
+    {
+      env: {},
+      ipcEndpoint: "test-endpoint",
+      reportDeadlineMs: 20,
+      createIpcClient: async () => ({ send: async () => {}, close: () => new Promise(() => {}) })
+    }
+  );
+  assert.equal(hangingClose.reason, "timeout");
+});