greprag 5.46.0 → 5.48.0

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

@@ -0,0 +1,25 @@
+/** watcherArm — the REFERENCE reminder-interrupt module (docs/reminder-interrupt.md
+ *  §Registry spec). The working pattern the whole registry is modeled on: detect the
+ *  watcher deficiency (unarmed) → fire while down → auto-silence when armed →
+ *  self-heal (watcher dies → next turn re-detects). Pure over ReminderEnv; the hook
+ *  supplies `armed` (isLocallyArmed) + `sessionUnread` (this session's own mail).
+ *  adr: adr/session-id-awareness.md */
+import { ReminderEnv, Detection, ReminderModule } from './reminder-types';
+/** SessionStart announce — the heavy half, loaded once (+ re-fired on compact via the
+ *  session-id hook). Leads with ARM NOW (not "here's how for later") so the agent arms
+ *  immediately; states peers ARE reaching this session, and teaches the drop-anytime →
+ *  MUST re-arm fact that licenses the per-turn reminder. Carries the deferred-Monitor
+ *  call shape (ToolSearch select:Monitor + required description/timeout_ms) so the arm
+ *  call succeeds unaided. Do NOT trim the ToolSearch clause — the deferral made it
+ *  load-bearing (adr/session-id-awareness.md 2026-05-29). adr: adr/session-id-awareness.md */
+export declare function buildArmAnnounce(short: string, ownerPid?: number | null, alias?: string | null, assistant?: boolean): string;
+/** Detect the watcher deficiency. armed → silent (the auto-stop). Unarmed → nag when a
+ *  peer has actually messaged this session (grounded + TRUE — nag only when
+ *  sessionUnread>0, so it never decays into a cried-wolf banner), else nudge. */
+export declare function armDetect(env: ReminderEnv): Detection;
+/** Per-turn thin line. nag = a real peer message waits (true by construction); nudge =
+ *  unarmed with no mail. The heavy how-to-arm lives in the SessionStart announce. */
+export declare function buildArmReminder(d: Detection): string | null;
+/** The reference module. detect = unarmed; announce = the urgent how-to; reminder = the
+ *  thin line. Wired into the registry container (reminder-registry.ts). */
+export declare const watcherArmModule: ReminderModule;

package/dist/commands/arm-reminder.js

