@hayasaka7/haya-pet 0.2.6 → 0.2.8

package/docs/architecture.md

@@ -103,6 +103,14 @@ with mouse-move forwarding). The pet is positioned inside the window and dragged
 via CSS; the bubble panel is placed on whichever side of the pet has room so it
 stays fully on-screen. The pet currently lives on a single display's work area.
 
+The bubble panel shows at most three sessions and scrolls for the rest (capped
+by the smaller of a height budget and a count budget, see
+`bubble-list-viewport.js`). It renders **incrementally** — the list element and
+each session's bubble persist across updates and are mutated in place rather
+than rebuilt — because status pushes and a 2 s linger tick arrive constantly,
+and replacing the node under the cursor would drop an in-progress scroll
+gesture and reset the scroll position.
+
 ## Distribution & runtime dependencies
 
 - `electron` is a **runtime dependency** (not just a dev tool), because

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.8",
   "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");
+});