greprag 5.46.0 → 5.48.0

package/dist/commands/memory-reflex.d.ts

@@ -0,0 +1,115 @@
+/** memory-reflex — greprag episodic memory as a context-fill reflex (the first
+ *  "greprag service as a reminder-interrupt module" beyond the harness's own arm/mechanic).
+ *  docs/reminder-interrupt.md §Registry spec + the announce-featureset discussion (2026-06-20).
+ *
+ *  THE IDEA: when the agent is about to answer without context it could have, surface the
+ *  relevant project memory inline — seamlessly, no tool call. Three trigger layers feed ONE
+ *  reminder (the hybrid): keyword (user signals recall) · self-report (agent flags its own
+ *  gap) · nano (implicit gap). P1 = keyword (this file's `hasRecallIntent`) + the announce
+ *  that teaches the capability; self-report (the marker below) + nano land next.
+ *
+ *  SEARCH-THEN-INJECT, not nudge: a trigger fires a memory search in the hook; only a hit
+ *  ABOVE the confidence gate is injected (top 1-2, capped). A miss = silence — so the search
+ *  result is its own precision filter and the reflex never becomes wallpaper (the
+ *  banner-blindness failure mode, fix `16a29a8b`). PURE module: the hook owns the search
+ *  (I/O) + frames the hit via `buildMemoryInjection`, then routes the string through env —
+ *  exactly the front-desk module's shape.
+ *
+ *  EXCESSIVENESS is the watched risk (operator's call 2026-06-20): two filters bound it —
+ *  high-precision keyword phrases (low fire rate) + the confidence gate (low inject rate) —
+ *  and every fire is tallied (`MemoryReflexStats`) so /mechanic can monitor the rate and the
+ *  inject/fire ratio, and auto-quiet if it turns noisy. adr: adr/memory-reflex.md */
+import { ReminderModule } from './reminder-types';
+/** Does this prompt signal a recall need? Pure, total — the hook gates the inline search
+ *  on it. The query handed to the search is the prompt itself (the search is built for
+ *  natural queries; fragile noun-extraction buys nothing). */
+export declare function hasRecallIntent(prompt: string | null | undefined): boolean;
+/** The marker the announce teaches the agent to emit when it notices its OWN context gap.
+ *  Distinctive + greppable + cheap to type. The Stop-hook scan that consumes it (→ a
+ *  next-turn pull) is P1b; defined here now so the announce + the regex share one source. */
+export declare const RECALL_MARKER_RE: RegExp;
+/** Extract the topic from a self-report marker in the agent's response (P1b — the Stop-scan).
+ *  Returns the trimmed, capped topic, or null when no marker. Pure, total. */
+export declare function extractRecallMarker(response: string | null | undefined): string | null;
+/** Minimal hit shape the module needs — the hook maps the /v1/memory/query QueryNode onto
+ *  this so the module stays decoupled from the search client. */
+export interface MemoryHit {
+    content: string;
+    score: number;
+    confidence?: number | null;
+    shape?: string | null;
+    createdAt?: string | null;
+    projectName?: string | null;
+}
+/** Confidence gate — a hit must clear this to be injected. Below it, the reflex stays
+ *  silent (the search result IS the precision filter). Reranked hits carry a calibrated
+ *  `confidence` (0-1); unreranked hits fall back to a raw-score floor. */
+export declare const MEMORY_CONFIDENCE_GATE = 0.5;
+/** The hits that clear the gate, capped — the SINGLE source of "what gets shown", shared by the
+ *  injection framing AND the efficacy capture, so the overlap is scored against exactly what
+ *  was injected. */
+export declare function selectGatedHits(hits: MemoryHit[]): MemoryHit[];
+/** Raw content of the gated hits (no framing boilerplate) — stashed at inject-time so the
+ *  Stop-hook overlap scores the response against the actual memory, not the frame. */
+export declare function gatedHitText(hits: MemoryHit[]): string;
+/** Frame the gated top hits into the inline injection block; null when nothing clears the
+ *  gate (→ the module stays silent that turn). Tier is ambient (soft context, never a
+ *  forced-decision directive). Tight + capped by design. */
+export declare function buildMemoryInjection(hits: MemoryHit[]): string | null;
+/** The business card, loaded once. Teaches BOTH the passive auto-surface AND (P1b, now live)
+ *  the active self-report marker. Action-first, token-minimal, per the reminder-interrupt
+ *  authoring rules. */
+export declare function buildMemoryAnnounce(): string;
+/** Did the agent's response reuse distinctive content from the injection? Pure, total. */
+export declare function injectionWasUsed(hitText: string, prompt: string, response: string): boolean;
+/** Per-trigger fire tally — the monitor reads this. `fires` = recall intent detected;
+ *  `injected` = a hit cleared the gate and was surfaced; `silent` = fired but nothing cleared
+ *  the gate (miss/timeout); `used` = the agent's response drew on an injection (the EFFICACY
+ *  numerator, recorded at Stop). The two signals the monitor watches: a low injected/fires
+ *  ratio = firing without finding (noise), and a low **used/injected** ratio = injecting
+ *  without helping (the most important one — fires that never change behavior). Either,
+ *  sustained → tighten or auto-quiet. */
+export interface MemoryReflexStats {
+    fires: number;
+    injected: number;
+    silent: number;
+    used: number;
+    byTrigger: {
+        keyword: number;
+        selfReport: number;
+        flash: number;
+    };
+    firstFiredAt?: string;
+    lastFiredAt?: string;
+    lastTurnCount?: number;
+}
+export type MemoryTrigger = 'keyword' | 'selfReport' | 'flash';
+/** Tally one fire — PURE (the hook supplies the clock). `didInject` splits the
+ *  fire into injected vs silent so the monitor can read the inject/fire ratio. */
+export declare function tallyMemoryFire(prior: MemoryReflexStats | null, trigger: MemoryTrigger, didInject: boolean, turnCount: number, nowIso: string): MemoryReflexStats;
+/** Record that an injection was USED (the efficacy numerator) — PURE; bumped at Stop when the
+ *  overlap proxy (or, later, the Flash-Lite judge) finds the response drew on the injection.
+ *  Never decrements; `used ≤ injected` by construction of the call sites. */
+export declare function tallyMemoryUsed(prior: MemoryReflexStats | null): MemoryReflexStats;
+/** The server (the Flash-Lite judge, `@greprag/core` memory-efficacy) owns the
+ *  auto-quiet THRESHOLD and ships its verdict on the /v1/memory/query response.
+ *  The hook caches that boolean and honors it with a TTL — how long to trust a
+ *  cached verdict before re-probing. While quiet the reflex skips the search, so
+ *  no fresh verdict arrives and the cache ages; once stale the reflex fires again
+ *  to re-probe and the server re-judges. That gives auto-quiet TEETH (a real
+ *  silent window) while staying self-healing — a reflex that recovers is never
+ *  permanently silenced (unlike the hard, manual mechanicKilled() switch). */
+export declare const MEMORY_QUIET_CACHE_TTL_MS: number;
+export interface MemoryQuietCache {
+    quiet: boolean;
+    cachedAt: string;
+}
+/** Does the locally-cached server verdict say "stay silent THIS turn"? PURE +
+ *  total. Silent only when the cache is present, says quiet, and is still fresh.
+ *  Fail-open everywhere else (missing / malformed / stale → NOT silent) so a bad
+ *  cache can never permanently kill the reflex. */
+export declare function quietCacheSaysSilent(cache: MemoryQuietCache | null | undefined, nowMs: number): boolean;
+/** memory-reflex as a reminder-interrupt module. announce teaches memory once; reminder
+ *  routes the hook-supplied injection (env.memoryHit); detect gates on its presence. PURE —
+ *  the hook owns the keyword gate + the search + the framing + the tally. */
+export declare const memoryReflexModule: ReminderModule;