@@ -0,0 +1,65 @@
+"use strict";
+/** watcherArm — the REFERENCE reminder-interrupt module (docs/reminder-interrupt.md
+ *  §Registry spec). The working pattern the whole registry is modeled on: detect the
+ *  watcher deficiency (unarmed) → fire while down → auto-silence when armed →
+ *  self-heal (watcher dies → next turn re-detects). Pure over ReminderEnv; the hook
+ *  supplies `armed` (isLocallyArmed) + `sessionUnread` (this session's own mail).
+ *  adr: adr/session-id-awareness.md */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.watcherArmModule = void 0;
+exports.buildArmAnnounce = buildArmAnnounce;
+exports.armDetect = armDetect;
+exports.buildArmReminder = buildArmReminder;
+const session_id_1 = require("../session-id");
+/** SessionStart announce — the heavy half, loaded once (+ re-fired on compact via the
+ *  session-id hook). Leads with ARM NOW (not "here's how for later") so the agent arms
+ *  immediately; states peers ARE reaching this session, and teaches the drop-anytime →
+ *  MUST re-arm fact that licenses the per-turn reminder. Carries the deferred-Monitor
+ *  call shape (ToolSearch select:Monitor + required description/timeout_ms) so the arm
+ *  call succeeds unaided. Do NOT trim the ToolSearch clause — the deferral made it
+ *  load-bearing (adr/session-id-awareness.md 2026-05-29). adr: adr/session-id-awareness.md */
+function buildArmAnnounce(short, ownerPid, alias = null, assistant = false) {
+    const handle = alias || '<handle>';
+    return (`[⚠ ARM YOUR INBOX WATCHER NOW. Peers are live in your mesh trying to coordinate `
+        + `with this session, and the operator can DM you — but they reach you ONLY while armed. `
+        + `Unarmed, you're invisible and their messages silently pile up. The watcher can DROP `
+        + `ANYTIME (crash / reload / OOM) — every turn you're flagged unarmed you MUST re-arm, `
+        + `or coordination breaks. `
+        + `ARM: Monitor is a deferred tool — first load its schema (ToolSearch query `
+        + `"select:Monitor"), then call Monitor with persistent:true, timeout_ms:3600000, `
+        + `description:"greprag inbox ${short}", and command: `
+        + `\`${(0, session_id_1.armMonitorCommand)(short, ownerPid, assistant)}\`. `
+        + `Then drain what's waiting: \`greprag inbox\`. `
+        + `Reply to you: ${handle}@greprag.com/${short}.]`);
+}
+/** Detect the watcher deficiency. armed → silent (the auto-stop). Unarmed → nag when a
+ *  peer has actually messaged this session (grounded + TRUE — nag only when
+ *  sessionUnread>0, so it never decays into a cried-wolf banner), else nudge. */
+function armDetect(env) {
+    if (env.armed)
+        return { tier: 'silent' };
+    const unread = env.sessionUnread > 0 ? env.sessionUnread : 0;
+    return unread > 0
+        ? { tier: 'nag', detail: { unread } }
+        : { tier: 'nudge', detail: { unread: 0 } };
+}
+/** Per-turn thin line. nag = a real peer message waits (true by construction); nudge =
+ *  unarmed with no mail. The heavy how-to-arm lives in the SessionStart announce. */
+function buildArmReminder(d) {
+    if (d.tier === 'silent')
+        return null;
+    const unread = Number((d.detail && d.detail.unread) || 0);
+    if (unread > 0) {
+        return `⚠ A peer messaged you (${unread} waiting) & you're UNARMED — arm + answer NOW: greprag inbox.`;
+    }
+    return `⚠ Watcher down — peers can't reach you. RE-ARM now.`;
+}
+/** The reference module. detect = unarmed; announce = the urgent how-to; reminder = the
+ *  thin line. Wired into the registry container (reminder-registry.ts). */
+exports.watcherArmModule = {
+    id: 'watcher-arm',
+    detect: armDetect,
+    announce: (env) => buildArmAnnounce(env.short, env.ownerPid, env.alias ?? null, env.assistant ?? false),
+    reminder: (d) => buildArmReminder(d),
+};
+//# sourceMappingURL=arm-reminder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arm-reminder.js","sourceRoot":"","sources":["../../src/commands/arm-reminder.ts"],"names":[],"mappings":";AAAA;;;;;uCAKuC;;;AAYvC,4CAiBC;AAKD,8BAMC;AAID,4CAOC;AAhDD,8CAAkD;AAElD;;;;;;8FAM8F;AAC9F,SAAgB,gBAAgB,CAC9B,KAAa,EAAE,QAAwB,EAAE,QAAuB,IAAI,EAAE,SAAS,GAAG,KAAK;IAEvF,MAAM,MAAM,GAAG,KAAK,IAAI,UAAU,CAAC;IACnC,OAAO,CACL,kFAAkF;UAChF,wFAAwF;UACxF,sFAAsF;UACtF,sFAAsF;UACtF,0BAA0B;UAC1B,4EAA4E;UAC5E,iFAAiF;UACjF,8BAA8B,KAAK,kBAAkB;UACrD,KAAK,IAAA,8BAAiB,EAAC,KAAK,EAAE,QAAQ,EAAE,SAAS,CAAC,MAAM;UACxD,gDAAgD;UAChD,iBAAiB,MAAM,gBAAgB,KAAK,IAAI,CACnD,CAAC;AACJ,CAAC;AAED;;iFAEiF;AACjF,SAAgB,SAAS,CAAC,GAAgB;IACxC,IAAI,GAAG,CAAC,KAAK;QAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;IACzC,MAAM,MAAM,GAAG,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7D,OAAO,MAAM,GAAG,CAAC;QACf,CAAC,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,EAAE;QACrC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;AAC/C,CAAC;AAED;qFACqF;AACrF,SAAgB,gBAAgB,CAAC,CAAY;IAC3C,IAAI,CAAC,CAAC,IAAI,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAC;IACrC,MAAM,MAAM,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,IAAK,CAAC,CAAC,MAA8B,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC;IACnF,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;QACf,OAAO,0BAA0B,MAAM,+DAA+D,CAAC;IACzG,CAAC;IACD,OAAO,qDAAqD,CAAC;AAC/D,CAAC;AAED;2EAC2E;AAC9D,QAAA,gBAAgB,GAAmB;IAC9C,EAAE,EAAE,aAAa;IACjB,MAAM,EAAE,SAAS;IACjB,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,gBAAgB,CAAC,GAAG,CAAC,KAAK,EAAE,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,KAAK,IAAI,IAAI,EAAE,GAAG,CAAC,SAAS,IAAI,KAAK,CAAC;IACvG,QAAQ,EAAE,CAAC,CAAC,EAAE,EAAE,CAAC,gBAAgB,CAAC,CAAC,CAAC;CACrC,CAAC"}

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

@@ -0,0 +1,9 @@
+/** assistant-doctrine — the flagged-assistant-project doctrine auto-load as a
+ *  reminder-interrupt module (docs/reminder-interrupt.md §Registry spec). announce-ONLY
+ *  + pass-through: the doctrine text is PRECOMPUTED by the hook (buildAssistantDoctrineContext
+ *  reads doctrine files — I/O that belongs in the hook). Fires ONLY for the assistant
+ *  project — env.assistantDoctrine is null everywhere else, so a normal project sees
+ *  nothing. adr: adr/assistant-role.md */
+import { ReminderEnv, Detection, ReminderModule } from './reminder-types';
+export declare function assistantDetect(env: ReminderEnv): Detection;
+export declare const assistantDoctrineModule: ReminderModule;

package/dist/commands/assistant-reminder.js

