greprag 5.50.0 → 5.52.0

package/dist/opencode-plugin.bundle.js

@@ -1840,10 +1840,20 @@ function buildDocPointerAnnounce(pointers) {
     return null;
   const shown = pointers.slice(0, ANNOUNCE_CAP);
   const more = pointers.length > shown.length ? ` (+${pointers.length - shown.length} more registered)` : "";
+  const line = (p) => {
+    if (p.buried)
+      return `\u26A0 ${p.path} \u2014 ${p.hook}  [likely stale: ${p.decayNote} \u2014 verify or remove]`;
+    if (p.decayNote)
+      return `\u2022 ${p.path} \u2014 ${p.hook}  [${p.decayNote}]`;
+    return `\u2022 ${p.path} \u2014 ${p.hook}`;
+  };
+  const buriedN = shown.filter((p) => p.buried).length;
+  const staleFooter = buriedN > 0 ? `
+${buriedN} doc(s) flagged likely-stale (cited files vanished) \u2014 confirm or remove them.` : "";
   return [
     `[greprag docs \u2014 core documents on file for this project (auto-registered)${more}:]`,
-    ...shown.map((p) => `\u2022 ${p.path} \u2014 ${p.hook}`),
-    "One of these covers your topic? READ IT before re-deriving what it already answers."
+    ...shown.map(line),
+    "One of these covers your topic? READ IT before re-deriving what it already answers." + staleFooter
   ].join("\n");
 }
 var docPointerAnnounceModule = {
@@ -2078,6 +2088,28 @@ var skillGainAnnounceModule = {
   reminder: () => null
 };
 
+// src/commands/skill-mirror-reminder.ts
+function buildSkillMirrorAnnounce(m) {
+  if (!m || m.count <= 0)
+    return null;
+  const sample = m.names.slice(0, 4).join(", ");
+  const more = m.count > 4 ? ", \u2026" : "";
+  return [
+    `[greprag skills \u2014 ${m.count} of your skills travel with the harness (auto-mirrored from use, always fresh): ${sample}${more}.]`,
+    "Any machine or harness with the greprag CLI can use them \u2014 `greprag load` to browse, `greprag load <skill>` to read one inline. No ~/.claude/skills needed."
+  ].join("\n");
+}
+var skillMirrorAnnounceModule = {
+  id: "skill-mirror-announce",
+  source: "prompt",
+  dependsOn: ["load-primer"],
+  // references `greprag load` — the primer establishes it
+  detect: (_env) => ({ tier: "silent" }),
+  // announce-only
+  announce: (env) => buildSkillMirrorAnnounce(env.mirroredSkills),
+  reminder: () => null
+};
+
 // src/commands/reminder-registry.ts
 var REGISTRY = [
   inboxPrimerModule,
@@ -2087,7 +2119,9 @@ var REGISTRY = [
   docPointerAnnounceModule,
   // announce-only "core documents" list (docs/doc-pointer-system.md)
   skillGainAnnounceModule,
-  // announce-only skill-gain landings + proposals (docs/skill-learning-loop.md)
+  // announce-only skill-gain landings (docs/skill-learning-loop.md)
+  skillMirrorAnnounceModule,
+  // one-line Tier-3 pointer: your skills travel via greprag load (docs/load-system.md)
   setupWarningModule,
   versionUpgradeModule,
   // Deficiency-gated announce — silent unless a newer release exists

package/dist/procedure-watch.d.ts

@@ -0,0 +1,153 @@
+/** Procedure watch — the Procedure System's span-watch state + close logic
+ *  (docs/procedure-system.md §V1 LEARN-leg build spec, component 1).
+ *
+ *  The unit of learning is a WATCH WINDOW: the UserPromptSubmit trigger opens
+ *  it, the Stop hook observes each turn inside it, negative continuity closes
+ *  it ("is the <verb> procedure still live?" — cessation, never completion).
+ *  One JSON file beside the procedure store; ONE active watch at a time (v1).
+ *
+ *  PURE open/advance/close (openWatch / buildTurnDigest / advanceWatch /
+ *  liveSpan / applyDistillTransition) is split from the file I/O (read/write/
+ *  clear) — the procedure.ts shape — so hysteresis, the watchdog, and the
+ *  transition table are unit-testable without a hook.
+ *
+ *  Endpoint-detection invariants (§Endpoint detection):
+ *    - hysteresis: one OFF turn never closes (a tangent can't truncate the
+ *      span); close at offStreak ≥ 2.
+ *    - the endpoint stamps at the LAST LIVE turn, not the first dead one —
+ *      span = observations[0 .. lastLiveTurn].
+ *    - judge unreachable → offStreak untouched (the watch extends); the
+ *      max-turn watchdog is the backstop, never the primary mechanism. */
+import { type Procedure, type ProcedureStore, type ProcedureMatch } from './procedure';
+export type WatchPhase = 'LEARN' | 'REPLAY';
+/** One observed turn, compact (≤1.5K serialized — the digest cap bounds both
+ *  the per-turn observe POST and the close-time distill call). */
+export interface ProcedureTurnDigest {
+    /** 1-based turn index within the watch. */
+    turn: number;
+    /** User-prompt head. */
+    user: string;
+    /** Bash commands the turn ran, each with a short output-tail exit hint. */
+    commands: string[];
+    /** Files the turn touched (project-relative where possible). */
+    files: string[];
+    /** Turn status: completed | interrupted | errored. */
+    status: string;
+}
+export interface ProcedureWatch {
+    verb: string;
+    phase: WatchPhase;
+    openedAt: string;
+    /** Turns observed so far (== observations.length). */
+    turnCount: number;
+    observations: ProcedureTurnDigest[];
+    /** The last turn the judge called LIVE — where the endpoint stamps.
+     *  0 = never live. */
+    lastLiveTurn: number;
+    /** Consecutive not-live turns. Close at ≥ WATCH_OFF_STREAK_CLOSE. */
+    offStreak: number;
+}
+/** Watchdog backstop: a watch never observes past this many turns — the next
+ *  turn aborts it (log a fix-queue smell, never distill). */
+export declare const WATCH_MAX_TURNS = 15;
+/** Hysteresis: consecutive OFF turns required to close (a one-turn tangent
+ *  can't truncate the span). */
+export declare const WATCH_OFF_STREAK_CLOSE = 2;
+/** Per-turn digest cap, serialized. */
+export declare const DIGEST_TOTAL_CAP = 1500;
+/** User-prompt head cap inside the digest. */
+export declare const DIGEST_USER_CAP = 300;
+/** The Tier-1 trigger set for OPENING A LEARN WATCH, independent of the store
+ *  (docs/procedure-system.md §Tier 1: deploy / push / release / ship / build /
+ *  test — `ship` phrases map to the `release` verb, matching GIT_SEED_SET).
+ *  `build` + `test` have no seed: the clean LEARN proof case. `push` is
+ *  destructive — it sits here only so the opener can NAME the refusal; a LEARN
+ *  watch never opens for it (the seed is the canon even when stale). Entries
+ *  are Procedure-shaped (steps empty — vocabulary, not recipes) so the same
+ *  matcher + intent guard run over them. */
+export declare const TIER1_LEARN_TRIGGERS: Procedure[];
+/** Match a prompt against the Tier-1 LEARN vocabulary (same matcher + intent
+ *  guard as the store path). PURE. */
+export declare function matchLearnTrigger(prompt: string): ProcedureMatch | null;
+/** Is this verb destructive — per the store's procedure OR the Tier-1
+ *  vocabulary? Destructive verbs are never learn-writable and a LEARN watch
+ *  never opens for them. PURE. */
+export declare function isDestructiveVerb(verb: string, store: ProcedureStore): boolean;
+/** The trigger phrases a LEARNED procedure should match on next time — the
+ *  store procedure's own triggers when it exists (stale re-learn keeps them),
+ *  else the Tier-1 vocabulary's, else the bare verb. PURE. */
+export declare function learnTriggersForVerb(verb: string, store: ProcedureStore): string[];
+export declare function openWatch(verb: string, phase: WatchPhase, openedAt?: string): ProcedureWatch;
+/** What the digest builder needs from the parsed turn — a structural subset of
+ *  the hook's ParsedTurn (Bash briefs carry the command; _output the stdout). */
+export interface DigestSourceTurn {
+    userPrompt: string;
+    toolCalls: Array<{
+        name: string;
+        brief?: string;
+        _output?: string;
+    }>;
+    filesTouched: string[];
+    status: string;
+}
+/** Build one compact TurnDigest: user-prompt head ≤300 chars, Bash commands
+ *  (+ a short output-tail exit hint) from toolCalls, files touched, turn
+ *  status — ≤1.5K serialized total. PURE — unit-tested. */
+export declare function buildTurnDigest(turn: DigestSourceTurn, turnNumber: number): ProcedureTurnDigest;
+export type WatchDisposition = 'continue' | 'close' | 'watchdog';
+/** Would observing one more turn cross the watchdog? The caller checks this
+ *  BEFORE the judge call so the aborting turn costs nothing. PURE. */
+export declare function willExceedWatchdog(watch: ProcedureWatch): boolean;
+/** Advance the watch by one observed turn. Appends the digest, then applies
+ *  the continuity verdict per §Endpoint detection:
+ *    live=true  → stamp lastLiveTurn, reset offStreak
+ *    live=false → offStreak++
+ *    live=null  → judge unreachable: offStreak UNTOUCHED (the watch extends;
+ *                 the watchdog is the backstop)
+ *  Dispositions: 'watchdog' when the turn count exceeds the cap (defensive —
+ *  callers should pre-check willExceedWatchdog), 'close' at
+ *  offStreak ≥ WATCH_OFF_STREAK_CLOSE, else 'continue'. PURE — unit-tested. */
+export declare function advanceWatch(watch: ProcedureWatch, digest: ProcedureTurnDigest, live: boolean | null): {
+    watch: ProcedureWatch;
+    disposition: WatchDisposition;
+};
+/** The live span — the endpoint stamps at the last LIVE turn, so trailing
+ *  not-live turns never enter the artifact. Span = observations[0 ..
+ *  lastLiveTurn]. Empty when the watch was never live (nothing to distill —
+ *  never register garbage). PURE. */
+export declare function liveSpan(watch: ProcedureWatch): ProcedureTurnDigest[];
+export interface DistilledFields {
+    steps: string;
+    endpoint: string;
+    caveats?: string;
+}
+export type TransitionAction = 'learned' | 'confirmed' | 'relearned' | 'discarded';
+/** Apply the spec's transition table (component 6) to the procedure store:
+ *
+ *    LEARN  | any (span ended)  | status=learned, steps/endpoint/caveats from distill
+ *    REPLAY | clean             | status=confirmed (steps untouched)
+ *    REPLAY | floundered        | re-learn in place: distill the failed span → learned
+ *    any    | distill unreadable / judge down | no write; watch discarded
+ *
+ *  Each row gates on the fields it actually consumes: LEARN and
+ *  REPLAY-floundered need the distilled fields; REPLAY-clean needs the
+ *  outcome. A missing required field = the unreadable/judge-down row → no
+ *  write. All writes flow through upsertProcedure, whose destructive guard
+ *  already refuses to overwrite a `push` seed (never weakened here).
+ *  PURE — unit-tested. Returns the (possibly unchanged) store + what happened. */
+export declare function applyDistillTransition(store: ProcedureStore, watch: Pick<ProcedureWatch, 'verb' | 'phase'>, outcome: 'clean' | 'floundered' | null, distilled: DistilledFields | null, fallbackTriggers: string[]): {
+    store: ProcedureStore;
+    action: TransitionAction;
+};
+export declare function procedureWatchPath(projectId: string): string;
+/** The Stop-hook observer's zero-cost gate: no file → no watch → no work. */
+export declare function hasProcedureWatch(projectId: string): boolean;
+/** Read the active watch. Null on any miss/corruption — fail-open; the caller
+ *  clears the file so a corrupt watch can't wedge the observer. */
+export declare function readProcedureWatch(projectId: string): ProcedureWatch | null;
+export declare function writeProcedureWatch(projectId: string, watch: ProcedureWatch): void;
+export declare function clearProcedureWatch(projectId: string): void;
+/** Open a watch iff none is active (ONE active watch at a time, v1 — an
+ *  in-flight watch is never replaced by a new trigger). Returns whether a
+ *  watch was opened. */
+export declare function openWatchIfIdle(projectId: string, verb: string, phase: WatchPhase): boolean;

package/dist/procedure-watch.js

@@ -0,0 +1,349 @@
+"use strict";
+/** Procedure watch — the Procedure System's span-watch state + close logic
+ *  (docs/procedure-system.md §V1 LEARN-leg build spec, component 1).
+ *
+ *  The unit of learning is a WATCH WINDOW: the UserPromptSubmit trigger opens
+ *  it, the Stop hook observes each turn inside it, negative continuity closes
+ *  it ("is the <verb> procedure still live?" — cessation, never completion).
+ *  One JSON file beside the procedure store; ONE active watch at a time (v1).
+ *
+ *  PURE open/advance/close (openWatch / buildTurnDigest / advanceWatch /
+ *  liveSpan / applyDistillTransition) is split from the file I/O (read/write/
+ *  clear) — the procedure.ts shape — so hysteresis, the watchdog, and the
+ *  transition table are unit-testable without a hook.
+ *
+ *  Endpoint-detection invariants (§Endpoint detection):
+ *    - hysteresis: one OFF turn never closes (a tangent can't truncate the
+ *      span); close at offStreak ≥ 2.
+ *    - the endpoint stamps at the LAST LIVE turn, not the first dead one —
+ *      span = observations[0 .. lastLiveTurn].
+ *    - judge unreachable → offStreak untouched (the watch extends); the
+ *      max-turn watchdog is the backstop, never the primary mechanism. */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIER1_LEARN_TRIGGERS = exports.DIGEST_USER_CAP = exports.DIGEST_TOTAL_CAP = exports.WATCH_OFF_STREAK_CLOSE = exports.WATCH_MAX_TURNS = void 0;
+exports.matchLearnTrigger = matchLearnTrigger;
+exports.isDestructiveVerb = isDestructiveVerb;
+exports.learnTriggersForVerb = learnTriggersForVerb;
+exports.openWatch = openWatch;
+exports.buildTurnDigest = buildTurnDigest;
+exports.willExceedWatchdog = willExceedWatchdog;
+exports.advanceWatch = advanceWatch;
+exports.liveSpan = liveSpan;
+exports.applyDistillTransition = applyDistillTransition;
+exports.procedureWatchPath = procedureWatchPath;
+exports.hasProcedureWatch = hasProcedureWatch;
+exports.readProcedureWatch = readProcedureWatch;
+exports.writeProcedureWatch = writeProcedureWatch;
+exports.clearProcedureWatch = clearProcedureWatch;
+exports.openWatchIfIdle = openWatchIfIdle;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const procedure_1 = require("./procedure");
+/** Watchdog backstop: a watch never observes past this many turns — the next
+ *  turn aborts it (log a fix-queue smell, never distill). */
+exports.WATCH_MAX_TURNS = 15;
+/** Hysteresis: consecutive OFF turns required to close (a one-turn tangent
+ *  can't truncate the span). */
+exports.WATCH_OFF_STREAK_CLOSE = 2;
+/** Per-turn digest cap, serialized. */
+exports.DIGEST_TOTAL_CAP = 1_500;
+/** User-prompt head cap inside the digest. */
+exports.DIGEST_USER_CAP = 300;
+const DIGEST_MAX_COMMANDS = 6;
+const DIGEST_COMMAND_CAP = 180;
+const DIGEST_EXIT_HINT_CAP = 80;
+const DIGEST_MAX_FILES = 8;
+// ---------- Tier-1 LEARN trigger vocabulary (PURE data) -----------------------
+/** The Tier-1 trigger set for OPENING A LEARN WATCH, independent of the store
+ *  (docs/procedure-system.md §Tier 1: deploy / push / release / ship / build /
+ *  test — `ship` phrases map to the `release` verb, matching GIT_SEED_SET).
+ *  `build` + `test` have no seed: the clean LEARN proof case. `push` is
+ *  destructive — it sits here only so the opener can NAME the refusal; a LEARN
+ *  watch never opens for it (the seed is the canon even when stale). Entries
+ *  are Procedure-shaped (steps empty — vocabulary, not recipes) so the same
+ *  matcher + intent guard run over them. */
+exports.TIER1_LEARN_TRIGGERS = [
+    { verb: 'deploy', triggers: ['deploy', 'deploy the api', 'deploy the worker', 'redeploy'], steps: '', status: 'seeded' },
+    { verb: 'push', triggers: ['push', 'git push', 'push to remote', 'push it up', 'push upstream'], steps: '', status: 'seeded', destructive: true },
+    { verb: 'release', triggers: ['release', 'ship', 'ship it', 'ship a release', 'cut a release', 'publish the release', 'do a release'], steps: '', status: 'seeded' },
+    { verb: 'build', triggers: ['build', 'rebuild', 'compile', 'run the build'], steps: '', status: 'seeded' },
+    { verb: 'test', triggers: ['test', 'tests', 'run the tests', 'run tests'], steps: '', status: 'seeded' },
+];
+/** Match a prompt against the Tier-1 LEARN vocabulary (same matcher + intent
+ *  guard as the store path). PURE. */
+function matchLearnTrigger(prompt) {
+    return (0, procedure_1.matchProcedure)(prompt, {
+        version: procedure_1.PROCEDURE_STORE_VERSION,
+        procedures: exports.TIER1_LEARN_TRIGGERS,
+    });
+}
+/** Is this verb destructive — per the store's procedure OR the Tier-1
+ *  vocabulary? Destructive verbs are never learn-writable and a LEARN watch
+ *  never opens for them. PURE. */
+function isDestructiveVerb(verb, store) {
+    if (store.procedures.some(p => p.verb === verb && p.destructive))
+        return true;
+    return exports.TIER1_LEARN_TRIGGERS.some(p => p.verb === verb && p.destructive);
+}
+/** The trigger phrases a LEARNED procedure should match on next time — the
+ *  store procedure's own triggers when it exists (stale re-learn keeps them),
+ *  else the Tier-1 vocabulary's, else the bare verb. PURE. */
+function learnTriggersForVerb(verb, store) {
+    const existing = store.procedures.find(p => p.verb === verb);
+    if (existing && existing.triggers.length)
+        return existing.triggers;
+    const vocab = exports.TIER1_LEARN_TRIGGERS.find(p => p.verb === verb);
+    if (vocab && vocab.triggers.length)
+        return vocab.triggers;
+    return [verb];
+}
+// ---------- Open (PURE) -------------------------------------------------------
+function openWatch(verb, phase, openedAt) {
+    return {
+        verb,
+        phase,
+        openedAt: openedAt || new Date().toISOString(),
+        turnCount: 0,
+        observations: [],
+        lastLiveTurn: 0,
+        offStreak: 0,
+    };
+}
+function oneLine(s) {
+    return (s || '').replace(/\s+/g, ' ').trim();
+}
+/** Build one compact TurnDigest: user-prompt head ≤300 chars, Bash commands
+ *  (+ a short output-tail exit hint) from toolCalls, files touched, turn
+ *  status — ≤1.5K serialized total. PURE — unit-tested. */
+function buildTurnDigest(turn, turnNumber) {
+    const commands = [];
+    for (const tc of turn.toolCalls) {
+        if (tc.name !== 'Bash' || !tc.brief)
+            continue;
+        if (commands.length >= DIGEST_MAX_COMMANDS)
+            break;
+        let cmd = oneLine(tc.brief).slice(0, DIGEST_COMMAND_CAP);
+        if (tc._output) {
+            const lines = tc._output.split('\n').map(l => l.trim()).filter(Boolean);
+            const tail = lines.length ? lines[lines.length - 1].slice(0, DIGEST_EXIT_HINT_CAP) : '';
+            if (tail)
+                cmd += ` ⇒ ${tail}`;
+        }
+        commands.push(cmd);
+    }
+    const digest = {
+        turn: turnNumber,
+        user: oneLine(turn.userPrompt).slice(0, exports.DIGEST_USER_CAP),
+        commands,
+        files: turn.filesTouched.slice(0, DIGEST_MAX_FILES).map(f => f.slice(0, 160)),
+        status: turn.status || 'completed',
+    };
+    // Total-size guard: trim breadth (files, then commands, then the user head)
+    // until the serialized digest fits the cap.
+    while (JSON.stringify(digest).length > exports.DIGEST_TOTAL_CAP) {
+        if (digest.files.length > 2)
+            digest.files = digest.files.slice(0, digest.files.length - 1);
+        else if (digest.commands.length > 1)
+            digest.commands = digest.commands.slice(0, digest.commands.length - 1);
+        else if (digest.user.length > 100)
+            digest.user = digest.user.slice(0, digest.user.length - 50);
+        else
+            break; // structurally minimal — accept
+    }
+    return digest;
+}
+/** Would observing one more turn cross the watchdog? The caller checks this
+ *  BEFORE the judge call so the aborting turn costs nothing. PURE. */
+function willExceedWatchdog(watch) {
+    return watch.turnCount >= exports.WATCH_MAX_TURNS;
+}
+/** Advance the watch by one observed turn. Appends the digest, then applies
+ *  the continuity verdict per §Endpoint detection:
+ *    live=true  → stamp lastLiveTurn, reset offStreak
+ *    live=false → offStreak++
+ *    live=null  → judge unreachable: offStreak UNTOUCHED (the watch extends;
+ *                 the watchdog is the backstop)
+ *  Dispositions: 'watchdog' when the turn count exceeds the cap (defensive —
+ *  callers should pre-check willExceedWatchdog), 'close' at
+ *  offStreak ≥ WATCH_OFF_STREAK_CLOSE, else 'continue'. PURE — unit-tested. */
+function advanceWatch(watch, digest, live) {
+    const next = {
+        ...watch,
+        turnCount: watch.turnCount + 1,
+        observations: [...watch.observations, digest],
+    };
+    if (next.turnCount > exports.WATCH_MAX_TURNS) {
+        return { watch: next, disposition: 'watchdog' };
+    }
+    if (live === true) {
+        next.lastLiveTurn = next.turnCount;
+        next.offStreak = 0;
+    }
+    else if (live === false) {
+        next.offStreak = watch.offStreak + 1;
+    } // live === null → untouched
+    if (next.offStreak >= exports.WATCH_OFF_STREAK_CLOSE) {
+        return { watch: next, disposition: 'close' };
+    }
+    return { watch: next, disposition: 'continue' };
+}
+/** The live span — the endpoint stamps at the last LIVE turn, so trailing
+ *  not-live turns never enter the artifact. Span = observations[0 ..
+ *  lastLiveTurn]. Empty when the watch was never live (nothing to distill —
+ *  never register garbage). PURE. */
+function liveSpan(watch) {
+    return watch.observations.slice(0, watch.lastLiveTurn);
+}
+/** Apply the spec's transition table (component 6) to the procedure store:
+ *
+ *    LEARN  | any (span ended)  | status=learned, steps/endpoint/caveats from distill
+ *    REPLAY | clean             | status=confirmed (steps untouched)
+ *    REPLAY | floundered        | re-learn in place: distill the failed span → learned
+ *    any    | distill unreadable / judge down | no write; watch discarded
+ *
+ *  Each row gates on the fields it actually consumes: LEARN and
+ *  REPLAY-floundered need the distilled fields; REPLAY-clean needs the
+ *  outcome. A missing required field = the unreadable/judge-down row → no
+ *  write. All writes flow through upsertProcedure, whose destructive guard
+ *  already refuses to overwrite a `push` seed (never weakened here).
+ *  PURE — unit-tested. Returns the (possibly unchanged) store + what happened. */
+function applyDistillTransition(store, watch, outcome, distilled, fallbackTriggers) {
+    const existing = store.procedures.find(p => p.verb === watch.verb);
+    if (watch.phase === 'LEARN') {
+        if (!distilled)
+            return { store, action: 'discarded' };
+        const proc = {
+            verb: watch.verb,
+            triggers: existing?.triggers?.length ? existing.triggers : fallbackTriggers,
+            steps: distilled.steps,
+            endpoint: distilled.endpoint,
+            caveats: distilled.caveats,
+            status: 'learned',
+            destructive: existing?.destructive,
+        };
+        return { store: (0, procedure_1.upsertProcedure)(store, proc), action: 'learned' };
+    }
+    // REPLAY
+    if (outcome === 'clean') {
+        if (!existing)
+            return { store, action: 'discarded' };
+        return {
+            store: (0, procedure_1.upsertProcedure)(store, { ...existing, status: 'confirmed' }),
+            action: 'confirmed',
+        };
+    }
+    if (outcome === 'floundered') {
+        // The failed span already contains the new winning path — a stale REPLAY
+        // span IS the next LEARN span; no extra failure needed.
+        if (!distilled)
+            return { store, action: 'discarded' };
+        const proc = {
+            verb: watch.verb,
+            triggers: existing?.triggers?.length ? existing.triggers : fallbackTriggers,
+            steps: distilled.steps,
+            endpoint: distilled.endpoint,
+            caveats: distilled.caveats,
+            status: 'learned',
+            destructive: existing?.destructive,
+        };
+        return { store: (0, procedure_1.upsertProcedure)(store, proc), action: 'relearned' };
+    }
+    // outcome null → judge down → no write.
+    return { store, action: 'discarded' };
+}
+// ---------- Watch file I/O (beside the procedure store) -----------------------
+function stateDir() {
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    return path.join(home, '.greprag', 'state');
+}
+function procedureWatchPath(projectId) {
+    return path.join(stateDir(), `procedure-watch-${projectId}.json`);
+}
+/** The Stop-hook observer's zero-cost gate: no file → no watch → no work. */
+function hasProcedureWatch(projectId) {
+    try {
+        return fs.existsSync(procedureWatchPath(projectId));
+    }
+    catch {
+        return false;
+    }
+}
+/** Read the active watch. Null on any miss/corruption — fail-open; the caller
+ *  clears the file so a corrupt watch can't wedge the observer. */
+function readProcedureWatch(projectId) {
+    try {
+        const raw = fs.readFileSync(procedureWatchPath(projectId), 'utf-8');
+        const w = JSON.parse(raw);
+        if (w && typeof w.verb === 'string' && w.verb
+            && (w.phase === 'LEARN' || w.phase === 'REPLAY')
+            && Array.isArray(w.observations)) {
+            return {
+                verb: w.verb,
+                phase: w.phase,
+                openedAt: typeof w.openedAt === 'string' ? w.openedAt : '',
+                turnCount: typeof w.turnCount === 'number' ? w.turnCount : w.observations.length,
+                observations: w.observations,
+                lastLiveTurn: typeof w.lastLiveTurn === 'number' ? w.lastLiveTurn : 0,
+                offStreak: typeof w.offStreak === 'number' ? w.offStreak : 0,
+            };
+        }
+    }
+    catch { /* missing / unreadable → null */ }
+    return null;
+}
+function writeProcedureWatch(projectId, watch) {
+    const file = procedureWatchPath(projectId);
+    const dir = path.dirname(file);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(watch, null, 2) + '\n');
+}
+function clearProcedureWatch(projectId) {
+    try {
+        fs.unlinkSync(procedureWatchPath(projectId));
+    }
+    catch { /* already gone */ }
+}
+/** Open a watch iff none is active (ONE active watch at a time, v1 — an
+ *  in-flight watch is never replaced by a new trigger). Returns whether a
+ *  watch was opened. */
+function openWatchIfIdle(projectId, verb, phase) {
+    if (hasProcedureWatch(projectId))
+        return false;
+    writeProcedureWatch(projectId, openWatch(verb, phase));
+    return true;
+}
+//# sourceMappingURL=procedure-watch.js.map

package/dist/procedure-watch.js.map

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

package/dist/skill-mirror-client.d.ts

@@ -0,0 +1,37 @@
+/** Skill-mirror client — the Tier-3 mirror's upload half
+ *  (docs/load-system.md §Tier 3). Runs inside the Stop hook: a skill-load turn
+ *  triggers `maybeMirrorSkill`, which content-hashes the skill's markdown and
+ *  uploads ONLY on change. Follower semantics — files canonical, the mirror
+ *  shadows "last used state." Best-effort end to end: a mirror failure never
+ *  touches the turn.
+ *
+ *  Local freshness state (`~/.greprag/state/skill-mirror.json`) remembers the
+ *  last-mirrored hash per skill so an unchanged skill costs one hash pass and
+ *  ZERO network. Markdown only, v1 — SKILL.md + docs/**\/*.md; script-bearing
+ *  assets stay file-bound (see the spec's named gaps). */
+export interface SkillFile {
+    path: string;
+    content: string;
+}
+/** Collect the skill's markdown: SKILL.md (required) + docs/**\/*.md, capped.
+ *  Returns null when the dir has no SKILL.md. Never throws. */
+export declare function collectSkillFiles(skillDir: string): SkillFile[] | null;
+/** Deterministic content hash over path+content pairs. PURE — unit-tested. */
+export declare function computeMirrorHash(files: SkillFile[]): string;
+interface MirrorState {
+    skills: Record<string, {
+        hash: string;
+        mirroredAt: string;
+    }>;
+}
+export declare function readMirrorState(): MirrorState;
+export declare function writeMirrorState(state: MirrorState): void;
+export type MirrorOutcome = 'mirrored' | 'fresh' | 'skipped';
+/** Mirror one skill if its content changed since the last mirror. Never throws. */
+export declare function maybeMirrorSkill(params: {
+    skill: string;
+    cwd: string;
+    apiUrl: string;
+    apiKey: string;
+}): Promise<MirrorOutcome>;
+export {};