@hayasaka7/haya-pet 0.3.9 → 0.3.10

package/CHANGELOG.md

@@ -7,6 +7,24 @@ 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.10]
+
+### Fixed
+- **A running Claude Code subagent no longer drives the main session's status.**
+  With hooks enabled and a multi-agent run, once the main agent had stopped but a
+  subagent was still working, two things went wrong: the pet dropped to *idle*
+  (even though work was ongoing), and while the subagent ran its tool calls flipped
+  the pet between *running tools* / *editing files* / *thinking*. Fix, checked
+  **only at the main agent's `Stop`** (no timers, no persisted state): (1) Claude's
+  `Stop` payload carries a live `background_tasks` snapshot — when it still lists a
+  running **subagent**, the pet shows *running tools* with the message **"Subagent
+  running"**, and the follow-up `Stop` (empty `background_tasks`) clears it back to
+  *idle*; (2) every subagent-originated hook event carries an `agent_id`, so the
+  reporter now **drops any event with an `agent_id`**, and a subagent's activity can
+  no longer overwrite the main session's status. Background **shells** are
+  deliberately not surfaced (their completion isn't reliably observable). See
+  `docs/known-issues.md`.
+
 ## [0.3.9]
 
 ### Fixed

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

@@ -5,7 +5,7 @@ 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, readHookTranscriptPathFromStdin } from "../../../packages/cli-core/src/run-state.js";
+import { parseStateArgs, runStateCommand, readHookPayloadFromStdin } 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";
@@ -969,20 +969,31 @@ 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.
+// hook child — read the hook payload from stdin once to learn: this session's real
+// transcript path (for the session->transcript link); the live background_tasks
+// snapshot (so a Stop with a still-running subagent keeps a working cue instead of
+// idle); and the agent_id (present only for subagent-originated events, which the
+// reporter drops so a subagent's activity never overwrites the main status). All
+// are handed to the reporter via dependencies. 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();
+      const { transcriptPath, backgroundTasks, agentId } = await readHookPayloadFromStdin();
       if (transcriptPath) {
         dependencies.transcriptPath = transcriptPath;
       }
+      if (Array.isArray(backgroundTasks) && backgroundTasks.length > 0) {
+        dependencies.backgroundTasks = backgroundTasks;
+      }
+      // Present only for subagent-originated events — the reporter drops those so a
+      // subagent's tool use never overwrites the main session's status.
+      if (agentId) {
+        dependencies.agentId = agentId;
+      }
     } catch {
       // a missing/garbled payload just means no binding this time — never fatal
     }

package/docs/known-issues.md

@@ -150,19 +150,60 @@ Issues found in live use, with their current status.
   to *thinking* (the agent continues the turn) and the next real event refines it.
   Verified live on the manual path; auto uses the identical matcher mechanism.
 