@@ -0,0 +1,20 @@
+"use strict";
+/** assistant-doctrine — the flagged-assistant-project doctrine auto-load as a
+ *  reminder-interrupt module (docs/reminder-interrupt.md §Registry spec). announce-ONLY
+ *  + pass-through: the doctrine text is PRECOMPUTED by the hook (buildAssistantDoctrineContext
+ *  reads doctrine files — I/O that belongs in the hook). Fires ONLY for the assistant
+ *  project — env.assistantDoctrine is null everywhere else, so a normal project sees
+ *  nothing. adr: adr/assistant-role.md */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assistantDoctrineModule = void 0;
+exports.assistantDetect = assistantDetect;
+function assistantDetect(env) {
+    return env.assistantDoctrine ? { tier: 'ambient' } : { tier: 'silent' };
+}
+exports.assistantDoctrineModule = {
+    id: 'assistant-doctrine',
+    detect: assistantDetect,
+    announce: (env) => env.assistantDoctrine ?? null,
+    reminder: () => null,
+};
+//# sourceMappingURL=assistant-reminder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"assistant-reminder.js","sourceRoot":"","sources":["../../src/commands/assistant-reminder.ts"],"names":[],"mappings":";AAAA;;;;;0CAK0C;;;AAI1C,0CAEC;AAFD,SAAgB,eAAe,CAAC,GAAgB;IAC9C,OAAO,GAAG,CAAC,iBAAiB,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AAC1E,CAAC;AAEY,QAAA,uBAAuB,GAAmB;IACrD,EAAE,EAAE,oBAAoB;IACxB,MAAM,EAAE,eAAe;IACvB,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,iBAAiB,IAAI,IAAI;IAChD,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI;CACrB,CAAC"}

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

@@ -0,0 +1,14 @@
+/** checkpoint — the open-checkpoints SessionStart landmark as a reminder-interrupt
+ *  module (docs/reminder-interrupt.md §Registry spec). announce-ONLY: checkpoints are
+ *  operator-triggered landmarks surfaced once at session start, never per-turn traffic
+ *  (reminder → null). `detect` gates on the hook-supplied list so the announce auto-
+ *  silences when nothing is open. The PURE render (list → hint block) lives here — the
+ *  hook owns only the fetch (I/O), keeping the module unit-testable. */
+import { ReminderEnv, Detection, ReminderModule, OpenCheckpointSlim } from './reminder-types';
+/** Format the open-checkpoints hint block: 3-most-recent rows + a single overflow line
+ *  when there are more. Returns null on zero (the announce is then skipped). */
+export declare function renderCheckpointHint(open: OpenCheckpointSlim[], projectName: string): string | null;
+/** Open checkpoints present → ambient announce; none (or per-turn, where the list is
+ *  absent) → silent. */
+export declare function checkpointDetect(env: ReminderEnv): Detection;
+export declare const checkpointModule: ReminderModule;

package/dist/commands/checkpoint-reminder.js

@@ -0,0 +1,50 @@
+"use strict";
+/** checkpoint — the open-checkpoints SessionStart landmark as a reminder-interrupt
+ *  module (docs/reminder-interrupt.md §Registry spec). announce-ONLY: checkpoints are
+ *  operator-triggered landmarks surfaced once at session start, never per-turn traffic
+ *  (reminder → null). `detect` gates on the hook-supplied list so the announce auto-
+ *  silences when nothing is open. The PURE render (list → hint block) lives here — the
+ *  hook owns only the fetch (I/O), keeping the module unit-testable. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkpointModule = void 0;
+exports.renderCheckpointHint = renderCheckpointHint;
+exports.checkpointDetect = checkpointDetect;
+/** Render a YYYY-MM-DD date in UTC for the session-start hint. */
+function fmtCheckpointDate(iso) {
+    return iso.slice(0, 10);
+}
+/** Format the open-checkpoints hint block: 3-most-recent rows + a single overflow line
+ *  when there are more. Returns null on zero (the announce is then skipped). */
+function renderCheckpointHint(open, projectName) {
+    if (open.length === 0)
+        return null;
+    // Server returns DESC by created_at; take the 3 most recent.
+    const top = open.slice(0, 3);
+    const overflow = open.length - top.length;
+    const lines = [];
+    lines.push(`[${open.length} checkpoint${open.length === 1 ? '' : 's'} open in ${projectName}:`);
+    for (const cp of top) {
+        lines.push(`  · ${cp.nodeId}  ${cp.title} (since ${fmtCheckpointDate(cp.createdAt)})`);
+    }
+    if (overflow > 0) {
+        lines.push(`  · ${overflow} more — greprag checkpoint list]`);
+    }
+    else {
+        lines.push(` View one: greprag checkpoint show <id>]`);
+    }
+    return lines.join('\n');
+}
+/** Open checkpoints present → ambient announce; none (or per-turn, where the list is
+ *  absent) → silent. */
+function checkpointDetect(env) {
+    return (env.openCheckpoints && env.openCheckpoints.length > 0)
+        ? { tier: 'ambient' }
+        : { tier: 'silent' };
+}
+exports.checkpointModule = {
+    id: 'checkpoint',
+    detect: checkpointDetect,
+    announce: (env) => renderCheckpointHint(env.openCheckpoints ?? [], env.projectName ?? ''),
+    reminder: () => null,
+};
+//# sourceMappingURL=checkpoint-reminder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoint-reminder.js","sourceRoot":"","sources":["../../src/commands/checkpoint-reminder.ts"],"names":[],"mappings":";AAAA;;;;;wEAKwE;;;AAWxE,oDAgBC;AAID,4CAIC;AA/BD,kEAAkE;AAClE,SAAS,iBAAiB,CAAC,GAAW;IACpC,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AAC1B,CAAC;AAED;gFACgF;AAChF,SAAgB,oBAAoB,CAAC,IAA0B,EAAE,WAAmB;IAClF,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACnC,6DAA6D;IAC7D,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC7B,MAAM,QAAQ,GAAG,IAAI,CAAC,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC;IAC1C,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,KAAK,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,MAAM,cAAc,IAAI,CAAC,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,YAAY,WAAW,GAAG,CAAC,CAAC;IAChG,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC;QACrB,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,MAAM,KAAK,EAAE,CAAC,KAAK,WAAW,iBAAiB,CAAC,EAAE,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC;IACzF,CAAC;IACD,IAAI,QAAQ,GAAG,CAAC,EAAE,CAAC;QACjB,KAAK,CAAC,IAAI,CAAC,OAAO,QAAQ,kCAAkC,CAAC,CAAC;IAChE,CAAC;SAAM,CAAC;QACN,KAAK,CAAC,IAAI,CAAC,0CAA0C,CAAC,CAAC;IACzD,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED;wBACwB;AACxB,SAAgB,gBAAgB,CAAC,GAAgB;IAC/C,OAAO,CAAC,GAAG,CAAC,eAAe,IAAI,GAAG,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC,CAAC;QAC5D,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE;QACrB,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AACzB,CAAC;AAEY,QAAA,gBAAgB,GAAmB;IAC9C,EAAE,EAAE,YAAY;IAChB,MAAM,EAAE,gBAAgB;IACxB,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,oBAAoB,CAAC,GAAG,CAAC,eAAe,IAAI,EAAE,EAAE,GAAG,CAAC,WAAW,IAAI,EAAE,CAAC;IACzF,QAAQ,EAAE,GAAG,EAAE,CAAC,IAAI;CACrB,CAAC"}

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

