@hayasaka7/haya-pet 0.3.9 → 0.3.11

package/CHANGELOG.md

@@ -7,6 +7,35 @@ 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.11]
+
+### Fixed
+- **Codex live-status hooks now work with custom profiles.** HAYA Pet no longer
+  injects its own `-p haya-pet` profile or skips hooks when the wrapped Codex
+  command already has `-p` / `--profile`. Instead it merges stable HAYA-managed
+  hook entries into `$CODEX_HOME/hooks.json`, preserving any existing user hooks
+  and leaving profile args such as `--profile fugu` untouched. The wrapper still
+  resolves profile-specific `approvals_reviewer` settings so approval status
+  matches the selected Codex profile.
+
+## [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/README.md

@@ -193,6 +193,12 @@ resolved `approvals_reviewer` setting, and transcript watchers report tool/file
 activity plus guardian-review outcomes. With **"Approve for me"** the pet shows
 *reviewing* immediately; *waiting for approval* is reserved for Codex's manual
 "Ask for approval" mode.
+
+Codex custom profiles are preserved. HAYA Pet installs its live-status hooks in
+`$CODEX_HOME/hooks.json` instead of passing its own `-p` profile, so launches such
+as `haya-pet run --client codex -- codex --profile fugu` keep both the selected
+Codex profile and HAYA live status.
+
 Per-tool `PreToolUse` hooks still depend on an upstream Codex gap
 ([openai/codex#16732](https://github.com/openai/codex/issues/16732)); the
 transcript watcher covers that in the meantime.

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";
@@ -219,8 +219,10 @@ function resolveCodexApprovalsReviewer(options = {}) {
 
   const home = options.codexHome ?? env.CODEX_HOME ?? resolveHomeCodexDir(options.homeDir, env);
   const readFile = options.readFile ?? readFileSync;
+  const profileName = findCodexProfileInArgs(options.childArgs ?? []);
+  const fromProfile = profileName ? readCodexApprovalsReviewerFromProfile(home, profileName, readFile) : undefined;
   const fromConfig = readCodexApprovalsReviewerFromConfig(home, readFile);
-  return fromConfig ?? "user";
+  return fromProfile ?? fromConfig ?? "user";
 }
 
 function resolveHomeCodexDir(homeDir, env) {
@@ -250,12 +252,49 @@ function findCodexApprovalsReviewerInArgs(args) {
   return reviewer;
 }
 
+function findCodexProfileInArgs(args) {
+  let profileName;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    let value;
+    if (arg === "-p" || arg === "--profile") {
+      value = args[index + 1];
+      index += 1;
+    } else if (arg.startsWith("--profile=")) {
+      value = arg.slice("--profile=".length);
+    } else if (arg.startsWith("-p=")) {
+      value = arg.slice("-p=".length);
+    } else if (arg.startsWith("-p") && arg.length > 2) {
+      value = arg.slice(2);
+    }
+
+    if (isCodexProfileName(value)) {
+      profileName = value;
+    }
+  }
+  return profileName;
+}
+
+function isCodexProfileName(value) {
+  return typeof value === "string" && /^[A-Za-z0-9_-]+$/.test(value);
+}
+
+function readCodexApprovalsReviewerFromProfile(codexHome, profileName, readFile) {
+  if (!codexHome || !isCodexProfileName(profileName)) {
+    return undefined;
+  }
+  return readCodexApprovalsReviewerFromFile(join(codexHome, `${profileName}.config.toml`), readFile);
+}
 function readCodexApprovalsReviewerFromConfig(codexHome, readFile) {
   if (!codexHome) {
     return undefined;
   }
+  return readCodexApprovalsReviewerFromFile(join(codexHome, "config.toml"), readFile);
+}
+
+function readCodexApprovalsReviewerFromFile(path, readFile) {
   try {
-    return parseTopLevelApprovalsReviewer(readFile(join(codexHome, "config.toml"), "utf8"));
+    return parseTopLevelApprovalsReviewer(readFile(path, "utf8"));
   } catch {
     return undefined;
   }
@@ -407,162 +446,154 @@ async function runRunCommand(parsed, dependencies) {
     };
   }
 
-  // Codex: no `--settings` equivalent, so inject a stable profile and add
-  // `-p <name>` at the FRONT (a global flag must precede any subcommand). Codex
-  // takes only one profile, so if the user already passes their own -p/--profile
-  // we skip injection and say so rather than clobber their choice. Codex
+  // Codex: no `--settings` equivalent, so install stable user-level hooks in
+  // CODEX_HOME/hooks.json. Codex loads user hooks alongside any selected
+  // -p/--profile, so the wrapper never consumes the user's single profile slot.
   // PreToolUse is not reliable, so a transcript watcher supplies tool activity.
   const codexHooksOn = hooksOn && parsed.clientId === "codex";
   if (codexHooksOn) {
-    if (hasProfileArg(parsed.childArgs)) {
-      print(
-        "haya-pet: Codex live-status hooks skipped — you passed your own -p/--profile (Codex allows only one)."
-      );
-    } else {
-      const injected = injectCodexHooks();
-      childArgs = ["-p", injected.profileName, ...parsed.childArgs];
-      childEnv = {
-        ...env,
-        HAYA_PET_SESSION_ID: sessionId,
-        HAYA_PET_CODEX_APPROVAL_REVIEWER: resolveCodexApprovalsReviewer({
-          childArgs: parsed.childArgs,
-          env,
-          homeDir: dependencies.homeDir,
-          codexHome: dependencies.codexHome,
-          readFile: dependencies.readFile
-        })
-      };
-      cleanup = injected.cleanup;
-
-      // Pin both Codex watchers to THIS session's rollout via the
-      // session->transcript link the `haya-pet state` reporter records from the
-      // hook payload's transcript_path, instead of guessing newest-by-mtime (which
-      // leaks a concurrent same-cwd session's activity/interrupts).
-      const sessionDir = resolveSessionDir(dependencies, env);
-
-      const activeToolCalls = new Set();
-      const watcher = watchCodexTranscript({
+    const injected = injectCodexHooks();
+    childEnv = {
+      ...env,
+      HAYA_PET_SESSION_ID: sessionId,
+      HAYA_PET_CODEX_APPROVAL_REVIEWER: resolveCodexApprovalsReviewer({
+        childArgs: parsed.childArgs,
+        env,
         homeDir: dependencies.homeDir,
-        sessionsRoot: dependencies.codexSessionsRoot,
-        cwd,
-        startedAt: now(),
-        sessionId,
-        sessionDir,
-        onToolEvent: (event) => {
-          hookDebugLog(env, now, {
-            source: "codex_transcript",
-            event: event.type,
-            toolCallId: event.toolCallId,
-            toolName: event.toolName,
-            state: event.state
-          });
-
-          // Esc-interrupt fires no Stop hook, so without this the pet stays stuck
-          // on "thinking"/"running" until the stale sweep.
-          if (event.type === "turn_aborted") {
-            activeToolCalls.clear();
-            messageSender
-              .send({
-                type: "state",
-                sessionId,
-                state: "interrupted",
-                summary: "interrupted",
-                confidence: 0.9,
-                source: "client_log",
-                updatedAt: now()
-              })
-              .catch(() => {});
-            return;
-          }
+        codexHome: dependencies.codexHome,
+        readFile: dependencies.readFile
+      })
+    };
+    cleanup = injected.cleanup;
 
-          if (event.type === "tool_started") {
-            activeToolCalls.add(event.toolCallId);
-            messageSender
-              .send({
-                type: "state",
-                sessionId,
-                state: event.state,
-                summary: event.toolName,
-                confidence: 0.85,
-                source: "client_log",
-                updatedAt: now()
-              })
-              .catch(() => {});
-            return;
-          }
+    // Pin both Codex watchers to THIS session's rollout via the
+    // session->transcript link the `haya-pet state` reporter records from the
+    // hook payload's transcript_path, instead of guessing newest-by-mtime (which
+    // leaks a concurrent same-cwd session's activity/interrupts).
+    const sessionDir = resolveSessionDir(dependencies, env);
 
-          if (event.type === "tool_finished") {
-            activeToolCalls.delete(event.toolCallId);
-            if (activeToolCalls.size === 0) {
-              messageSender
-                .send({
-                  type: "state",
-                  sessionId,
-                  state: "thinking",
-                  confidence: 0.85,
-                  source: "client_log",
-                  updatedAt: now()
-                })
-                .catch(() => {});
-            }
-          }
+    const activeToolCalls = new Set();
+    const watcher = watchCodexTranscript({
+      homeDir: dependencies.homeDir,
+      sessionsRoot: dependencies.codexSessionsRoot,
+      cwd,
+      startedAt: now(),
+      sessionId,
+      sessionDir,
+      onToolEvent: (event) => {
+        hookDebugLog(env, now, {
+          source: "codex_transcript",
+          event: event.type,
+          toolCallId: event.toolCallId,
+          toolName: event.toolName,
+          state: event.state
+        });
+
+        // Esc-interrupt fires no Stop hook, so without this the pet stays stuck
+        // on "thinking"/"running" until the stale sweep.
+        if (event.type === "turn_aborted") {
+          activeToolCalls.clear();
+          messageSender
+            .send({
+              type: "state",
+              sessionId,
+              state: "interrupted",
+              summary: "interrupted",
+              confidence: 0.9,
+              source: "client_log",
+              updatedAt: now()
+            })
+            .catch(() => {});
+          return;
         }
-      });
-      const previousStopWatcher = stopWatcher;
-      stopWatcher = () => {
-        watcher.stop();
-        previousStopWatcher();
-      };
-
-      // With "Approve for me" (approvals_reviewer=auto_review, legacy alias
-      // guardian_subagent), Codex routes approval requests to a guardian
-      // subagent and never shows the human approval UI — yet the
-      // PermissionRequest hook still fires at request creation. The hook's
-      // reporter uses the resolved approvals reviewer config: auto-review
-      // reports reviewing immediately, while manual review reports waiting.
-      // The guardian's own rollout is the only observable record of the
-      // review, so tail it: a review turn starting proves the agent is
-      // reviewing; an "allow" verdict proves the action proceeds; a "deny"
-      // verdict goes back to the model, which keeps working. An unreadable
-      // verdict reports nothing — a pending cue is never cleared on a guess.
-      const guardianWatcher = watchCodexGuardianReviews({
-        homeDir: dependencies.homeDir,
-        sessionsRoot: dependencies.codexSessionsRoot,
-        cwd,
-        startedAt: now(),
-        sessionId,
-        sessionDir,
-        onReviewEvent: (event) => {
-          hookDebugLog(env, now, {
-            source: "codex_guardian",
-            event: event.type,
-            outcome: event.outcome
-          });
-
-          const report = resolveGuardianStateReport(event);
-          if (!report) {
-            return;
-          }
+
+        if (event.type === "tool_started") {
+          activeToolCalls.add(event.toolCallId);
           messageSender
             .send({
               type: "state",
               sessionId,
-              state: report.state,
-              summary: report.summary,
+              state: event.state,
+              summary: event.toolName,
               confidence: 0.85,
               source: "client_log",
               updatedAt: now()
             })
             .catch(() => {});
+          return;
         }
-      });
-      const stopWithoutGuardian = stopWatcher;
-      stopWatcher = () => {
-        guardianWatcher.stop();
-        stopWithoutGuardian();
-        removeSessionTranscriptLink({ sessionDir, sessionId });
-      };
-    }
+
+        if (event.type === "tool_finished") {
+          activeToolCalls.delete(event.toolCallId);
+          if (activeToolCalls.size === 0) {
+            messageSender
+              .send({
+                type: "state",
+                sessionId,
+                state: "thinking",
+                confidence: 0.85,
+                source: "client_log",
+                updatedAt: now()
+              })
+              .catch(() => {});
+          }
+        }
+      }
+    });
+    const previousStopWatcher = stopWatcher;
+    stopWatcher = () => {
+      watcher.stop();
+      previousStopWatcher();
+    };
+
+    // With "Approve for me" (approvals_reviewer=auto_review, legacy alias
+    // guardian_subagent), Codex routes approval requests to a guardian
+    // subagent and never shows the human approval UI — yet the
+    // PermissionRequest hook still fires at request creation. The hook's
+    // reporter uses the resolved approvals reviewer config: auto-review
+    // reports reviewing immediately, while manual review reports waiting.
+    // The guardian's own rollout is the only observable record of the
+    // review, so tail it: a review turn starting proves the agent is
+    // reviewing; an "allow" verdict proves the action proceeds; a "deny"
+    // verdict goes back to the model, which keeps working. An unreadable
+    // verdict reports nothing — a pending cue is never cleared on a guess.
+    const guardianWatcher = watchCodexGuardianReviews({
+      homeDir: dependencies.homeDir,
+      sessionsRoot: dependencies.codexSessionsRoot,
+      cwd,
+      startedAt: now(),
+      sessionId,
+      sessionDir,
+      onReviewEvent: (event) => {
+        hookDebugLog(env, now, {
+          source: "codex_guardian",
+          event: event.type,
+          outcome: event.outcome
+        });
+
+        const report = resolveGuardianStateReport(event);
+        if (!report) {
+          return;
+        }
+        messageSender
+          .send({
+            type: "state",
+            sessionId,
+            state: report.state,
+            summary: report.summary,
+            confidence: 0.85,
+            source: "client_log",
+            updatedAt: now()
+          })
+          .catch(() => {});
+      }
+    });
+    const stopWithoutGuardian = stopWatcher;
+    stopWatcher = () => {
+      guardianWatcher.stop();
+      stopWithoutGuardian();
+      removeSessionTranscriptLink({ sessionDir, sessionId });
+    };
   }
 
   try {
@@ -629,13 +660,6 @@ function isTruthyFlag(value) {
   return value === "1" || value === "true";
 }
 
-// Detect a user-supplied Codex profile flag so we don't clobber it: -p, --profile,
-// or the `--profile=foo` / `-p=foo` forms.
-function hasProfileArg(args) {
-  return args.some(
-    (arg) => arg === "-p" || arg === "--profile" || arg.startsWith("--profile=") || arg.startsWith("-p=")
-  );
-}
 
 function createConfigStateFile(dependencies) {
   const paths = getDefaultPaths({
@@ -969,20 +993,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/apps/cli/test/haya-pet.test.mjs

@@ -537,7 +537,7 @@ test("hooks command parses and persists the toggle", async () => {
   assert.ok(lines.some((l) => l.includes("on")));
 });
 
-test("persisted `hooks on` injects a Codex profile via -p at the front of args", async () => {
+test("persisted `hooks on` installs Codex hooks without consuming the profile slot", async () => {
   const calls = [];
   let injected = 0;
   await runAiPet(["run", "--client", "codex", "--", "codex"], {
@@ -546,7 +546,7 @@ test("persisted `hooks on` injects a Codex profile via -p at the front of args",
     heartbeatIntervalMs: 10,
     send: async () => {},
     createStateFile: hooksStateFile(true),
-    injectCodexHooks: () => { injected += 1; return { profileName: "haya-pet", cleanup: () => {} }; },
+    injectCodexHooks: () => { injected += 1; return { hooksPath: "C:\\Users\\A\\.codex\\hooks.json", cleanup: () => {} }; },
     runGenericCommand: async (options) => {
       calls.push(options);
       return { sessionId: options.sessionId, pid: 1, exitCode: 0 };
@@ -554,7 +554,8 @@ test("persisted `hooks on` injects a Codex profile via -p at the front of args",
   });
 
   assert.equal(injected, 1, "config preference enables Codex hooks");
-  assert.deepEqual(calls[0].args, ["-p", "haya-pet"], "profile flag goes at the front");
+  assert.deepEqual(calls[0].args, [], "Codex args stay untouched");
+  assert.equal(calls[0].env.HAYA_PET_SESSION_ID, calls[0].sessionId);
   assert.equal(calls[0].env.HAYA_PET_CODEX_APPROVAL_REVIEWER, "user");
 });
 
@@ -577,6 +578,27 @@ test("codex hooks pass auto-review config to the PermissionRequest reporter", as
   assert.equal(calls[0].env.HAYA_PET_CODEX_APPROVAL_REVIEWER, "auto_review");
 });
 
+test("codex hooks read approvals reviewer from the selected profile config", async () => {
+  const calls = [];
+  await runAiPet(["run", "--client", "codex", "--", "codex", "--profile=fugu"], {
+    cwd: process.cwd(),
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    send: async () => {},
+    createStateFile: hooksStateFile(true),
+    injectCodexHooks: () => ({ hooksPath: "C:\\Users\\A\\.codex\\hooks.json", cleanup: () => {} }),
+    readFile: (path) => String(path).endsWith("fugu.config.toml")
+      ? 'approvals_reviewer = "auto_review"\n'
+      : 'approvals_reviewer = "user"\n',
+    runGenericCommand: async (options) => {
+      calls.push(options);
+      return { sessionId: options.sessionId, pid: 1, exitCode: 0 };
+    }
+  });
+
+  assert.deepEqual(calls[0].args, ["--profile=fugu"], "profile arg is untouched");
+  assert.equal(calls[0].env.HAYA_PET_CODEX_APPROVAL_REVIEWER, "auto_review");
+});
 test("codex hooks also start a transcript watcher for tool activity", async () => {
   const sent = [];
   let fireToolEvent;
@@ -658,9 +680,10 @@ test("codex hooks also start a guardian-review watcher that reports review state
   ]);
 });
 
-test("codex hooks are skipped (with a notice) when the user passes their own -p", async () => {
+test("codex hooks preserve user profile args and still wire live status", async () => {
   const calls = [];
   let injected = 0;
+  let watched = 0;
   const lines = [];
   await runAiPet(["run", "--client", "codex", "--", "codex", "-p", "mine"], {
     cwd: process.cwd(),
@@ -669,16 +692,19 @@ test("codex hooks are skipped (with a notice) when the user passes their own -p"
     send: async () => {},
     createStateFile: hooksStateFile(true),
     print: (line) => lines.push(line),
-    injectCodexHooks: () => { injected += 1; return { profileName: "haya-pet", cleanup: () => {} }; },
+    injectCodexHooks: () => { injected += 1; return { hooksPath: "C:\\Users\\A\\.codex\\hooks.json", cleanup: () => {} }; },
+    watchCodexTranscript: () => { watched += 1; return { stop: () => {} }; },
     runGenericCommand: async (options) => {
       calls.push(options);
       return { sessionId: options.sessionId, pid: 1, exitCode: 0 };
     }
   });
 
-  assert.equal(injected, 0, "user's profile is respected — no injection");
+  assert.equal(injected, 1, "hooks are installed even when Codex gets a user profile");
+  assert.equal(watched, 1, "transcript watcher still starts for profiled runs");
   assert.deepEqual(calls[0].args, ["-p", "mine"], "user args untouched");
-  assert.ok(lines.some((l) => /skipped/i.test(l)), "user is told why");
+  assert.equal(calls[0].env.HAYA_PET_SESSION_ID, calls[0].sessionId);
+  assert.ok(!lines.some((l) => /skipped/i.test(l)), "profile runs no longer skip hooks");
 });
 
 test("codex does NOT inject hooks by default (safe out-of-box)", async () => {

package/docs/architecture.md

@@ -63,11 +63,10 @@ in-session activity through the shared, client-agnostic `haya-pet state` command
 
 The injection mechanism differs per client. **Claude Code** takes a stable
 `claude --settings <file>`. **Codex** has no per-invocation settings flag, so the
-wrapper writes a stable `$CODEX_HOME/haya-pet.config.toml` profile and prepends
-`-p haya-pet` to the codex args (a profile layers on top of the user's base config,
-leaving auth/model/MCP intact, and is inert otherwise). Codex allows only one
-profile, so if the user already passes `-p/--profile`, injection is skipped with a
-notice. Codex's hook command must be unquoted at the program position (it runs via
+wrapper merges stable user-level hooks into `$CODEX_HOME/hooks.json`. Codex loads
+that hook source alongside any selected `-p/--profile`, so custom profiles remain
+untouched while HAYA Pet still sets the per-session environment and watchers.
+Codex's hook command must be unquoted at the program position (it runs via
 `cmd /c`, which strips a leading quote) and its matchers can't use look-around
 (Rust regex) — see [known-issues.md](known-issues.md). Codex's L4 is **partial**:
 `PreToolUse` doesn't fire upstream yet, so tool activity comes from an L3