greprag 5.46.0 → 5.47.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/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/init.js

@@ -1339,6 +1339,26 @@ function applySettings(settings, apiKey) {
     else {
         changes.push('UserPromptSubmit mail hook already configured (skipped)');
     }
+    // UserPromptSubmit (friction-reminder) — the active Mechanic's dynamic friction
+    // reminder, BESIDE the arm directive. Each turn it reads the Stop-stashed state
+    // bag (stress + turnCount) and, on a stress-driven tier (silent → ambient →
+    // nudge → nag), injects a one-line forced-decision pointer to spawn the mechanic
+    // reflex chip. Paired with the SessionStart announce (recap) — the no-orphan
+    // invariant. Additive + fail-open (own hook, never breaks the arm/mail chain);
+    // self-silences at rest and under `mechanic off`. docs/reminder-interrupt.md
+    const frictionReminderHook = {
+        matcher: '',
+        hooks: [{ type: 'command', command: 'greprag-hook friction-reminder', timeout: 3000 }],
+    };
+    if (!hasGrepragHook(settings.hooks.UserPromptSubmit, 'friction-reminder')) {
+        if (!settings.hooks.UserPromptSubmit)
+            settings.hooks.UserPromptSubmit = [];
+        settings.hooks.UserPromptSubmit.push(frictionReminderHook);
+        changes.push('Added UserPromptSubmit hook (active-Mechanic friction reminder)');
+    }
+    else {
+        changes.push('UserPromptSubmit friction-reminder hook already configured (skipped)');
+    }
     // Context governor (Chip C) — two local-only hooks, no API calls.
     // Stop probe: reads the transcript TAIL, records live context size to
     // ~/.greprag/context-state/<8hex>.json — read it with `greprag context status`.