package/dist/commands/memory-reflex.js

@@ -0,0 +1,243 @@
+"use strict";
+/** memory-reflex — greprag episodic memory as a context-fill reflex (the first
+ *  "greprag service as a reminder-interrupt module" beyond the harness's own arm/mechanic).
+ *  docs/reminder-interrupt.md §Registry spec + the announce-featureset discussion (2026-06-20).
+ *
+ *  THE IDEA: when the agent is about to answer without context it could have, surface the
+ *  relevant project memory inline — seamlessly, no tool call. Three trigger layers feed ONE
+ *  reminder (the hybrid): keyword (user signals recall) · self-report (agent flags its own
+ *  gap) · nano (implicit gap). P1 = keyword (this file's `hasRecallIntent`) + the announce
+ *  that teaches the capability; self-report (the marker below) + nano land next.
+ *
+ *  SEARCH-THEN-INJECT, not nudge: a trigger fires a memory search in the hook; only a hit
+ *  ABOVE the confidence gate is injected (top 1-2, capped). A miss = silence — so the search
+ *  result is its own precision filter and the reflex never becomes wallpaper (the
+ *  banner-blindness failure mode, fix `16a29a8b`). PURE module: the hook owns the search
+ *  (I/O) + frames the hit via `buildMemoryInjection`, then routes the string through env —
+ *  exactly the front-desk module's shape.
+ *
+ *  EXCESSIVENESS is the watched risk (operator's call 2026-06-20): two filters bound it —
+ *  high-precision keyword phrases (low fire rate) + the confidence gate (low inject rate) —
+ *  and every fire is tallied (`MemoryReflexStats`) so /mechanic can monitor the rate and the
+ *  inject/fire ratio, and auto-quiet if it turns noisy. adr: adr/memory-reflex.md */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryReflexModule = exports.MEMORY_QUIET_CACHE_TTL_MS = exports.MEMORY_CONFIDENCE_GATE = exports.RECALL_MARKER_RE = void 0;
+exports.hasRecallIntent = hasRecallIntent;
+exports.extractRecallMarker = extractRecallMarker;
+exports.selectGatedHits = selectGatedHits;
+exports.gatedHitText = gatedHitText;
+exports.buildMemoryInjection = buildMemoryInjection;
+exports.buildMemoryAnnounce = buildMemoryAnnounce;
+exports.injectionWasUsed = injectionWasUsed;
+exports.tallyMemoryFire = tallyMemoryFire;
+exports.tallyMemoryUsed = tallyMemoryUsed;
+exports.quietCacheSaysSilent = quietCacheSaysSilent;
+// ---------- Layer 1: keyword trigger (free, same-turn) -----------------------
+/** High-precision recall-intent phrases — MULTI-WORD by design (a single word like
+ *  "previously" over-fires). Each strongly implies the agent needs recalled project
+ *  context it may not hold. Tuned conservatively; the /mechanic monitor reports the
+ *  false-fire rate and this list is where we'd loosen/tighten. */
+const RECALL_PHRASES = [
+    'last time', 'we decided', 'we agreed', 'we chose', 'we discussed',
+    'we talked about', 'you said', 'you mentioned', 'you told me',
+    'remember when', 'remember that', 'what did we', 'what was our',
+    'as we discussed', 'as i mentioned', 'earlier you', 'earlier we',
+    'refresh my memory', 'catch me up', 'where did we leave',
+    'the bug we', 'that bug we', 'the plan we', 'did we ever', 'how did we',
+];
+const RECALL_RE = new RegExp(`\\b(${RECALL_PHRASES.join('|').replace(/ /g, '\\s+')})\\b`, 'i');
+/** Does this prompt signal a recall need? Pure, total — the hook gates the inline search
+ *  on it. The query handed to the search is the prompt itself (the search is built for
+ *  natural queries; fragile noun-extraction buys nothing). */
+function hasRecallIntent(prompt) {
+    return !!prompt && RECALL_RE.test(prompt);
+}
+// ---------- Layer 2: self-report marker (free, next-turn — scan lands in P1b) -
+/** The marker the announce teaches the agent to emit when it notices its OWN context gap.
+ *  Distinctive + greppable + cheap to type. The Stop-hook scan that consumes it (→ a
+ *  next-turn pull) is P1b; defined here now so the announce + the regex share one source. */
+exports.RECALL_MARKER_RE = /\[\[recall:\s*([^\]]+)\]\]/i;
+/** Extract the topic from a self-report marker in the agent's response (P1b — the Stop-scan).
+ *  Returns the trimmed, capped topic, or null when no marker. Pure, total. */
+function extractRecallMarker(response) {
+    const m = exports.RECALL_MARKER_RE.exec(response || '');
+    if (!m)
+        return null;
+    const topic = (m[1] || '').trim();
+    return topic ? topic.slice(0, 200) : null;
+}
+/** Confidence gate — a hit must clear this to be injected. Below it, the reflex stays
+ *  silent (the search result IS the precision filter). Reranked hits carry a calibrated
+ *  `confidence` (0-1); unreranked hits fall back to a raw-score floor. */
+exports.MEMORY_CONFIDENCE_GATE = 0.5;
+const RAW_SCORE_FLOOR = 0.15;
+/** Hard cap — never inject more than this many hits (context-bloat discipline; we just
+ *  spent a session draining the heap). */
+const MAX_INJECTED = 2;
+/** Per-hit trim — keep each injected snippet tight. */
+const HIT_TRIM = 280;
+function passesGate(h) {
+    return typeof h.confidence === 'number'
+        ? h.confidence >= exports.MEMORY_CONFIDENCE_GATE
+        : h.score >= RAW_SCORE_FLOOR;
+}
+/** The hits that clear the gate, capped — the SINGLE source of "what gets shown", shared by the
+ *  injection framing AND the efficacy capture, so the overlap is scored against exactly what
+ *  was injected. */
+function selectGatedHits(hits) {
+    return (hits || []).filter(passesGate).slice(0, MAX_INJECTED);
+}
+/** Raw content of the gated hits (no framing boilerplate) — stashed at inject-time so the
+ *  Stop-hook overlap scores the response against the actual memory, not the frame. */
+function gatedHitText(hits) {
+    return selectGatedHits(hits).map(h => h.content || '').join('\n');
+}
+function trim(s, n) {
+    const t = (s || '').replace(/\s+/g, ' ').trim();
+    return t.length > n ? t.slice(0, n - 1) + '…' : t;
+}
+/** Frame the gated top hits into the inline injection block; null when nothing clears the
+ *  gate (→ the module stays silent that turn). Tier is ambient (soft context, never a
+ *  forced-decision directive). Tight + capped by design. */
+function buildMemoryInjection(hits) {
+    const passing = selectGatedHits(hits);
+    if (passing.length === 0)
+        return null;
+    const lines = ['[📁 greprag memory — possibly relevant, auto-surfaced (pull more: `greprag memory search`):'];
+    for (const h of passing) {
+        const meta = [h.shape, h.createdAt ? h.createdAt.slice(0, 10) : null, h.projectName]
+            .filter(Boolean).join(', ');
+        lines.push(`  · ${trim(h.content, HIT_TRIM)}${meta ? `  (${meta})` : ''}`);
+    }
+    lines.push(']');
+    return lines.join('\n');
+}
+// ---------- SessionStart announce (teach the capability once) -----------------
+/** The business card, loaded once. Teaches BOTH the passive auto-surface AND (P1b, now live)
+ *  the active self-report marker. Action-first, token-minimal, per the reminder-interrupt
+ *  authoring rules. */
+function buildMemoryAnnounce() {
+    return [
+        '[greprag memory — this project has episodic memory (every past session, searchable).]',
+        'When THIS turn leans on earlier work — a past decision, a bug you hit before, what was discussed — relevant memory is auto-surfaced inline; use it.',
+        'When you notice you are MISSING context this project would hold and it did NOT surface, emit `[[recall: <topic>]]` in your reply — that topic is pulled in on your next turn.',
+        'Or pull on demand any time: `greprag memory search "<topic>"` (`greprag memory recap` to catch up).',
+    ].join('\n');
+}
+// ---------- Efficacy: did the injection get USED (the overlap proxy) ----------
+/** Free overlap proxy for "did the response draw on the injected memory" — the efficacy
+ *  numerator's cheap first rung. (The Flash-Lite judge calibrates/replaces it later,
+ *  server-side; greprag's judge model is Gemini Flash-Lite, never nano.) Distinctive CONTENT
+ *  terms the injection introduced — in the hit, NOT already in the prompt, not stopwords /
+ *  frame boilerplate — that reappear in the response. ≥ USED_MIN_TERMS reused → used.
+ *  Imperfect (paraphrase escapes it, coincidence trips it) but a real aggregate signal at
+ *  zero cost + zero latency. */
+const USED_MIN_TERMS = 2;
+const MIN_TERM_LEN = 4;
+const TERM_STOPWORDS = new Set([
+    'this', 'that', 'with', 'from', 'have', 'were', 'your', 'they', 'them', 'then', 'than',
+    'will', 'would', 'could', 'should', 'about', 'there', 'their', 'what', 'when', 'which',
+    'into', 'over', 'also', 'been', 'more', 'most', 'some', 'such', 'only', 'just', 'like',
+    'here', 'where', 'these', 'those', 'them', 'because',
+    // injection-frame boilerplate — never count these as "used":
+    'greprag', 'memory', 'relevant', 'surfaced', 'auto', 'session', 'project', 'search', 'recap', 'pull',
+]);
+function contentTerms(text) {
+    const out = new Set();
+    for (const raw of (text || '').toLowerCase().split(/[^a-z0-9]+/)) {
+        if (raw.length >= MIN_TERM_LEN && !TERM_STOPWORDS.has(raw))
+            out.add(raw);
+    }
+    return out;
+}
+/** Did the agent's response reuse distinctive content from the injection? Pure, total. */
+function injectionWasUsed(hitText, prompt, response) {
+    const hitTerms = contentTerms(hitText);
+    if (hitTerms.size === 0)
+        return false;
+    const promptTerms = contentTerms(prompt);
+    const respTerms = contentTerms(response);
+    let used = 0;
+    for (const t of hitTerms) {
+        if (promptTerms.has(t))
+            continue; // not distinctive — already in the prompt
+        if (respTerms.has(t) && ++used >= USED_MIN_TERMS)
+            return true;
+    }
+    return false;
+}
+function normalizeStats(prior) {
+    const p = (prior && typeof prior === 'object') ? prior : {};
+    const bt = (p.byTrigger && typeof p.byTrigger === 'object') ? p.byTrigger : {};
+    return {
+        fires: Number.isFinite(p.fires) ? p.fires : 0,
+        injected: Number.isFinite(p.injected) ? p.injected : 0,
+        silent: Number.isFinite(p.silent) ? p.silent : 0,
+        used: Number.isFinite(p.used) ? p.used : 0,
+        byTrigger: {
+            keyword: Number.isFinite(bt.keyword) ? bt.keyword : 0,
+            selfReport: Number.isFinite(bt.selfReport) ? bt.selfReport : 0,
+            flash: Number.isFinite(bt.flash) ? bt.flash : 0,
+        },
+        firstFiredAt: p.firstFiredAt,
+        lastFiredAt: p.lastFiredAt,
+        lastTurnCount: p.lastTurnCount,
+    };
+}
+/** Tally one fire — PURE (the hook supplies the clock). `didInject` splits the
+ *  fire into injected vs silent so the monitor can read the inject/fire ratio. */
+function tallyMemoryFire(prior, trigger, didInject, turnCount, nowIso) {
+    const s = normalizeStats(prior);
+    s.fires += 1;
+    if (didInject)
+        s.injected += 1;
+    else
+        s.silent += 1;
+    s.byTrigger[trigger] += 1;
+    s.firstFiredAt = s.firstFiredAt || nowIso;
+    s.lastFiredAt = nowIso;
+    if (Number.isFinite(turnCount))
+        s.lastTurnCount = turnCount;
+    return s;
+}
+/** Record that an injection was USED (the efficacy numerator) — PURE; bumped at Stop when the
+ *  overlap proxy (or, later, the Flash-Lite judge) finds the response drew on the injection.
+ *  Never decrements; `used ≤ injected` by construction of the call sites. */
+function tallyMemoryUsed(prior) {
+    const s = normalizeStats(prior);
+    s.used += 1;
+    return s;
+}
+// ---------- Auto-quiet (server efficacy verdict, cached locally) --------------
+/** The server (the Flash-Lite judge, `@greprag/core` memory-efficacy) owns the
+ *  auto-quiet THRESHOLD and ships its verdict on the /v1/memory/query response.
+ *  The hook caches that boolean and honors it with a TTL — how long to trust a
+ *  cached verdict before re-probing. While quiet the reflex skips the search, so
+ *  no fresh verdict arrives and the cache ages; once stale the reflex fires again
+ *  to re-probe and the server re-judges. That gives auto-quiet TEETH (a real
+ *  silent window) while staying self-healing — a reflex that recovers is never
+ *  permanently silenced (unlike the hard, manual mechanicKilled() switch). */
+exports.MEMORY_QUIET_CACHE_TTL_MS = 12 * 60 * 60 * 1000; // 12h
+/** Does the locally-cached server verdict say "stay silent THIS turn"? PURE +
+ *  total. Silent only when the cache is present, says quiet, and is still fresh.
+ *  Fail-open everywhere else (missing / malformed / stale → NOT silent) so a bad
+ *  cache can never permanently kill the reflex. */
+function quietCacheSaysSilent(cache, nowMs) {
+    if (!cache || cache.quiet !== true || typeof cache.cachedAt !== 'string')
+        return false;
+    const t = Date.parse(cache.cachedAt);
+    if (!Number.isFinite(t))
+        return false;
+    return (nowMs - t) < exports.MEMORY_QUIET_CACHE_TTL_MS;
+}
+// ---------- The registry module ----------------------------------------------
+/** memory-reflex as a reminder-interrupt module. announce teaches memory once; reminder
+ *  routes the hook-supplied injection (env.memoryHit); detect gates on its presence. PURE —
+ *  the hook owns the keyword gate + the search + the framing + the tally. */
+exports.memoryReflexModule = {
+    id: 'memory-reflex',
+    detect: (env) => (env.memoryHit ? { tier: 'ambient' } : { tier: 'silent' }),
+    announce: () => buildMemoryAnnounce(),
+    reminder: (_d, env) => env.memoryHit ?? null,
+};
+//# sourceMappingURL=memory-reflex.js.map