@@ -0,0 +1,92 @@
+/** friction-reminder — the active Mechanic as a reminder-interrupt registry module
+ *  (docs/reminder-interrupt.md §Registry spec). The GRADED sibling of the watcher-arm
+ *  reference module: its detector is stress-gated (silent at calm, escalating with the
+ *  live stress level) rather than a binary resolvable deficiency.
+ *
+ *  A reminder-interrupt MODULE is `{ id, detect, announce, reminder }` (reminder-types.ts):
+ *  `detect(env)` reads the live state → a tier (`silent` = nothing to fix); a SessionStart
+ *  `announce` loads the schema ONCE; a per-turn `reminder` fires a thin, grounded pointer
+ *  back at it. The no-orphan invariant requires the PAIR. The container (reminder-registry.ts)
+ *  wires every module; the hook (hook.ts) assembles the env and emits — see `injectReminders`.
+ *
+ *  PURE: imports only the stress constants; returns strings + a tier + a tally. No fs, no
+ *  network, no clock — the hook does ALL I/O. Keeping detect/tier a pure function is what
+ *  makes the detect→silent transition (the auto-stop) unit-testable (the regression-lock). */
+import { Tier, ReminderModule } from './reminder-types';
+/** The firing-tier ladder (docs/reminder-interrupt.md §Firing tiers). `silent`
+ *  is the off rung; the other three escalate wording intensity with the cost of
+ *  inaction: ambient = soft pointer, nudge = imperative + reason, nag = LOUD
+ *  forced-decision. */
+export type FrictionTier = Tier;
+/** Ambient (calm-state) cadence: one soft pointer every N turns. The low-rate
+ *  trickle for a capability with no live bad-state to gate on. */
+export declare const AMBIENT_EVERY_N = 5;
+/** Decide the friction reminder's firing tier from the live state bag — PURE so
+ *  the ladder is unit-testable (the regression-lock rung). DYNAMIC: urgency tracks
+ *  the live stress level (docs/stress-trigger.md), not a hand-set knob.
+ *
+ *    stress HIGH (2)     → nag    — LOUD forced-decision; fires while the live bad
+ *                                   state holds and goes silent the instant it flips.
+ *    stress ELEVATED (1) → nudge  — imperative + reason, while elevated.
+ *    stress CALM (0)     → ambient every Nth turn (turnCount % AMBIENT_EVERY_N),
+ *                                   else silent.
+ *
+ *  Defensive: non-finite inputs collapse to 0 (calm / turn 0 → silent), so a
+ *  missing or corrupt state bag can never escalate — fail-quiet by construction. */
+export declare function frictionReminderTier(turnCount: number, stress: number): FrictionTier;
+/** SessionStart announce — the mechanic-launch schema, loaded ONCE. The heavy
+ *  half of the pair: it (1) TEACHES the method the per-turn reminder triggers, so
+ *  the reminder stays a thin pointer, and (2) PRIMES adherence — the agent acts on
+ *  a reminder for a capability it was *taught*, not a cold mid-session imperative
+ *  (the no-orphan invariant, docs/reminder-interrupt.md). Written for an AGENT under
+ *  token pressure per the doc's authoring rules: action-first, reason+method
+ *  bundled, directive-framed, token-minimal. ~150 tokens; amortized over the
+ *  session. */
+export declare function buildMechanicAnnounce(): string;
+/** Per-turn reminder line for a given tier — the thin pointer back at the announce
+ *  schema; null on `silent`. Wording intensity scales with the tier (the doc):
+ *  ambient = soft pointer, nudge = imperative + reason, nag = LOUD forced-decision.
+ *  Every non-silent line is action-first, bundles reason+method, and ends on a
+ *  forced binary (act → spawn / clear → continue) so it CONVERTS instead of becoming
+ *  wallpaper (the fix-`16a29a8b` banner-blindness failure mode). Grounded to the
+ *  live signal where there is one (nudge/nag name the stress). The act-now directive
+ *  envelope (authoring rule #4) is applied by the hook, not here — this module owns
+ *  the wording, the caller owns the framing. */
+export declare function buildFrictionReminder(tier: FrictionTier): string | null;
+/** Persisted fire-counter (docs/reminder-interrupt.md §Measurement). The
+ *  DENOMINATOR of the adherence ratio: how many friction reminders were shown, by
+ *  tier. The numerator (reflex chips actually spawned after a reminder) is the next
+ *  measurement increment — see `reflexSpawns` (stamped by the spawn path when it
+ *  lands). Read the file to compute the fire rate: `reflexSpawns / total`. */
+export interface FrictionStats {
+    /** Total non-silent reminders shown. */
+    total: number;
+    /** Per-tier breakdown of `total`. */
+    byTier: {
+        ambient: number;
+        nudge: number;
+        nag: number;
+    };
+    /** Reflex chips observed spawned after a reminder (the adherence numerator).
+     *  Bumped by the spawn path; reminders never touch it. */
+    reflexSpawns: number;
+    firstFiredAt?: string;
+    lastFiredAt?: string;
+    /** turnCount at the most recent fire — lets the reader compute a per-N-turn rate. */
+    lastTurnCount?: number;
+}
+/** Tally one reminder fire — PURE (the hook supplies the clock via `nowIso`, so
+ *  this stays testable and resume-safe). A `silent` tier is NOT a fire: it returns
+ *  the prior stats unchanged, so the denominator only ever counts shown reminders. */
+export declare function tallyFrictionFire(prior: FrictionStats | null, tier: FrictionTier, turnCount: number, nowIso: string): FrictionStats;
+/** Record an observed reflex-chip spawn — PURE; the adherence numerator. The spawn
+ *  path calls this when it sees a chip preloaded from the reflex-chip template land
+ *  after a reminder. Never decrements; idempotency is the caller's concern. */
+export declare function tallyReflexSpawn(prior: FrictionStats | null): FrictionStats;
+/** The active Mechanic, recast onto the detector model (docs/reminder-interrupt.md
+ *  §Registry spec). `detect` is stress-gated — the friction signal IS the live
+ *  deficiency; `announce` teaches the reflex-chip schema once; `reminder` is the thin
+ *  per-turn line. Wired through the container (reminder-registry.ts). Unlike the
+ *  watcher-arm reference module (binary, auto-silences when armed), this one is
+ *  GRADED — silent at calm, escalating with the live stress level. */
+export declare const mechanicFrictionModule: ReminderModule;

