@hayasaka7/haya-pet 0.3.4 → 0.3.5

package/CHANGELOG.md

@@ -7,6 +7,34 @@ 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.5]
+
+### Fixed
+- **The pet no longer gets stuck on "compacting" in Claude Code.** `PreCompact`
+  set the status to *compacting*, but nothing ever cleared it — Claude's `Stop`
+  does not fire for a `/compact`, so the pet sat on *compacting* until the next
+  prompt or the 30 s stale sweep. The Claude hook table now also subscribes
+  **`PostCompact`**, split by the documented `manual`/`auto` trigger matcher: a
+  **manual** `/compact` returns to *idle* (control is back at the prompt), while
+  an **auto** compaction (context filled mid-turn) resumes to *thinking* and the
+  next real event refines from there. Mirrors Codex, which already handled
+  `PostCompact`.
+
+### Added
+- **`HAYA_PET_DAEMON_DEBUG` diagnostic.** When set to a file path, the companion
+  appends one JSONL line per incoming non-heartbeat message in daemon **arrival
+  order** (with `updatedAt`), making out-of-order state delivery observable. Added
+  to investigate the Codex interrupt issue below.
+
+### Known issues
+- **Codex interrupt can still leave the pet "working".** On some interrupts the
+  pet keeps a working state instead of *interrupted*. The transcript watcher does
+  record `turn_aborted` (the "a late tool result resets it" theory was ruled out
+  across 257 real aborts), so the suspect is the daemon applying state by IPC
+  **arrival order**, letting a stale "working" message land after *interrupted*.
+  Instrumented via `HAYA_PET_DAEMON_DEBUG`; **fix to follow shortly.** See
+  `docs/known-issues.md`.
+
 ## [0.3.4]
 
 ### Fixed

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

@@ -1,6 +1,6 @@
 import { app, BrowserWindow, ipcMain, Menu, nativeImage, screen, shell, Tray } from "electron";
 import { fileURLToPath } from "node:url";
-import { readFileSync } from "node:fs";
+import { appendFileSync, readFileSync } from "node:fs";
 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";
@@ -30,6 +30,35 @@ const __dirname = dirname(fileURLToPath(import.meta.url));
 const TRAY_ICON_DATA_URL =
   "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAANElEQVR4nGNgoAXIW/HvPzZMtkaiDCJWM05DKDKAVM0YhowaQAUDBj4dUCUpE2MQQY3kAACyf/g8DHVl5wAAAABJRU5ErkJggg==";
 
+// Best-effort daemon-side diagnostic, mirroring the wrapper's HAYA_PET_HOOK_DEBUG.
+// When HAYA_PET_DAEMON_DEBUG points at a file, append one JSONL line per incoming
+// non-heartbeat message in DAEMON ARRIVAL ORDER, with its updatedAt. This is the
+// only place the true apply order is visible: the registry is last-writer-wins by
+// arrival and ignores updatedAt, so a stale "working" message that arrives after
+// "interrupted" would surface here as the clobber. Never throws.
+function debugLogDaemonMessage(message) {
+  const target = process.env.HAYA_PET_DAEMON_DEBUG;
+  if (!target || !message || message.type === "heartbeat") {
+    return;
+  }
+  try {
+    appendFileSync(
+      target,
+      `${JSON.stringify({
+        ts: Date.now(),
+        type: message.type,
+        sessionId: message.sessionId,
+        state: message.state,
+        source: message.source,
+        updatedAt: message.updatedAt,
+        summary: message.summary
+      })}\n`
+    );
+  } catch {
+    // diagnostics must never break the daemon
+  }
+}
+
 const paths = getDefaultPaths();
 const capabilities = getPlatformCapabilities();
 const stateFile = createStateFile({ statePath: paths.statePath });
@@ -113,6 +142,7 @@ async function bootstrap() {
         app.quit();
         return;
       }