package/dist/commands/memory-reflex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-reflex.js","sourceRoot":"","sources":["../../src/commands/memory-reflex.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,24 @@
+/** The reminder-interrupt registry CONTAINER (docs/reminder-interrupt.md §Registry
+ *  spec). One loop over all modules: per turn, fire each module's thin reminder while
+ *  its detector says deficient; at SessionStart, emit each announce. Stacking welcome.
+ *  PURE over ReminderEnv — the hook assembles env (i/o) and emits the returned lines;
+ *  a broken module never blocks a turn (fail-open per module). */
+import { ReminderEnv, ReminderModule, Detection } from './reminder-types';
+/** Registry order = display order. THE single agent-facing announce/reminder assembly:
+ *  the hook does I/O → fills ReminderEnv → collectAnnounces (SessionStart) / collectReminders
+ *  (per turn) render every module here in this order. Order preserves the historical recap
+ *  preamble (setup-warning → front-desk → checkpoint → assistant-doctrine) and keeps the two
+ *  loud, action-first modules last (watcher-arm → mechanic) so they read most-recent at
+ *  SessionStart. Add a module here to wire it into BOTH surfaces at once. */
+export declare const REGISTRY: ReminderModule[];
+export interface FiredReminder {
+    id: string;
+    tier: Detection['tier'];
+    line: string;
+}
+/** Per-turn: every module's live reminder line (skipping silent), in registry order.
+ *  Stacking — a turn may carry several. A detector or reminder that throws drops that
+ *  module for the turn; it never blocks the others or the turn. */
+export declare function collectReminders(env: ReminderEnv, registry?: ReminderModule[]): FiredReminder[];
+/** SessionStart: every module's announce (skipping null), in registry order. */
+export declare function collectAnnounces(env: ReminderEnv, registry?: ReminderModule[]): string[];