package/dist/commands/friction-reminder.js

@@ -0,0 +1,147 @@
+"use strict";
+/** friction-reminder — the active Mechanic as a reminder-interrupt registry module
+ *  (docs/reminder-interrupt.md §Registry spec). The GRADED sibling of the watcher-arm
+ *  reference module: its detector is stress-gated (silent at calm, escalating with the
+ *  live stress level) rather than a binary resolvable deficiency.
+ *
+ *  A reminder-interrupt MODULE is `{ id, detect, announce, reminder }` (reminder-types.ts):
+ *  `detect(env)` reads the live state → a tier (`silent` = nothing to fix); a SessionStart
+ *  `announce` loads the schema ONCE; a per-turn `reminder` fires a thin, grounded pointer
+ *  back at it. The no-orphan invariant requires the PAIR. The container (reminder-registry.ts)
+ *  wires every module; the hook (hook.ts) assembles the env and emits — see `injectReminders`.
+ *
+ *  PURE: imports only the stress constants; returns strings + a tier + a tally. No fs, no
+ *  network, no clock — the hook does ALL I/O. Keeping detect/tier a pure function is what
+ *  makes the detect→silent transition (the auto-stop) unit-testable (the regression-lock). */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mechanicFrictionModule = exports.AMBIENT_EVERY_N = void 0;
+exports.frictionReminderTier = frictionReminderTier;
+exports.buildMechanicAnnounce = buildMechanicAnnounce;
+exports.buildFrictionReminder = buildFrictionReminder;
+exports.tallyFrictionFire = tallyFrictionFire;
+exports.tallyReflexSpawn = tallyReflexSpawn;
+const state_trigger_1 = require("./state-trigger");
+/** Ambient (calm-state) cadence: one soft pointer every N turns. The low-rate
+ *  trickle for a capability with no live bad-state to gate on. */
+exports.AMBIENT_EVERY_N = 5;
+/** Decide the friction reminder's firing tier from the live state bag — PURE so
+ *  the ladder is unit-testable (the regression-lock rung). DYNAMIC: urgency tracks
+ *  the live stress level (docs/stress-trigger.md), not a hand-set knob.
+ *
+ *    stress HIGH (2)     → nag    — LOUD forced-decision; fires while the live bad
+ *                                   state holds and goes silent the instant it flips.
+ *    stress ELEVATED (1) → nudge  — imperative + reason, while elevated.
+ *    stress CALM (0)     → ambient every Nth turn (turnCount % AMBIENT_EVERY_N),
+ *                                   else silent.
+ *
+ *  Defensive: non-finite inputs collapse to 0 (calm / turn 0 → silent), so a
+ *  missing or corrupt state bag can never escalate — fail-quiet by construction. */
+function frictionReminderTier(turnCount, stress) {
+    const s = Number.isFinite(stress) ? stress : 0;
+    const t = Number.isFinite(turnCount) ? turnCount : 0;
+    if (s >= state_trigger_1.STRESS_HIGH)
+        return 'nag';
+    if (s >= state_trigger_1.STRESS_ELEVATED)
+        return 'nudge';
+    if (t >= 1 && t % exports.AMBIENT_EVERY_N === 0)
+        return 'ambient';
+    return 'silent';
+}
+// ---------- Authored text (announce + per-turn reminder) ---------------------
+/** The HOW string — the method every tier points at. Kept in one place so the
+ *  announce and the per-turn line can never drift on the spawn mechanic. */
+const SPAWN_METHOD = 'spawn a fire-and-forget reflex chip (spawn_task → packages/cli/skill/templates/reflex-chip.md)';
+/** SessionStart announce — the mechanic-launch schema, loaded ONCE. The heavy
+ *  half of the pair: it (1) TEACHES the method the per-turn reminder triggers, so
+ *  the reminder stays a thin pointer, and (2) PRIMES adherence — the agent acts on
+ *  a reminder for a capability it was *taught*, not a cold mid-session imperative
+ *  (the no-orphan invariant, docs/reminder-interrupt.md). Written for an AGENT under
+ *  token pressure per the doc's authoring rules: action-first, reason+method
+ *  bundled, directive-framed, token-minimal. ~150 tokens; amortized over the
+ *  session. */
+function buildMechanicAnnounce() {
+    return [
+        '[Active Mechanic — keep the harness healthy IN-SESSION. Friction is a signal to fix now, not to defer.]',
+        'WHEN you hit friction this session — repeated yourself, fought a tool, got corrected ≥2× on the same thing, or rediscovered something already known — fix the PATTERN now; do not push through.',
+        `HOW: ${SPAWN_METHOD}. The chip is preloaded with the mechanic tools + live \`greprag mechanic status\`, so it orients instantly, lands a Tier-0 born-shadow repair, and ends — no gate to wait at.`,
+        'MODES: fix (land the repair) · log (`greprag fix log "<obs>"` when it is a mechanism for /mechanic later) · ask-human (the operator must decide).',
+        'WHY now: immediate-fix beats the backlog — the moment that produced the friction still holds the context the fix needs; deferred, that context is gone.',
+        'A per-turn reminder fires LOUD when live friction is detected — act on it, or say "clear" and continue.',
+    ].join('\n');
+}
+/** Per-turn reminder line for a given tier — the thin pointer back at the announce
+ *  schema; null on `silent`. Wording intensity scales with the tier (the doc):
+ *  ambient = soft pointer, nudge = imperative + reason, nag = LOUD forced-decision.
+ *  Every non-silent line is action-first, bundles reason+method, and ends on a
+ *  forced binary (act → spawn / clear → continue) so it CONVERTS instead of becoming
+ *  wallpaper (the fix-`16a29a8b` banner-blindness failure mode). Grounded to the
+ *  live signal where there is one (nudge/nag name the stress). The act-now directive
+ *  envelope (authoring rule #4) is applied by the hook, not here — this module owns
+ *  the wording, the caller owns the framing. */
+function buildFrictionReminder(tier) {
+    switch (tier) {
+        case 'nag':
+            return `⚠ FRICTION HIGH (live signal: repetition / errors / churn) — STOP pushing through; fix the PATTERN now → ${SPAWN_METHOD}. No friction? say "clear" + continue.`;
+        case 'nudge':
+            return `⚠ Friction rising — if you have repeated yourself or fought a tool, fix it now → ${SPAWN_METHOD}. Otherwise say "clear" + continue.`;
+        case 'ambient':
+            return `💡 Hit friction since the last check (repeated yourself, fought a tool, corrected ≥2×)? → ${SPAWN_METHOD}. If not, say "clear" + continue.`;
+        default:
+            return null;
+    }
+}
+/** Normalize any prior-stats blob (possibly missing/partial/corrupt) into a fully
+ *  populated FrictionStats. Pure, total. */
+function normalizeStats(prior) {
+    const p = (prior && typeof prior === 'object') ? prior : {};
+    const bt = (p.byTier && typeof p.byTier === 'object') ? p.byTier : {};
+    return {
+        total: Number.isFinite(p.total) ? p.total : 0,
+        byTier: {
+            ambient: Number.isFinite(bt.ambient) ? bt.ambient : 0,
+            nudge: Number.isFinite(bt.nudge) ? bt.nudge : 0,
+            nag: Number.isFinite(bt.nag) ? bt.nag : 0,
+        },
+        reflexSpawns: Number.isFinite(p.reflexSpawns) ? p.reflexSpawns : 0,
+        firstFiredAt: p.firstFiredAt,
+        lastFiredAt: p.lastFiredAt,
+        lastTurnCount: p.lastTurnCount,
+    };
+}
+/** Tally one reminder fire — PURE (the hook supplies the clock via `nowIso`, so
+ *  this stays testable and resume-safe). A `silent` tier is NOT a fire: it returns
+ *  the prior stats unchanged, so the denominator only ever counts shown reminders. */
+function tallyFrictionFire(prior, tier, turnCount, nowIso) {
+    const s = normalizeStats(prior);
+    if (tier === 'silent')
+        return s;
+    s.total += 1;
+    s.byTier[tier] += 1;
+    s.firstFiredAt = s.firstFiredAt || nowIso;
+    s.lastFiredAt = nowIso;
+    if (Number.isFinite(turnCount))
+        s.lastTurnCount = turnCount;
+    return s;
+}
+/** Record an observed reflex-chip spawn — PURE; the adherence numerator. The spawn
+ *  path calls this when it sees a chip preloaded from the reflex-chip template land
+ *  after a reminder. Never decrements; idempotency is the caller's concern. */
+function tallyReflexSpawn(prior) {
+    const s = normalizeStats(prior);
+    s.reflexSpawns += 1;
+    return s;
+}
+// ---------- Registry module --------------------------------------------------
+/** The active Mechanic, recast onto the detector model (docs/reminder-interrupt.md
+ *  §Registry spec). `detect` is stress-gated — the friction signal IS the live
+ *  deficiency; `announce` teaches the reflex-chip schema once; `reminder` is the thin
+ *  per-turn line. Wired through the container (reminder-registry.ts). Unlike the
+ *  watcher-arm reference module (binary, auto-silences when armed), this one is
+ *  GRADED — silent at calm, escalating with the live stress level. */
+exports.mechanicFrictionModule = {
+    id: 'mechanic-friction',
+    detect: (env) => ({ tier: frictionReminderTier(env.turnCount, env.stress) }),
+    announce: () => buildMechanicAnnounce(),
+    reminder: (d) => buildFrictionReminder(d.tier),
+};
+//# sourceMappingURL=friction-reminder.js.map

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

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

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

