continuous-improvement 3.11.0 → 3.15.0

package/plugins/continuous-improvement/hooks/companion-preference.mjs

@@ -12,11 +12,17 @@
  *                             (when installed) or the install hint (when not).
  *
  * Fail-open: any unexpected error reading stdin / parsing settings / probing
- * the filesystem → emit { decision: "allow" } and exit 0. The hook never
- * blocks on its own bugs.
+ * the filesystem → exit 0 with empty stdout (allow). The hook never blocks
+ * on its own bugs.
  *
  * Stdin  : JSON { tool_name, tool_input }
- * Stdout : JSON { decision: "allow" | "block", reason?: string }
+ * Stdout : empty on allow (no output = no opinion, the call proceeds); on
+ *          deny, the documented PreToolUse shape:
+ *          { hookSpecificOutput: { hookEventName: "PreToolUse",
+ *            permissionDecision: "deny", permissionDecisionReason } }
+ *          A bare { decision: "allow" } is not schema-valid for PreToolUse
+ *          (the deprecated enum is "approve" | "block") and surfaces as a
+ *          "Hook JSON output validation failed" error on every tool call.
  * Exit   : 0 always — decision lives in stdout, never in the exit code.
  *
  * OVERRIDES map must stay row-aligned with skills/superpowers.md
@@ -50,8 +56,20 @@ const OVERRIDES = {
         plugin: "oh-my-claudecode",
     },
 };
