claude-spotter 0.11.0 → 0.12.0

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## 0.12.0
+
+**親 PID watch を heartbeat 方式に置換 + UserPromptSubmit auto-resurrect**。v0.6.2 で導入した `--parent-pid` watch (Claude Code 本体 PID を `process.kill(pid, 0)` で 5 秒間隔 ping) が VSCode native extension 環境で誤爆する問題を解消。`process.ppid` は extension host から spawn される短命ラッパーを指していて、5 秒で ESRCH → daemon 自死していた (`~/.spotter/logs/ppid-probe.log` の env dump で実測: hook の ppid が毎回 (55692, 46020 等) 変わるのに対し `VSCODE_PID=39964` は固定、CLAUDE_* 系には PID 系 env なし)。
+
+### 設計
+
+- **heartbeat 方式 (b 案)**: daemon が envelope を受信するたびに `setTimeout(selfShutdown, 30min)` を `clearTimeout` + 再 set。ポーリングではなく event-driven で CPU 負荷ゼロ、検出は精密。30 分を超える Claude Code 沈黙は通常の使用では発生しない閾値
+- **OS / 環境依存ゼロ**: VSCODE_PID / CLAUDE_*_PID 等の探索が不要、CLI / native extension / 将来の他クライアント全てで同一挙動
+- **auto-resurrect**: UserPromptSubmit hook が `E_UNREACHABLE` (socket 不在) を検出したら spawn + readiness 待ち + retry。daemon が 30 分 timeout で死んでも crash していても、次のユーザー入力で自動復活する。「daemon が死んでたら pass」(§0 silent fallback 違反) ではなく「daemon が死んでたら起こす」で対処
+- **PreToolUse / Stop は復活させない**: turn の途中で daemon が居なかった場合、used_tools 欠落・preamble 未送信の歪んだ状態で監査再開すると誤検出が増える。次の UserPromptSubmit (新 turn の起点) で復活する設計
+
+### 変更点
+
+- **編集 [src/daemon/daemon.mjs](src/daemon/daemon.mjs)**: parent-pid watch (`setInterval` + `process.kill(pid, 0)`) を削除、`heartbeatTimeoutMs` パラメータ + `resetHeartbeat()` (clearTimeout + setTimeout の per-envelope re-arm) に置換。`isProcessAlive` も削除 (status.mjs に独立コピー有り)
+- **編集 [src/cli/daemon-cmd.mjs](src/cli/daemon-cmd.mjs)**: `--parent-pid` パース削除、`startDaemon` 呼び出しから `parentPid` 削除
+- **新規 [src/hooks/spawn-daemon.mjs](src/hooks/spawn-daemon.mjs)**: spawn detached + readiness poll を session-start / user-prompt の両方から使えるように共通化
+- **編集 [src/hooks/session-start.mjs](src/hooks/session-start.mjs)**: spawn ロジックを spawn-daemon.mjs に委譲、`--parent-pid` 渡し削除
+- **編集 [src/hooks/user-prompt.mjs](src/hooks/user-prompt.mjs)**: `sendRequest` が `E_UNREACHABLE` で失敗したら `spawnDaemonAndWaitReady` を呼んで retry (1 回のみ)
+- **削除 [src/hooks/ppid-probe.mjs]**: env dump 用の調査 hook、役目終了
+- **編集 [.claude/settings.json](.claude/settings.json)**: probe hook 登録撤去
+- **編集 [test/daemon.test.mjs](test/daemon.test.mjs)**: parent-watch test 2 件を削除、heartbeat timeout / heartbeat reset / heartbeatTimeoutMs validation の 3 件を追加
+
+### 非互換
+
+- `startDaemon({parentPid, parentWatchIntervalMs})` → `startDaemon({heartbeatTimeoutMs})`: API 変更。CLI の `--parent-pid` 引数も廃止 (受け取らなくなる)。Spotter は hook + daemon を同一 npm package で配布するため `npm install -g claude-spotter@latest` で一括更新すれば混在は起きない
+
+## 0.11.1
+
+**hotfix: `src/version.mjs` を `package.json` から読み取る**。0.11.0 は package.json を 0.11.0 に bump したが `src/version.mjs` のハードコード文字列 (`'0.10.0'`) を上げ忘れていたため、`spotter --version` が `0.10.0` のまま表示される不整合があった。同じミスを防ぐため ESM JSON import (`import pkg from '../package.json' with { type: 'json' }`) で package.json から動的に引くよう変更。以降は package.json の version を bump するだけで CLI 出力も追従する。
+
+### 変更点
+
+- **編集 [src/version.mjs](src/version.mjs)**: ハードコード廃止、`package.json` の version フィールドを ESM JSON import で読み取る
+- **編集 [package.json](package.json)**: 0.11.0 → 0.11.1
+
 ## 0.11.0
 
 **短プロンプトの Haiku スキップ**。ユーザーの入力が trim 後 10 文字 (コードポイント) 以下なら、挨拶・相槌・短い確認質問などツール不要な会話が支配的なため、UserPromptSubmit hook で早期 return して Haiku 呼び出しを完全にスキップする。daemon には user_input を送らず、`state.lastUserInput=null` のまま次の turn_end が `reason=no_user_input` で自動 pass する。preamble 57 件の判定コストを、最も的外れになりやすい短文ターンで丸ごと節約する。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-spotter",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Audit agent running alongside Claude Code that catches missed tool calls — 気づく役と実行する役の分離",
   "type": "module",
   "bin": {

package/src/cli/daemon-cmd.mjs

@@ -6,15 +6,11 @@ import { join } from 'node:path';
 import { open } from 'node:fs/promises';
 
 function parseArgs(argv) {
-  const out = { sessionId: null, parentPid: null, projectRoot: null };
+  const out = { sessionId: null, projectRoot: null };
   for (let i = 0; i < argv.length; i += 1) {
     if (argv[i] === '--session-id') {
       out.sessionId = argv[i + 1];
       i += 1;
-    } else if (argv[i] === '--parent-pid') {
-      const n = parseInt(argv[i + 1], 10);
-      if (Number.isInteger(n) && n > 0) out.parentPid = n;
-      i += 1;
     } else if (argv[i] === '--project-root') {
       out.projectRoot = argv[i + 1];
       i += 1;
@@ -24,7 +20,7 @@ function parseArgs(argv) {
 }
 
 export async function runDaemonStart({ argv }) {
-  const { sessionId, parentPid, projectRoot } = parseArgs(argv);
+  const { sessionId, projectRoot } = parseArgs(argv);
   if (!sessionId) {
     process.stderr.write('spotter daemon start: --session-id is required\n');
     process.exit(2);
@@ -48,11 +44,9 @@ export async function runDaemonStart({ argv }) {
     // v0.5.0: no warmup. Session-scoped Haiku (--resume on follow-ups) pays cold-start
     // only on the first real call; warmup added complexity for marginal benefit and is
     // removed along with the stateless regime that required it.
-    // v0.6.2: parentPid (Claude Code PID, captured by SessionStart hook as process.ppid)
-    // is threaded in so the daemon self-terminates when the parent dies without
-    // SessionEnd (crash / kill / IDE reload).
     // v0.7.0: projectRoot drives tool-db loading (replaces the old tools.yaml catalog).
-    running = await startDaemon({ sessionId, projectRoot, parentPid, logFn: log });
+    // v0.12.0: orphan-cleanup is heartbeat-based inside startDaemon (no parent-PID arg).
+    running = await startDaemon({ sessionId, projectRoot, logFn: log });
   } catch (err) {
     if (err instanceof DaemonAlreadyRunningError) {
       // v0.2 PID-preexist layer: a sibling daemon already serves this session.

package/src/daemon/daemon.mjs

@@ -16,6 +16,12 @@
 // §5.7: event dispatch follows the envelope contract.
 // §14:  unexpected errors are thrown; hooks convert them to exit codes.
 //
+// v0.12.0: orphan-cleanup is now heartbeat-based instead of parent-PID watch. Every
+// envelope (including readiness) resets a setTimeout; if no hook event arrives within
+// HEARTBEAT_TIMEOUT_MS (30 min), the daemon self-shuts. Replaces v0.6.2's --parent-pid
+// scheme, which mis-fired in VSCode native-extension environments where process.ppid
+// pointed at a short-lived wrapper. UserPromptSubmit hook auto-resurrects a dead daemon.
+//
 // v0.2 defence layers against daemon proliferation (see plan §18) — still active:
 //   - SPOTTER_PARENT_PID env var (set by haiku-caller when spawning claude -p; hooks skip on presence)
 //   - agent_id gate (subagent hooks exit 0 before reaching the daemon)
@@ -45,11 +51,11 @@ const DEFAULT_HAIKU_CALL_WINDOW_MS = 10_000;
 // being excessive, and a role-collapse recovery cycle (reset → next call is effectively
 // a cold start again) stays within budget.
 const DEFAULT_HAIKU_TIMEOUT_MS = 30_000;
-// v0.6.2: parent-process watch interval. SessionStart hook passes the Claude Code PID;
-// the daemon polls it so it can self-terminate when Claude Code dies without firing
-// SessionEnd (crash, kill -9, IDE reload). 5s is a balance between responsiveness and
-// idle CPU cost — well below the cost of an orphan daemon staying up indefinitely.
-const DEFAULT_PARENT_WATCH_INTERVAL_MS = 5_000;
+// v0.12.0: heartbeat-based orphan cleanup. Every envelope resets a setTimeout; if no
+// hook event arrives within this window, the daemon self-shuts. 30 min is the longest
+// silence we expect from a live Claude Code session. UserPromptSubmit auto-resurrects
+// a dead daemon, so over-aggressive timeout would just cause a visible re-spawn.
+const DEFAULT_HEARTBEAT_TIMEOUT_MS = 30 * 60 * 1000;
 
 export class DaemonAlreadyRunningError extends Error {
   constructor(sessionId, pid) {
@@ -67,14 +73,13 @@ export async function startDaemon({
   haikuCaller,
   logFn = () => {},
   haikuCallWindowMs = DEFAULT_HAIKU_CALL_WINDOW_MS,
-  parentPid = null,
-  parentWatchIntervalMs = DEFAULT_PARENT_WATCH_INTERVAL_MS,
+  heartbeatTimeoutMs = DEFAULT_HEARTBEAT_TIMEOUT_MS,
 } = {}) {
   if (!sessionId) {
     throw new TypeError('sessionId is required');
   }
-  if (parentPid !== null && (!Number.isInteger(parentPid) || parentPid <= 0)) {
-    throw new TypeError('parentPid must be a positive integer or null');
+  if (!Number.isFinite(heartbeatTimeoutMs) || heartbeatTimeoutMs <= 0) {
+    throw new TypeError('heartbeatTimeoutMs must be a positive number');
   }
 
   await ensureRuntimeDir();
@@ -141,7 +146,24 @@ export async function startDaemon({
     }
   };
 
+  // v0.12.0: heartbeat. Reset on every envelope; if no event arrives within
+  // heartbeatTimeoutMs the daemon self-shuts. Replaces v0.6.2 parent-PID watch.
+  // The timer itself is created after server.listen() succeeds (see below).
+  let heartbeatHandle = null;
+  const resetHeartbeat = () => {
+    if (heartbeatHandle !== null) clearTimeout(heartbeatHandle);
+    heartbeatHandle = setTimeout(() => {
+      heartbeatHandle = null;
+      logFn(`heartbeat timeout (${heartbeatTimeoutMs}ms), shutting down`);
+      shutdown(server, sessionId, logFn).catch((err) => {
+        logFn(`heartbeat shutdown error: ${err.message}`);
+      });
+    }, heartbeatTimeoutMs);
+    heartbeatHandle.unref();
+  };
+
   const handler = async (envelope) => {
+    resetHeartbeat();
     if (!envelope || typeof envelope !== 'object') {
       const err = new Error('invalid envelope');
       err.code = 'E_INTERNAL';
@@ -276,29 +298,15 @@ export async function startDaemon({
   const pidPath = pidFilePath(sessionId);
   await writeFile(pidPath, String(process.pid), 'utf8');
 
-  // v0.6.2: parent-process watch. SessionEnd is a graceful path; if Claude Code dies
-  // without it (crash, kill, IDE reload), nothing else cleans us up. Poll the parent
-  // PID and self-terminate on its disappearance.
-  let parentWatchHandle = null;
-  if (parentPid !== null) {
-    logFn(`watching parent pid=${parentPid} (interval=${parentWatchIntervalMs}ms)`);
-    parentWatchHandle = setInterval(() => {
-      if (!isProcessAlive(parentPid)) {
-        logFn(`parent pid=${parentPid} gone, shutting down`);
-        clearInterval(parentWatchHandle);
-        parentWatchHandle = null;
-        shutdown(server, sessionId, logFn).catch((err) => {
-          logFn(`parent-watch shutdown error: ${err.message}`);
-        });
-      }
-    }, parentWatchIntervalMs);
-    parentWatchHandle.unref();
-  }
+  // Start the heartbeat. The first hook event (typically SessionStart's readiness
+  // ping moments later) will reset it; if nothing arrives in heartbeatTimeoutMs we self-shut.
+  logFn(`heartbeat armed (timeout=${heartbeatTimeoutMs}ms)`);
+  resetHeartbeat();
 
   const stop = async () => {
-    if (parentWatchHandle !== null) {
-      clearInterval(parentWatchHandle);
-      parentWatchHandle = null;
+    if (heartbeatHandle !== null) {
+      clearTimeout(heartbeatHandle);
+      heartbeatHandle = null;
     }
     return shutdown(server, sessionId, logFn);
   };
@@ -311,18 +319,6 @@ export async function startDaemon({
   };
 }
 
-function isProcessAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    if (err.code === 'ESRCH') return false;
-    if (err.code === 'EPERM') return true; // exists but owned by another user
-    // Unknown errno — be conservative and assume alive (don't auto-kill on transient).
-    return true;
-  }
-}
-
 async function assertNoLiveDaemon(sessionId) {
   const pidPath = pidFilePath(sessionId);
   let raw;

package/src/hooks/session-start.mjs

@@ -11,31 +11,21 @@
 // v0.3 gate:
 //   - isOutsideSpotterProject: cwd has no .spotter/marker.json above it → exit 0
 //     (Throughline workdir etc. — `claude -p` from tools outside any installed project)
+//
+// v0.12.0: spawn + readiness-poll moved to spawn-daemon.mjs (shared with auto-resurrect
+// in user-prompt.mjs). The --parent-pid scheme from v0.6.2 is gone; orphan cleanup is
+// now heartbeat-based inside the daemon.
 
-import { spawn } from 'node:child_process';
-import { setTimeout as delay } from 'node:timers/promises';
-import { fileURLToPath } from 'node:url';
-import { dirname, resolve } from 'node:path';
 import { readStdinJson, requireString, die, isChildCall, isSubagentCall, isOutsideSpotterProject, findSpotterMarker } from './lib.mjs';
-import { sendRequest, TransportError } from '../daemon/transport.mjs';
-
-const READINESS_TIMEOUT_MS = 3_000;
-const POLL_INTERVAL_MS = 100;
+import { spawnDaemonAndWaitReady } from './spawn-daemon.mjs';
 
-export async function runSessionStart({ argv = process.argv, now = Date.now } = {}) {
-  // Gate 1 (pre-stdin): Spotter's own claude -p subprocess — exit without reading stdin.
+export async function runSessionStart({ now = Date.now } = {}) {
   if (isChildCall()) return;
 
   const input = await readStdinJson();
 
-  // Gate 2: Task subagent — skip audit.
   if (isSubagentCall(input)) return;
-
-  // Gate 3: non-startup sources (resume/compact/clear) don't spawn a new daemon.
   if (input.source !== 'startup') return;
-
-  // Gate 4 (v0.3): cwd is not inside any project that has been `spotter install`-ed.
-  // Other tools (Throughline etc.) launching `claude -p` in unrelated workdirs land here.
   if (isOutsideSpotterProject(input)) return;
 
   const sessionId = requireString(input, 'session_id');
@@ -44,66 +34,9 @@ export async function runSessionStart({ argv = process.argv, now = Date.now } =
     die(`SessionStart: failed to locate project root from cwd=${input.cwd}`, 2);
   }
 
-  spawnDaemon(sessionId, projectRoot, argv);
-
-  const deadline = now() + READINESS_TIMEOUT_MS;
-  while (now() < deadline) {
-    try {
-      const resp = await sendRequest({
-        sessionId,
-        event: 'readiness',
-        timeoutMs: 500,
-      });
-      if (resp.ok === true && resp.result && resp.result.ready === true) {
-        return; // success — exit 0 implicitly
-      }
-    } catch (err) {
-      if (!(err instanceof TransportError) || err.code !== 'E_UNREACHABLE') {
-        // E_TIMEOUT or internal errors while daemon is booting — keep polling.
-        // E_UNREACHABLE means the socket file/pipe doesn't exist yet — also retryable.
-      }
-    }
-    await delay(POLL_INTERVAL_MS);
-  }
-
-  die(`daemon did not reach readiness within ${READINESS_TIMEOUT_MS}ms for session ${sessionId}`, 2);
-}
-
-function spawnDaemon(sessionId, projectRoot, argv) {
-  // Invoke `node <spotter-bin> daemon start --session-id ...` detached.
-  // v0.6.2: pass --parent-pid so the daemon can self-terminate when Claude Code dies
-  // without firing SessionEnd. process.ppid here is Claude Code (this hook's parent).
-  // v0.7.0: pass --project-root for tool-db loading.
-  const spotterBin = resolveSpotterBin(argv);
-  const child = spawn(
-    process.execPath,
-    [
-      spotterBin, 'daemon', 'start',
-      '--session-id', sessionId,
-      '--parent-pid', String(process.ppid),
-      '--project-root', projectRoot,
-    ],
-    {
-      detached: true,
-      stdio: 'ignore',
-      windowsHide: true,
-    }
-  );
-  child.on('error', (err) => {
-    // best effort: the polling below will fail if the spawn actually didn't work
-    process.stderr.write(`spotter-hook: daemon spawn error: ${err.message}\n`);
-  });
-  child.unref();
-}
-
-function resolveSpotterBin(argv) {
-  // argv[1] is the path to the currently running script (bin/spotter.mjs when invoked via CLI,
-  // or src/hooks/session-start.mjs in tests). Walk up to the package root.
-  const here = dirname(fileURLToPath(import.meta.url));
-  return resolve(here, '..', '..', 'bin', 'spotter.mjs');
+  await spawnDaemonAndWaitReady({ sessionId, projectRoot, now });
 }
 
-// Direct-execution entry — used when called as `node session-start.mjs`.
 if (import.meta.url === `file://${process.argv[1]?.replace(/\\/g, '/')}`) {
   runSessionStart().catch((err) => die(err.message, err.exitCode ?? 2));
 }

package/src/hooks/spawn-daemon.mjs

@@ -0,0 +1,72 @@
+// Shared daemon-spawn + readiness-poll plumbing.
+//
+// Used by:
+//   - session-start.mjs (initial daemon for a fresh session)
+//   - user-prompt.mjs   (auto-resurrect when a heartbeat-killed or crashed daemon
+//                        is detected at the start of a new turn — v0.12.0)
+//
+// The hook caller is responsible for the v0.2 gates (isChildCall / isSubagentCall /
+// isOutsideSpotterProject) and for resolving sessionId + projectRoot before invoking
+// this. We keep this module narrowly focused on "spawn detached + poll until ready".
+
+import { spawn } from 'node:child_process';
+import { setTimeout as delay } from 'node:timers/promises';
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+import { sendRequest, TransportError } from '../daemon/transport.mjs';
+
+const READINESS_TIMEOUT_MS = 3_000;
+const POLL_INTERVAL_MS = 100;
+
+export async function spawnDaemonAndWaitReady({ sessionId, projectRoot, now = Date.now }) {
+  spawnDaemon(sessionId, projectRoot);
+
+  const deadline = now() + READINESS_TIMEOUT_MS;
+  while (now() < deadline) {
+    try {
+      const resp = await sendRequest({
+        sessionId,
+        event: 'readiness',
+        timeoutMs: 500,
+      });
+      if (resp.ok === true && resp.result && resp.result.ready === true) {
+        return;
+      }
+    } catch (err) {
+      if (!(err instanceof TransportError) || err.code !== 'E_UNREACHABLE') {
+        // E_TIMEOUT or internal errors while daemon is booting — keep polling.
+      }
+    }
+    await delay(POLL_INTERVAL_MS);
+  }
+
+  const err = new Error(`daemon did not reach readiness within ${READINESS_TIMEOUT_MS}ms for session ${sessionId}`);
+  err.exitCode = 2;
+  throw err;
+}
+
+function spawnDaemon(sessionId, projectRoot) {
+  const spotterBin = resolveSpotterBin();
+  const child = spawn(
+    process.execPath,
+    [
+      spotterBin, 'daemon', 'start',
+      '--session-id', sessionId,
+      '--project-root', projectRoot,
+    ],
+    {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+    }
+  );
+  child.on('error', (err) => {
+    process.stderr.write(`spotter-hook: daemon spawn error: ${err.message}\n`);
+  });
+  child.unref();
+}
+
+function resolveSpotterBin() {
+  const here = dirname(fileURLToPath(import.meta.url));
+  return resolve(here, '..', '..', 'bin', 'spotter.mjs');
+}

package/src/hooks/user-prompt.mjs

@@ -1,5 +1,11 @@
 // UserPromptSubmit hook — send user_input to daemon, inject additionalContext (§12.2 transparent).
 // v0.2 gates: see src/hooks/session-start.mjs comment.
+//
+// v0.12.0: auto-resurrect. If sendRequest fails with E_UNREACHABLE (daemon was
+// heartbeat-killed for 30 min idle, crashed, or was never spawned because SessionStart
+// fired in a context we skipped), we spawn a fresh daemon and retry once. This is the
+// natural recovery point — the start of a new turn — so the user's prompt is still
+// audited even after long pauses or daemon failures.
 
 import {
   readStdinJson,
@@ -10,8 +16,10 @@ import {
   isChildCall,
   isSubagentCall,
   isOutsideSpotterProject,
+  findSpotterMarker,
 } from './lib.mjs';
-import { sendRequest } from '../daemon/transport.mjs';
+import { sendRequest, TransportError } from '../daemon/transport.mjs';
+import { spawnDaemonAndWaitReady } from './spawn-daemon.mjs';
 
 const TIMEOUT_MS = 30_000;
 const SHORT_PROMPT_MAX_CHARS = 10;
@@ -25,22 +33,43 @@ export async function runUserPrompt() {
   const sessionId = requireString(input, 'session_id');
   const prompt = requireString(input, 'prompt');
 
-  // Short prompts (<=10 codepoints after trim) are almost never tool-required
-  // (greetings, acknowledgements, short questions). Skip Haiku entirely —
-  // daemon keeps lastUserInput=null, so the next turn_end passes with reason=no_user_input.
   if ([...prompt.trim()].length <= SHORT_PROMPT_MAX_CHARS) return;
 
-  let response;
-  try {
-    response = await sendRequest({
+  const sendUserInput = () =>
+    sendRequest({
       sessionId,
       event: 'user_input',
       payload: { user_input: prompt },
       timeoutMs: TIMEOUT_MS,
     });
+
+  let response;
+  try {
+    response = await sendUserInput();
   } catch (err) {
-    die(`user-prompt transport failure: ${err.code ?? '?'}: ${err.message}`, exitCodeFor(err));
-    return;
+    if (err instanceof TransportError && err.code === 'E_UNREACHABLE') {
+      // v0.12.0: daemon is gone (heartbeat shutdown, crash, missing). Resurrect and retry.
+      const projectRoot = findSpotterMarker(input.cwd);
+      if (!projectRoot) {
+        die(`user-prompt: cannot resurrect daemon — no .spotter/marker.json above cwd=${input.cwd}`, 2);
+        return;
+      }
+      try {
+        await spawnDaemonAndWaitReady({ sessionId, projectRoot });
+      } catch (spawnErr) {
+        die(`user-prompt: daemon resurrect failed: ${spawnErr.message}`, spawnErr.exitCode ?? 2);
+        return;
+      }
+      try {
+        response = await sendUserInput();
+      } catch (retryErr) {
+        die(`user-prompt transport failure after resurrect: ${retryErr.code ?? '?'}: ${retryErr.message}`, exitCodeFor(retryErr));
+        return;
+      }
+    } else {
+      die(`user-prompt transport failure: ${err.code ?? '?'}: ${err.message}`, exitCodeFor(err));
+      return;
+    }
   }
 
   if (response.ok !== true) {
@@ -50,7 +79,7 @@ export async function runUserPrompt() {
 
   const result = response.result;
   if (result.pass === true) {
-    return; // no additionalContext to inject
+    return;
   }
 
   const additionalContext = formatTransparentContext(result.missing_tools);

package/src/version.mjs

@@ -1 +1,2 @@
-export const version = '0.10.0';
+import pkg from '../package.json' with { type: 'json' };
+export const version = pkg.version;