@@ -0,0 +1,23 @@
+/** front-desk — the shared tenant front-desk mailbox as a reminder-interrupt module
+ *  (docs/reminder-interrupt.md §Registry spec). The module that uses BOTH halves of the
+ *  pair: a SessionStart `announce` (discreet count of cold opens + inbound email waiting
+ *  at the shared desk) AND a per-turn `reminder` (envelope-only "you've got mail from X"
+ *  notice). This is the "announce + reminder often utilize each other" case the registry
+ *  was consolidated for — one module, one mailbox, two surfaces.
+ *
+ *  PURE: the hook owns the count fetch (frontDeskUnread) AND the notice's network + per-
+ *  machine dedup (frontDeskNotice), passing both via env; the module only formats the
+ *  count and routes the precomputed notice.
+ *
+ *  Privacy — front-desk is the SHARED tenant mailbox (cold opens + inbound email addressed
+ *  to nobody's session), so its count leaks nothing private. This is NOT the v5.6.1
+ *  project-wide eavesdrop vector that betrayed a sibling session's session-targeted DMs.
+ *  adr: adr/address-grammar.md (2026-06-10), docs/front-desk-switchboard.md §5 */
+import { ReminderEnv, Detection, ReminderModule } from './reminder-types';
+/** SessionStart count hint — the discreet door (count + how to read), never content.
+ *  Null at zero so the announce is skipped. */
+export declare function buildFrontDeskAnnounce(unread: number): string | null;
+/** Either surface has something → ambient (soft, never a forced-decision directive); else
+ *  silent. SessionStart sets frontDeskUnread; per-turn sets frontDeskNotice. */
+export declare function frontDeskDetect(env: ReminderEnv): Detection;
+export declare const frontDeskModule: ReminderModule;