-function emitAndExit(d) {
-    process.stdout.write(`${JSON.stringify(d)}\n`);
+// Allow = empty stdout + exit 0. Emitting JSON here is wrong: PreToolUse has
+// no { decision: "allow" } shape, and the invalid output surfaces as a
+// per-tool-call "Hook JSON output validation failed" error in the client.
+function emitAllowAndExit() {
+    process.exit(0);
+}
+function emitDenyAndExit(reason) {
+    process.stdout.write(`${JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "deny",
+            permissionDecisionReason: reason,
+        },
+    })}\n`);
     process.exit(0);
 }
 function readStdin() {
@@ -137,19 +155,19 @@ function main() {
         payload = JSON.parse(raw);
     }
     catch {
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     if (payload.tool_name !== "Skill") {
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     const skill = payload.tool_input?.skill;
     if (typeof skill !== "string" || skill.length === 0) {
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     const normalized = normalizeSkill(skill);
     const override = OVERRIDES[normalized];
     if (!override) {
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     const home = resolveHome();
     const mode = readMode(home);
@@ -166,25 +184,19 @@ function main() {
         // Shadow row: what companions-first would have done. This is the data
         // set that earns a future default-flip decision.
         writeTelemetry(home, { ...baseEvent, mode, action: "observation" });
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     if (mode === "companions-first") {
         process.stderr.write(`[continuous-improvement] companion_preference=companions-first → prefer \`${override.companion}\` over \`ci:${normalized}\`.\n`);
         writeTelemetry(home, { ...baseEvent, mode, action: "advisory" });
-        emitAndExit({ decision: "allow" });
+        emitAllowAndExit();
     }
     // strict-companions: always block; reason depends on install state.
     if (installed) {
         writeTelemetry(home, { ...baseEvent, mode, action: "block" });
-        emitAndExit({
-            decision: "block",
-            reason: `companion_preference=strict-companions: route to \`${override.companion}\` instead of \`ci:${normalized}\`. The CI fallback is suppressed by your setting.`,
-        });
+        emitDenyAndExit(`companion_preference=strict-companions: route to \`${override.companion}\` instead of \`ci:${normalized}\`. The CI fallback is suppressed by your setting.`);
     }
     writeTelemetry(home, { ...baseEvent, mode, action: "block-not-installed" });
-    emitAndExit({
-        decision: "block",
-        reason: `companion_preference=strict-companions: companion plugin \`${override.plugin}\` is not installed. Install with \`/plugin install ${override.plugin}@continuous-improvement\` or relax the setting to \`companions-first\` or \`ci-first\` in ~/.claude/settings.json.`,
-    });
+    emitDenyAndExit(`companion_preference=strict-companions: companion plugin \`${override.plugin}\` is not installed. Install with \`/plugin install ${override.plugin}@continuous-improvement\` or relax the setting to \`companions-first\` or \`ci-first\` in ~/.claude/settings.json.`);
 }
 main();

package/plugins/continuous-improvement/hooks/gateguard.mjs

@@ -3,7 +3,13 @@
  * Runtime PreToolUse gateguard hook.
  *
  * Stdin  : JSON { tool_name, tool_input }
- * Stdout : JSON { decision: "allow" | "block", reason?: string }
+ * Stdout : empty on allow (no output = no opinion, the call proceeds); on
+ *          deny, the documented PreToolUse shape:
+ *          { hookSpecificOutput: { hookEventName: "PreToolUse",
+ *            permissionDecision: "deny", permissionDecisionReason } }
+ *          A bare { decision: "allow" } is not schema-valid for PreToolUse
+ *          (the deprecated enum is "approve" | "block") and surfaces as a
+ *          "Hook JSON output validation failed" error on every tool call.
  * Exit   : 0 always (decision is in stdout, fail-open on parse error).
  *
  * Three-stage gate per skills/gateguard.md:
@@ -27,7 +33,8 @@
  * path.
  */
 import { readFileSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
 import { MAX_CLEARED_FILES, canonicalizeFileKey, isCapReached, isFileCleared, loadState, markFileCleared, resolveSessionDir, saveState, } from "../lib/gateguard-state.mjs";
 const TOOL_ROUTE = {
     Read: "allow",
@@ -104,11 +111,23 @@ function formatFileTarget(filePaths) {
         return nonEmpty[0];
     return `${nonEmpty.length} files (${nonEmpty.join(", ")})`;
 }
+// Resolved from the hook's own location at load time. The block reason must
+// print a command the agent can run in its OWN shell, where ${CLAUDE_PLUGIN_ROOT}
+// is empty — that variable is only populated while this hook itself executes.
+// bin/ is a sibling of hooks/ in both the repo layout and the plugin-bundle
+// mirror, so this resolves correctly from either.
+const CLEAR_CLI_PATH = join(dirname(fileURLToPath(import.meta.url)), "..", "bin", "gateguard-clear.mjs");
+// Quote a path for the printed clearance command. Forward slashes (node accepts
+// them on every platform and they survive a Bash double-quote without escaping)
+// inside JSON quotes — JSON.stringify still escapes any embedded quote, so a
+// path like a"b.ts stays safe rather than collapsing into a bare-quoted token.
+function quotePath(p) {
+    return JSON.stringify(p.replace(/\\/g, "/"));
+}
 function buildMutatingFileReason(toolName, filePaths, stateFilePath) {
     const target = formatFileTarget(filePaths);
     const pathList = filePaths.filter((p) => p !== "");
-    const jsonArray = (pathList.length > 0 ? pathList : [target]).map((p) => JSON.stringify(p)).join(", ");
-    const cliArgs = (pathList.length > 0 ? pathList : [target]).map((p) => JSON.stringify(p)).join(" ");
+    const quoted = (pathList.length > 0 ? pathList : [target]).map((p) => quotePath(p));
     return [
         `Before ${toolName === "Write" ? "creating" : "editing"} ${target}, present these facts:`,
         "",
@@ -117,13 +136,12 @@ function buildMutatingFileReason(toolName, filePaths, stateFilePath) {
         "  3. If this file reads/writes data files, show field names, structure, and date format",
         "  4. Quote the user's current instruction verbatim",
         "",
-        "Then clear the gate and retry the same call. Any one of:",
-        `  A. MCP tool:  ci_gateguard_clear  {file_paths: [${jsonArray}]}`,
-        `  B. CLI (Bash, never gated): node "\${CLAUDE_PLUGIN_ROOT}/bin/gateguard-clear.mjs" ${cliArgs}`,
-        `  C. Manual: append each path to "cleared_files" in ${stateFilePath} via a non-destructive Bash write.`,
-        "  Clearance matches regardless of drive-letter case or path separator.",
-        "  (On harnesses that forward unknown tool params you may instead retry with",
-        "  `_gateguard_facts_presented: true`; Claude Code's strict schema rejects that, so use A/B/C.)",
+        "Then clear the gate and retry the same call. Either route works:",
+        `  A. Bash (always works — run verbatim): node ${quotePath(CLEAR_CLI_PATH)} --state ${quotePath(stateFilePath)} ${quoted.join(" ")}`,
+        `  B. MCP tool (when the continuous-improvement server is connected): ci_gateguard_clear  {file_paths: [${quoted.join(", ")}], state_path: ${quotePath(stateFilePath)}}`,
+        "  Both canonicalize paths — drive-letter case and separators don't matter.",
+        "  (Harnesses that forward unknown tool params may instead retry the call with",
+        "  `_gateguard_facts_presented: true`; Claude Code's strict schema rejects that, so use A or B.)",
     ].join("\n");
 }
 function buildDestructiveBashReason(command) {
@@ -139,13 +157,26 @@ function buildDestructiveBashReason(command) {
 }
 function buildCapReachedReason() {
     return [
-        `Gateguard session clearance cap reached (${MAX_CLEARED_FILES} distinct files).`,
-        "Start a new Claude Code session to reset the gate. The cap exists to bound",
-        "stuck-loop or rogue-agent clearance from compounding within a single session.",
+        `Gateguard clearance cap reached (${MAX_CLEARED_FILES} distinct files this session).`,
+        "The cap is per-session: start a new Claude Code session to reset it, or wait",
+        "for the state file to self-heal. It bounds stuck-loop or rogue-agent clearance",
+        "from compounding within one session without affecting your other sessions.",
     ].join("\n");
 }
-function emit(decision) {
-    process.stdout.write(`${JSON.stringify(decision)}\n`);
+// Allow = empty stdout + exit 0. Emitting JSON here is wrong: PreToolUse has
+// no { decision: "allow" } shape, and the invalid output surfaces as a
+// per-tool-call "Hook JSON output validation failed" error in the client.
+function emitAllow() {
+    process.exit(0);
+}
+function emitDeny(reason) {
+    process.stdout.write(`${JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            permissionDecision: "deny",
+            permissionDecisionReason: reason,
+        },
+    })}\n`);
     process.exit(0);
 }
 function main() {
@@ -154,7 +185,7 @@ function main() {
         raw = readFileSync(0, "utf8");
     }
     catch {
-        emit({ decision: "allow" });
+        emitAllow();
         return;
     }
     let payload;
@@ -162,23 +193,26 @@ function main() {
         payload = JSON.parse(raw);
     }
     catch {
-        emit({ decision: "allow" }); // fail-open
+        emitAllow(); // fail-open
         return;
     }
     const toolName = typeof payload.tool_name === "string" ? payload.tool_name : "";
     const toolInput = payload.tool_input ?? {};
     const gate = classifyTool(toolName, toolInput);
     if (gate === "allow") {
-        emit({ decision: "allow" });
+        emitAllow();
         return;
     }
     if (gate === "destructive-bash") {
         const cmd = typeof toolInput.command === "string" ? toolInput.command : "";
-        emit({ decision: "block", reason: buildDestructiveBashReason(cmd) });
+        emitDeny(buildDestructiveBashReason(cmd));
         return;
     }
-    // mutating-file
-    const sessionDir = resolveSessionDir();
+    // mutating-file — scope state to THIS session so the clearance cap never
+    // bleeds across concurrent same-day sessions. session_id is the standard hook
+    // stdin field (see recall-briefing / observe-event); absent → legacy dir.
+    const sessionId = typeof payload.session_id === "string" ? payload.session_id : undefined;
+    const sessionDir = resolveSessionDir(sessionId);
     const stateFilePath = join(sessionDir, "gateguard-session.json");
     const state = loadState(sessionDir);
     const filePaths = extractFilePaths(toolInput);
@@ -187,12 +221,12 @@ function main() {
     const alreadyCleared = filePaths.length > 0 && filePaths.every((path) => isFileCleared(state, path));
     const newFileCount = countDistinctNewFilePaths(filePaths, state);
     if (!factsFlagged && !alreadyCleared) {
-        emit({ decision: "block", reason: buildMutatingFileReason(toolName, filePaths.length > 0 ? filePaths : [filePath], stateFilePath) });
+        emitDeny(buildMutatingFileReason(toolName, filePaths.length > 0 ? filePaths : [filePath], stateFilePath));
         return;
     }
     if (factsFlagged && !alreadyCleared) {
         if (isCapReached(state) || Object.keys(state.cleared_files).length + newFileCount > MAX_CLEARED_FILES) {
-            emit({ decision: "block", reason: buildCapReachedReason() });
+            emitDeny(buildCapReachedReason());
             return;
         }
         let nextState = state;
@@ -202,6 +236,6 @@ function main() {
         if (filePaths.length > 0)
             saveState(sessionDir, nextState);
     }
-    emit({ decision: "allow" });
+    emitAllow();
 }
 main();

package/plugins/continuous-improvement/hooks/hook-pack.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Runtime PreToolUse enforcing-hook pack (v1).
+ *
+ * Stdin  : JSON { tool_name, tool_input: { command } }
+ * Stdout : empty on allow / warn (warn prints to stderr); on block, the
+ *          documented PreToolUse shape:
+ *          { hookSpecificOutput: { hookEventName: "PreToolUse",
+ *            permissionDecision: "deny", permissionDecisionReason } }
+ *          A bare { decision: "allow" } is not schema-valid for PreToolUse.
+ * Exit   : 0 always (decision is in stdout; fail-open on any error).
+ *
+ * Two gates over Bash git commands (pure logic in ../lib/hook-pack-gate.mjs):
+ *   - push-to-main : a direct `git push` to main/master/release-*
+ *   - commit-size  : a `git commit` staging more than COMMIT_FILE_LIMIT files
+ *
+ * Mode via CLAUDE_CI_HOOKPACK_GATE: "warn" (default) | "block" | "off".
+ *   warn  : print a one-line notice to stderr; never blocks.
+ *   block : emit the PreToolUse deny shape.
+ *   off   : no-op.
+ *
+ * Only `git push` / `git commit` commands spawn a git subprocess; every other
+ * Bash command and non-Bash tool returns immediately. No network. Fail-open.
+ */
+import { execFileSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import { COMMIT_FILE_LIMIT, classifyCommand, decide, evaluateCommitSize, evaluatePush, parseMode, } from "../lib/hook-pack-gate.mjs";
+function readStdinSync() {
+    try {
+        return readFileSync(0, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function safeJsonParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+function gitCurrentBranch() {
+    try {
+        const branch = execFileSync("git", ["rev-parse", "--abbrev-ref", "HEAD"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        return branch || null;
+    }
+    catch {
+        return null;
+    }
+}
+function gitStagedCount() {
+    try {
+        const out = execFileSync("git", ["diff", "--cached", "--name-only"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return out.split(/\r?\n/).filter(Boolean).length;
+    }
+    catch {
+        return 0;
+    }
+}
+const ALLOW = { action: "allow", reason: "" };
+function compute() {
+    const mode = parseMode(process.env.CLAUDE_CI_HOOKPACK_GATE);
+    if (mode === "off")
+        return ALLOW;
+    const payload = safeJsonParse(readStdinSync());
+    if (!payload || typeof payload !== "object")
+        return ALLOW;
+    const obj = payload;
+    if (obj.tool_name !== "Bash")
+        return ALLOW;
+    const input = (obj.tool_input && typeof obj.tool_input === "object"
+        ? obj.tool_input
+        : {});
+    const command = typeof input.command === "string" ? input.command : "";
+    const kind = classifyCommand(command);
+    if (kind === "push") {
+        const res = evaluatePush(command, gitCurrentBranch());
+        return decide(mode, res.gated, `Direct push to protected branch "${res.branch}" — open a feature branch + PR instead.`);
+    }
+    if (kind === "commit") {
+        const res = evaluateCommitSize(command, gitStagedCount());
+        return decide(mode, res.gated, `This commit stages more than ${COMMIT_FILE_LIMIT} files — exceeds the one-concern limit. Split by layer, or set CLAUDE_CI_HOOKPACK_GATE=off for genuinely generated bulk.`);
+    }
+    return ALLOW;
+}
+function main() {
+    const decision = compute();
+    if (decision.action === "block") {
+        process.stdout.write(JSON.stringify({
+            hookSpecificOutput: {
+                hookEventName: "PreToolUse",
+                permissionDecision: "deny",
+                permissionDecisionReason: decision.reason,
+            },
+        }));
+    }
+    else if (decision.action === "warn") {
+        process.stderr.write(`[hook-pack] ${decision.reason}\n`);
+    }
+    process.exit(0);
+}
+main();

package/plugins/continuous-improvement/hooks/hooks.json

@@ -1,5 +1,5 @@
 {
-  "description": "Gateguard fact-forcing PreToolUse, companion-preference enforcement, observation, session lifecycle, 3-section-close discipline, goal-drift Stop gate, and UserPromptSubmit lazy-routing hooks for continuous-improvement.",
+  "description": "Gateguard fact-forcing PreToolUse, companion-preference enforcement, observation, session lifecycle, 3-section-close discipline, goal-drift Stop gate, and UserPromptSubmit lazy-routing plus opt-in proactive recall-briefing hooks for continuous-improvement.",
   "hooks": {
     "PreToolUse": [
       {
@@ -15,6 +15,16 @@
             "timeout": 5
           }
         ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/hook-pack.mjs\"",
+            "timeout": 5
+          }
+        ]
       }
     ],
     "PostToolUse": [
@@ -35,6 +45,11 @@
             "type": "command",
             "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/route-prompt.mjs\"",
             "timeout": 5
+          },
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/recall-briefing.mjs\"",
+            "timeout": 5
           }
         ]
       }

package/plugins/continuous-improvement/hooks/recall-briefing.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+/**
+ * Runtime UserPromptSubmit recall-briefing hook (opt-in amplifier).
+ *
+ * On the first substantive prompt of a session, searches this project's past
+ * observations (BM25, via recall-index.mts) and injects a one-time
+ * `<system-reminder>` listing the most relevant prior activity — so the agent
+ * reuses a past fix instead of re-deriving it. This makes episodic memory
+ * proactive instead of opt-in-per-query (the ci_recall MCP tool stays available
+ * for explicit, deeper searches).
+ *
+ * Opt-in: runs only when CLAUDE_RECALL_BRIEFING is 1/on/true. Default off, so it
+ * never changes the prompt path for users who have not enabled it.
+ *
+ * Stdin  : JSON { prompt, session_id?, cwd? }
+ * Stdout : JSON { hookSpecificOutput: { hookEventName: "UserPromptSubmit",
+ *                                       additionalContext: string } }
+ *          OR empty when it should not brief.
+ * Exit   : 0 always — this is an amplifier, never a gate; it cannot block a prompt.
+ *
+ * Fail-open: any error (no env flag, bad stdin, missing/short observations log,
+ * unreadable state) emits nothing and exits 0. State at
+ * ~/.claude/instincts/<project-hash>/recall-briefing-session.json records which
+ * session_ids have been briefed so each session is briefed at most once.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { buildIndex, query } from "../lib/recall-index.mjs";
+import { DEFAULT_MAX_HITS, decideBriefing } from "../lib/recall-briefing.mjs";
+const ENABLED_VALUES = new Set(["1", "on", "true", "yes"]);
+const MAX_BRIEFED_KEYS = 1000;
+function isEnabled() {
+    const flag = (process.env.CLAUDE_RECALL_BRIEFING ?? "").trim().toLowerCase();
+    return ENABLED_VALUES.has(flag);
+}
+function readStdin() {
+    try {
+        return readFileSync(0, "utf8");
+    }
+    catch {
+        return "";
+    }
+}
+function resolveHome() {
+    return process.env.HOME ?? process.env.USERPROFILE ?? homedir();
+}
+function resolveProjectRoot() {
+    const fromEnv = process.env.CLAUDE_PROJECT_DIR;
+    if (fromEnv)
+        return fromEnv;
+    try {
+        const root = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (root)
+            return root;
+    }
+    catch {
+        // not in a git repo
+    }
+    return "global";
+}
+function instinctsDir(home) {
+    const hash = createHash("sha256").update(resolveProjectRoot()).digest("hex").slice(0, 12);
+    return join(home, ".claude", "instincts", hash);
+}
+function readObservations(dir) {
+    const path = join(dir, "observations.jsonl");
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const rows = [];
+    for (const line of raw.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            rows.push(JSON.parse(trimmed));
+        }
+        catch {
+            // skip a malformed line; never let one bad row sink the briefing
+        }
+    }
+    return rows;
+}
+function readState(dir) {
+    try {
+        const parsed = JSON.parse(readFileSync(join(dir, "recall-briefing-session.json"), "utf8"));
+        if (parsed && typeof parsed.briefed === "object" && parsed.briefed !== null)
+            return parsed;
+    }
+    catch {
+        // missing or malformed → fresh state
+    }
+    return { briefed: {} };
+}
+function writeState(dir, state, sessionKey) {
+    try {
+        const keys = Object.keys(state.briefed);
+        // Bound growth: if the map is huge, keep only the most recent run plus this one.
+        const briefed = keys.length >= MAX_BRIEFED_KEYS ? {} : state.briefed;
+        briefed[sessionKey] = new Date().toISOString();
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "recall-briefing-session.json"), `${JSON.stringify({ briefed }, null, 2)}\n`);
+    }
+    catch {
+        // fail-open: a missed state write at worst briefs twice; it never blocks
+    }
+}
+function emit(additionalContext) {
+    if (additionalContext !== null) {
+        process.stdout.write(`${JSON.stringify({
+            hookSpecificOutput: { hookEventName: "UserPromptSubmit", additionalContext },
+        })}\n`);
+    }
+    process.exit(0);
+}
+function main() {
+    if (!isEnabled()) {
+        emit(null);
+        return;
+    }
+    let payload;
+    try {
+        payload = JSON.parse(readStdin());
+    }
+    catch {
+        emit(null);
+        return;
+    }
+    const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
+    if (prompt.length === 0) {
+        emit(null);
+        return;
+    }
+    const sessionKey = typeof payload.session_id === "string" && payload.session_id ? payload.session_id : "no-session";
+    const home = resolveHome();
+    const dir = instinctsDir(home);
+    const state = readState(dir);
+    const alreadyBriefed = Object.prototype.hasOwnProperty.call(state.briefed, sessionKey);
+    const observations = readObservations(dir);
+    const index = buildIndex(observations);
+    const hits = query(index, prompt, { k: DEFAULT_MAX_HITS });
+    const decision = decideBriefing({ enabled: true, alreadyBriefed, prompt, hits });
+    if (!decision.shouldBrief || decision.reminder === null) {
+        emit(null);
+        return;
+    }
+    writeState(dir, state, sessionKey);
+    emit(decision.reminder);
+}
+try {
+    main();
+}
+catch {
+    // Absolute fail-open backstop: never let a hook bug block a prompt.
+    process.exit(0);
+}