@hayasaka7/haya-pet 0.2.5 → 0.2.7

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/codex-guardian-watcher.test.mjs

@@ -0,0 +1,217 @@
+import assert from "node:assert/strict";
+import { appendFileSync, mkdirSync, mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { test } from "../../../test/harness.mjs";
+import { watchCodexGuardianReviews } from "../src/codex-guardian-watcher.js";
+
+const noopTimers = { setInterval: () => ({}), clearInterval: () => {} };
+
+function metaLine(payload) {
+  return `${JSON.stringify({ type: "session_meta", payload })}\n`;
+}
+
+function reviewStarted(turnId = "turn-1", timestamp) {
+  return `${JSON.stringify({
+    ...(timestamp ? { timestamp } : {}),
+    type: "event_msg",
+    payload: { type: "task_started", turn_id: turnId }
+  })}\n`;
+}
+
+function reviewFinished(outcome, turnId = "turn-1") {
+  return `${JSON.stringify({
+    type: "event_msg",
+    payload: {
+      type: "task_complete",
+      turn_id: turnId,
+      last_agent_message: JSON.stringify({ outcome })
+    }
+  })}\n`;
+}
+
+function makeSessionsRoot() {
+  const root = mkdtempSync(join(tmpdir(), "codex-guardian-"));
+  const dir = join(root, "2026", "06", "12");
+  mkdirSync(dir, { recursive: true });
+  return { root, dir };
+}
+
+test("watchCodexGuardianReviews tails the guardian trunk of the main session", () => {
+  const { root, dir } = makeSessionsRoot();
+  writeFileSync(
+    join(dir, "rollout-main.jsonl"),
+    metaLine({ id: "main-1", parent_thread_id: null, source: "cli", thread_source: "user" })
+  );
+  // A non-guardian subagent of the same parent must not be tailed.
+  writeFileSync(
+    join(dir, "rollout-collab.jsonl"),
+    metaLine({ id: "agent-1", parent_thread_id: "main-1", source: { subagent: { other: "collab" } } }) +
+      reviewStarted("decoy")
+  );
+  const trunkPath = join(dir, "rollout-guardian.jsonl");
+  writeFileSync(
+    trunkPath,
+    metaLine({ id: "guardian-1", parent_thread_id: "main-1", source: { subagent: { other: "guardian" } } })
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+  assert.deepEqual(events, [], "no review turns yet");
+
+  appendFileSync(trunkPath, reviewStarted());
+  watcher._tick();
+  appendFileSync(trunkPath, reviewFinished("allow"));
+  watcher._tick();
+
+  assert.deepEqual(events, [
+    { type: "review_started" },
+    { type: "review_finished", outcome: "allow" }
+  ]);
+
+  watcher.stop();
+});
+
+test("watchCodexGuardianReviews replays a trunk discovered after the review began", () => {
+  const { root, dir } = makeSessionsRoot();
+  writeFileSync(
+    join(dir, "rollout-main.jsonl"),
+    metaLine({ id: "main-1", parent_thread_id: null, source: "cli", thread_source: "user" })
+  );
+  writeFileSync(
+    join(dir, "rollout-guardian.jsonl"),
+    metaLine({ id: "guardian-1", parent_thread_id: "main-1", source: { subagent: { other: "guardian" } } }) +
+      reviewStarted("turn-1") +
+      reviewFinished("deny", "turn-1")
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+
+  assert.deepEqual(events, [
+    { type: "review_started" },
+    { type: "review_finished", outcome: "deny" }
+  ]);
+
+  watcher.stop();
+});
+
+test("watchCodexGuardianReviews skips review records from before the session start", () => {
+  const { root, dir } = makeSessionsRoot();
+  writeFileSync(
+    join(dir, "rollout-main.jsonl"),
+    metaLine({ id: "main-1", parent_thread_id: null, source: "cli", thread_source: "user" })
+  );
+  writeFileSync(
+    join(dir, "rollout-guardian.jsonl"),
+    metaLine({ id: "guardian-1", parent_thread_id: "main-1", source: { subagent: { other: "guardian" } } }) +
+      reviewStarted("turn-old", "2026-06-12T00:00:00.000Z") +
+      reviewStarted("turn-new", "2026-06-12T02:00:00.000Z")
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    startedAt: Date.parse("2026-06-12T01:00:00.000Z"),
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+
+  assert.deepEqual(events, [{ type: "review_started" }]);
+
+  watcher.stop();
+});
+
+test("watchCodexGuardianReviews emits nothing without a classifiable main session", () => {
+  const { root, dir } = makeSessionsRoot();
+  // Guardian trunk exists but there is no main rollout to bind its parent to.
+  writeFileSync(
+    join(dir, "rollout-guardian.jsonl"),
+    metaLine({ id: "guardian-1", parent_thread_id: "main-1", source: { subagent: { other: "guardian" } } }) +
+      reviewStarted()
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+  watcher._tick();
+
+  assert.deepEqual(events, []);
+
+  watcher.stop();
+});
+
+test("watchCodexGuardianReviews ignores guardian trunks of other parents", () => {
+  const { root, dir } = makeSessionsRoot();
+  writeFileSync(
+    join(dir, "rollout-main.jsonl"),
+    metaLine({ id: "main-1", parent_thread_id: null, source: "cli", thread_source: "user" })
+  );
+  writeFileSync(
+    join(dir, "rollout-guardian-other.jsonl"),
+    metaLine({ id: "guardian-9", parent_thread_id: "someone-else", source: { subagent: { other: "guardian" } } }) +
+      reviewStarted()
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+
+  assert.deepEqual(events, []);
+
+  watcher.stop();
+});
+
+test("watchCodexGuardianReviews picks up a trunk created after watching began", () => {
+  const { root, dir } = makeSessionsRoot();
+  writeFileSync(
+    join(dir, "rollout-main.jsonl"),
+    metaLine({ id: "main-1", parent_thread_id: null, source: "cli", thread_source: "user" })
+  );
+
+  const events = [];
+  const watcher = watchCodexGuardianReviews({
+    sessionsRoot: root,
+    onReviewEvent: (event) => events.push(event),
+    ...noopTimers
+  });
+
+  watcher._tick();
+  assert.deepEqual(events, [], "no trunk yet");
+
+  const trunkPath = join(dir, "rollout-guardian.jsonl");
+  writeFileSync(
+    trunkPath,
+    metaLine({ id: "guardian-1", parent_thread_id: "main-1", source: { subagent: { other: "guardian" } } }) +
+      reviewStarted()
+  );
+  watcher._tick();
+
+  assert.deepEqual(events, [{ type: "review_started" }]);
+
+  watcher.stop();
+});

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