package/dist/commands/frontdesk-reminder.js

@@ -0,0 +1,40 @@
+"use strict";
+/** front-desk — the shared tenant front-desk mailbox as a reminder-interrupt module
+ *  (docs/reminder-interrupt.md §Registry spec). The module that uses BOTH halves of the
+ *  pair: a SessionStart `announce` (discreet count of cold opens + inbound email waiting
+ *  at the shared desk) AND a per-turn `reminder` (envelope-only "you've got mail from X"
+ *  notice). This is the "announce + reminder often utilize each other" case the registry
+ *  was consolidated for — one module, one mailbox, two surfaces.
+ *
+ *  PURE: the hook owns the count fetch (frontDeskUnread) AND the notice's network + per-
+ *  machine dedup (frontDeskNotice), passing both via env; the module only formats the
+ *  count and routes the precomputed notice.
+ *
+ *  Privacy — front-desk is the SHARED tenant mailbox (cold opens + inbound email addressed
+ *  to nobody's session), so its count leaks nothing private. This is NOT the v5.6.1
+ *  project-wide eavesdrop vector that betrayed a sibling session's session-targeted DMs.
+ *  adr: adr/address-grammar.md (2026-06-10), docs/front-desk-switchboard.md §5 */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.frontDeskModule = void 0;
+exports.buildFrontDeskAnnounce = buildFrontDeskAnnounce;
+exports.frontDeskDetect = frontDeskDetect;
+/** SessionStart count hint — the discreet door (count + how to read), never content.
+ *  Null at zero so the announce is skipped. */
+function buildFrontDeskAnnounce(unread) {
+    if (!unread || unread <= 0)
+        return null;
+    return `[📬 ${unread} message${unread === 1 ? '' : 's'} at the front desk — \`greprag inbox --front-desk\` to read]`;
+}
+/** Either surface has something → ambient (soft, never a forced-decision directive); else
+ *  silent. SessionStart sets frontDeskUnread; per-turn sets frontDeskNotice. */
+function frontDeskDetect(env) {
+    const unread = env.frontDeskUnread ?? 0;
+    return (unread > 0 || env.frontDeskNotice) ? { tier: 'ambient' } : { tier: 'silent' };
+}
+exports.frontDeskModule = {
+    id: 'front-desk',
+    detect: frontDeskDetect,
+    announce: (env) => buildFrontDeskAnnounce(env.frontDeskUnread ?? 0),
+    reminder: (_d, env) => env.frontDeskNotice ?? null,
+};
+//# sourceMappingURL=frontdesk-reminder.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"frontdesk-reminder.js","sourceRoot":"","sources":["../../src/commands/frontdesk-reminder.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;kFAckF;;;AAMlF,wDAGC;AAID,0CAGC;AAZD;+CAC+C;AAC/C,SAAgB,sBAAsB,CAAC,MAAc;IACnD,IAAI,CAAC,MAAM,IAAI,MAAM,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IACxC,OAAO,OAAO,MAAM,WAAW,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAAG,8DAA8D,CAAC;AACvH,CAAC;AAED;gFACgF;AAChF,SAAgB,eAAe,CAAC,GAAgB;IAC9C,MAAM,MAAM,GAAG,GAAG,CAAC,eAAe,IAAI,CAAC,CAAC;IACxC,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;AACxF,CAAC;AAEY,QAAA,eAAe,GAAmB;IAC7C,EAAE,EAAE,YAAY;IAChB,MAAM,EAAE,eAAe;IACvB,QAAQ,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,sBAAsB,CAAC,GAAG,CAAC,eAAe,IAAI,CAAC,CAAC;IACnE,QAAQ,EAAE,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,eAAe,IAAI,IAAI;CACnD,CAAC"}