-## ✅ Resolved: Claude Code subagent completion changed the main session status
-
-- **Symptom:** In Claude Code multi-agent runs, the main agent could already be
-  stopped while a subagent was still finishing. When that late subagent emitted
-  `SubagentStop`, the pet treated it as a main-session `idle` update and could
-  show a misleading working/done transition after the main agent had settled.
-- **Root cause:** The Claude hook table mapped `SubagentStop` to `idle`. That is
-  only safe if subagent completion is ordered before the main turn finishes, which
-  Claude Code does not guarantee.
-- **Fix:** Claude `SubagentStop` is now ignored. Main-session idle still comes
-  from Claude's real `Stop` hook, while late subagent completion cannot override
-  the current main-agent state. Codex keeps its separate behavior because Codex
-  uses `Stop` as the only idle signal and treats `SubagentStop` as mid-turn.
+## ✅ Resolved: subagent activity drove the main session status (Claude Code)
+
+- **Symptom:** With Claude Code hooks enabled and a multi-agent run, two things
+  went wrong once the **main agent had stopped but a subagent was still working**:
+  (1) the pet dropped to *idle* even though real work was ongoing in the
+  background; and (2) while the subagent ran, its own tool calls flipped the pet
+  between *running tools* / *editing files* / *thinking* — the subagent's activity
+  was driving the main session's status.
+- **Root cause:** Two gaps. (a) The hook table mapped `Stop` → *idle*
+  unconditionally, with no awareness that a backgrounded subagent can outlive the
+  main turn. (b) A backgrounded subagent's tool calls fire the **parent session's**
+  `PreToolUse` / `PostToolUse` hooks, which ran `haya-pet state running_tool`
+  (etc.) under the main session id and overwrote its status. (An earlier fix only
+  stopped `SubagentStop` from reporting *idle*; it addressed neither of these.)
+- **Fix — only ever decided at the main agent's `Stop`; no timers, no persisted
+  state:**
+  - **The "Subagent running" cue.** Claude's `Stop` payload carries an
+    (undocumented) **`background_tasks`** array: a live snapshot of work still
+    running at that instant. When `Stop` would report *idle* but `background_tasks`
+    still lists a running **subagent**, the reporter instead reports *running
+    tools* with the summary **"Subagent running"**
+    (`packages/cli-core/src/background-tasks.js`). When that subagent finishes,
+    Claude fires `Stop` **again** with an empty `background_tasks`, which clears the
+    cue back to *idle* — self-retracting, no timer. (Verified against live hook
+    traces: a backgrounded subagent appears in `Stop`'s `background_tasks` as
+    `type:"subagent", status:"running"`, and a second `Stop` arrives with `[]` once
+    it completes.)
+  - **Subagent events are dropped.** Every hook payload from a subagent context
+    carries an **`agent_id`** — the documented field that distinguishes subagent
+    hook calls from main-thread calls. The reporter now drops any event with an
+    `agent_id` (`extractAgentId` in `run-state.js`), so a subagent's tool use can
+    never overwrite the main session's status. Main-agent events have no `agent_id`
+    and report as before; the main `Stop` (also no `agent_id`) still carries the
+    `background_tasks` snapshot used for the cue above. `SubagentStop` is likewise
+    not wired.
+- **Known limitations (accepted):**
+  - **Only subagents, never background shells.** A `background_tasks` entry can
+    also be `type:"shell"` (e.g. a `sleep 120` the agent backgrounded). These are
+    deliberately **not** surfaced: their completion isn't reliably observable here,
+    and a "working" cue we can't retract is worse than showing *idle*. So a
+    backgrounded shell still running after the main agent stops shows *idle*.
+  - **The `agent_id` discriminator is documented but not yet captured live on
+    `PreToolUse` / `PostToolUse`.** The Claude hooks reference lists `agent_id` /
+    `agent_type` as optional fields delivered to all hooks to distinguish subagent
+    calls, and the observed flicker confirms subagent tool calls reach the parent
+    hooks — but a subagent `PreToolUse` payload hasn't been captured on disk to
+    100% confirm `agent_id` is present there. If a future Claude build omits it the
+    flicker could recur; the marker would then be widened to also match
+    `agent_type` / `agent_transcript_path`.
+- **How to diagnose if it recurs:** with `HAYA_PET_HOOK_DEBUG=<path>` set, the
+  reporter logs an `agentId` field on subagent-sourced events (which it then
+  drops). A subagent event logged with **no** `agentId` is the signal to widen the
+  marker. Codex keeps its separate behavior: it uses `Stop` as the only idle signal
+  and treats `SubagentStop` as mid-turn.
 
 ## ✅ Resolved: false "waiting for approval" while Codex auto-reviews an approval (Approve for me)
 
@@ -426,8 +467,12 @@ observation (`--observe`) or L1 lifecycle as the fallback. Current state:
   `Notification`/`PreCompact`/`PostCompact`/`Stop` events to `haya-pet state <state>`,
   reported to the daemon over the IPC pipe. `PostCompact` is split by its
   `manual`/`auto` trigger matcher (manual `/compact` → *idle*, auto compaction →
-  *thinking*) so the pet never sticks on *compacting*. `SubagentStop` is intentionally ignored because
-  it is not a main-turn idle signal. `PreToolUse` distinguishes
+  *thinking*) so the pet never sticks on *compacting*. Subagent-originated events
+  are **dropped** by the reporter (they carry an `agent_id`), so a subagent's tool
+  use never drives the main status, and `SubagentStop` is not wired; when `Stop`
+  fires while a subagent is still running, its `background_tasks` snapshot surfaces
+  as a *running tools* / "Subagent running" cue that the next (empty) `Stop` clears
+  — see the resolved subagent entry above. `PreToolUse` distinguishes
   file-editing tools (`Edit`/`Write`/`MultiEdit`/`NotebookEdit` → *editing files*)
   from other tools (→ *running tools*) via the hook `matcher`. **Why opt-in:**
   injecting hooks makes Claude show a one-time *review hooks* trust prompt; the

