heyspex 0.1.0 → 0.2.0

package/scripts/claude-hooks/plan-exit-ingest-gate.mjs

@@ -0,0 +1,170 @@
+#!/usr/bin/env node
+// Claude Code PostToolUse hook → ExitPlanMode reminder + session marker.
+//
+// [[HS-38J5-2BXD-DIAG-plan-execute-boundary-has-no-ingest-clai]] — the
+// ExitPlanMode PreToolUse gate (plan-review-gate.mjs) hard-gates plan QUALITY
+// (V1 review + QC), but nothing gated plan → execute: an approved plan let the
+// agent go straight to coding with no epic filed and no claim acquired. This is
+// item 1 of the diagnose's REMAINING fix list — the "soft (unavoidable)" half:
+// rides the ONE event guaranteed to fire once a plan is approved (PostToolUse
+// on ExitPlanMode), and fail-silent (never blocks — plan-review-gate already
+// owns the hard quality gate on this same tool).
+//
+// It does two things on every ExitPlanMode PostToolUse:
+//   1. Emits an unavoidable `additionalContext` reminder: ingest the approved
+//      plan as an epic (plan-ingest-agent-workflow) and claim before coding.
+//   2. Arms a per-session marker (.heyspex/post-plan-pending/<sessionId>.json)
+//      that claim-before-code-gate.mjs (the PreToolUse Edit|Write HARD gate,
+//      item 2 of the same diagnose) reads to know "this session just exited
+//      plan mode" before deciding whether to deny the first code edit.
+//
+// The marker is cleared by claim-before-code-gate.mjs once a claim is observed
+// (or left to age out — it is advisory only, never itself a security boundary).
+//
+// No CLAUDE_AGENT gate ([[HS-DT9L-NLR7-DIAG-nine-hooks-are-switched-off-in]]).
+// This hook never denies anything — it only emits a reminder and arms a marker file
+// — so there is no approval-fatigue risk in firing it everywhere. Removing the gate
+// also unblocks claim-before-code-gate.mjs, which reads the marker this hook arms:
+// with this hook silent in interactive sessions, the marker never existed there, so
+// that gate was doubly inert regardless of its own env gate.
+//
+// Env gate:
+//   HEYSPEX_PLAN_EXIT_GATE_OFF=1  Hard kill switch.
+//
+// MUST exit 0 on every failure path — a reminder that breaks Claude Code is
+// worse than no reminder.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import { resolveSessionId } from './claim-liveness-shared.mjs';
+
+export function repoRoot() {
+  const fromEnv = process.env.CLAUDE_PROJECT_DIR?.trim();
+  if (fromEnv) return fromEnv.replace(/[\\/]+$/, '');
+  return path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+}
+
+const MARKER_DIR = 'post-plan-pending';
+// Advisory TTL — long enough to cover a slow ingest+claim, short enough that a
+// marker from an old plan/session can't linger forever. Not a security boundary
+// (claim-before-code-gate's actual deny decision comes from the claim-liveness
+// negative cache, which has its own TTL) — this only decides whether the "did
+// this session just exit plan mode" nudge/gate applies at all.
+export const MARKER_TTL_MS = 2 * 60 * 60 * 1000; // 2h
+
+function markerFile(sessionId, root) {
+  return path.join(root, '.heyspex', MARKER_DIR, `${sessionId}.json`);
+}
+
+/** Arm the per-session "just exited plan mode" marker. Best-effort; never throws. */
+export function armPlanExitMarker(sessionId, root = repoRoot()) {
+  const trimmed = typeof sessionId === 'string' ? sessionId.trim() : '';
+  if (!trimmed) return;
+  try {
+    const file = markerFile(trimmed, root);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, JSON.stringify({ armedAt: Date.now(), sessionId: trimmed }));
+  } catch {
+    // never block the hook
+  }
+}
+
+/** True when `sessionId` has a live (unexpired) plan-exit marker. Never throws. */
+export function hasFreshPlanExitMarker(sessionId, root = repoRoot()) {
+  const trimmed = typeof sessionId === 'string' ? sessionId.trim() : '';
+  if (!trimmed) return false;
+  try {
+    const raw = JSON.parse(fs.readFileSync(markerFile(trimmed, root), 'utf8'));
+    const armedAt = typeof raw?.armedAt === 'number' ? raw.armedAt : 0;
+    return armedAt > 0 && Date.now() - armedAt < MARKER_TTL_MS;
+  } catch {
+    return false;
+  }
+}
+
+/** Clear the marker (called once a claim is acquired — no more nudging needed). */
+export function clearPlanExitMarker(sessionId, root = repoRoot()) {
+  const trimmed = typeof sessionId === 'string' ? sessionId.trim() : '';
+  if (!trimmed) return;
+  try {
+    fs.unlinkSync(markerFile(trimmed, root));
+  } catch {
+    // absent is fine
+  }
+}
+
+export const PLAN_EXIT_REMINDER =
+  'HEYSPEX — plan approved (ExitPlanMode). Before writing any code: (1) ingest the ' +
+  'approved plan into the vault — heyspex_preflight({ intent: "file_epic" }) then ' +
+  'file the epic (heyspex_file_spec / heyspex_push_plan) per plan-ingest-agent-workflow ' +
+  '(heyspex_get_procedure({ name: "plan-ingest-agent-workflow" })) — unless the plan is a ' +
+  'trivial fix with no new spec warranted; (2) claim the spec you are about to work ' +
+  '(heyspex_claim_spec) before the first non-plan Edit/Write. The plan→execute boundary ' +
+  'has no other enforcement besides this reminder and the PreToolUse claim gate on ' +
+  'code edits — do not skip filing+claiming because the plan already passed review.';
+
+async function readStdinJson() {
+  if (process.stdin.isTTY) return null;
+  return new Promise((resolve) => {
+    let buf = '';
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    };
+    const timer = setTimeout(() => finish(buf || ''), 200);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      buf += chunk;
+    });
+    process.stdin.on('end', () => {
+      clearTimeout(timer);
+      finish(buf);
+    });
+    process.stdin.on('error', () => {
+      clearTimeout(timer);
+      finish(buf);
+    });
+  });
+}
+
+function emit(additionalContext) {
+  process.stdout.write(
+    JSON.stringify({
+      hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext },
+    }),
+  );
+}
+
+async function main() {
+  if (process.env.HEYSPEX_PLAN_EXIT_GATE_OFF === '1') return;
+
+  const raw = await readStdinJson();
+  if (!raw) return;
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    return;
+  }
+  if (payload?.hook_event_name !== 'PostToolUse') return;
+  if (payload?.tool_name !== 'ExitPlanMode') return;
+  // A denied/errored ExitPlanMode (e.g. plan-review-gate blocked it) never actually
+  // left plan mode — nothing to arm or remind about.
+  if (payload?.tool_response?.is_error === true) return;
+
+  const sessionId = resolveSessionId(payload);
+  armPlanExitMarker(sessionId);
+  emit(PLAN_EXIT_REMINDER);
+}
+
+const INVOKED_DIRECTLY =
+  !!process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+if (INVOKED_DIRECTLY) {
+  main().catch(() => {
+    // Never break Claude Code on a hook failure.
+  });
+}