package/dist/commands/inbox-watch-supervisor.d.ts

@@ -35,7 +35,32 @@ export declare const FATAL_EXIT_CODE = 64;
  *  so it respawns; SIGINT/SIGTERM skip these and return via the
  *  normal abort path. */
 export declare function installLastResortHandlers(): void;
+type ChildExit = {
+    code: number | null;
+    signal: NodeJS.Signals | null;
+    err: Error | null;
+};
+/** Human-readable cause for a child death + whether it was an OS-level native
+ *  crash. Turns "exit 3221226091" into "native crash 0xC000026B (DLL init failed —
+ *  out of commit memory / window station gone)" so both the respawn log and the
+ *  stand-down diagnostic are actionable instead of opaque digits. */
+export declare function describeChildExit(exit: ChildExit): {
+    reason: string;
+    native: boolean;
+};
+/** Pure crash-loop decision (testable, mirrors capSurplusVerdict/gcVerdict).
+ *  Given how long the just-exited child lived (`liveMs`) and the running
+ *  fast-death `streak`, return the updated streak and whether the supervisor
+ *  should STAND DOWN instead of respawning. A child that lived at least
+ *  `lifetimeMs` did real work → streak resets to 0. Otherwise the streak grows
+ *  and trips once it reaches `maxDeaths`. This is the whole breaker rule — no
+ *  process state, just a count + a lifetime floor. */
+export declare function crashLoopVerdict(liveMs: number, streak: number, lifetimeMs: number, maxDeaths: number): {
+    streak: number;
+    standDown: boolean;
+};
 /** Parent supervisor. Spawns the watch loop as a Node child, forwards
  *  stdio so Monitor sees each printed line as a notification verbatim,
  *  and respawns on any non-clean exit. */
 export declare function runSupervisor(): Promise<void>;
+export {};