package/package.json

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

package/packages/cli-core/src/background-tasks.js

@@ -0,0 +1,63 @@
+// Pure helpers for the Claude "subagent still running at Stop" cue.
+//
+// When the main Claude agent ends its turn it fires `Stop`, whose payload carries
+// a `background_tasks` array — a live snapshot of work still running at that
+// instant (the hooks docs omit this field; it was verified against live traces).
+// If a backgrounded *subagent* is still running, the main agent is paused but real
+// work continues, so the pet keeps a "working" cue with a message rather than
+// dropping to idle. When that subagent finishes, Claude fires `Stop` AGAIN with an
+// empty `background_tasks`, which naturally clears the cue — so this needs no
+// timers, no persisted state, and no subagent-event wiring. The only check is at
+// the main agent's Stop, exactly as scoped.
+//
+// Scoped to `type: "subagent"` ONLY. Background *shells* are intentionally
+// excluded: their completion isn't reliably observable here, and a status we
+// cannot retract is worse than none.
+
+// A single, fixed cue message. The user only wants to know that a subagent is
+// still working after the main agent paused — NOT which one or how many.
+const SUBAGENT_RUNNING_SUMMARY = "Subagent running";
+
+// Parse a Claude hook payload (JSON on stdin) and return its background_tasks
+// array. Defensive: any non-JSON / missing / wrong-typed input yields [].
+export function extractBackgroundTasks(raw) {
+  if (typeof raw !== "string" || raw.trim() === "") {
+    return [];
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed?.background_tasks) ? parsed.background_tasks : [];
+  } catch {
+    return [];
+  }
+}
+
+// The still-running *subagent* tasks. Shells and finished tasks are dropped.
+export function runningSubagentTasks(tasks) {
+  if (!Array.isArray(tasks)) {
+    return [];
+  }
+  return tasks.filter((task) => task && task.type === "subagent" && task.status === "running");
+}
+
+// A fixed cue message when any subagent is still running, or undefined when none
+// are (the caller then leaves the reported state untouched). Intentionally not
+// detailed — just "a subagent is still working".
+export function summarizeSubagentTasks(tasks) {
+  return runningSubagentTasks(tasks).length > 0 ? SUBAGENT_RUNNING_SUMMARY : undefined;
+}
+
+// Decide the effective state/summary for a reported state given the Stop payload's
+// background_tasks. Only an `idle` report with a running subagent is upgraded to a
+// working cue; everything else passes through unchanged — including the follow-up
+// Stop whose background_tasks is empty, which is what retracts the cue.
+export function applySubagentBackgroundTasks({ state, summary, backgroundTasks }) {
+  if (state !== "idle") {
+    return { state, summary };
+  }
+  const message = summarizeSubagentTasks(backgroundTasks);
+  if (!message) {
+    return { state, summary };
+  }
+  return { state: "running_tool", summary: message };
+}

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

