@hayasaka7/haya-pet 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -0,0 +1,94 @@
+# Changelog
+
+All notable changes to Haya Pet are documented here. This project adheres to
+[Semantic Versioning](https://semver.org/).
+
+> Note: some entries originally drafted under 0.2.0 actually landed *after* the
+> 0.2.0 npm publish; they are listed under 0.2.1, which is the first version that
+> ships them.
+
+## [0.2.1]
+
+### Added
+- **Approval-accept detection** — when you **approve** a permission prompt for a
+  command, the pet now flips from *waiting for approval* to *working* a couple of
+  seconds after the command actually starts, instead of showing "waiting" for the
+  tool's whole run. Clients emit **no event at the accept moment** (verified for
+  Claude Code: no hook, no transcript record; `PostToolUse` only fires when the
+  tool *finishes*) — so for a long approved build/test the pet used to sit on
+  "waiting" for minutes. Detection is **event-based, never a timer**: while a
+  session waits, the companion watches the client's **process tree**, and only a
+  new process that verifiably starts under the client (and survives two
+  consecutive polls, filtering hook blips) counts as an approval. An unanswered
+  prompt spawns nothing, so the warning stays up until you actually decide.
+  In-process approvals (file edits) aren't detected but complete in milliseconds
+  after approval anyway. Windows verified live; macOS (`ps`) and Linux (`/proc`)
+  listers are included pending live hardware verification. Details in
+  `docs/known-issues.md`.
+- **`haya-pet hooks on` / `off` / `status`** — persists the live-status preference,
+  so you enable it once instead of setting an env var every shell. The toggle is
+  **global**: it covers every hook-capable client (Claude Code and Codex).
+  `HAYA_PET_HOOKS=1` (on) / `HAYA_PET_NO_HOOKS=1` (off) still work as per-run overrides.
+- **Codex live status via per-session hooks** (opt-in: `haya-pet hooks on`). haya-pet
+  injects a stable `~/.codex/haya-pet.config.toml` profile and launches
+  `codex -p haya-pet`, layering the hooks on top of your base config (auth/model/MCP
+  untouched). The hooks report through the same `haya-pet state` reporter, with full
+  terminal fidelity. First run shows Codex's one-time *review hooks* prompt; approve
+  it once. If you already pass your own `-p/--profile`, haya-pet skips injection and
+  says so (Codex allows only one profile). Hooks cover `thinking` (turn start /
+  after tools) and `idle` (turn end); a **Codex transcript watcher** fills in tool
+  activity (`running_tool` / `editing_files`) by tailing the session JSONL, since
+  Codex's `PreToolUse` hook doesn't fire upstream yet
+  ([openai/codex#16732](https://github.com/openai/codex/issues/16732)).
+  *Waiting for approval* stays unavailable for Codex until that lands.
+- **L3 transcript watcher (Claude Code)** — tails Claude's session JSONL to reliably
+  clear *waiting for approval* when a permission is **denied** (Claude fires no hook
+  on a manual denial). Ground-truth based, never a timer, so a genuinely-pending
+  approval keeps alerting until you actually decide.
+- **`PermissionRequest` hook** for a snappier *waiting for approval* cue (fires the
+  instant the dialog appears, ahead of the notification).
+
+### Fixed
+- Pet stuck on *waiting for approval* after a manual **denial** (see the Claude
+  transcript watcher above).
+- Pet stuck on *waiting for approval* after an **accept**, for as long as the
+  approved tool kept running (see approval-accept detection above).
+- `Notification` events other than permission prompts (e.g. `idle_prompt`) were
+  mislabeled as *waiting for approval*; they are now mapped correctly.
+
+## [0.2.0]
+
+### Changed
+- **`haya-pet run` now defaults to native passthrough** (`stdio: "inherit"`). The
+  wrapped CLI talks directly to your terminal, so **Shift+Tab**, mouse-wheel
+  scroll, and word-edit all work normally. PTY observation is now opt-in via
+  `--observe` (it routes input through ConPTY on Windows, which can mangle special
+  keys — use it only for non-interactive runs).
+
+### Added
+- **Claude Code live status via per-session hooks** (opt-in: `HAYA_PET_HOOKS=1` in
+  this release; 0.2.1 adds the persisted `haya-pet hooks on` toggle).
+  Injects a stable settings file through `claude --settings <file>` — no change to
+  your global config — wiring Claude's events to a new `haya-pet state` reporter so
+  the pet shows thinking / running tools / editing files / waiting for approval,
+  with full terminal fidelity (no PTY). First run shows Claude's one-time
+  *review hooks* prompt; approve it once.
+- **`haya-pet state <state>` command** — reporter used by client hooks to push live
+  status to the daemon over IPC.
+- **`HAYA_PET_HOOK_DEBUG=<file>`** — append one JSONL line per status event
+  (hook- and transcript-sourced) for diagnostics.
+
+### Fixed
+- Claude Code TUI accepted no keyboard input when hooks were injected — caused by a
+  volatile per-session argument and temp path that re-triggered Claude's hook-trust
+  review every launch. Hook commands and the settings path are now stable; the
+  session id is passed via the `HAYA_PET_SESSION_ID` env var.
+
+### Notes
+- In this release Codex and Antigravity had no hook adapter — native passthrough
+  with lifecycle status, or `--observe` for coarse PTY activity. 0.2.1 adds the
+  Codex adapter; Antigravity remains a planned follow-up.
+
+## [0.1.0]
+- Initial generic AI CLI pet runtime: overlay companion, session bubbles, daemon
+  IPC, client adapters, pet asset pipeline, cross-OS paths.

package/README.md

@@ -52,8 +52,8 @@ Haya Pet watches all of them and presents one ambient interface:
   (`thinking`, `running_tool`, `waiting_approval`, `reviewing`, `failed`, …).
 - 🧩 **Client adapters** with tiered support (process wrapper → PTY observer →
   client hooks) so the daemon never bakes in client-specific logic. Default is
-  lifecycle status; richer status is opt-in (Claude Code hooks via `HAYA_PET_HOOKS=1`,
-  or PTY `--observe` for any client).
+  lifecycle status; richer status is opt-in (Claude Code / Codex hooks via
+  `haya-pet hooks on`, or PTY `--observe` for any client).
 - 🚀 **Zero-setup launch** — `haya-pet run …` auto-starts the overlay; no separate
   daemon to manage.
 - 🖼️ **Codex-compatible pet assets** (1536×1872 sprite atlas, 9 actions).
@@ -94,8 +94,8 @@ Haya Pet watches all of them and presents one ambient interface:
 | **Node ≥ 18** | Runtime + companion (Electron) |
 | **npm** | Install + scripts |
 
-> Default status is lifecycle-only and needs no extra modules. Opt-in Claude Code
-> hooks (`HAYA_PET_HOOKS=1`) also need none. The opt-in `--observe` PTY mode uses
+> Default status is lifecycle-only and needs no extra modules. Opt-in Claude Code /
+> Codex hooks (`haya-pet hooks on`) also need none. The opt-in `--observe` PTY mode uses
 > `node-pty` (installed automatically when it can build; without it, `--observe`
 > degrades to lifecycle-only tracking).
 
@@ -157,11 +157,12 @@ Two **opt-in** ways to get richer *in-session* status (thinking / running tools
 editing files / waiting for approval):
 
 ```bash
-# Claude Code — live status via per-session hooks, NO terminal-fidelity tradeoff.
-# Enable once (persisted); the first run shows a one-time Claude "review hooks"
-# prompt you approve once.
+# Claude Code AND Codex — live status via per-session hooks, NO terminal-fidelity
+# tradeoff. Enable once (persisted, global); the first run for each client shows a
+# one-time "review hooks" prompt you approve once.
 haya-pet hooks on
 haya-pet run --client claude-code -- claude
+haya-pet run --client codex       -- codex
 #   (per-run override without persisting: HAYA_PET_HOOKS=1 …, or $env:HAYA_PET_HOOKS=1 in PowerShell)
 #   (turn back off: haya-pet hooks off   ·   check: haya-pet hooks status)
 
@@ -169,10 +170,25 @@ haya-pet run --client claude-code -- claude
 haya-pet run --observe --client codex -- codex
 ```
 
+> **Codex coverage.** Codex shows `thinking` (working) and `idle` (done) via hooks,
+> plus `running_tool` / `editing_files` via a session-transcript watcher.
+> *Waiting for approval* doesn't arrive yet because of an upstream gap where
+> Codex's `PermissionRequest` hook doesn't fire
+> ([openai/codex#16732](https://github.com/openai/codex/issues/16732)); it'll start
+> working automatically once Codex fixes it. Also: if you pass your own
+> `-p/--profile` to codex, haya-pet skips hook injection (Codex allows one
+> profile) and tells you. Claude Code has full coverage.
+
+> **Approval prompts resolve correctly** (Claude Code): deny → the pet returns to
+> idle the moment the denial lands in the session transcript; accept a command →
+> the pet flips to *working* a couple of seconds after the approved command
+> actually starts running (detected from the client's process tree — a real
+> event, never a timeout, so an unanswered prompt keeps warning until you decide).
+
 > **Why opt-in?**
-> - **Hooks (Claude Code):** injecting hooks makes Claude show a one-time
->   *review hooks* trust prompt. We don't disrupt your session by default; turn it
->   on once with `haya-pet hooks on` when you're happy to approve the hooks.
+> - **Hooks (Claude Code / Codex):** injecting hooks makes the client show a
+>   one-time *review hooks* trust prompt. We don't disrupt your session by default;
+>   turn it on once with `haya-pet hooks on` when you're happy to approve the hooks.
 > - **`--observe` (any client):** PTY observation infers status from output, but on
 >   Windows it routes input through ConPTY, which can break **Shift+Tab**, mouse
 >   scroll, and word-edit. Use it only for non-interactive runs. See
@@ -246,8 +262,8 @@ Full list (incl. repairing a broken Electron install): [docs/troubleshooting.md]
 | Client | Status | Support level |
 |---|---|---|
 | Generic CLI | ✅ | L1 process wrapper (+ L2 PTY via `--observe`) |
-| Codex | ✅ | L1 wrapper (+ L2 PTY via `--observe`) |
-| Claude Code | ✅ | L1 wrapper + **L4 live-status hooks** (opt-in `HAYA_PET_HOOKS=1`) |
+| Codex | ✅ | L1 wrapper + **L4 live-status hooks** (opt-in `haya-pet hooks on`; partial — see note) |
+| Claude Code | ✅ | L1 wrapper + **L4 live-status hooks** (opt-in `haya-pet hooks on`) |
 | Antigravity | ✅ | L1 wrapper (+ L2 PTY via `--observe`) |
 | Gemini CLI / Aider / others | 🔜 | via the generic adapter |
 

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

@@ -6,13 +6,15 @@ import { fileURLToPath } from "node:url";
 import { runGenericCommand as defaultRunGenericCommand } from "../../../packages/cli-core/src/run-command.js";
 import { parseStateArgs, runStateCommand } from "../../../packages/cli-core/src/run-state.js";
 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";
 import { watchClaudeTranscript as defaultWatchClaudeTranscript } from "../../../packages/cli-core/src/claude-transcript-watcher.js";
+import { watchCodexTranscript as defaultWatchCodexTranscript } from "../../../packages/cli-core/src/codex-transcript-watcher.js";
 import { ensureCompanionConnection } from "../../../packages/cli-core/src/companion-launcher.js";
 import { createIpcClient as defaultCreateIpcClient } from "../../../packages/daemon-core/src/ipc-server.js";
 import { getDefaultPaths } from "../../../packages/platform-core/src/paths.js";
 import { discoverPets as defaultDiscoverPets } from "../../../packages/pet-core/src/discovery.js";
 import { createStateFile as defaultCreateStateFile } from "../../../packages/app-state/src/state-file.js";
-import { getSelectedPetId, setSelectedPet, getClaudeHooksEnabled, setClaudeHooksEnabled } from "../../../packages/app-state/src/state.js";
+import { getSelectedPetId, setSelectedPet, getHooksEnabled, setHooksEnabled } from "../../../packages/app-state/src/state.js";
 import { getAdapterInfo } from "../../../packages/adapters/src/adapter-info.js";
 
 const CLIENT_DISPLAY_NAMES = Object.freeze({
@@ -123,7 +125,10 @@ export async function runStartCommand(_parsed, dependencies = {}) {
 async function runRunCommand(parsed, dependencies) {
   const runGenericCommand = dependencies.runGenericCommand ?? defaultRunGenericCommand;
   const injectClaudeHooks = dependencies.injectClaudeHooks ?? defaultInjectClaudeHooks;
+  const injectCodexHooks = dependencies.injectCodexHooks ?? defaultInjectCodexHooks;
   const watchClaudeTranscript = dependencies.watchClaudeTranscript ?? defaultWatchClaudeTranscript;
+  const watchCodexTranscript = dependencies.watchCodexTranscript ?? defaultWatchCodexTranscript;
+  const print = dependencies.print ?? defaultPrint;
   const env = dependencies.env ?? process.env;
   const now = dependencies.now ?? Date.now;
   const cwd = dependencies.cwd ?? process.cwd();
@@ -135,14 +140,16 @@ async function runRunCommand(parsed, dependencies) {
   let cleanup = () => {};
   let stopWatcher = () => {};
 
-  // Claude Code: native passthrough is always the default (full terminal fidelity).
-  // Live-status hooks are OPT-IN — persisted via `haya-pet hooks on`, or per-run via
-  // HAYA_PET_HOOKS=1 — because injecting hooks makes Claude show a one-time "review
-  // hooks" trust prompt; we never disrupt the user's session uninvited. When enabled,
-  // inject a stable settings file so Claude reports live status via `haya-pet state`
-  // (no PTY, so Shift+Tab works).
-  const claudeHooksOn =
-    parsed.clientId === "claude-code" && (await resolveClaudeHooksEnabled(env, dependencies));
+  // Native passthrough is always the default (full terminal fidelity). Live-status
+  // hooks are OPT-IN — persisted via `haya-pet hooks on`, or per-run via
+  // HAYA_PET_HOOKS=1 — because injecting hooks makes the client show a one-time
+  // "review hooks" trust prompt; we never disrupt the user's session uninvited.
+  // Both clients report live status via the `haya-pet state` reporter (no PTY, so
+  // Shift+Tab works); the session id rides in via HAYA_PET_SESSION_ID.
+  const hooksOn = await resolveHooksEnabled(env, dependencies);
+
+  // Claude Code: inject a stable `--settings` file.
+  const claudeHooksOn = hooksOn && parsed.clientId === "claude-code";
   if (claudeHooksOn) {
     const injected = injectClaudeHooks();
     childArgs = [...parsed.childArgs, "--settings", injected.settingsPath];
@@ -175,6 +182,78 @@ async function runRunCommand(parsed, dependencies) {
     stopWatcher = watcher.stop;
   }
 
+  // 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
+  // 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 };
+      cleanup = injected.cleanup;
+
+      const activeToolCalls = new Set();
+      const watcher = watchCodexTranscript({
+        homeDir: dependencies.homeDir,
+        sessionsRoot: dependencies.codexSessionsRoot,
+        startedAt: now(),
+        onToolEvent: (event) => {
+          hookDebugLog(env, now, {
+            source: "codex_transcript",
+            event: event.type,
+            toolCallId: event.toolCallId,
+            toolName: event.toolName,
+            state: event.state
+          });
+
+          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;
+          }
+
+          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();
+      };
+    }
+  }
+
   try {
     return await runGenericCommand({
       command: parsed.childCommand,
@@ -197,10 +276,11 @@ async function runRunCommand(parsed, dependencies) {
   }
 }
 
-// Resolve whether Claude Code hooks should be injected for this run.
-// Precedence: HAYA_PET_NO_HOOKS forces off, HAYA_PET_HOOKS forces on (per-run
-// overrides), otherwise the persisted `haya-pet hooks on/off` preference.
-async function resolveClaudeHooksEnabled(env, dependencies) {
+// Resolve whether live-status hooks should be injected for this run (any
+// hook-capable client). Precedence: HAYA_PET_NO_HOOKS forces off, HAYA_PET_HOOKS
+// forces on (per-run overrides), otherwise the persisted `haya-pet hooks on/off`
+// preference.
+async function resolveHooksEnabled(env, dependencies) {
   if (isTruthyFlag(env.HAYA_PET_NO_HOOKS)) {
     return false;
   }
@@ -209,7 +289,7 @@ async function resolveClaudeHooksEnabled(env, dependencies) {
   }
   try {
     const state = await createConfigStateFile(dependencies).load();
-    return getClaudeHooksEnabled(state);
+    return getHooksEnabled(state);
   } catch {
     return false;
   }
@@ -219,6 +299,14 @@ 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({
     platform: dependencies.platform,
@@ -310,25 +398,26 @@ function parseHooksArgs(args) {
   throw new Error(`Unknown hooks action: ${action} (use on, off, or status)`);
 }
 
-// Persisted toggle for Claude Code live-status hooks (the convenient alternative
-// to setting HAYA_PET_HOOKS every shell).
+// Persisted GLOBAL toggle for live-status hooks (the convenient alternative to
+// setting HAYA_PET_HOOKS every shell). Covers every hook-capable client — Claude
+// Code and Codex today.
 export async function runHooksCommand(parsed, dependencies = {}) {
   const print = dependencies.print ?? defaultPrint;
   const stateFile = createConfigStateFile(dependencies);
   const state = await stateFile.load();
 
   if (parsed.action === "status") {
-    const enabled = getClaudeHooksEnabled(state);
-    print(`Claude Code live-status hooks: ${enabled ? "on" : "off"}`);
+    const enabled = getHooksEnabled(state);
+    print(`Live-status hooks: ${enabled ? "on" : "off"}`);
     return { command: "hooks", action: "status", enabled };
   }
 
   const enabled = parsed.action === "on";
-  await stateFile.save(setClaudeHooksEnabled(state, enabled));
+  await stateFile.save(setHooksEnabled(state, enabled));
   print(
     enabled
-      ? "Claude Code live-status hooks: on. The first `haya-pet run --client claude-code` asks Claude to review the hooks once — approve it."
-      : "Claude Code live-status hooks: off."
+      ? "Live-status hooks: on. The first `haya-pet run` for Claude Code or Codex asks the client to review the hooks once — approve it."
+      : "Live-status hooks: off."
   );
   return { command: "hooks", action: parsed.action, enabled };
 }

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

@@ -335,8 +335,8 @@ test("parses the state command", () => {
   });
 });
 
-const hooksStateFile = (claudeHooks) => () => ({
-  load: async () => ({ settings: { claudeHooks } }),
+const hooksStateFile = (hooksEnabled) => () => ({
+  load: async () => ({ settings: { hooksEnabled } }),
   save: async (state) => state
 });
 
@@ -409,7 +409,7 @@ test("hooks command parses and persists the toggle", async () => {
   let saved;
   const lines = [];
   const store = {
-    load: async () => ({ settings: { claudeHooks: false } }),
+    load: async () => ({ settings: { hooksEnabled: false } }),
     save: async (state) => { saved = state; return state; }
   };
   const result = await runAiPet(["hooks", "on"], {
@@ -419,10 +419,113 @@ test("hooks command parses and persists the toggle", async () => {
   });
 
   assert.equal(result.enabled, true);
-  assert.equal(saved.settings.claudeHooks, true);
+  assert.equal(saved.settings.hooksEnabled, true);
   assert.ok(lines.some((l) => l.includes("on")));
 });
 
+test("persisted `hooks on` injects a Codex profile via -p at the front of args", async () => {
+  const calls = [];
+  let injected = 0;
+  await runAiPet(["run", "--client", "codex", "--", "codex"], {
+    cwd: process.cwd(),
+    env: { USERPROFILE: "C:\\Users\\A" }, // no HAYA_PET_HOOKS
+    heartbeatIntervalMs: 10,
+    send: async () => {},
+    createStateFile: hooksStateFile(true),
+    injectCodexHooks: () => { injected += 1; return { profileName: "haya-pet", cleanup: () => {} }; },
+    runGenericCommand: async (options) => {
+      calls.push(options);
+      return { sessionId: options.sessionId, pid: 1, exitCode: 0 };
+    }
+  });
+
+  assert.equal(injected, 1, "config preference enables Codex hooks");
+  assert.deepEqual(calls[0].args, ["-p", "haya-pet"], "profile flag goes at the front");
+});
+
+test("codex hooks also start a transcript watcher for tool activity", async () => {
+  const sent = [];
+  let fireToolEvent;
+  let stopped = false;
+
+  await runAiPet(["run", "--client", "codex", "--", "codex"], {
+    cwd: process.cwd(),
+    env: { USERPROFILE: "C:\\Users\\A" },
+    now: () => 42,
+    heartbeatIntervalMs: 10,
+    send: async (message) => sent.push(message),
+    createStateFile: hooksStateFile(true),
+    injectCodexHooks: () => ({ profileName: "haya-pet", cleanup: () => {} }),
+    watchCodexTranscript: ({ onToolEvent }) => {
+      fireToolEvent = onToolEvent;
+      return { stop: () => { stopped = true; } };
+    },
+    runGenericCommand: async (options) => {
+      fireToolEvent({
+        type: "tool_started",
+        toolCallId: "call_shell",
+        toolName: "shell_command",
+        state: "running_tool"
+      });
+      fireToolEvent({
+        type: "tool_finished",
+        toolCallId: "call_shell"
+      });
+      return { sessionId: options.sessionId, pid: 1, exitCode: 0 };
+    }
+  });
+
+  assert.ok(stopped, "transcript watcher is stopped after the wrapped command exits");
+  assert.deepEqual(
+    sent.filter((message) => message.type === "state" && message.source === "client_log").map((message) => message.state),
+    ["running_tool", "thinking"]
+  );
+  assert.ok(sent.every((message) => message.updatedAt === undefined || message.updatedAt === 42));
+});
+
+test("codex hooks are skipped (with a notice) when the user passes their own -p", async () => {
+  const calls = [];
+  let injected = 0;
+  const lines = [];
+  await runAiPet(["run", "--client", "codex", "--", "codex", "-p", "mine"], {
+    cwd: process.cwd(),
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    send: async () => {},
+    createStateFile: hooksStateFile(true),
+    print: (line) => lines.push(line),
+    injectCodexHooks: () => { injected += 1; return { profileName: "haya-pet", cleanup: () => {} }; },
+    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.deepEqual(calls[0].args, ["-p", "mine"], "user args untouched");
+  assert.ok(lines.some((l) => /skipped/i.test(l)), "user is told why");
+});
+
+test("codex does NOT inject hooks by default (safe out-of-box)", async () => {
+  const calls = [];
+  let injected = 0;
+  await runAiPet(["run", "--client", "codex", "--", "codex"], {
+    cwd: process.cwd(),
+    env: { USERPROFILE: "C:\\Users\\A" },
+    heartbeatIntervalMs: 10,
+    send: async () => {},
+    createStateFile: hooksStateFile(false),
+    injectCodexHooks: () => { injected += 1; return { profileName: "haya-pet", cleanup: () => {} }; },
+    runGenericCommand: async (options) => {
+      calls.push(options);
+      return { sessionId: "s", pid: 1, exitCode: 0 };
+    }
+  });
+
+  assert.equal(injected, 0, "no hook injection unless opted in");
+  assert.deepEqual(calls[0].args, []);
+});
+
 test("HAYA_PET_HOOKS=1 opts claude-code into --settings + HAYA_PET_SESSION_ID", async () => {
   const calls = [];
   let watched = 0;
@@ -471,14 +574,15 @@ test("a transcript denial clears the stuck approval to idle", async () => {
   assert.equal(idle.updatedAt, 42);
 });
 
-test("non-claude clients are never injected even with HAYA_PET_HOOKS=1", async () => {
+test("non-hook-capable clients are never injected even with HAYA_PET_HOOKS=1", async () => {
   const calls = [];
-  await runAiPet(["run", "--client", "codex", "--", "codex"], {
+  await runAiPet(["run", "--client", "generic", "--", "aider"], {
     cwd: process.cwd(),
     env: { HAYA_PET_HOOKS: "1", USERPROFILE: "C:\\Users\\A" },
     heartbeatIntervalMs: 10,
     send: async () => {},
-    injectClaudeHooks: () => { throw new Error("should not inject for codex"); },
+    injectClaudeHooks: () => { throw new Error("should not inject for generic"); },
+    injectCodexHooks: () => { throw new Error("should not inject for generic"); },
     runGenericCommand: async (options) => {
       calls.push(options);
       return { sessionId: "s", pid: 1, exitCode: 0 };

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

@@ -3,6 +3,11 @@ import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 import { createDaemonRuntime } from "../../../../packages/daemon-core/src/daemon-runtime.js";
 import { createIpcServer } from "../../../../packages/daemon-core/src/ipc-server.js";
+import {
+  createApprovalWatchCoordinator,
+  watchForApprovedProcess
+} from "../../../../packages/daemon-core/src/approval-process-watcher.js";
+import { createProcessSnapshotLister } from "../../../../packages/platform-core/src/process-snapshot.js";
 import { getDefaultPaths } from "../../../../packages/platform-core/src/paths.js";
 import { getPlatformCapabilities } from "../../../../packages/platform-core/src/capabilities.js";
 import { buildBubbleViews } from "../../../../packages/session-core/src/bubble-view.js";
@@ -38,6 +43,7 @@ let runtime;
 let currentWorkArea;
 let currentDisplayId;
 let petLocal = { x: 0, y: 0 };
+let approvalWatch;
 
 // Electron singleton: a second launch forwards to the running instance.
 if (!app.requestSingleInstanceLock()) {
@@ -54,8 +60,40 @@ async function bootstrap() {
   positionState = await stateFile.load();
   pets = await discoverPets(paths.petSearchPaths);
 
+  // Clients fire no event at the moment the user ACCEPTS a permission prompt
+  // (only denial/finish are observable), so a waiting_approval session would
+  // otherwise look stuck until its tool completed. The approval watcher flips
+  // it to running_tool when the approved command verifiably starts — a new
+  // persistent process under the client — and never on a timer, so a genuinely
+  // unanswered prompt keeps warning. Unsupported platforms simply skip this.
+  const processLister = createProcessSnapshotLister();
+  approvalWatch = processLister
+    ? createApprovalWatchCoordinator({
+        createWatcher: ({ rootPid, onApproved }) =>
+          watchForApprovedProcess({ rootPid, listProcesses: processLister, onApproved }),
+        onApproved: (sessionId) => {
+          try {
+            runtime.handleMessage({
+              type: "state",
+              sessionId,
+              state: "running_tool",
+              summary: "approved",
+              confidence: 0.6,
+              source: "client_log",
+              updatedAt: Date.now()
+            });
+          } catch {
+            // The session may have unregistered between detection and report.
+          }
+        }
+      })
+    : undefined;
+
   runtime = createDaemonRuntime({
-    onSessionChanged: () => pushSessions()
+    onSessionChanged: (session) => {
+      approvalWatch?.onSessionChanged(session);
+      pushSessions();
+    }
   });
 
   ipcServer = await createIpcServer({
@@ -85,6 +123,7 @@ async function bootstrap() {
 
   app.on("before-quit", async () => {
     clearInterval(sweep);
+    approvalWatch?.stopAll();
     await ipcServer?.close();
   });
 }

package/apps/companion/test/position-store.test.mjs

@@ -18,7 +18,7 @@ test("creates default position state", () => {
     settings: {
       displayMode: "hybrid",
       attachBubblesToTerminals: true,
-      claudeHooks: false
+      hooksEnabled: false
     }
   });
 });