package/scripts/claude-hooks/plan-ingest-close-reminder.mjs

@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+// UserPromptSubmit hook → after plan mode, file specs and close — do not implement.
+//
+// Command Code / harnesses default to "exit plan → implement". HeySpex plan-ingest
+// sessions file milestone+epic specs via MCP, validate linkage, then end session.
+// Fires on distinctive plan-exit phrasing in the user prompt or agent narration.
+//
+// Invoke via native UserPromptSubmit (Claude Code) or heyspex_hooks_invoke
+// ({ event: "UserPromptSubmit", prompt: "..." }) in Command Code.
+//
+// FAIL-SAFE: exit 0 on every path.
+
+const PLAN_EXIT_PATTERNS = [
+  /\bexited?\s+plan\s+mode\b/i,
+  /\bPLAN\s*\(\s*exit\s*\)/i,
+  /\bexit\s+plan\s+mode\b/i,
+  /\bnow\s+implementing\b/i,
+  /\bleaving\s+plan\s+mode\b/i,
+  /\bplan\s+mode\s+ended\b/i,
+];
+
+const INJECT =
+  'HeySpex plan-ingest close: you just left plan mode. Do NOT start coding. ' +
+  'File milestones and epics via heyspex_push_plan / heyspex_file_spec, run ' +
+  'heyspex_validate_linkage, confirm summaries, then close with ' +
+  'heyspex_preflight({ intent: "close_session", thread_type: "plan_ingest" }) ' +
+  'and heyspex_session_end({ reason: "plan_ingest_complete" }). ' +
+  'Task filing and code execution are a separate session via /hs-next.';
+
+async function readStdinJson() {
+  if (process.stdin.isTTY) return null;
+  let buf = '';
+  process.stdin.setEncoding('utf8');
+  for await (const chunk of process.stdin) buf += chunk;
+  if (!buf.trim()) return null;
+  try {
+    return JSON.parse(buf);
+  } catch {
+    return null;
+  }
+}
+
+function emit(additionalContext) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      additionalContext,
+    },
+  }));
+}
+
+async function main() {
+  if (process.env.HEYSPEX_PLAN_INGEST_REMINDER_OFF === '1') return;
+
+  const payload = await readStdinJson();
+  if (!payload || payload.hook_event_name !== 'UserPromptSubmit') return;
+
+  const prompt = payload.prompt ?? payload.tool_input?.prompt ?? '';
+  if (typeof prompt !== 'string' || !prompt.trim()) return;
+
+  if (!PLAN_EXIT_PATTERNS.some((re) => re.test(prompt))) return;
+
+  emit(INJECT);
+}
+
+main().catch(() => {});