@@ -7,6 +7,7 @@ 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";
+import { applySubagentBackgroundTasks, extractBackgroundTasks } from "./background-tasks.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
@@ -60,8 +61,28 @@ export async function runStateCommand(parsed, dependencies = {}) {
   const env = dependencies.env ?? process.env;
   const now = dependencies.now ?? Date.now;
   const sessionId = parsed.session ?? env.HAYA_PET_SESSION_ID;
+  const agentId = dependencies.agentId;
 
-  debugLog(env, now, { state: parsed.state, sessionId, summary: parsed.summary });
+  debugLog(
+    env,
+    now,
+    agentId
+      ? { state: parsed.state, sessionId, summary: parsed.summary, agentId }
+      : { state: parsed.state, sessionId, summary: parsed.summary }
+  );
+
+  // A subagent's own activity must NEVER drive the main session's status. A
+  // backgrounded subagent's tool calls fire the PARENT session's PreToolUse/
+  // PostToolUse hooks, which would otherwise overwrite the main agent's status
+  // (and the "Subagent running" cue) with running_tool/thinking/editing_files as
+  // the subagent works. The payload's `agent_id` is the documented field that
+  // distinguishes subagent hook calls from main-thread calls — when it's present
+  // the event came from a subagent, so we drop it entirely. The ONE place a
+  // subagent surfaces is the main agent's own Stop (no agent_id), via
+  // background_tasks; see applySubagentBackgroundTasks below.
+  if (agentId) {
+    return { command: "state", ok: false, reason: "subagent-event" };
+  }
 
   if (!sessionId) {
     return { command: "state", ok: false, reason: "no-session" };
@@ -77,6 +98,17 @@ export async function runStateCommand(parsed, dependencies = {}) {
   // session's interrupt/denial. Best-effort and synchronous; never blocks the hook.
   recordTranscriptLink(sessionId, env, dependencies);
 
+  // When the main agent's Stop reports idle but its background_tasks (from the hook
+  // payload, passed in via dependencies) still lists a running subagent, keep a
+  // working cue with a message instead — the main agent is paused but real work
+  // continues. The follow-up Stop carries an empty list and clears it. Scoped to
+  // subagents only; see background-tasks.js.
+  const effective = applySubagentBackgroundTasks({
+    state: parsed.state,
+    summary: parsed.summary,
+    backgroundTasks: dependencies.backgroundTasks
+  });
+
   const createIpcClient = dependencies.createIpcClient ?? defaultCreateIpcClient;
   const deadlineMs = dependencies.reportDeadlineMs ?? REPORT_DEADLINE_MS;
 
@@ -93,8 +125,8 @@ export async function runStateCommand(parsed, dependencies = {}) {
         await client.send({
           type: "state",
           sessionId,
-          state: parsed.state,
-          summary: parsed.summary,
+          state: effective.state,
+          summary: effective.summary,
           confidence: 0.9,
           source: "official_plugin",
           updatedAt: now()
@@ -152,19 +184,50 @@ export function extractTranscriptPath(raw) {
   }
 }
 
-// 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 = {}) {
+// Pull `agent_id` out of a Claude hook payload (JSON on stdin). Present only for
+// subagent-originated events (the documented field distinguishing subagent hook
+// calls from main-thread calls); absent for main-agent events. Pure and
+// defensive: any non-JSON, missing-field, or wrong-type input yields undefined.
+export function extractAgentId(raw) {
+  if (typeof raw !== "string" || raw.trim() === "") {
+    return undefined;
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    const value = parsed?.agent_id;
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+// Read the Claude hook payload from stdin and return everything the reporter
+// needs from it in one read (stdin can only be consumed once): the session's
+// transcript_path (for the watcher binding) and the live background_tasks snapshot
+// (for the subagent-at-Stop cue). 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 empty results rather than ever hanging the host
+// client's hook.
+export async function readHookPayloadFromStdin(options = {}) {
+  const raw = await readHookPayloadRaw(options);
+  return {
+    transcriptPath: extractTranscriptPath(raw),
+    backgroundTasks: extractBackgroundTasks(raw),
+    agentId: extractAgentId(raw)
+  };
+}
+
+// Accumulate the raw payload string from stdin under a hard deadline and byte cap.
+// Always resolves (never rejects); an error or no payload yields "".
+function readHookPayloadRaw(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);
+      resolve("");
       return;
     }
 
@@ -172,7 +235,7 @@ export function readHookTranscriptPathFromStdin(options = {}) {
     let settled = false;
     let timer;
 
-    const finish = (value) => {
+    const finish = () => {
       if (settled) {
         return;
       }
@@ -188,17 +251,20 @@ export function readHookTranscriptPathFromStdin(options = {}) {
       } catch {
         // detaching is best-effort
       }
-      resolve(value);
+      resolve(data);
     };
 
     const onData = (chunk) => {
       data += chunk;
       if (data.length > maxBytes) {
-        finish(extractTranscriptPath(data));
+        finish();
       }
     };
-    const onEnd = () => finish(extractTranscriptPath(data));
-    const onError = () => finish(undefined);
+    const onEnd = () => finish();
+    const onError = () => {
+      data = "";
+      finish();
+    };
 
     try {
       stdin.setEncoding("utf8");
@@ -206,12 +272,12 @@ export function readHookTranscriptPathFromStdin(options = {}) {
       stdin.on("end", onEnd);
       stdin.on("error", onError);
       stdin.resume();
-      timer = setTimeout(() => finish(extractTranscriptPath(data)), timeoutMs);
+      timer = setTimeout(finish, timeoutMs);
       if (timer && typeof timer.unref === "function") {
         timer.unref();
       }
     } catch {
-      finish(undefined);
+      finish();
     }
   });
 }

package/packages/cli-core/test/background-tasks.test.mjs

@@ -0,0 +1,115 @@
+import assert from "node:assert/strict";
+import { test } from "../../../test/harness.mjs";
+import {
+  applySubagentBackgroundTasks,
+  extractBackgroundTasks,
+  runningSubagentTasks,
+  summarizeSubagentTasks
+} from "../src/background-tasks.js";
+
+test("extractBackgroundTasks pulls the array out of a Claude Stop payload", () => {
+  const raw = JSON.stringify({
+    hook_event_name: "Stop",
+    background_tasks: [
+      { id: "x", type: "subagent", status: "running", description: "Survey repo structure" }
+    ]
+  });
+  assert.deepEqual(extractBackgroundTasks(raw), [
+    { id: "x", type: "subagent", status: "running", description: "Survey repo structure" }
+  ]);
+});
+
+test("extractBackgroundTasks is defensive about junk, missing field, and wrong types", () => {
+  assert.deepEqual(extractBackgroundTasks("{not json"), []);
+  assert.deepEqual(extractBackgroundTasks(JSON.stringify({ hook_event_name: "Stop" })), []);
+  assert.deepEqual(extractBackgroundTasks(JSON.stringify({ background_tasks: "nope" })), []);
+  assert.deepEqual(extractBackgroundTasks(""), []);
+  assert.deepEqual(extractBackgroundTasks(undefined), []);
+});
+
+test("runningSubagentTasks keeps only running subagents (drops shells and finished)", () => {
+  const tasks = [
+    { id: "a", type: "subagent", status: "running", description: "A" },
+    { id: "b", type: "subagent", status: "completed", description: "B" },
+    { id: "c", type: "shell", status: "running", command: "sleep 120" },
+    null,
+    { id: "d", type: "subagent", status: "running", description: "D" }
+  ];
+  assert.deepEqual(runningSubagentTasks(tasks).map((t) => t.id), ["a", "d"]);
+  assert.deepEqual(runningSubagentTasks(undefined), []);
+  assert.deepEqual(runningSubagentTasks("nope"), []);
+});
+
+test("summarizeSubagentTasks returns a fixed message when any subagent runs (no detail)", () => {
+  // Same generic message regardless of description, agent_type, or count.
+  assert.equal(
+    summarizeSubagentTasks([
+      { type: "subagent", status: "running", description: "Survey repo structure" }
+    ]),
+    "Subagent running"
+  );
+  assert.equal(
+    summarizeSubagentTasks([{ type: "subagent", status: "running", agent_type: "explore" }]),
+    "Subagent running"
+  );
+  assert.equal(
+    summarizeSubagentTasks([
+      { type: "subagent", status: "running", description: "A" },
+      { type: "subagent", status: "running", description: "B" }
+    ]),
+    "Subagent running"
+  );
+});
+
+test("summarizeSubagentTasks returns undefined when nothing is running", () => {
+  assert.equal(summarizeSubagentTasks([]), undefined);
+  assert.equal(summarizeSubagentTasks([{ type: "shell", status: "running" }]), undefined);
+  assert.equal(summarizeSubagentTasks([{ type: "subagent", status: "completed" }]), undefined);
+});
+
+test("applySubagentBackgroundTasks upgrades idle to a working cue when a subagent runs", () => {
+  assert.deepEqual(
+    applySubagentBackgroundTasks({
+      state: "idle",
+      summary: undefined,
+      backgroundTasks: [
+        { type: "subagent", status: "running", description: "Survey repo structure" }
+      ]
+    }),
+    { state: "running_tool", summary: "Subagent running" }
+  );
+});
+
+test("applySubagentBackgroundTasks leaves a non-idle state untouched", () => {
+  assert.deepEqual(
+    applySubagentBackgroundTasks({
+      state: "thinking",
+      summary: "hi",
+      backgroundTasks: [{ type: "subagent", status: "running", description: "A" }]
+    }),
+    { state: "thinking", summary: "hi" }
+  );
+});
+
+test("applySubagentBackgroundTasks passes idle through when nothing runs (the retraction case)", () => {
+  // The follow-up Stop carries an empty background_tasks — this is what clears the cue.
+  assert.deepEqual(
+    applySubagentBackgroundTasks({ state: "idle", summary: undefined, backgroundTasks: [] }),
+    { state: "idle", summary: undefined }
+  );
+  assert.deepEqual(
+    applySubagentBackgroundTasks({ state: "idle", summary: "idle", backgroundTasks: undefined }),
+    { state: "idle", summary: "idle" }
+  );
+});
+
+test("applySubagentBackgroundTasks ignores background shells (deliberately unsupported)", () => {
+  assert.deepEqual(
+    applySubagentBackgroundTasks({
+      state: "idle",
+      summary: undefined,
+      backgroundTasks: [{ type: "shell", status: "running", command: "sleep 120" }]
+    }),
+    { state: "idle", summary: undefined }
+  );
+});

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

@@ -3,7 +3,7 @@ import { mkdtempSync, readFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { test } from "../../../test/harness.mjs";
-import { extractTranscriptPath, parseStateArgs, runStateCommand } from "../src/run-state.js";
+import { extractAgentId, 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 () => {
@@ -35,6 +35,40 @@ test("extractTranscriptPath pulls transcript_path out of a Claude hook payload",
   assert.equal(extractTranscriptPath(undefined), undefined);
 });
 
+test("extractAgentId pulls agent_id out of a subagent hook payload", () => {
+  assert.equal(
+    extractAgentId(JSON.stringify({ hook_event_name: "PreToolUse", agent_id: "a9a8317d", agent_type: "Explore" })),
+    "a9a8317d"
+  );
+  // Main-agent events carry no agent_id; junk and wrong types yield undefined.
+  assert.equal(extractAgentId(JSON.stringify({ hook_event_name: "Stop" })), undefined);
+  assert.equal(extractAgentId(JSON.stringify({ agent_id: 42 })), undefined);
+  assert.equal(extractAgentId(JSON.stringify({ agent_id: "" })), undefined);
+  assert.equal(extractAgentId("{not json"), undefined);
+  assert.equal(extractAgentId(undefined), undefined);
+});
+
+test("runStateCommand ignores subagent-originated events so they never drive main status", async () => {
+  let connected = false;
+  const sent = [];
+  const result = await runStateCommand(
+    { command: "state", state: "running_tool", summary: undefined, session: "sess_main" },
+    {
+      now: () => 9,
+      agentId: "a9a8317d3457d6364",
+      createIpcClient: async () => {
+        connected = true;
+        return { send: async (m) => sent.push(m), close: async () => {} };
+      }
+    }
+  );
+
+  assert.equal(result.ok, false);
+  assert.equal(result.reason, "subagent-event");
+  assert.equal(connected, false);
+  assert.equal(sent.length, 0);
+});
+
 test("runStateCommand records the session->transcript link when given a transcript path", async () => {
   const sessionDir = mkdtempSync(join(tmpdir(), "sess-"));
   await runStateCommand(
@@ -112,6 +146,39 @@ test("runStateCommand sends one official_plugin state message", async () => {
   });
 });
 
+test("runStateCommand upgrades a Stop idle to a working cue when a subagent still runs", async () => {
+  const sent = [];
+  const result = await runStateCommand(
+    { command: "state", state: "idle", summary: undefined, session: "sess_bg" },
+    {
+      now: () => 42,
+      backgroundTasks: [
+        { id: "x", type: "subagent", status: "running", description: "Survey repo structure" }
+      ],
+      createIpcClient: async () => ({ send: async (m) => sent.push(m), close: async () => {} })
+    }
+  );
+
+  assert.equal(result.ok, true);
+  assert.equal(sent[0].state, "running_tool");
+  assert.equal(sent[0].summary, "Subagent running");
+});
+
+test("runStateCommand reports plain idle when the follow-up Stop has no running subagents", async () => {
+  const sent = [];
+  await runStateCommand(
+    { command: "state", state: "idle", summary: undefined, session: "sess_done" },
+    {
+      now: () => 43,
+      backgroundTasks: [],
+      createIpcClient: async () => ({ send: async (m) => sent.push(m), close: async () => {} })
+    }
+  );
+
+  assert.equal(sent[0].state, "idle");
+  assert.equal(sent[0].summary, undefined);
+});
+
 test("runStateCommand falls back to HAYA_PET_SESSION_ID", async () => {
   const sent = [];
   const result = await runStateCommand(