greprag 5.54.0 → 5.56.0

package/dist/opencode-plugin.bundle.js

@@ -24,9 +24,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 
 // src/opencode-plugin.ts
 var crypto2 = __toESM(require("crypto"));
-var fs2 = __toESM(require("fs"));
+var fs3 = __toESM(require("fs"));
 var os = __toESM(require("os"));
-var path2 = __toESM(require("path"));
+var path3 = __toESM(require("path"));
 
 // src/opencode-plugin-helpers.ts
 var crypto = __toESM(require("crypto"));
@@ -2160,6 +2160,64 @@ var skillMirrorAnnounceModule = {
   reminder: () => null
 };
 
+// src/commands/procedure-reminder.ts
+function buildProcedureAnnounce(lines) {
+  const active = (lines ?? []).map((s) => s.trim()).filter(Boolean);
+  if (!active.length)
+    return null;
+  return [
+    "[greprag procedures \u2014 active project procedures:]",
+    ...active.map((line) => `\u2022 ${line}`)
+  ].join("\n");
+}
+var procedureAnnounceModule = {
+  id: "procedure-announce",
+  // ship-through references peer coordination taught by the inbox primer.
+  dependsOn: ["inbox-primer"],
+  detect: (_env) => ({ tier: "silent" }),
+  announce: (env) => buildProcedureAnnounce(env.procedureAnnounces),
+  reminder: () => null
+};
+
+// src/commands/loadout-reminder.ts
+function matchLoadouts(promptText, equipped) {
+  const prompt = (promptText || "").toLowerCase();
+  if (!prompt.trim() || !equipped || equipped.length === 0)
+    return [];
+  return equipped.filter((l) => (l.keywords || []).some((kw) => {
+    const k = kw.trim().toLowerCase();
+    return k.length >= 3 && prompt.includes(k);
+  }));
+}
+function buildLoadoutAnnounce(equipped) {
+  const decls = (equipped || []).filter((l) => l.announceLine);
+  if (decls.length === 0)
+    return null;
+  return [
+    "[greprag loadouts \u2014 equipped skill bundles (served on demand via `greprag load`):]",
+    ...decls.map((l) => `  ${l.announceLine}`)
+  ].join("\n");
+}
+function buildLoadoutReminder(matched) {
+  if (matched.length === 0)
+    return null;
+  return matched.map((l) => `\u{1F392} your equipped loadout "${l.name}" covers this \u2192 \`greprag load ${l.advisor}\` (it routes to the right expert)`).join("\n");
+}
+function loadoutDetect(env) {
+  const matched = matchLoadouts(env.promptText, env.equippedLoadouts);
+  if (matched.length === 0)
+    return { tier: "silent" };
+  return { tier: "nudge", detail: { matched } };
+}
+var loadoutRegistrarModule = {
+  id: "loadout-registrar",
+  // The announce says "greprag load" — depends on the load primer teaching it.
+  dependsOn: ["load-primer"],
+  detect: loadoutDetect,
+  announce: (env) => buildLoadoutAnnounce(env.equippedLoadouts),
+  reminder: (d) => buildLoadoutReminder(d.detail?.matched || [])
+};
+
 // src/commands/reminder-registry.ts
 var REGISTRY = [
   inboxPrimerModule,
@@ -2174,6 +2232,10 @@ var REGISTRY = [
   // 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)
+  procedureAnnounceModule,
+  // active project procedures, rendered generically from operator-owned installs
+  loadoutRegistrarModule,
+  // equipped loadouts: one advisor announce each + per-turn keyword Match (docs/loadout.md)
   setupWarningModule,
   versionUpgradeModule,
   // Deficiency-gated announce — silent unless a newer release exists
@@ -2253,6 +2315,7 @@ var OPENCODE_MODULE_IDS = /* @__PURE__ */ new Set([
   "setup-warning",
   "version-upgrade",
   "memory-primer",
+  "procedure-announce",
   "collision"
 ]);
 var opencodeRegistry = REGISTRY.filter(
@@ -2268,7 +2331,8 @@ function buildOpenCodeEnv(params) {
     projectName: params.projectName,
     setupWarning: params.setupWarning ?? null,
     corpusApiDocs: params.corpusApiDocs ?? [],
-    updateAvailable: params.updateAvailable ?? null
+    updateAvailable: params.updateAvailable ?? null,
+    procedureAnnounces: params.procedureAnnounces ?? []
   };
 }
 var OPENCODE_CHIP_BOOTLOADER_POINTER = '[greprag chips \u2014 agent coordination is built in (messaging plumbing in the inbox primer).]\n\u2022 Delegating a component of a plan to an isolated sub-session (a "chip") for focused, efficient work? \u2192 run `greprag load chip-bootloader` for the copyable bootloader template (Block 1 setup + Block 2 report-back).';
@@ -2279,15 +2343,123 @@ function getOpenCodeReminders(env) {
   return collectReminders(env, opencodeRegistry);
 }
 
+// src/procedure.ts
+var path2 = __toESM(require("path"));
+var fs2 = __toESM(require("fs"));
+var PROCEDURE_STORE_VERSION = "2";
+function stateDir() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return path2.join(home, ".greprag", "state");
+}
+function procedureStorePath(projectId) {
+  return path2.join(stateDir(), `procedures-${projectId}.json`);
+}
+function readProcedureStore(projectId) {
+  try {
+    const raw = fs2.readFileSync(procedureStorePath(projectId), "utf-8");
+    const parsed = JSON.parse(raw);
+    if (parsed && Array.isArray(parsed.procedures)) {
+      return {
+        version: parsed.version || "1",
+        procedures: parsed.procedures,
+        installs: Array.isArray(parsed.installs) ? parsed.installs : []
+      };
+    }
+  } catch {
+  }
+  return { version: PROCEDURE_STORE_VERSION, procedures: [], installs: [] };
+}
+function procedureId(proc) {
+  return proc.verb;
+}
+function explicitInstall(store, id) {
+  return (store.installs ?? []).find((i) => i.procedureId === id) ?? null;
+}
+function effectiveInstall(store, proc) {
+  const id = procedureId(proc);
+  const found = explicitInstall(store, id);
+  if (found)
+    return found;
+  const legacyStored = store.procedures.some((p) => procedureId(p) === id);
+  return {
+    procedureId: id,
+    definitionVersion: proc.definitionVersion ?? 1,
+    state: legacyStored ? "active" : "disabled",
+    autonomy: legacyStored ? "advise" : proc.defaultInstall?.autonomy ?? "advise",
+    authority: legacyStored ? "fresh" : proc.defaultInstall?.authority ?? "fresh",
+    settings: defaultProcedureSettings(proc),
+    updatedAt: proc.updatedAt ?? ""
+  };
+}
+function defaultProcedureSettings(proc) {
+  return Object.fromEntries(Object.entries(proc.settingsSchema ?? {}).map(([key, spec]) => [key, spec.default]));
+}
+var SHIP_THROUGH_PROCEDURE = {
+  verb: "ship-through",
+  triggers: [],
+  steps: [
+    "Start the run with `greprag procedure begin ship-through`, then reach a coherent diff.",
+    "Confer with reachable same-project GrepRAG peers; if none are reachable, use an independent local reviewer/subagent.",
+    "Incorporate valid findings, run proportional checks, then attest current-artifact review with `greprag procedure attest ship-through review --via peer|local --ref <reviewer>`.",
+    "Commit/merge only the task-scoped files.",
+    "Invoke only the affected target's registered deploy procedure(s).",
+    "Verify production health and the changed behavior."
+  ].join(" "),
+  caveats: "Routine code changes only. Stop for failed checks, missing migrations/secrets, money, destructive live data, undeclared external systems, or scope expansion. Peer review informs correctness but never grants authority.",
+  endpoint: "the affected production target is healthy and verified at the reviewed current commit",
+  status: "seeded",
+  definitionVersion: 1,
+  settingsSchema: {
+    review_strategy: {
+      type: "string",
+      default: "peer-or-local",
+      enum: ["peer-or-local", "peer-required", "local"],
+      riskBearing: true,
+      description: "Independent review source before commit/deploy."
+    }
+  },
+  defaultInstall: { autonomy: "execute", authority: "standing" },
+  announce: {
+    summary: "`ship-through` ACTIVE \u2014 change/build tasks end peer-reviewed and verified in production, not \u201Cready to deploy.\u201D Start: `greprag procedure begin ship-through`; contract: `greprag procedure show ship-through`.",
+    reannounceOnCompact: true
+  },
+  risk: {
+    maximumAutonomy: "execute",
+    standingAuthorityAllowed: true,
+    authorityScope: ["task-scoped commit/merge", "registered deploy procedures", "production verification"]
+  }
+};
+var BUILTIN_PROCEDURES = [SHIP_THROUGH_PROCEDURE];
+function listProcedureDefinitions(store) {
+  const out = [...store.procedures];
+  const seen = new Set(out.map(procedureId));
+  for (const proc of BUILTIN_PROCEDURES) {
+    if (!seen.has(procedureId(proc)))
+      out.push(proc);
+  }
+  return out;
+}
+function activeProcedureAnnounces(store) {
+  const lines = [];
+  for (const proc of listProcedureDefinitions(store)) {
+    if (!proc.announce)
+      continue;
+    if (effectiveInstall(store, proc).state !== "active")
+      continue;
+    lines.push(proc.announce.summary);
+  }
+  return lines;
+}
+
 // src/opencode-plugin.ts
-var DEBUG_LOG_PATH = path2.join(os.homedir(), ".greprag", "opencode-plugin-debug.log");
+var DEBUG_LOG_PATH = path3.join(os.homedir(), ".greprag", "opencode-plugin-debug.log");
 var _debugLogReady = false;
 function dlogInit() {
   if (_debugLogReady)
     return;
   _debugLogReady = true;
   try {
-    fs2.writeFileSync(DEBUG_LOG_PATH, "");
+    fs3.writeFileSync(DEBUG_LOG_PATH, "");
   } catch {
   }
 }
@@ -2296,7 +2468,7 @@ function dlog(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [greprag-memory] ${msg}
 `;
   try {
-    fs2.appendFileSync(DEBUG_LOG_PATH, line);
+    fs3.appendFileSync(DEBUG_LOG_PATH, line);
   } catch {
   }
 }
@@ -2304,9 +2476,9 @@ dlog(`module top reached: pid=${process.pid} argv0=${process.argv[0]} distPath=$
 var API_URL = "https://api.greprag.com";
 function loadEnvFile(filePath) {
   try {
-    if (!fs2.existsSync(filePath))
+    if (!fs3.existsSync(filePath))
       return;
-    const raw = fs2.readFileSync(filePath, "utf-8");
+    const raw = fs3.readFileSync(filePath, "utf-8");
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#"))
@@ -2326,12 +2498,12 @@ function loadEnvFile(filePath) {
   }
 }
 function loadGrepragEnv() {
-  loadEnvFile(path2.join(HOME, ".greprag", ".env"));
+  loadEnvFile(path3.join(HOME, ".greprag", ".env"));
   try {
-    const p = path2.join(HOME, ".claude", "settings.json");
-    if (!fs2.existsSync(p))
+    const p = path3.join(HOME, ".claude", "settings.json");
+    if (!fs3.existsSync(p))
       return;
-    const data = JSON.parse(fs2.readFileSync(p, "utf-8"));
+    const data = JSON.parse(fs3.readFileSync(p, "utf-8"));
     if (data && data.env && typeof data.env === "object") {
       for (const [key, val] of Object.entries(data.env)) {
         if (!process.env[key] && typeof val === "string") {
@@ -2344,11 +2516,11 @@ function loadGrepragEnv() {
 }
 loadGrepragEnv();
 dlog(`env loaded: MEMORY_HOOK_ENABLED=${process.env.MEMORY_HOOK_ENABLED || "<unset>"} GREPRAG_API_KEY=${process.env.GREPRAG_API_KEY ? "set" : "<unset>"} GREPRAG_OPENCODE_CAPTURE=${process.env.GREPRAG_OPENCODE_CAPTURE || "<unset>"}`);
-var WATCHER_LOCK = path2.join(HOME || os.homedir(), ".greprag", "opencode-watch.lock");
+var WATCHER_LOCK = path3.join(HOME || os.homedir(), ".greprag", "opencode-watch.lock");
 var WATCHER_STALE_MS = 3e4;
 function findGrepragBinary() {
   const override = process.env.GREPRAG_BIN;
-  if (override && fs2.existsSync(override))
+  if (override && fs3.existsSync(override))
     return override;
   const binaryName = process.platform === "win32" ? "greprag.cmd" : "greprag";
   try {
@@ -2357,14 +2529,14 @@ function findGrepragBinary() {
       const candidate = line.trim();
       if (!candidate)
         continue;
-      if (!fs2.existsSync(candidate))
+      if (!fs3.existsSync(candidate))
         continue;
       if (process.platform === "win32") {
-        const ext = path2.extname(candidate).toLowerCase();
+        const ext = path3.extname(candidate).toLowerCase();
         if (ext === ".cmd" || ext === ".exe" || ext === ".bat")
           return candidate;
         const cmdSibling = candidate + ".cmd";
-        if (fs2.existsSync(cmdSibling))
+        if (fs3.existsSync(cmdSibling))
           return cmdSibling;
         continue;
       }
@@ -2373,19 +2545,19 @@ function findGrepragBinary() {
   } catch {
   }
   const candidates = process.platform === "win32" ? [
-    path2.join(HOME, "AppData", "Roaming", "npm", "greprag.cmd"),
-    path2.join(HOME, "AppData", "Roaming", "npm", "greprag"),
-    path2.join(HOME, "AppData", "Local", "Yarn", "bin", "greprag.cmd"),
-    path2.join(HOME, "AppData", "Local", "pnpm", "bin", "greprag.cmd")
+    path3.join(HOME, "AppData", "Roaming", "npm", "greprag.cmd"),
+    path3.join(HOME, "AppData", "Roaming", "npm", "greprag"),
+    path3.join(HOME, "AppData", "Local", "Yarn", "bin", "greprag.cmd"),
+    path3.join(HOME, "AppData", "Local", "pnpm", "bin", "greprag.cmd")
   ] : [
     "/usr/local/bin/greprag",
     "/opt/homebrew/bin/greprag",
-    path2.join(HOME || "", ".local", "bin", "greprag"),
-    path2.join(HOME || "", ".yarn", "bin", "greprag")
+    path3.join(HOME || "", ".local", "bin", "greprag"),
+    path3.join(HOME || "", ".yarn", "bin", "greprag")
   ];
   for (const c of candidates) {
     try {
-      if (c && fs2.existsSync(c))
+      if (c && fs3.existsSync(c))
         return c;
     } catch {
     }
@@ -2394,18 +2566,18 @@ function findGrepragBinary() {
 }
 function tryClaimWatcherLock() {
   try {
-    const fd = fs2.openSync(WATCHER_LOCK, "wx");
+    const fd = fs3.openSync(WATCHER_LOCK, "wx");
     return { ok: true, fd };
   } catch (err) {
     if (err.code !== "EEXIST") {
       return { ok: false, reason: "lock-create-failed" };
     }
     try {
-      const stat = fs2.statSync(WATCHER_LOCK);
+      const stat = fs3.statSync(WATCHER_LOCK);
       const ageMs = Date.now() - stat.mtimeMs;
       let pidAlive = false;
       try {
-        const pid = parseInt(fs2.readFileSync(WATCHER_LOCK, "utf-8").trim(), 10);
+        const pid = parseInt(fs3.readFileSync(WATCHER_LOCK, "utf-8").trim(), 10);
         pidAlive = pid > 0 && isPidAlive(pid);
       } catch {
       }
@@ -2413,10 +2585,10 @@ function tryClaimWatcherLock() {
         return { ok: false, reason: "busy" };
       }
       try {
-        fs2.unlinkSync(WATCHER_LOCK);
+        fs3.unlinkSync(WATCHER_LOCK);
       } catch {
       }
-      const fd = fs2.openSync(WATCHER_LOCK, "wx");
+      const fd = fs3.openSync(WATCHER_LOCK, "wx");
       return { ok: true, fd };
     } catch (err2) {
       return { ok: false, reason: "lock-stale-replace-failed" };
@@ -2457,11 +2629,11 @@ function startCaptureWatcher() {
     return;
   }
   try {
-    fs2.writeSync(claim.fd, String(process.pid));
-    fs2.closeSync(claim.fd);
+    fs3.writeSync(claim.fd, String(process.pid));
+    fs3.closeSync(claim.fd);
   } catch {
     try {
-      fs2.unlinkSync(WATCHER_LOCK);
+      fs3.unlinkSync(WATCHER_LOCK);
     } catch {
     }
     return;
@@ -2477,11 +2649,11 @@ function startCaptureWatcher() {
     const claim2 = tryClaimWatcherLock();
     if (claim2.ok) {
       try {
-        fs2.writeSync(claim2.fd, String(process.pid));
-        fs2.closeSync(claim2.fd);
+        fs3.writeSync(claim2.fd, String(process.pid));
+        fs3.closeSync(claim2.fd);
       } catch {
         try {
-          fs2.unlinkSync(WATCHER_LOCK);
+          fs3.unlinkSync(WATCHER_LOCK);
         } catch {
         }
         return false;
@@ -2524,7 +2696,7 @@ function startCaptureWatcher() {
     childStartTime = Date.now();
     dlog(`startCaptureWatcher: spawned 'greprag opencode watch' pid=${child.pid ?? "<none>"}`);
     try {
-      fs2.writeFileSync(WATCHER_LOCK, String(child.pid));
+      fs3.writeFileSync(WATCHER_LOCK, String(child.pid));
     } catch {
     }
     child.stderr?.on("data", (chunk) => {
@@ -2536,9 +2708,9 @@ function startCaptureWatcher() {
     child.on("exit", (code, signal) => {
       dlog(`startCaptureWatcher: child pid=${child.pid ?? "<none>"} exited code=${code} signal=${signal || "none"}`);
       try {
-        const current = fs2.readFileSync(WATCHER_LOCK, "utf-8").trim();
+        const current = fs3.readFileSync(WATCHER_LOCK, "utf-8").trim();
         if (current === String(child.pid))
-          fs2.unlinkSync(WATCHER_LOCK);
+          fs3.unlinkSync(WATCHER_LOCK);
       } catch {
       }
       currentChild = null;
@@ -2567,7 +2739,7 @@ function startCaptureWatcher() {
 `
       );
       try {
-        fs2.unlinkSync(WATCHER_LOCK);
+        fs3.unlinkSync(WATCHER_LOCK);
       } catch {
       }
       return;
@@ -2599,7 +2771,7 @@ function startCaptureWatcher() {
       }, 2e3).unref();
     }
     try {
-      fs2.unlinkSync(WATCHER_LOCK);
+      fs3.unlinkSync(WATCHER_LOCK);
     } catch {
     }
   };
@@ -2674,11 +2846,11 @@ function startSessionRelay(sessionId, serverUrl) {
     return;
   }
   try {
-    fs2.writeSync(claim.fd, String(process.pid));
-    fs2.closeSync(claim.fd);
+    fs3.writeSync(claim.fd, String(process.pid));
+    fs3.closeSync(claim.fd);
   } catch {
     try {
-      fs2.unlinkSync(lockPath);
+      fs3.unlinkSync(lockPath);
     } catch {
     }
     return;
@@ -2693,11 +2865,11 @@ function startSessionRelay(sessionId, serverUrl) {
     const claim2 = tryClaimRelayLock(lockPath);
     if (claim2.ok) {
       try {
-        fs2.writeSync(claim2.fd, String(process.pid));
-        fs2.closeSync(claim2.fd);
+        fs3.writeSync(claim2.fd, String(process.pid));
+        fs3.closeSync(claim2.fd);
       } catch {
         try {
-          fs2.unlinkSync(lockPath);
+          fs3.unlinkSync(lockPath);
         } catch {
         }
         return false;
@@ -2733,7 +2905,7 @@ function startSessionRelay(sessionId, serverUrl) {
     childStartTime = Date.now();
     dlog(`startSessionRelay: spawned 'greprag opencode relay' pid=${child.pid ?? "<none>"}`);
     try {
-      fs2.writeFileSync(lockPath, String(child.pid));
+      fs3.writeFileSync(lockPath, String(child.pid));
     } catch {
     }
     child.stderr?.on("data", (chunk) => {
@@ -2744,9 +2916,9 @@ function startSessionRelay(sessionId, serverUrl) {
     });
     child.on("exit", (code, signal) => {
       try {
-        const current = fs2.readFileSync(lockPath, "utf-8").trim();
+        const current = fs3.readFileSync(lockPath, "utf-8").trim();
         if (current === String(child.pid))
-          fs2.unlinkSync(lockPath);
+          fs3.unlinkSync(lockPath);
       } catch {
       }
       currentChild = null;
@@ -2773,7 +2945,7 @@ function startSessionRelay(sessionId, serverUrl) {
 `
       );
       try {
-        fs2.unlinkSync(lockPath);
+        fs3.unlinkSync(lockPath);
       } catch {
       }
       return;
@@ -2805,7 +2977,7 @@ function startSessionRelay(sessionId, serverUrl) {
       }, 2e3).unref();
     }
     try {
-      fs2.unlinkSync(lockPath);
+      fs3.unlinkSync(lockPath);
     } catch {
     }
   };
@@ -2932,7 +3104,14 @@ ALWAYS pass \`--from-session ${sid82}\` when you run \`greprag send\`, so recipi
         const env = buildOpenCodeEnv({
           short: sid8,
           turnCount,
-          projectName: anchor.projectName
+          projectName: anchor.projectName,
+          procedureAnnounces: (() => {
+            try {
+              return activeProcedureAnnounces(readProcedureStore(anchor.projectId));
+            } catch {
+              return [];
+            }
+          })()
         });
         if (!announcedBySession.has(sid8)) {
           announcedBySession.add(sid8);

package/dist/opencode-plugin.js

@@ -98,6 +98,7 @@ const opencode_plugin_helpers_1 = require("./opencode-plugin-helpers");
 const proc_1 = require("./proc");
 const opencode_plugin_crush_1 = require("./opencode-plugin-crush");
 const opencode_interrupt_1 = require("./commands/opencode-interrupt");
+const procedure_1 = require("./procedure");
 // ============================================================================
 // File-based debug log. opencode's plugin loader (Bun) does NOT route plugin
 // stderr into the opencode log file at ~/.local/share/opencode/log/*.log —
@@ -906,6 +907,14 @@ const GrepRAGMemoryPlugin = async (ctx) => {
                     short: sid8,
                     turnCount,
                     projectName: anchor.projectName,
+                    procedureAnnounces: (() => {
+                        try {
+                            return (0, procedure_1.activeProcedureAnnounces)((0, procedure_1.readProcedureStore)(anchor.projectId));
+                        }
+                        catch {
+                            return [];
+                        }
+                    })(),
                 });
                 // Announces: inject on first fire per session (static primers)
                 if (!announcedBySession.has(sid8)) {