package/dist/commands/reminder-registry.js

@@ -0,0 +1,76 @@
+"use strict";
+/** The reminder-interrupt registry CONTAINER (docs/reminder-interrupt.md §Registry
+ *  spec). One loop over all modules: per turn, fire each module's thin reminder while
+ *  its detector says deficient; at SessionStart, emit each announce. Stacking welcome.
+ *  PURE over ReminderEnv — the hook assembles env (i/o) and emits the returned lines;
+ *  a broken module never blocks a turn (fail-open per module). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGISTRY = void 0;
+exports.collectReminders = collectReminders;
+exports.collectAnnounces = collectAnnounces;
+const setup_reminder_1 = require("./setup-reminder");
+const frontdesk_reminder_1 = require("./frontdesk-reminder");
+const checkpoint_reminder_1 = require("./checkpoint-reminder");
+const assistant_reminder_1 = require("./assistant-reminder");
+const memory_reflex_1 = require("./memory-reflex");
+const arm_reminder_1 = require("./arm-reminder");
+const friction_reminder_1 = require("./friction-reminder");
+/** Registry order = display order. THE single agent-facing announce/reminder assembly:
+ *  the hook does I/O → fills ReminderEnv → collectAnnounces (SessionStart) / collectReminders
+ *  (per turn) render every module here in this order. Order preserves the historical recap
+ *  preamble (setup-warning → front-desk → checkpoint → assistant-doctrine) and keeps the two
+ *  loud, action-first modules last (watcher-arm → mechanic) so they read most-recent at
+ *  SessionStart. Add a module here to wire it into BOTH surfaces at once. */
+exports.REGISTRY = [
+    setup_reminder_1.setupWarningModule,
+    frontdesk_reminder_1.frontDeskModule,
+    checkpoint_reminder_1.checkpointModule,
+    assistant_reminder_1.assistantDoctrineModule,
+    memory_reflex_1.memoryReflexModule,
+    arm_reminder_1.watcherArmModule,
+    friction_reminder_1.mechanicFrictionModule,
+];
+/** Per-turn: every module's live reminder line (skipping silent), in registry order.
+ *  Stacking — a turn may carry several. A detector or reminder that throws drops that
+ *  module for the turn; it never blocks the others or the turn. */
+function collectReminders(env, registry = exports.REGISTRY) {
+    const out = [];
+    for (const m of registry) {
+        let d;
+        try {
+            d = m.detect(env);
+        }
+        catch {
+            continue;
+        }
+        if (!d || d.tier === 'silent')
+            continue;
+        let line = null;
+        try {
+            line = m.reminder(d, env);
+        }
+        catch {
+            continue;
+        }
+        if (line)
+            out.push({ id: m.id, tier: d.tier, line });
+    }
+    return out;
+}
+/** SessionStart: every module's announce (skipping null), in registry order. */
+function collectAnnounces(env, registry = exports.REGISTRY) {
+    const out = [];
+    for (const m of registry) {
+        let a = null;
+        try {
+            a = m.announce(env);
+        }
+        catch {
+            continue;
+        }
+        if (a)
+            out.push(a);
+    }
+    return out;
+}
+//# sourceMappingURL=reminder-registry.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reminder-registry.js","sourceRoot":"","sources":["../../src/commands/reminder-registry.ts"],"names":[],"mappings":";AAAA;;;;kEAIkE;;;AAoClE,4CAaC;AAGD,4CAUC;AA3DD,qDAAsD;AACtD,6DAAuD;AACvD,+DAAyD;AACzD,6DAA+D;AAC/D,mDAAqD;AACrD,iDAAkD;AAClD,2DAA6D;AAE7D;;;;;6EAK6E;AAChE,QAAA,QAAQ,GAAqB;IACxC,mCAAkB;IAClB,oCAAe;IACf,sCAAgB;IAChB,4CAAuB;IACvB,kCAAkB;IAClB,+BAAgB;IAChB,0CAAsB;CACvB,CAAC;AAQF;;mEAEmE;AACnE,SAAgB,gBAAgB,CAC9B,GAAgB,EAAE,WAA6B,gBAAQ;IAEvD,MAAM,GAAG,GAAoB,EAAE,CAAC;IAChC,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,IAAI,CAAY,CAAC;QACjB,IAAI,CAAC;YAAC,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC;YAAC,SAAS;QAAC,CAAC;QAC9C,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ;YAAE,SAAS;QACxC,IAAI,IAAI,GAAkB,IAAI,CAAC;QAC/B,IAAI,CAAC;YAAC,IAAI,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC;YAAC,SAAS;QAAC,CAAC;QACtD,IAAI,IAAI;YAAE,GAAG,CAAC,IAAI,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;IACvD,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC;AAED,gFAAgF;AAChF,SAAgB,gBAAgB,CAC9B,GAAgB,EAAE,WAA6B,gBAAQ;IAEvD,MAAM,GAAG,GAAa,EAAE,CAAC;IACzB,KAAK,MAAM,CAAC,IAAI,QAAQ,EAAE,CAAC;QACzB,IAAI,CAAC,GAAkB,IAAI,CAAC;QAC5B,IAAI,CAAC;YAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC;YAAC,SAAS;QAAC,CAAC;QAChD,IAAI,CAAC;YAAE,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IACrB,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

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