+      debugLogDaemonMessage(message);
       return runtime.handleMessage(message);
     },
     onProtocolError: (error) => console.error("protocol error:", error.message)

package/docs/known-issues.md

@@ -2,6 +2,43 @@
 
 Issues found in live use, with their current status.
 
+## ⏳ In progress: Codex interrupt sometimes leaves the pet "working"
+
+- **Symptom:** Pressing Esc to interrupt a Codex turn occasionally does **not**
+  flip the pet to *interrupted* — it keeps showing a working state (*thinking* /
+  *running*) even though the turn was cut short. Intermittent ("some occasions").
+- **Investigation so far:** The "a late `function_call_output` resets the state to
+  *thinking*" theory was **ruled out** — across 257 real `turn_aborted` events in
+  live `~/.codex/sessions`, **zero** had a tool result after the abort. Codex
+  fires no hook on an abort, and the L3 transcript watcher does record
+  `turn_aborted` and emit `interrupted`.
+- **Leading suspect:** The daemon registry applies session state **last-writer-
+  wins by IPC arrival order** (`registry.js` `applyState` ignores `updatedAt` and
+  `confidence`). Hooks (separate `haya-pet state` subprocesses) and the interrupt
+  watcher use different IPC connections, so a stale "working" message can arrive
+  *after* `interrupted` and clobber it. Discovery edges (a resumed session whose
+  `session_meta.timestamp` predates the wrapper launch is filtered out; concurrent
+  Codex sessions can attach the watcher to the wrong rollout) are secondary
+  candidates.
+- **Status:** Instrumented with a daemon-side arrival trace (`HAYA_PET_DAEMON_DEBUG`,
+  in `apps/companion/src/main/index.js`) to confirm whether `interrupted` is never
+  emitted (watcher/discovery) vs. emitted-then-clobbered (arrival-order race).
+  **Fix to follow shortly** — likely an `updatedAt`-monotonic guard in `applyState`.
+
+## ✅ Resolved: Claude pet stuck on "compacting" after a compaction
+
+- **Symptom:** With Claude Code hooks enabled, the pet entered *compacting* on
+  `PreCompact` and never left — it sat there until the 30 s stale sweep or the
+  next prompt. Most visible after a manual `/compact`.
+- **Root cause:** The Claude hook table subscribed `PreCompact` → *compacting* but
+  had **no completion event**. Claude's `Stop` does not fire for a compaction, so
+  nothing cleared the state. (Codex already subscribed `PostCompact`.)
+- **Fix:** The Claude hook table now also subscribes **`PostCompact`**, split by
+  the documented `manual`/`auto` trigger matcher: a **manual** `/compact` returns
+  to *idle* (control is back at the prompt), while an **auto** compaction resumes
+  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
@@ -259,8 +296,10 @@ observation (`--observe`) or L1 lifecycle as the fallback. Current state:
   lifecycle status). Live in-session status is **opt-in** via `HAYA_PET_HOOKS=1`,
   which injects a settings file (`claude --settings <stable-file>`, no change to
   your global config) wiring Claude's `UserPromptSubmit`/`PreToolUse`/`PostToolUse`/
