@hayasaka7/haya-pet 0.1.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

@@ -51,7 +51,9 @@ Haya Pet watches all of them and presents one ambient interface:
 - 🧠 **Normalized state model** — every client maps to a shared state vocabulary
   (`thinking`, `running_tool`, `waiting_approval`, `reviewing`, `failed`, …).
 - 🧩 **Client adapters** with tiered support (process wrapper → PTY observer →
-  log/state → official plugin) so the daemon never bakes in client-specific logic.
+  client hooks) so the daemon never bakes in client-specific logic. Default is
+  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).
@@ -92,8 +94,10 @@ Haya Pet watches all of them and presents one ambient interface:
 | **Node ≥ 18** | Runtime + companion (Electron) |
 | **npm** | Install + scripts |
 
-> Live activity status uses the optional `node-pty` (installed automatically when
-> it can build; the pet degrades to lifecycle-only tracking without it).
+> 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).
 
 ## Install
 
@@ -138,19 +142,57 @@ shows success (a green check) or failure (a red cross), then fades.
 
 ### Live activity status
 
-By default the wrapper runs the CLI through a pseudo-terminal and shows *working*
-while the AI produces output, returning to *idle* after a short quiet window.
-Success/failure come from the real exit code — never from scraping the word
-"error" out of output. Your terminal stays fully interactive.
+`haya-pet run` uses **native passthrough by default** — the CLI talks directly to
+your terminal, so every input mode (Shift+Tab, mouse wheel, word-edit) works
+exactly as it does without the wrapper. Out of the box, every client shows
+**lifecycle status** (a session bubble while it runs; success/failure from the
+real exit code, never from scraping "error" out of output).
 
 ```bash
-haya-pet run -- claude          # live status (default)
-haya-pet run --no-observe -- claude   # lifecycle only (opt out of PTY observation)
+haya-pet run --client claude-code -- claude   # full fidelity, lifecycle status
+haya-pet run --client codex       -- codex    # full fidelity, lifecycle status
 ```
 
