greprag 5.49.8 → 5.49.10

package/dist/commands/reminder-types.d.ts

@@ -35,11 +35,17 @@ export interface ReminderEnv {
     setupWarning?: string | null;
     /** Front-desk unread count (the SessionStart count announce). */
     frontDeskUnread?: number;
-    /** Open checkpoints for this project (the SessionStart landmark announce). */
-    openCheckpoints?: OpenCheckpointSlim[];
     /** Precomputed assistant-doctrine context — the hook owns the doctrine-file read, so
      *  this module half is a pass-through. Null for any non-assistant project. */
     assistantDoctrine?: string | null;
+    /** Deficiency-gated announce signal: the installed greprag is behind the latest
+     *  published version. Set by the hook (daily-cached npm-registry check); null/undefined
+     *  when current. Drives the version-upgrade announce — "new release, upgrade with X".
+     *  docs/reminder-interrupt.md (a Deficiency-gated announce, not a new type). */
+    updateAvailable?: {
+        current: string;
+        latest: string;
+    } | null;
     /** Names of the api-docs-tagged corpus stores (the hook lists `?tag=api-docs`).
      *  Drives the corpus announce: name the on-tap reference banks so an agent
      *  searches them before answering from training data. Empty/undefined → the
@@ -52,14 +58,14 @@ export interface ReminderEnv {
      *  the search + the confidence gate + framing; the memory-reflex module routes the
      *  framed string as its per-turn reminder. Null = nothing cleared the gate this turn. */
     memoryHit?: string | null;
-}
-/** Slim open-checkpoint row (the SessionStart landmark announce, checkpoint module).
- *  Lives here — not in checkpoint-reminder.ts — because ReminderEnv references it and a
- *  module file importing from here would otherwise close an import cycle. */
-export interface OpenCheckpointSlim {
-    nodeId: string;
-    title: string;
-    createdAt: string;
+    /** The Bash command about to run (the `command` read surface for a Match trigger).
+     *  Present only on the PreToolUse env; undefined at UserPromptSubmit. */
+    toolCommand?: string | null;
+    /** Same-repo peers live right now (the hook does the fresh watcher read off the
+     *  hot path and passes the result; the collision module detects purely on it). */
+    collisionPeers?: {
+        short: string;
+    }[];
 }
 /** A module's per-turn read of its deficiency. `tier:'silent'` = resolved → no fire. */
 export interface Detection {
@@ -72,6 +78,18 @@ export interface Detection {
  *  unit-testable regression-lock. */
 export interface ReminderModule {
     id: string;
+    /** Which READ surface this module fires on (docs/reminder-interrupt.md — the landed
+     *  map). `prompt` (default) modules run at UserPromptSubmit; `command` modules run at
+     *  PreToolUse, reading `env.toolCommand`. The call site filters the registry by source
+     *  so each hook event evaluates only its own modules. */
+    source?: 'prompt' | 'command';
+    /** Boot-sequence dependencies (docs/load-system.md §boot sequence): module ids whose
+     *  announce MUST be emitted before this one's. A primer that references a concept an
+     *  earlier primer establishes declares it here (e.g. the mechanic primer references chip
+     *  vehicles → `dependsOn: ['chip-spawn-pointer']`; every pointer that says "greprag load"
+     *  → `dependsOn: ['load-primer']`). collectAnnounces topologically sorts on this, so the
+     *  boot order is a declared graph, not fragile array position. Omit = no dependency. */
+    dependsOn?: string[];
     /** Read the live deficiency. The gate: `silent` ⇒ the module is quiet this turn. */
     detect: (env: ReminderEnv) => Detection;
     /** SessionStart schema, loaded once (teach method + why). null = nothing to announce. */

package/dist/commands/version-reminder.d.ts

@@ -0,0 +1,15 @@
+/** version-reminder — the release-upgrade announce. A DEFICIENCY-gated announce
+ *  (docs/reminder-interrupt.md): the Deficiency trigger ("a required state is missing")
+ *  applied to the ANNOUNCE surface — the required state is "running the latest greprag,"
+ *  the deficiency is "installed < latest published." When behind, the SessionStart announce
+ *  tells the user a new release is out + how to upgrade; it auto-clears once they upgrade.
+ *
+ *  This is what makes a release PROPAGATE — without it, users never learn to upgrade.
+ *  NOT a new announce kind: it is a primer gated by Deficiency, exactly like setup-warning
+ *  (which announces only when there's a drift gap). The hook does the I/O (the daily-cached
+ *  npm-registry version check) and passes the verdict as env.updateAvailable; this module
+ *  is PURE — announce-only (detect → silent, reminder → null). */
+import { ReminderModule } from './reminder-types';
+/** The upgrade announce — null unless the hook detected a newer published version. */
+export declare function buildVersionAnnounce(current: string, latest: string): string;
+export declare const versionUpgradeModule: ReminderModule;

package/dist/commands/version-reminder.js

@@ -0,0 +1,34 @@
+"use strict";
+/** version-reminder — the release-upgrade announce. A DEFICIENCY-gated announce
+ *  (docs/reminder-interrupt.md): the Deficiency trigger ("a required state is missing")
+ *  applied to the ANNOUNCE surface — the required state is "running the latest greprag,"
+ *  the deficiency is "installed < latest published." When behind, the SessionStart announce
+ *  tells the user a new release is out + how to upgrade; it auto-clears once they upgrade.
+ *
+ *  This is what makes a release PROPAGATE — without it, users never learn to upgrade.
+ *  NOT a new announce kind: it is a primer gated by Deficiency, exactly like setup-warning
+ *  (which announces only when there's a drift gap). The hook does the I/O (the daily-cached
+ *  npm-registry version check) and passes the verdict as env.updateAvailable; this module
+ *  is PURE — announce-only (detect → silent, reminder → null). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionUpgradeModule = void 0;
+exports.buildVersionAnnounce = buildVersionAnnounce;
+/** The upgrade announce — null unless the hook detected a newer published version. */
+function buildVersionAnnounce(current, latest) {
+    return [
+        `[greprag — a new release is out: v${latest} (you are on v${current}).]`,
+        `Upgrade: \`npm i -g greprag@latest\`. New behavior + fixes land on your next session.`,
+    ].join('\n');
+}
+exports.versionUpgradeModule = {
+    id: 'version-upgrade',
+    detect: (_env) => ({ tier: 'silent' }), // announce-only
+    announce: (env) => {
+        const u = env.updateAvailable;
+        if (!u || !u.current || !u.latest)
+            return null;
+        return buildVersionAnnounce(u.current, u.latest);
+    },
+    reminder: () => null,
+};
+//# sourceMappingURL=version-reminder.js.map

package/dist/commands/version-reminder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version-reminder.js","sourceRoot":"","sources":["../../src/commands/version-reminder.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;kEAUkE;;;AAKlE,oDAKC;AAND,sFAAsF;AACtF,SAAgB,oBAAoB,CAAC,OAAe,EAAE,MAAc;IAClE,OAAO;QACL,qCAAqC,MAAM,iBAAiB,OAAO,KAAK;QACxE,uFAAuF;KACxF,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AACf,CAAC;AAEY,QAAA,oBAAoB,GAAmB;IAClD,EAAE,EAAE,iBAAiB;IACrB,MAAM,EAAE,CAAC,IAAiB,EAAa,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,gBAAgB;IAChF,QAAQ,EAAE,CAAC,GAAgB,EAAiB,EAAE;QAC5C,MAAM,CAAC,GAAG,GAAG,CAAC,eAAe,CAAC;QAC9B,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,CAAC,MAAM;YAAE,OAAO,IAAI,CAAC;QAC/C,OAAO,oBAAoB,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;IACnD,CAAC;IACD,QAAQ,EAAE,GAAkB,EAAE,CAAC,IAAI;CACpC,CAAC"}

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,25 +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 */ }
+    // (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;
@@ -841,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,
@@ -863,28 +838,7 @@ async function store(input, source = 'claude-code') {
 // pushed to the system prompt is the same for Claude/Codex and the opencode
 // plugin; per-harness wrappers (preamble, output mode, transform-hook push)
 // stay local.
-/** Fetch a slim summary of open checkpoints for the given project. Returns
- *  up to `limit` rows so the checkpoint module can compute the overflow
- *  (3-most-recent + "N more" hint). Returns [] on any error — the hook
- *  must never block on a checkpoint query failure. (OpenCheckpointSlim +
- *  renderCheckpointHint now live in commands/checkpoint-reminder.ts; the hook
- *  owns only this fetch.) */
-async function fetchOpenCheckpoints(apiUrl, apiKey, projectId, limit = 10) {
-    try {
-        const url = `${apiUrl}/v1/checkpoints/${encodeURIComponent(projectId)}`
-            + `?status=open&limit=${limit}`;
-        const res = await fetch(url, { headers: { 'Authorization': `Bearer ${apiKey}` } });
-        if (!res.ok)
-            return [];
-        const data = await res.json();
-        return (data.checkpoints || []).map(c => ({
-            nodeId: c.nodeId, title: c.title, createdAt: c.createdAt,
-        }));
-    }
-    catch {
-        return [];
-    }
-}
+// (fetchOpenCheckpoints removed 2026-06-22 with the open-checkpoints SessionStart announce.)
 /** Fetch unread inbox count for the given project context. Project-scoped
  *  count includes tenant-level messages (mail addressed to the user, not
  *  any specific project, still shows up). Returns 0 on any error so the
@@ -963,44 +917,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
@@ -1075,6 +991,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
@@ -1173,10 +1161,9 @@ async function recap(input, mode = 'plain') {
     // (and then read) another session's session-targeted DM. Live inbox now
     // belongs exclusively to Monitor watchers; the agent learns about its own
     // mail via the watcher's session-scoped stream.
-    // Open-checkpoints — checkpoints are operator-triggered landmarks, not message-shape
-    // inbox traffic, no privacy issue. The hook owns ONLY this fetch; the checkpoint module
-    // (commands/checkpoint-reminder.ts) renders the list → hint block in its announce.
-    const openCheckpoints = await fetchOpenCheckpoints(cfg.apiUrl, cfg.apiKey, anchor.projectId, 10);
+    // (Open-checkpoints announce removed 2026-06-22 — operator found stale bookmarks
+    // cluttering every SessionStart. The `greprag checkpoint` command stays; only the
+    // auto-announce is gone. No fetch here anymore.)
     // Front-desk awareness — a discreet count of cold opens + inbound email waiting at the
     // shared tenant front desk, so a stranger's first contact isn't stranded until someone
     // runs `greprag inbox`. Content is NEVER injected — just the count + the door, formatted
@@ -1193,6 +1180,9 @@ async function recap(input, mode = 'plain') {
     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,
@@ -1214,9 +1204,9 @@ async function recap(input, mode = 'plain') {
         projectName: anchor.projectName,
         setupWarning,
         frontDeskUnread,
-        openCheckpoints,
         assistantDoctrine,
         corpusApiDocs,
+        updateAvailable,
     };
     let announceReg = mechanicKilled() ? reminder_registry_1.REGISTRY.filter(m => m.id !== 'mechanic-friction') : reminder_registry_1.REGISTRY;
     if (!announceShort)
@@ -1390,129 +1380,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 */ }
-}
-/** 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. */
@@ -1539,41 +1414,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: recall-intent in THIS prompt fires an inline search. One
-        // injection per turn. (The self-report [[recall:]] marker was removed 2026-06-22.)
-        let memQuery = null;
-        const memTrigger = 'keyword';
-        if ((0, memory_reflex_1.hasRecallIntent)(prompt)) {
-            memQuery = prompt.slice(0, 500);
-        }
-        // 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;
@@ -1753,7 +1609,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;
@@ -1764,7 +1620,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',
@@ -1835,7 +1691,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;
@@ -1847,7 +1704,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,
@@ -1855,15 +1713,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');
 }