@@ -0,0 +1,76 @@
+/** Shared types for the reminder-interrupt registry (docs/reminder-interrupt.md
+ *  §Registry spec — the detector model). Modeled on the WORKING arm-check loop:
+ *  detect a live external deficiency → fire while it holds → auto-silence the
+ *  instant it resolves. `detect(env)` is the primitive (the arm-check's
+ *  `isLocallyArmed`, generalized); a turn counter is not. */
+/** Firing-tier ladder. `silent` = the deficiency is resolved (the auto-stop); the
+ *  rest escalate wording intensity with the cost of inaction (ambient = soft
+ *  pointer, nudge = imperative + reason, nag = LOUD forced-decision). */
+export type Tier = 'silent' | 'ambient' | 'nudge' | 'nag';
+/** The live-state bag the hook assembles ONCE per turn — ALL i/o lives in the hook
+ *  so modules stay pure (and their detect→silent transition stays unit-testable).
+ *  Grows as modules need new signals. */
+export interface ReminderEnv {
+    /** 8-hex session id. */
+    short: string;
+    /** Turns elapsed this session (for any ambient-cadence module). */
+    turnCount: number;
+    /** Live behavioral stress (docs/stress-trigger.md): 0 calm / 1 elevated / 2 high. */
+    stress: number;
+    /** Live local watcher present? (isLocallyArmed) — the arm-check's signal. */
+    armed: boolean;
+    /** Unread messages addressed to THIS session (own mail — NOT the project-wide
+     *  v5.6.1 eavesdrop count). */
+    sessionUnread: number;
+    /** Owning claude.exe PID — baked into the arm command. */
+    ownerPid?: number | null;
+    /** Identity handle (alias before @) for reply-address templating. */
+    alias?: string | null;
+    /** Assistant project → elevated watcher arm. */
+    assistant?: boolean;
+    /** Project display name (for the checkpoint announce). */
+    projectName?: string;
+    /** Precomputed identity setup/drift warning — the hook owns the anchor logic AND its
+     *  rate-limit stamp (a side-effect), so this module half is a pass-through. */
+    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;
+    /** Envelope-only "you've got mail" front-desk notice — the hook owns the network +
+     *  per-machine dedup; the front-desk module routes it as its per-turn reminder. */
+    frontDeskNotice?: string | null;
+    /** Auto-surfaced episodic-memory injection — the hook owns the recall-intent gate +
+     *  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;
+}
+/** A module's per-turn read of its deficiency. `tier:'silent'` = resolved → no fire. */
+export interface Detection {
+    tier: Tier;
+    /** Optional grounding data the reminder line interpolates (e.g. unread count). */
+    detail?: Record<string, unknown>;
+}
+/** A reminder-interrupt registry module (docs/reminder-interrupt.md §Registry spec).
+ *  PURE over ReminderEnv — the container/hook owns all i/o, so detect→silent is the
+ *  unit-testable regression-lock. */
+export interface ReminderModule {
+    id: 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. */
+    announce: (env: ReminderEnv) => string | null;
+    /** Per-turn thin line for a live detection; null when silent. */
+    reminder: (d: Detection, env: ReminderEnv) => string | null;
+}

package/dist/commands/reminder-types.js

@@ -0,0 +1,8 @@
+"use strict";
+/** Shared types for the reminder-interrupt registry (docs/reminder-interrupt.md
+ *  §Registry spec — the detector model). Modeled on the WORKING arm-check loop:
+ *  detect a live external deficiency → fire while it holds → auto-silence the
+ *  instant it resolves. `detect(env)` is the primitive (the arm-check's
+ *  `isLocallyArmed`, generalized); a turn counter is not. */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=reminder-types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reminder-types.js","sourceRoot":"","sources":["../../src/commands/reminder-types.ts"],"names":[],"mappings":";AAAA;;;;6DAI6D"}

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

@@ -0,0 +1,9 @@
+/** setup-warning — the identity setup/drift warning as a reminder-interrupt module
+ *  (docs/reminder-interrupt.md §Registry spec). announce-ONLY + pass-through: the warning
+ *  string is PRECOMPUTED by the hook because deriving it stamps a weekly rate-limit
+ *  (a side-effect) and reads the git-derived id — I/O that must stay in the hook. The
+ *  module just routes the result and gates on its presence. nudge tier: identity drift
+ *  silently scatters memory across UUIDs, so it is worth more than an ambient pointer. */
+import { ReminderEnv, Detection, ReminderModule } from './reminder-types';
+export declare function setupDetect(env: ReminderEnv): Detection;
+export declare const setupWarningModule: ReminderModule;

package/dist/commands/setup-reminder.js

@@ -0,0 +1,20 @@
+"use strict";
+/** setup-warning — the identity setup/drift warning as a reminder-interrupt module
+ *  (docs/reminder-interrupt.md §Registry spec). announce-ONLY + pass-through: the warning
+ *  string is PRECOMPUTED by the hook because deriving it stamps a weekly rate-limit
+ *  (a side-effect) and reads the git-derived id — I/O that must stay in the hook. The
+ *  module just routes the result and gates on its presence. nudge tier: identity drift
+ *  silently scatters memory across UUIDs, so it is worth more than an ambient pointer. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupWarningModule = void 0;
+exports.setupDetect = setupDetect;
+function setupDetect(env) {
+    return env.setupWarning ? { tier: 'nudge' } : { tier: 'silent' };
+}
+exports.setupWarningModule = {
+    id: 'setup-warning',
+    detect: setupDetect,
+    announce: (env) => env.setupWarning ?? null,
+    reminder: () => null,
+};
+//# sourceMappingURL=setup-reminder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"setup-reminder.js","sourceRoot":"","sources":["../../src/commands/setup-reminder.ts"],"names":[],"mappings":";AAAA;;;;;0FAK0F;;;AAI1F,kCAEC;AAFD,SAAgB,WAAW,CAAC,GAAgB;IAC1C,OAAO,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AACnE,CAAC;AAEY,QAAA,kBAAkB,GAAmB;IAChD,EAAE,EAAE,eAAe;IACnB,MAAM,EAAE,WAAW;IACnB,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,YAAY,IAAI,IAAI;IAC3C,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI;CACrB,CAAC"}