-> ⚠️ Running a CLI through the default PTY observation currently affects terminal
-> scrolling and backspace in some setups — see
-> [docs/known-issues.md](docs/known-issues.md). `--no-observe` avoids it.
+Two **opt-in** ways to get richer *in-session* status (thinking / running tools /
+editing files / waiting for approval):
+
+```bash
+# 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)
+
+# Any client — coarse live status by watching output through a PTY.
+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 / 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
+>   [docs/known-issues.md](docs/known-issues.md).
 
 ## Add and choose a pet
 
@@ -219,14 +261,14 @@ Full list (incl. repairing a broken Electron install): [docs/troubleshooting.md]
 
 | Client | Status | Support level |
 |---|---|---|
-| Generic CLI | ✅ | L1 process wrapper |
-| Codex | ✅ | L1 + L2 PTY observation |
-| Claude Code | ✅ | L1 + L2 PTY observation |
-| Antigravity | ✅ | L1 wrapper |
+| Generic CLI | ✅ | L1 process wrapper (+ L2 PTY via `--observe`) |
+| 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 |
 
 (See [docs/architecture.md](docs/architecture.md) for the support tiers and the
-platform matrix.)
+platform matrix, and [CHANGELOG.md](CHANGELOG.md) for release notes.)
 
 ## Privacy
 

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

@@ -1,14 +1,20 @@
 #!/usr/bin/env node
-import { realpathSync } from "node:fs";
+import { realpathSync, appendFileSync } from "node:fs";
 import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
 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 } 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({
@@ -41,6 +47,14 @@ export function parseAiPetArgs(argv) {
     return { command: "stop" };
   }
 
+  if (command === "state") {
+    return parseStateArgs(rest);
+  }
+
+  if (command === "hooks") {
+    return parseHooksArgs(rest);
+  }
+
   throw new Error(`Unsupported haya-pet command: ${command}`);
 }
 
@@ -59,6 +73,14 @@ export async function runAiPet(argv, dependencies = {}) {
     return runStopCommand(parsed, dependencies);
   }
 
+  if (parsed.command === "state") {
+    return runStateCommand(parsed, dependencies);
+  }
+
+  if (parsed.command === "hooks") {
+    return runHooksCommand(parsed, dependencies);
+  }
+
   return runRunCommand(parsed, dependencies);
 }
 
@@ -102,26 +124,213 @@ 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();
   const messageSender = await createMessageSender(dependencies);
 
+  const sessionId = dependencies.sessionId ?? `sess_${randomUUID()}`;
+  let childArgs = parsed.childArgs;
+  let childEnv = env;
+  let cleanup = () => {};
+  let stopWatcher = () => {};
+
+  // 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];
+    childEnv = { ...env, HAYA_PET_SESSION_ID: sessionId };
+    cleanup = injected.cleanup;
+
+    // Claude fires NO hook when the user manually denies a permission, so the
+    // pet would stay stuck on "waiting for approval". Tail the session transcript
+    // (ground truth) and clear to idle the moment a denial is recorded — never on
+    // a timer, so a genuinely-pending approval keeps alerting until it's resolved.
+    const watcher = watchClaudeTranscript({
+      cwd,
+      homeDir: dependencies.homeDir,
+      startedAt: now(),
+      onDenial: (event) => {
+        hookDebugLog(env, now, { source: "transcript", event: "denied", state: "idle", toolUseId: event?.toolUseId });
+        messageSender
+          .send({
+            type: "state",
+            sessionId,
+            state: "idle",
+            summary: "approval denied",
+            confidence: 0.9,
+            source: "client_log",
+            updatedAt: now()
+          })
+          .catch(() => {});
+      }
+    });
+    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,
-      args: parsed.childArgs,
-      cwd: dependencies.cwd ?? process.cwd(),
+      args: childArgs,
+      cwd,
       clientId: parsed.clientId,
       clientDisplayName: CLIENT_DISPLAY_NAMES[parsed.clientId] ?? parsed.clientId,
       observe: parsed.observe,
+      sessionId,
+      env: childEnv,
       heartbeatIntervalMs: dependencies.heartbeatIntervalMs,
       now: dependencies.now,
       stdio: dependencies.stdio,
       send: messageSender.send
     });
   } finally {
+    stopWatcher();
+    cleanup();
     await messageSender.close();
   }
 }
 
+// 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;
+  }
+  if (isTruthyFlag(env.HAYA_PET_HOOKS)) {
+    return true;
+  }
+  try {
+    const state = await createConfigStateFile(dependencies).load();
+    return getHooksEnabled(state);
+  } catch {
+    return false;
+  }
+}
+
+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,
+    env: dependencies.env,
+    homeDir: dependencies.homeDir
+  });
+  const createStateFile = dependencies.createStateFile ?? defaultCreateStateFile;
+  return createStateFile({ statePath: paths.statePath });
+}
+
+// Best-effort: mirror the reporter's HAYA_PET_HOOK_DEBUG log so transcript-driven
+// events (which don't go through `haya-pet state`) show up in the same trace.
+function hookDebugLog(env, now, entry) {
+  const target = env.HAYA_PET_HOOK_DEBUG;
+  if (!target) {
+    return;
+  }
+  try {
+    appendFileSync(target, `${JSON.stringify({ ts: now(), ...entry })}\n`);
+  } catch {
+    // diagnostics must never break the run
+  }
+}
+
 export async function runPetsCommand(parsed, dependencies = {}) {
   const paths = getDefaultPaths({
     platform: dependencies.platform,
@@ -181,6 +390,38 @@ export async function main(argv = process.argv.slice(2), dependencies = {}) {
   return result;
 }
 
+function parseHooksArgs(args) {
+  const [action = "status"] = args;
+  if (action === "on" || action === "off" || action === "status") {
+    return { command: "hooks", action };
+  }
+  throw new Error(`Unknown hooks action: ${action} (use on, off, or status)`);
+}
+
+// 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 = getHooksEnabled(state);
+    print(`Live-status hooks: ${enabled ? "on" : "off"}`);
+    return { command: "hooks", action: "status", enabled };
+  }
+
+  const enabled = parsed.action === "on";
+  await stateFile.save(setHooksEnabled(state, enabled));
+  print(
+    enabled
+      ? "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 };
+}
+
 function parsePetsArgs(args) {
   if (args.length === 0) {
     return { command: "pets", action: "list" };
@@ -205,7 +446,7 @@ function parsePetsArgs(args) {
 
 function parseRunArgs(args) {
   let clientId = "generic";
-  let observe = true; // live PTY observation is on by default; --no-observe opts out
+  let observe = false; // native passthrough by default (full terminal fidelity); --observe opts in
   let childStart = -1;
 
   for (let index = 0; index < args.length; index += 1) {