package/scripts/claude-hooks/plan-review-gate.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+// GENERATED by scripts/generate-hook-shells.mjs (HS-IQBF) — do not hand-edit.
+// This file only wires Claude Code's hook stdin/stdout contract to the
+// spexharness engine port of this gate. To change what this gate DECIDES,
+// edit spexharness/src/gates/plan-review-gate.mjs. To change the SHAPE of this shell,
+// edit the generator, then rerun: node scripts/generate-hook-shells.mjs
+
+import { runGateAsHook } from '../../spexharness/src/adapters/claude-code.mjs';
+import gate from '../../spexharness/src/gates/plan-review-gate.mjs';
+
+await runGateAsHook(gate);

package/scripts/claude-hooks/preflight-reminder.mjs

@@ -0,0 +1,262 @@
+#!/usr/bin/env node
+// Claude Code hook → inject preflight reminders for high-stakes intents.
+//
+// Phase 3 of HS-EPIC-3QS8 (procedure discovery & enforcement). Fires on
+// UserPromptSubmit and PreToolUse to nudge the agent toward heyspex_preflight /
+// heyspex_get_procedure / destructive-action-checklist at the moment of need —
+// even when the agent forgets to ask.
+//
+// Three intent categories:
+//   1. UserPromptSubmit  → user says "file a milestone" / "create an epic" /
+//                          "file a new task" → the registry-driven
+//                          spec-creation-via-minter prime ([[HS-EPIC-ZGWR]] AC#6):
+//                          patterns + inject live in the guardrail registry, not here.
+//   2. PreToolUse Edit   → file_path under specs/protocols/ → protocol_edit
+//                          reminder (spec-hierarchy §Agent autonomy).
+//   3. PreToolUse Bash/PowerShell → command contains rm -rf, git push --force,
+//                          git reset --hard, Remove-Item -Recurse -Force →
+//                          destructive-action-checklist reminder.
+//
+// Env gate (per HS-EPIC-3QS8 resolved Open question on "Hook scope"):
+//   CLAUDE_AGENT=true  Set to opt in. When unset, the hook exits 0 silently so
+//                      humans typing the same triggers in an interactive
+//                      Claude Code session don't get spammed.
+//   HEYSPEX_PREFLIGHT_REMINDER_OFF=1  Hard kill switch — exits silently even
+//                      when CLAUDE_AGENT=true. Useful for parallel agents that
+//                      want to mute reminders without touching the gate.
+//
+// MUST exit 0 on every failure path (matches the [[claude-code-hooks-integration]]
+// fail-silent contract). A reminder that breaks Claude Code is worse than no
+// reminder.
+//
+// Output shape:
+//   { hookSpecificOutput: { hookEventName, additionalContext } }
+// Plain JSON to stdout; Claude Code injects additionalContext into the model's
+// next turn alongside the prompt or tool result.
+
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// HS-N01T: the UserPromptSubmit half (the registry-driven filing-intent prime and the
+// grounding nudge) is PORTED to the engine — spexharness/src/gates/preflight-reminder-gate.mjs
+// — and this hook is now the thin Claude Code shell over it: same decision function, same
+// reminder text, same per-rule config/injected-content gating. What stays here is the
+// plumbing (stdin, the CLAUDE_AGENT opt-in gate, the single emit) and the PreToolUse half.
+import {
+  detectRegistryPrimeReminder as detectPrimeReminderPorted,
+  detectDesignIntent,
+  PRIME_RULES_OWNED_ELSEWHERE,
+} from '../../spexharness/src/gates/preflight-reminder-gate.mjs';
+import { defaultConfigRoot } from '../../spexharness/src/config-root.mjs';
+
+const REPO_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+// Filing-intent priming is REGISTRY-DRIVEN ([[HS-EPIC-ZGWR]] AC#6): the prime rules on
+// the userpromptsubmit surface (e.g. spec-creation-via-minter) carry their patterns +
+// inject text in specs/protocols/*.md → .heyspex/guardrails.json, so editing the nudge
+// is a prose edit with zero JS change. research-before-decision is a userpromptsubmit
+// prime rule too, but it has its own dedicated dispatch (via the unified
+// intent-classifier-trigger.mjs router; the old standalone research-trigger.mjs shim
+// was retired after burn-in, HS-IYU1) that does
+// extra workflow orchestration — exclude it here so it never double-injects. That
+// exclusion set (`PRIME_RULES_OWNED_ELSEWHERE`) now lives in the engine gate and is passed
+// back in explicitly below, so this hook's sweep is unchanged.
+
+// Destructive shell patterns. Conservative — only patterns that map to real
+// data loss / shared-state mutation, not arbitrary "dangerous-looking" calls.
+const DESTRUCTIVE_PATTERNS = [
+  // POSIX rm with recursive force in any flag order
+  /\brm\s+(?:-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*|-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*|--recursive\s+--force|--force\s+--recursive)\b/,
+  // git force-push (--force, -f, --force-with-lease)
+  /\bgit\s+push\s+(?:.*\s+)?(?:--force\b|-f\b|--force-with-lease\b)/,
+  // git reset --hard
+  /\bgit\s+reset\s+--hard\b/,
+  // git clean -fd / -fdx (untracked + ignored)
+  /\bgit\s+clean\s+(?:-[a-zA-Z]*f[a-zA-Z]*d[a-zA-Z]*|-[a-zA-Z]*d[a-zA-Z]*f[a-zA-Z]*)/,
+  // git branch -D / branch --delete --force
+  /\bgit\s+branch\s+(?:.*\s+)?(?:-D\b|--delete\s+--force\b|-d\s+--force\b)/,
+  // PowerShell Remove-Item -Recurse -Force
+  /\bRemove-Item\s+(?:[^|;&\n]*\s)?-Recurse\b(?:[^|;&\n]*\s)?-Force\b/i,
+  /\bRemove-Item\s+(?:[^|;&\n]*\s)?-Force\b(?:[^|;&\n]*\s)?-Recurse\b/i,
+];
+
+const PROTOCOL_EDIT_REGEX = /(?:^|[\\/])specs[\\/]protocols[\\/][^\\/]+\.md$/i;
+
+// CLAUDE.md edit gate ([[HS-UFQS-5PQ2-DIAG]]): CLAUDE.md is the always-loaded
+// agent contract — a decision recorded correctly in a protocol/memory doc that
+// also gets INLINED into CLAUDE.md silently wins once the protocol drifts,
+// because CLAUDE.md is what every session actually reads. Fires on the FILE
+// being edited (any CLAUDE.md, root or a nested customer-vault scaffold), not
+// on a folder pattern — mirrors detectProtocolEdit above.
+const CLAUDE_MD_EDIT_REGEX = /(?:^|[\\/])CLAUDE\.md$/;
+
+const DESTRUCTIVE_REMINDER =
+  'Detected destructive shell command (rm -rf, force-push, reset --hard, or ' +
+  'equivalent). Walk [[destructive-action-checklist]] before proceeding — ' +
+  '`heyspex_get_procedure({ name: "destructive-action-checklist" })` returns the ' +
+  'full checklist. If this is a non-vault scratch path or sandbox, you can ' +
+  'proceed; otherwise confirm with the user.';
+
+const PROTOCOL_EDIT_REMINDER =
+  'Detected an Edit on a file under `specs/protocols/`. Protocol edits require ' +
+  'user approval per spec-hierarchy §Agent autonomy. Fetch the full rule with ' +
+  '`heyspex_get_procedure({ name: "spec-hierarchy" })` and confirm scope with ' +
+  'the user before saving.';
+
+const CLAUDE_MD_EDIT_REMINDER =
+  'Detected an Edit/Write on CLAUDE.md — the always-loaded agent contract. Before ' +
+  'saving, check `heyspex_preflight({ intent: "protocol_edit" })` and ' +
+  '`heyspex_get_procedure({ name: "rule-placement-protocol" })`: procedure content ' +
+  'ranks ABOVE CLAUDE.md (CLAUDE.md is rank 4 — last resort, load-bearing handshake ' +
+  'rules only). Detail belongs in a `specs/protocols/*.md` procedure, fetched on ' +
+  'demand — never inlined here. An inlined copy silently overrides the live ' +
+  'procedure once it drifts, because CLAUDE.md is what every session actually reads ' +
+  '([[HS-UFQS-5PQ2-DIAG]]). If you are adding detail rather than a one-line pointer, ' +
+  'stop and move it to a procedure instead.';
+
+// Grounding-before-proposing nudge ([[HS-RES-2QX6]] / [[HS-EPIC-PLRV]]): the patterns and
+// GROUNDING_REMINDER text live in the engine gate (DESIGN_INTENT_PATTERNS /
+// GROUNDING_REMINDER there); `detectDesignIntent` is imported above.
+
+async function readStdinJson() {
+  if (process.stdin.isTTY) return null;
+  return new Promise((resolve) => {
+    let buf = '';
+    let settled = false;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolve(value);
+    };
+    const timer = setTimeout(() => finish(buf || ''), 200);
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+      buf += chunk;
+    });
+    process.stdin.on('end', () => {
+      clearTimeout(timer);
+      finish(buf);
+    });
+    process.stdin.on('error', () => {
+      clearTimeout(timer);
+      finish(buf);
+    });
+  });
+}
+
+function emit(eventName, additionalContext) {
+  if (!additionalContext) return;
+  const out = {
+    hookSpecificOutput: {
+      hookEventName: eventName,
+      additionalContext,
+    },
+  };
+  process.stdout.write(JSON.stringify(out));
+}
+
+// Registry-driven filing-intent prime ([[HS-EPIC-ZGWR]] AC#6). Reads the
+// userpromptsubmit `prime` rules from the compiled guardrail registry, matches the
+// prompt against each rule's authored patterns, and returns the rule's inject text.
+// Honors each rule's config_key gate + ignore_injected_content, and skips rules owned
+// by a dedicated hook. Fail-safe: any error → null (no reminder, never throws).
+// Exported so the smoke can unit-test the config/injected-content behavior in-process.
+// HS-N01T: the body is the engine gate's; this hook passes its OWN exclusion set (the
+// engine's default is wider — see the gate's header) so the hook's sweep is byte-identical.
+// HS-4C76: the registry (guardrails.json) stays on the code root, but the per-rule
+// config_key toggles live in `.heyspex/config.yaml` at the VAULT root. A caller passing
+// an explicit fixture root (the smoke) gets both from that root; the live path resolves
+// the config root through the vault resolver.
+export function detectRegistryPrimeReminder(
+  prompt,
+  repoRoot = REPO_ROOT,
+  configRoot = repoRoot === REPO_ROOT ? defaultConfigRoot() : repoRoot,
+) {
+  return detectPrimeReminderPorted(prompt, repoRoot, {
+    ownedElsewhere: PRIME_RULES_OWNED_ELSEWHERE,
+    configRoot,
+  });
+}
+
+function detectProtocolEdit(toolName, toolInput) {
+  if (toolName !== 'Edit' && toolName !== 'MultiEdit' && toolName !== 'Write') return false;
+  const path = toolInput?.file_path ?? toolInput?.path;
+  if (typeof path !== 'string') return false;
+  return PROTOCOL_EDIT_REGEX.test(path);
+}
+
+function detectClaudeMdEdit(toolName, toolInput) {
+  if (toolName !== 'Edit' && toolName !== 'MultiEdit' && toolName !== 'Write') return false;
+  const path = toolInput?.file_path ?? toolInput?.path;
+  if (typeof path !== 'string') return false;
+  return CLAUDE_MD_EDIT_REGEX.test(path);
+}
+
+function detectDestructiveCommand(toolName, toolInput) {
+  if (toolName !== 'Bash' && toolName !== 'PowerShell') return false;
+  const command = toolInput?.command;
+  if (typeof command !== 'string' || !command.trim()) return false;
+  return DESTRUCTIVE_PATTERNS.some((re) => re.test(command));
+}
+
+async function main() {
+  // Env gate: must be explicitly opted in. Hard kill switch wins.
+  if (process.env.HEYSPEX_PREFLIGHT_REMINDER_OFF === '1') return;
+  if (process.env.CLAUDE_AGENT !== 'true') return;
+
+  const raw = await readStdinJson();
+  if (!raw) return;
+  let payload;
+  try {
+    payload = JSON.parse(raw);
+  } catch {
+    return;
+  }
+
+  const event = payload?.hook_event_name;
+  if (!event) return;
+
+  if (event === 'UserPromptSubmit') {
+    // Combine reminders into ONE emit — emitting twice would write two JSON
+    // objects to stdout and break the hook contract. The filing-intent reminder
+    // and the grounding nudge are independent and can co-fire.
+    const parts = [];
+    const intentReminder = detectRegistryPrimeReminder(payload?.prompt, REPO_ROOT);
+    if (intentReminder) parts.push(intentReminder);
+    if (process.env.HEYSPEX_GROUNDING_NUDGE_OFF !== '1') {
+      const grounding = detectDesignIntent(payload?.prompt);
+      if (grounding) parts.push(grounding);
+    }
+    if (parts.length) emit(event, parts.join('\n\n'));
+    return;
+  }
+
+  if (event === 'PreToolUse') {
+    const toolName = payload?.tool_name;
+    const toolInput = payload?.tool_input ?? {};
+
+    if (detectProtocolEdit(toolName, toolInput)) {
+      emit(event, PROTOCOL_EDIT_REMINDER);
+      return;
+    }
+    if (detectClaudeMdEdit(toolName, toolInput)) {
+      emit(event, CLAUDE_MD_EDIT_REMINDER);
+      return;
+    }
+    if (detectDestructiveCommand(toolName, toolInput)) {
+      emit(event, DESTRUCTIVE_REMINDER);
+      return;
+    }
+    return;
+  }
+}
+
+// Entry-guard: run main() only when executed as the hook, NOT when imported (the smoke
+// imports detectRegistryPrimeReminder to unit-test the config/injected-content paths).
+const INVOKED_DIRECTLY =
+  !!process.argv[1] && fileURLToPath(import.meta.url) === path.resolve(process.argv[1]);
+if (INVOKED_DIRECTLY) {
+  main().catch(() => {
+    // Never break Claude Code on a hook failure. Match emit-claim-status.mjs.
+  });
+}