-  `Notification`/`PreCompact`/`Stop` events to `haya-pet state <state>`, reported
-  to the daemon over the IPC pipe. `SubagentStop` is intentionally ignored because
+  `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
   file-editing tools (`Edit`/`Write`/`MultiEdit`/`NotebookEdit` → *editing files*)
   from other tools (→ *running tools*) via the hook `matcher`. **Why opt-in:**

package/package.json

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

package/packages/adapters/src/claude-hooks.js

@@ -33,6 +33,14 @@ const HOOK_TABLE = Object.freeze([
   { event: "Notification", matcher: "idle_prompt", state: "idle", summary: "idle" },
   { event: "PermissionDenied", state: "idle", summary: "denied" },
   { event: "PreCompact", state: "compacting" },
+  // PostCompact is the authoritative "compaction finished" signal (verified in
+  // the Claude hooks docs). Without it the pet stays stuck on `compacting` until
+  // the 30s stale sweep. The `trigger` matcher splits the two outcomes: a manual
+  // /compact hands control back to an idle prompt, while an AUTO compaction fires
+  // mid-turn and the agent immediately resumes working (thinking) — the next real
+  // event (PreToolUse/Stop) refines from there. Mirrors codex-hooks' PostCompact.
+  { event: "PostCompact", matcher: "manual", state: "idle", summary: "compacted" },
+  { event: "PostCompact", matcher: "auto", state: "thinking", summary: "compacted" },
   { event: "Stop", state: "idle" },
   { event: "StopFailure", state: "idle", summary: "stopped" }
 ]);
@@ -49,6 +57,11 @@ export function mapClaudeEventToState(event, detail) {
     if (detail === "idle_prompt") return "idle";
     return undefined;
   }
+  if (event === "PostCompact") {
+    // `detail` is the compaction trigger ("manual" | "auto"). A manual /compact
+    // ends at an idle prompt; an auto compaction resumes the turn (thinking).
+    return detail === "manual" ? "idle" : "thinking";
+  }
   const entry = HOOK_TABLE.find((row) => row.event === event && row.matcher === undefined);
   return entry?.state;
 }

package/packages/adapters/test/claude-hooks.test.mjs

@@ -31,6 +31,15 @@ test("mapClaudeEventToState branches Notification on type (approval vs idle)", (
   assert.equal(mapClaudeEventToState("Notification", "auth_success"), undefined);
 });
 
+test("mapClaudeEventToState branches PostCompact on compaction trigger", () => {
+  // Manual /compact returns to an idle prompt; auto compaction resumes the turn.
+  assert.equal(mapClaudeEventToState("PostCompact", "manual"), "idle");
+  assert.equal(mapClaudeEventToState("PostCompact", "auto"), "thinking");
+  // Unknown/missing trigger defaults to the "still working" assumption, which the
+  // next real event corrects — never leaving the pet stuck on `compacting`.
+  assert.equal(mapClaudeEventToState("PostCompact"), "thinking");
+});
+
 test("buildClaudeHookSettings bakes node + cli, no volatile session id", () => {
   const settings = buildClaudeHookSettings({
     nodePath: "/usr/bin/node",
@@ -62,6 +71,15 @@ test("buildClaudeHookSettings splits Notification into approval + idle matchers"
   assert.match(idle.hooks[0].command, /state idle --summary idle$/);
 });
 
+test("buildClaudeHookSettings splits PostCompact into manual + auto triggers", () => {
+  const post = buildClaudeHookSettings({ nodePath: "n", cliPath: "c" }).hooks.PostCompact;
+  assert.equal(post.length, 2);
+  const manual = post.find((e) => e.matcher === "manual");
+  const auto = post.find((e) => e.matcher === "auto");
+  assert.match(manual.hooks[0].command, /state idle --summary compacted$/);
+  assert.match(auto.hooks[0].command, /state thinking --summary compacted$/);
+});
+
 test("buildClaudeHookSettings keeps two non-overlapping PreToolUse matchers", () => {
   const pre = buildClaudeHookSettings({ nodePath: "n", cliPath: "c" }).hooks.PreToolUse;
   assert.equal(pre.length, 2);
@@ -83,7 +101,7 @@ test("buildClaudeHookSettings includes all subscribed events", () => {
   for (const event of [
     "UserPromptSubmit", "PreToolUse", "PostToolUse", "PostToolUseFailure",
     "PermissionRequest", "Notification", "PermissionDenied", "PreCompact",
-    "Stop", "StopFailure"
+    "PostCompact", "Stop", "StopFailure"
   ]) {
     assert.ok(settings.hooks[event], `missing hook event ${event}`);
   }