greprag 5.49.6 → 5.49.9

package/dist/hook.js

@@ -78,7 +78,6 @@ const guard_1 = require("./guard");
 const reminder_registry_1 = require("./commands/reminder-registry");
 const inbox_primer_reminder_1 = require("./commands/inbox-primer-reminder");
 const friction_reminder_1 = require("./commands/friction-reminder");
-const memory_reflex_1 = require("./commands/memory-reflex");
 const worktree_state_1 = require("./worktree-state");
 // Ingress-trigger bridge, Adapter A (LOCAL/state half) — the Stop hook computes
 // the deterministic state values (stress / turnCount / keyword-seen) from the
@@ -786,37 +785,7 @@ async function store(input, source = 'claude-code') {
     if (source === 'codex') {
         turn.toolCalls.push(...(0, codex_hook_events_1.readCodexSubagentToolCalls)(input));
     }
-    // Memory-reflex EFFICACY capture (adr/memory-reflex.md). If a memory injection was surfaced
-    // this turn: (1) score the FREE overlap proxy locally → bump the `used` numerator, and (2)
-    // carry the injection onto the turn POST so the server-side Flash-Lite judge (Chip A) can
-    // score it accurately. Consume-once: the stash is always cleared, so a turn with no injection
-    // never reuses a stale sample. adr: adr/memory-reflex.md
-    let memoryInjectionForStore = null;
-    try {
-        const effShort = (0, session_id_1.truncateSessionId)(input.session_id);
-        if (effShort) {
-            const pending = consumeMemoryInjection(effShort);
-            if (pending) {
-                memoryInjectionForStore = pending.hitText;
-                if ((0, memory_reflex_1.injectionWasUsed)(pending.hitText, turn.userPrompt, turn.agentResponse)) {
-                    recordMemoryUsed(pending.projectId);
-                }
-            }
-        }
-    }
-    catch { /* efficacy capture is best-effort — never block the turn */ }
-    // Self-report scan (P1b, adr/memory-reflex.md). If the agent emitted a [[recall: X]] marker
-    // (taught by the memory announce) it's flagging its OWN context gap → stash the topic so the
-    // NEXT turn's notify pulls + injects it (the self-report trigger). Best-effort.
-    try {
-        const srShort = (0, session_id_1.truncateSessionId)(input.session_id);
-        if (srShort && anchor.projectId) {
-            const topic = (0, memory_reflex_1.extractRecallMarker)(turn.agentResponse);
-            if (topic)
-                stashSelfReport(srShort, anchor.projectId, topic);
-        }
-    }
-    catch { /* best-effort — never block the turn */ }
+    // (Memory-reflex efficacy capture removed 2026-06-22 with the auto-inject it scored.)
     // Empty turn — nothing to capture.
     if (!turn.userPrompt && !turn.agentResponse && turn.toolCalls.length === 0)
         return;
@@ -853,12 +822,6 @@ async function store(input, source = 'claude-code') {
         status: turn.status,
         userPrompt,
         agentResponse,
-        // The memory injection surfaced this turn (when any) — the SEAM the Flash-Lite efficacy
-        // judge (Chip A) consumes server-side at ingest to score used÷injected. Scrubbed + capped
-        // like the other text fields. Omitted entirely on the common no-injection turn.
-        ...(memoryInjectionForStore
-            ? { memoryInjection: capField((0, secret_scrubber_1.scrubString)(memoryInjectionForStore, redaction)) }
-            : {}),
         toolCalls,
         filesTouched: turn.filesTouched,
         artifacts: artifactRefs,
@@ -938,6 +901,24 @@ async function fetchFrontDeskUnread(apiUrl, apiKey) {
         return 0;
     }
 }
+/** Fetch the names of api-docs-tagged corpus stores (the corpus-announce signal).
+ *  Lists `/v1/stores?tag=api-docs` and returns the store names so the announce can
+ *  name the on-tap reference banks. Best-effort: [] on any error → the announce
+ *  stays silent. adr: adr/corpus-tags.md */
+async function fetchCorpusApiDocs(apiUrl, apiKey) {
+    try {
+        const res = await fetch(`${apiUrl}/v1/stores?tag=api-docs`, {
+            headers: { 'Authorization': `Bearer ${apiKey}` },
+        });
+        if (!res.ok)
+            return [];
+        const data = await res.json();
+        return (data.stores || []).map(s => s.name || '').filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
 /** Fetch this session's OWN unread count — messages addressed to `to_session_id =
  *  <short>` (mail a peer or the operator sent to THIS session). Safe + non-eavesdrop:
  *  reads only this session's mail, NOT the project-wide count the v5.6.1 removal retired
@@ -957,44 +938,6 @@ async function fetchSessionUnread(apiUrl, apiKey, short) {
         return 0;
     }
 }
-/** Fetch top episodic-memory hits for a query (the memory-reflex inline path), project-
- *  scoped, with a HARD timeout so a slow search never blocks the turn. POSTs the same
- *  `/v1/memory/query` the CLI `memory search` uses, with the de-pollution `session-turn`
- *  provenance filter. Returns [] on any error/abort → the reflex stays silent. The
- *  confidence gate + framing live in buildMemoryInjection (commands/memory-reflex.ts).
- *  adr: adr/memory-reflex.md */
-async function fetchMemoryHits(apiUrl, apiKey, projectId, query, limit = 3, timeoutMs = 2000) {
-    const ctl = new AbortController();
-    const timer = setTimeout(() => ctl.abort(), timeoutMs);
-    try {
-        const res = await fetch(`${apiUrl}/v1/memory/query`, {
-            method: 'POST',
-            headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify({ query, limit, projectId, filters: { provenance: 'session-turn' } }),
-            signal: ctl.signal,
-        });
-        if (!res.ok)
-            return { hits: [], quiet: false };
-        const data = await res.json();
-        // The server's Flash-Lite efficacy verdict rides the same response (adr/memory-reflex.md).
-        const quiet = data.memoryReflexQuiet === true;
-        if (!data.ok || !Array.isArray(data.nodes))
-            return { hits: [], quiet };
-        return {
-            hits: data.nodes.map(n => ({
-                content: n.content, score: n.score, confidence: n.confidence ?? null,
-                shape: n.shape ?? null, createdAt: n.createdAt ?? null, projectName: n.projectName ?? null,
-            })),
-            quiet,
-        };
-    }
-    catch {
-        return { hits: [], quiet: false };
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
 /** Identity-drift warning rate limiter.
  *
  *  The drift warning ("stored ID ≠ git-derived ID, run `greprag doctor`") used
@@ -1069,6 +1012,78 @@ function writeRecapOutput(text, mode) {
     }
     process.stdout.write(text);
 }
+/** This CLI's installed version (from the bundled package.json). Null if unreadable. */
+function installedVersion() {
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8'));
+        return typeof pkg.version === 'string' ? pkg.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Is semver `b` strictly greater than `a`? Plain numeric major.minor.patch compare
+ *  (greprag never ships pre-release tags). Non-numeric segments collapse to 0. */
+function isNewer(a, b) {
+    const pa = a.split('.').map(n => parseInt(n, 10) || 0);
+    const pb = b.split('.').map(n => parseInt(n, 10) || 0);
+    for (let i = 0; i < 3; i++) {
+        if ((pb[i] || 0) > (pa[i] || 0))
+            return true;
+        if ((pb[i] || 0) < (pa[i] || 0))
+            return false;
+    }
+    return false;
+}
+const VERSION_CHECK_TTL_MS = 24 * 60 * 60 * 1000; // once a day
+function versionCheckPath() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    return path.join(home, '.greprag', 'state', 'version-check.json');
+}
+/** The Deficiency-gated upgrade signal (version-reminder.ts). Returns {current, latest}
+ *  when the installed CLI is behind the latest published version, else null. The npm-registry
+ *  read is cached daily (a slow/offline check never blocks SessionStart — stale cache or no
+ *  cache → no announce, fail-quiet). */
+async function checkForUpdate() {
+    const current = installedVersion();
+    if (!current)
+        return null;
+    let latest = null;
+    try {
+        const raw = fs.readFileSync(versionCheckPath(), 'utf-8');
+        const c = JSON.parse(raw);
+        const age = c.checkedAt ? Date.now() - Date.parse(c.checkedAt) : Infinity;
+        if (typeof c.latest === 'string' && Number.isFinite(age) && age < VERSION_CHECK_TTL_MS) {
+            latest = c.latest; // fresh cache hit
+        }
+    }
+    catch { /* no/bad cache — refetch */ }
+    if (!latest) {
+        try {
+            const ctl = new AbortController();
+            const timer = setTimeout(() => ctl.abort(), 1500);
+            const res = await fetch('https://registry.npmjs.org/greprag/latest', { signal: ctl.signal });
+            clearTimeout(timer);
+            if (res.ok) {
+                const data = await res.json();
+                if (typeof data.version === 'string') {
+                    latest = data.version;
+                    try {
+                        const file = versionCheckPath();
+                        if (!fs.existsSync(path.dirname(file)))
+                            fs.mkdirSync(path.dirname(file), { recursive: true });
+                        fs.writeFileSync(file, JSON.stringify({ latest, checkedAt: new Date().toISOString() }) + '\n');
+                    }
+                    catch { /* cache write best-effort */ }
+                }
+            }
+        }
+        catch { /* offline / slow → no announce this session */ }
+    }
+    if (latest && isNewer(current, latest))
+        return { current, latest };
+    return null;
+}
 /** SessionStart — fetch recent episodic activity for this project and print
  *  to stdout. Claude Code injects the printed text as session context. Codex
  *  uses the same content via `hookSpecificOutput.additionalContext`. Fires
@@ -1177,12 +1192,19 @@ async function recap(input, mode = 'plain') {
     // by the front-desk module's announce. NOT the v5.6.1 eavesdrop vector — see
     // fetchFrontDeskUnread. adr: adr/address-grammar.md (2026-06-10), docs/front-desk-switchboard.md §5
     const frontDeskUnread = await fetchFrontDeskUnread(cfg.apiUrl, cfg.apiKey);
+    // Corpus-announce signal — the names of the api-docs-tagged reference banks on
+    // tap, so the corpus module can tell the agent to search them before answering
+    // from training data. Best-effort; empty → the announce stays silent.
+    const corpusApiDocs = await fetchCorpusApiDocs(cfg.apiUrl, cfg.apiKey);
     // Assistant doctrine auto-load — fires ONLY for the flagged assistant project
     // (isAssistantProject), so a normal project sees zero change. The hook owns the
     // doctrine-file read; the assistant-doctrine module routes the text. adr: adr/assistant-role.md
     const assistantDoctrine = (0, project_anchor_1.isAssistantProject)(anchor)
         ? (0, assistant_doctrine_1.buildAssistantDoctrineContext)(cwd)
         : null;
+    // Deficiency-gated upgrade announce: daily-cached npm check → tell the user to
+    // upgrade when behind. This is how a release actually propagates to everyone.
+    const updateAvailable = await checkForUpdate();
     // ── THE single SessionStart announce assembly (docs/reminder-interrupt.md §Registry
     // spec) ──────────────────────────────────────────────────────────────────────────────
     // Every agent-facing announce — setup-warning, front-desk, checkpoint, assistant-doctrine,
@@ -1206,6 +1228,8 @@ async function recap(input, mode = 'plain') {
         frontDeskUnread,
         openCheckpoints,
         assistantDoctrine,
+        corpusApiDocs,
+        updateAvailable,
     };
     let announceReg = mechanicKilled() ? reminder_registry_1.REGISTRY.filter(m => m.id !== 'mechanic-friction') : reminder_registry_1.REGISTRY;
     if (!announceShort)
@@ -1379,165 +1403,14 @@ function recordFrictionFire(projectId, tier, turnCount) {
     }
     catch { /* counter is best-effort — never block the turn */ }
 }
-/** Local path for this project's memory-reflex fire-counter — the data the /mechanic
- *  excessiveness monitor reads (fires · injected · silent · per-trigger). Beside the
- *  friction counter under ~/.greprag/state. */
-function memoryReflexStatsPath(projectId) {
-    const home = process.env.HOME || process.env.USERPROFILE || '';
-    return path.join(home, '.greprag', 'state', `memory-reflex-${projectId}.json`);
-}
-/** Tally one memory-reflex fire (best-effort). `didInject` splits fire→injected vs silent
- *  so the monitor can read the inject/fire ratio (firing without finding = noise). */
-function recordMemoryFire(projectId, trigger, didInject, turnCount) {
-    try {
-        const file = memoryReflexStatsPath(projectId);
-        let prior = null;
-        try {
-            prior = JSON.parse(fs.readFileSync(file, 'utf-8'));
-        }
-        catch { /* none yet */ }
-        const next = (0, memory_reflex_1.tallyMemoryFire)(prior, trigger, didInject, turnCount, new Date().toISOString());
-        const dir = path.dirname(file);
-        if (!fs.existsSync(dir))
-            fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(file, JSON.stringify(next, null, 2) + '\n');
-    }
-    catch { /* counter is best-effort — never block the turn */ }
-}
-/** Stash for the memory-reflex efficacy capture — the raw hit content injected THIS turn, so
- *  the Stop hook can score the response's overlap against it (the `used` numerator). Keyed by
- *  session (Stop has the short id); carries projectId so Stop needn't re-derive it. Written at
- *  inject-time, consumed + deleted at Stop. adr: adr/memory-reflex.md */
-function memoryReflexPendingPath(short) {
-    const home = process.env.HOME || process.env.USERPROFILE || '';
-    return path.join(home, '.greprag', 'state', `memory-reflex-pending-${short}.json`);
-}
-function stashMemoryInjection(short, projectId, hitText, turnCount) {
-    try {
-        const file = memoryReflexPendingPath(short);
-        const dir = path.dirname(file);
-        if (!fs.existsSync(dir))
-            fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(file, JSON.stringify({ projectId, hitText, turnCount }) + '\n');
-    }
-    catch { /* best-effort — a missed stash just means no efficacy sample this turn */ }
-}
-/** Read + DELETE the pending injection stash (consume-once, so a turn with no injection never
- *  reuses a stale sample). Returns null on the common no-stash path. */
-function consumeMemoryInjection(short) {
-    try {
-        const file = memoryReflexPendingPath(short);
-        const raw = fs.readFileSync(file, 'utf-8');
-        try {
-            fs.unlinkSync(file);
-        }
-        catch { /* already gone — fine */ }
-        const p = JSON.parse(raw);
-        if (!p || typeof p.projectId !== 'string' || typeof p.hitText !== 'string')
-            return null;
-        return { projectId: p.projectId, hitText: p.hitText };
-    }
-    catch {
-        return null; // no stash this turn (the common case)
-    }
-}
-/** Bump the memory-reflex EFFICACY numerator (the response drew on the injection) — best-effort. */
-function recordMemoryUsed(projectId) {
-    try {
-        const file = memoryReflexStatsPath(projectId);
-        let prior = null;
-        try {
-            prior = JSON.parse(fs.readFileSync(file, 'utf-8'));
-        }
-        catch { /* none yet */ }
-        const next = (0, memory_reflex_1.tallyMemoryUsed)(prior);
-        const dir = path.dirname(file);
-        if (!fs.existsSync(dir))
-            fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(file, JSON.stringify(next, null, 2) + '\n');
-    }
-    catch { /* counter is best-effort */ }
-}
-/** Self-report stash (P1b, adr/memory-reflex.md) — the topic the agent flagged via a
- *  `[[recall: X]]` marker LAST turn, so the NEXT turn's notify pulls + injects it. Separate
- *  from the efficacy-injection stash. Keyed by session; carries projectId. Written at Stop,
- *  consumed-once at the next notify. */
-function selfReportPendingPath(short) {
-    const home = process.env.HOME || process.env.USERPROFILE || '';
-    return path.join(home, '.greprag', 'state', `memory-reflex-selfreport-${short}.json`);
-}
-function stashSelfReport(short, projectId, topic) {
-    try {
-        const file = selfReportPendingPath(short);
-        const dir = path.dirname(file);
-        if (!fs.existsSync(dir))
-            fs.mkdirSync(dir, { recursive: true });
-        fs.writeFileSync(file, JSON.stringify({ projectId, topic }) + '\n');
-    }
-    catch { /* best-effort — a missed self-report just means no pull this round */ }
-}
-/** Read + DELETE the self-report stash (consume-once). Null on the common no-marker path. */
-function consumeSelfReport(short) {
-    try {
-        const file = selfReportPendingPath(short);
-        const raw = fs.readFileSync(file, 'utf-8');
-        try {
-            fs.unlinkSync(file);
-        }
-        catch { /* already gone — fine */ }
-        const p = JSON.parse(raw);
-        if (!p || typeof p.projectId !== 'string' || typeof p.topic !== 'string' || !p.topic)
-            return null;
-        return { projectId: p.projectId, topic: p.topic };
-    }
-    catch {
-        return null;
-    }
-}
-/** Local cache of the SERVER's auto-quiet verdict for this project (the
- *  mechanicKilled() analog for the memory-reflex). The Flash-Lite efficacy judge
- *  decides the threshold server-side and ships the boolean on the /v1/memory/query
- *  response; the hook caches it here and `memoryReflexQuieted` honors it with a
- *  TTL (quietCacheSaysSilent). Beside the fire-counter under ~/.greprag/state. */
-function memoryReflexQuietPath(projectId) {
-    const home = process.env.HOME || process.env.USERPROFILE || '';
-    return path.join(home, '.greprag', 'state', `memory-reflex-quiet-${projectId}.json`);
-}
-/** Has the server's efficacy judge QUIETED this project's memory-reflex (low
- *  used÷injected over a meaningful sample)? Reads the local cache; honors it only
- *  while fresh (TTL) so a recovered reflex re-probes instead of staying silenced.
- *  Fail-quiet: any error reads as NOT quieted (the reflex keeps working) —
- *  mirrors mechanicKilled()'s fail-open posture. */
-function memoryReflexQuieted(projectId) {
-    try {
-        const raw = fs.readFileSync(memoryReflexQuietPath(projectId), 'utf-8');
-        return (0, memory_reflex_1.quietCacheSaysSilent)(JSON.parse(raw), Date.now());
-    }
-    catch {
-        return false;
-    }
-}
-/** Cache the server's auto-quiet verdict from a /v1/memory/query response — written
- *  whenever the reflex actually probes (fired the search). Best-effort. */
-function cacheMemoryReflexQuiet(projectId, quiet) {
-    try {
-        const file = memoryReflexQuietPath(projectId);
-        const dir = path.dirname(file);
-        if (!fs.existsSync(dir))
-            fs.mkdirSync(dir, { recursive: true });
-        const payload = { quiet, cachedAt: new Date().toISOString() };
-        fs.writeFileSync(file, JSON.stringify(payload) + '\n');
-    }
-    catch { /* best-effort — a missed cache just means the reflex re-probes next turn */ }
-}
 /** The reminder-interrupt registry CONTAINER call (docs/reminder-interrupt.md §Registry
  *  spec) — invoked from the proven-registered `notify` hook (claude-code path). Assembles
  *  the live env (the ONLY i/o: armed via isLocallyArmed, this session's own unread, the
  *  Stop-stashed stress/turnCount, the front-desk envelope notice) and fires every module
  *  whose detector reports deficient: watcher-arm (unarmed → nag if a peer messaged you, else
- *  nudge; silent when armed), the stress-gated mechanic-friction, front-desk (a soft
- *  "you've got mail" when a new envelope landed), and memory-reflex (auto-surfaced episodic
- *  memory when THIS prompt signals recall — an inline, time-capped, confidence-gated search).
+ *  nudge; silent when armed), the stress-gated mechanic-friction, and front-desk (a soft
+ *  "you've got mail" when a new envelope landed). The memory PRIMER announces at SessionStart;
+ *  the auto-inject was dropped (knowledge injection, not a reminder — docs/reminder-interrupt.md).
  *  The announce-only modules (setup-warning / checkpoint / assistant-doctrine) stay silent per
  *  turn — their env signals are SessionStart-only. Stacking; emitted once. Fail-open — any miss
  *  → silent. The Mechanic kill switch drops ONLY the mechanic module; the rest keep working. */
@@ -1564,48 +1437,22 @@ async function injectReminders(input, cfg, short) {
         // null when nothing new. This is the network call the retired `mail` hook used to make;
         // it moves here so the whole announce/reminder surface rides ONE detector loop.
         const frontDeskNotice = await (0, front_desk_mail_1.buildFrontDeskNotice)(cfg.apiUrl, cfg.apiKey);
-        // Memory-reflex (keyword layer) — recall intent in THIS prompt fires an inline,
-        // time-capped, project-scoped search; a hit above the confidence gate is surfaced
-        // inline (top 1-2, capped) so the agent sees it AS it forms its reply. A miss stays
-        // silent (the search result is its own precision filter — no banner-blindness). Every
-        // fire is tallied for the /mechanic excessiveness monitor. Gated on recall-intent, so
-        // most turns skip the search entirely. docs/reminder-interrupt.md (memory-reflex).
-        let memoryHit = null;
-        const prompt = typeof input.prompt === 'string' ? input.prompt : '';
-        // Pick the memory query + trigger (the hybrid): a self-report marker the agent emitted LAST
-        // turn ([[recall: X]], stashed at Stop) takes precedence over recall-intent in THIS prompt —
-        // the agent explicitly flagged its own gap. One injection per turn.
-        let memQuery = null;
-        let memTrigger = 'keyword';
-        const selfReport = anchor.projectId ? consumeSelfReport(short) : null;
-        if (selfReport) {
-            memQuery = selfReport.topic;
-            memTrigger = 'selfReport';
-        }
-        else if ((0, memory_reflex_1.hasRecallIntent)(prompt)) {
-            memQuery = prompt.slice(0, 500);
-            memTrigger = 'keyword';
-        }
-        // Auto-quiet gate (adr/memory-reflex.md): if the server's Flash-Lite efficacy judge has
-        // QUIETED this project's reflex (low used÷injected over a meaningful sample), skip the search
-        // entirely — the cached verdict expires on a TTL so a recovered reflex re-probes. mechanicKilled() analog.
-        if (anchor.projectId && memQuery && !memoryReflexQuieted(anchor.projectId)) {
-            const { hits, quiet } = await fetchMemoryHits(cfg.apiUrl, cfg.apiKey, anchor.projectId, memQuery);
-            cacheMemoryReflexQuiet(anchor.projectId, quiet); // refresh the verdict from this probe
-            memoryHit = (0, memory_reflex_1.buildMemoryInjection)(hits);
-            recordMemoryFire(anchor.projectId, memTrigger, !!memoryHit, turnCount);
-            // Stash what was injected so the Stop hook can score whether the response used it
-            // (the efficacy numerator). Only when something was actually surfaced.
-            if (memoryHit)
-                stashMemoryInjection(short, anchor.projectId, (0, memory_reflex_1.gatedHitText)(hits), turnCount);
-        }
+        // NOTE: the per-turn memory AUTO-INJECT (recall-intent → search → surface a hit) was
+        // DROPPED 2026-06-22. It was knowledge-injection, NOT a behavioral reminder — a
+        // different (undeveloped) system that was jammed into this registry for lack of a slot.
+        // It also collided with the agent's own better-targeted `greprag memory search` (taught
+        // by the memory primer). The memory PRIMER (the announce) stays; only the auto-inject is
+        // gone. docs/reminder-interrupt.md (the landed map: reminder ≠ knowledge injection).
         const env = {
             short, turnCount, stress, armed, sessionUnread,
             ownerPid, alias: (0, session_id_1.readIdentityAlias)(), assistant,
-            frontDeskNotice, memoryHit,
+            frontDeskNotice,
         };
-        // Kill switch drops ONLY the mechanic module — watcher-arm keeps working.
-        const reg = mechanicKilled() ? reminder_registry_1.REGISTRY.filter(m => m.id !== 'mechanic-friction') : reminder_registry_1.REGISTRY;
+        // UserPromptSubmit evaluates the prompt-source modules only (command-source
+        // modules — the collision Match — run at PreToolUse). Kill switch drops ONLY
+        // the mechanic module — watcher-arm keeps working.
+        const base = (0, reminder_registry_1.promptModules)();
+        const reg = mechanicKilled() ? base.filter(m => m.id !== 'mechanic-friction') : base;
         const fired = (0, reminder_registry_1.collectReminders)(env, reg);
         if (!fired.length)
             return;
@@ -1785,7 +1632,7 @@ function validateChip(title, prompt) {
  *  adr/spawn-task-hook-mode.md 2026-05-27 entry — Tier 2 augmentation
  *  attempt). `permissionDecision: deny` IS honored, so the validator
  *  catches missing Block 1 / Block 2 markers; the agent re-composes the
- *  call with the templates from `~/.claude/docs/chip-spawn.md`. */
+ *  call with the templates from `greprag load chip-spawn`. */
 function handlePreSpawnCheck(input) {
     if (input.tool_name !== 'mcp__ccd_session__spawn_task')
         return;
@@ -1796,7 +1643,7 @@ function handlePreSpawnCheck(input) {
         return;
     const reason = `Chip prompt rejected by greprag PreToolUse validator. Fix the following and re-call spawn_task:\n  - ` +
         violations.join('\n  - ') +
-        `\n\nFull conventions: ~/.claude/docs/chip-spawn.md.`;
+        `\n\nFull conventions: run \`greprag load chip-spawn\`.`;
     process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
             hookEventName: 'PreToolUse',
@@ -1867,7 +1714,8 @@ async function coordinateGate(input) {
     if (!short)
         return; // no session id → silent
     // Local + cheap: classify BEFORE any network so non-risky calls cost nothing.
-    const trigger = (0, coordinate_gate_1.triggerFromPreToolUse)(input.tool_name || '', (input.tool_input || {}));
+    const toolInput = (input.tool_input || {});
+    const trigger = (0, coordinate_gate_1.triggerFromPreToolUse)(input.tool_name || '', toolInput);
     if (!trigger)
         return; // not a risky action → silent
     let anchor;
@@ -1879,7 +1727,8 @@ async function coordinateGate(input) {
     }
     if (!anchor.projectId)
         return; // unanchored → nothing to match
-    const directive = await (0, coordinate_gate_1.runCoordinateGate)(trigger, {
+    // I/O stays in the hook: fresh peer read off the hot path → env.collisionPeers.
+    const peers = await (0, coordinate_gate_1.resolveCollisionPeers)({
         short,
         projectId: anchor.projectId,
         projectName: anchor.projectName,
@@ -1887,15 +1736,26 @@ async function coordinateGate(input) {
         apiKey: cfg.apiKey,
         alias: (0, session_id_1.readIdentityAlias)(),
     });
-    if (!directive)
+    if (peers.length === 0)
         return; // no live peer in this repo → proceed
+    // Route through the registry: build the command-read env, run the command-source
+    // modules (the collision Match). The standalone gate is now a registry citizen.
+    const env = {
+        short, turnCount: 0, stress: 0, armed: false, sessionUnread: 0,
+        alias: (0, session_id_1.readIdentityAlias)(),
+        toolCommand: typeof toolInput.command === 'string' ? toolInput.command : '',
+        collisionPeers: peers,
+    };
+    const fired = (0, reminder_registry_1.collectReminders)(env, (0, reminder_registry_1.commandModules)());
+    if (!fired.length)
+        return;
     // EFFECT: inject as additionalContext — advisory heads-up, NO permission pause.
     // `ask` was too intrusive (prompted on every git op while peers were live); inject
     // keeps the agent aware without a manual-allow. adr: adr/monitor-resilience.md
     process.stdout.write(JSON.stringify({
         hookSpecificOutput: {
             hookEventName: input.hook_event_name || 'PreToolUse',
-            additionalContext: directive,
+            additionalContext: fired.map(f => f.line).join('\n\n'),
         },
     }) + '\n');
 }