greprag 5.74.0 → 5.74.2

package/dist/opencode-plugin.bundle.js

@@ -23,10 +23,10 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/opencode-plugin.ts
-var crypto2 = __toESM(require("crypto"));
-var fs4 = __toESM(require("fs"));
-var os = __toESM(require("os"));
-var path4 = __toESM(require("path"));
+var crypto5 = __toESM(require("crypto"));
+var fs7 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+var path7 = __toESM(require("path"));
 
 // src/opencode-plugin-helpers.ts
 var crypto = __toESM(require("crypto"));
@@ -66,13 +66,13 @@ function readAnchorFile(filePath) {
   }
 }
 function findExistingAnchorFile(startDir) {
-  const globalAnchorPath = path.join(HOME, ".greprag", "project.json");
-  const legacyGlobalAnchorPath = path.join(HOME, ".claude", "project.json");
+  const globalAnchorPath2 = path.join(HOME, ".greprag", "project.json");
+  const legacyGlobalAnchorPath2 = path.join(HOME, ".claude", "project.json");
   let dir = path.resolve(startDir);
   while (true) {
     for (const subdir of [".greprag", ".claude", ".opencode"]) {
       const candidate = path.join(dir, subdir, "project.json");
-      if (candidate !== globalAnchorPath && candidate !== legacyGlobalAnchorPath && fs.existsSync(candidate)) {
+      if (candidate !== globalAnchorPath2 && candidate !== legacyGlobalAnchorPath2 && fs.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -1753,7 +1753,7 @@ function buildOsPrimer(env) {
     '\u2022 Doctrine vs state: methods ship in the CLI (`greprag load`); live state lives in the repo. A skill that depends on repo state carries a "STATE \u2014 read these first" block naming exact paths.',
     "\u2022 Discoverability: every durable artifact must be findable next session \u2014 docs auto-register, skills auto-mirror, decisions get a dated ADR/decision-log entry, everything else gets its path named in the owning skill/doc. If nothing points at it, you didn't finish.",
     "\u2022 Pull before derive: `greprag memory search` / `corpus search` / `load` BEFORE asking the operator or re-deriving what the project already knows. Named person/org/project/repo/customer/handle or unexplained proper noun \u2192 search Memory before guessing, unless fully defined in-turn.",
-    `\u2022 Friction \u21D2 fix NOW: type by durable repair surface (\`harness|doctrine|injection|env|code\`) \u21D2 \`greprag fix spawn --type <type> "<unit>"\`. It PRINTS a fix-chip mission \u2014 YOU then create the visible child task with that mission as its first message (how: \`greprag load ${spawnEntry}\`, or your harness's native task tool). Repo write = isolated worktree; data-only row/diagnosis = no repo write. One unit per chip; the chip fixes it, explains the friction/fix, then stops for approval. Never queue friction.`,
+    `\u2022 Friction \u21D2 fix NOW: type by durable repair surface (\`harness|doctrine|injection|env|code\`) \u21D2 \`greprag fix spawn --type <type> "<unit>"\`. It PRINTS a fix-chip mission \u2014 YOU then create the visible child task with that mission as its first message (how: \`greprag load ${spawnEntry}\`, or your harness's native task tool). Repo write = isolated worktree; data-only row/diagnosis = no repo write. One unit per chip; the chip fixes, verifies, checkpoints, and hands it to the mission delivery owner. Never queue friction.`,
     "\u2022 Teach the system, not the chat: explained twice by the operator \u21D2 it belongs in a skill / load entry / STATE block / ADR, not the conversation."
   ].join("\n");
 }
@@ -2028,7 +2028,7 @@ function buildMechanicLiveNotice(_env) {
 function buildFrictionReminder(tier, env) {
   switch (tier) {
     case "nag":
-      return `\u26A0 FRICTION HIGH (live signal: repetition / errors / churn) \u2014 STOP pushing through. Name the ONE unit, choose type by repair surface, and spawn now: \`${FIX_SPAWN}\` (chip fixes it, explains the friction/fix, then stops for approval). No friction? say "clear" + continue.`;
+      return `\u26A0 FRICTION HIGH (live signal: repetition / errors / churn) \u2014 STOP pushing through. Name the ONE unit, choose type by repair surface, and spawn now: \`${FIX_SPAWN}\` (chip fixes, verifies, checkpoints, and hands it to the mission delivery owner). No friction? say "clear" + continue.`;
     case "nudge":
       return `\u26A0 Friction detected (live signal) \u2014 repeated yourself, fought a tool, or hit a wall? Choose type by repair surface and spawn: \`${FIX_SPAWN}\`, then keep working. Otherwise say "clear" + continue.`;
     default:
@@ -2041,7 +2041,7 @@ function buildBootstrapFrictionReminder(env) {
     return null;
   const repeats = b.repeats && b.repeats > 1 ? ` repeated ${b.repeats}x` : "";
   const error = b.error ? ` Last error: ${b.error}` : "";
-  return `\u26A0 BOOTSTRAP FRICTION detected${repeats}: setup/toolchain failure (${b.signal || "setup"}) around \`${b.command || "unknown command"}\`.${error} If this is not caused by the code you just edited, spawn a fix chip now: \`greprag fix spawn --type env "${bootstrapSummary(env)}"\`. The chip owns the root-cause repair, explains it, then stops for approval so future sessions stop hitting it.`;
+  return `\u26A0 BOOTSTRAP FRICTION detected${repeats}: setup/toolchain failure (${b.signal || "setup"}) around \`${b.command || "unknown command"}\`.${error} If this is not caused by the code you just edited, spawn a fix chip now: \`greprag fix spawn --type env "${bootstrapSummary(env)}"\`. The chip owns the root-cause repair, verifies it, and hands it to the mission delivery owner so future sessions stop hitting it.`;
 }
 function buildMechanicAnnounce() {
   return [
@@ -2049,7 +2049,7 @@ function buildMechanicAnnounce() {
     "WHEN friction happens \u2014 repeated yourself, fought a tool, got corrected >=2x on the same thing, rediscovered something already known, or hit a setup/toolchain failure not caused by code you just edited \u2014 spawn its fix chip NOW, then keep working. One unit = one chip; adjacent friction gets its own spawn. Never queue friction for later.",
     'TYPE = durable repair surface: harness=hooks/watchers/task dispatch; doctrine=greprag load/skills/AGENTS; injection=recap/Capture/doc-pointer/stateful injection; env=bootstrap/deps/scripts/worktree setup; code=product/source behavior. Use: `greprag fix spawn --type <type> "<one unit>"`.',
     "WORKSPACE ROUTING: `fix spawn` detects usable Git history before dispatch \u2014 Git uses an isolated worktree; non-Git, unavailable Git, or no commit uses the project-local task with serialized writes. No fail-then-fallback attempt.",
-    "THE CHIP'S CONTRACT (it self-enforces; you just spawn): identify the exact friction \u2192 make the smallest durable root-cause fix \u2192 explain the friction and fix in human terms \u2192 STOP for human approval before landing or cleanup.",
+    "THE CHIP'S CONTRACT (it self-enforces; you just spawn): identify the exact friction \u2192 make the smallest durable root-cause fix \u2192 explain and verify it \u2192 checkpoint \u2192 hand it to the mission delivery owner. With no live parent and a full-goal mission, the chip becomes delivery owner and follows the repo profile. No second lifecycle approval.",
     "Every repair is ROOT-CAUSE \u2014 fix the pattern that makes the friction class possible, never a guard on today's trigger.",
     'A per-turn reminder fires ONLY when live friction is DETECTED (the stress signal \u2014 repetition / errors / churn), never on a timer \u2014 act on it, or say "clear" and continue.'
   ].join("\n");
@@ -2648,59 +2648,160 @@ function effectiveInstall(store, proc) {
 function defaultProcedureSettings(proc) {
   return Object.fromEntries(Object.entries(proc.settingsSchema ?? {}).map(([key, spec]) => [key, spec.default]));
 }
-var REPO_BOUNDARY_PRECONDITION = [
-  "Before commit/merge/deploy/push/release: coordinate with reachable same-project peers and attribute every dirty file as intentional deploy work, peer-owned work, user-owned work, stale/discardable residue, or unknown.",
-  "Dirty checkout cleanup is deploy work: include yours/claimed intentional changes in the boundary artifact instead of escaping to a clean checkout or omitting them to make the checkout look clean.",
-  "Unknown ownership blocks the boundary until classified: exhaust local evidence and ask the human for direction if needed; overlapping peer work routes through handoff; stale generated residue is discarded only after evidence or human direction proves it is discardable.",
-  "Never stash, revert, sweep, or commit unrelated dirt just to appease a clean-tree deploy guard.",
-  "For tracked build output (for example site dist/), rebuild from the claimed source state and commit that generated artifact with its source; a separate deploy branch or worktree may isolate already-classified work, but a clean side checkout is not a substitute for settling pending repo work.",
-  "ABOUT TO COMMIT/MERGE/DEPLOY/PUSH/RELEASE after a skill guided the work? STOP - review the loaded skill(s): did this run reveal a durable rule, missing progressive-disclosure link, or method correction? If yes, run greprag load skill-change and update the canonical skill source only when the edit is narrow and low-risk; propose risky method changes instead of silently landing them. If no, say no skill update was needed. Never edit install artifacts as the source."
-].join(" ");
+function triggerHits(promptLower, triggerLower) {
+  if (!triggerLower)
+    return false;
+  if (/\s/.test(triggerLower))
+    return promptLower.includes(triggerLower);
+  const re = new RegExp(`(^|[^a-z0-9])${escapeRegex(triggerLower)}([^a-z0-9]|$)`);
+  return re.test(promptLower);
+}
+function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var INTENT_NEGATIONS = [
+  "don't",
+  "dont",
+  "not",
+  "no",
+  "never",
+  "without",
+  "avoid",
+  "won't",
+  "wont",
+  "didn't",
+  "didnt",
+  "cannot",
+  "can't",
+  "cant",
+  "stop"
+];
+var INTENT_COLLISION_PHRASES = [
+  "push back",
+  "push for",
+  "push notification",
+  "push notifications",
+  "pushover",
+  "merge conflict",
+  "merge conflicts",
+  "merge request",
+  "merge sort",
+  "press release",
+  "release notes",
+  "release candidate",
+  "release date",
+  "commit message",
+  "commit hash",
+  "commit history",
+  "commit sha"
+];
+function intentSuppressed(promptLower, triggerLower) {
+  for (const phrase of INTENT_COLLISION_PHRASES) {
+    if (phrase.includes(triggerLower) && promptLower.includes(phrase)) {
+      const stripped = promptLower.split(phrase).join(" \xB7 ");
+      if (!triggerHits(stripped, triggerLower))
+        return true;
+    }
+  }
+  const idx = promptLower.search(new RegExp(`(^|[^a-z0-9])${escapeRegex(triggerLower)}([^a-z0-9]|$)`));
+  if (idx >= 0) {
+    const before = promptLower.slice(0, idx).split(/[^a-z']+/).filter(Boolean);
+    const window = " " + before.slice(-3).join(" ") + " ";
+    if (INTENT_NEGATIONS.some((neg) => window.includes(" " + neg + " ")))
+      return true;
+  }
+  return false;
+}
+function matchProcedure(prompt, store, opts = {}) {
+  if (!prompt)
+    return null;
+  const promptLower = prompt.toLowerCase();
+  let best = null;
+  let bestLen = -1;
+  for (const procedure of store.procedures) {
+    if (!opts.includeInactive && effectiveInstall(store, procedure).state !== "active")
+      continue;
+    for (const trigger of procedure.triggers) {
+      const t = trigger.toLowerCase();
+      if (!triggerHits(promptLower, t))
+        continue;
+      if (!opts.ignoreIntentGuard && intentSuppressed(promptLower, t))
+        continue;
+      if (t.length > bestLen) {
+        best = { procedure, trigger };
+        bestLen = t.length;
+      }
+    }
+  }
+  return best;
+}
+function buildProcedureInjection(proc) {
+  const lines = [];
+  const tag = proc.destructive ? " \u26A0 DESTRUCTIVE" : "";
+  lines.push(`[Procedure: ${proc.verb} \u2014 ${proc.status}${tag}] This repo has a known recipe for "${proc.verb}".`);
+  if (proc.preconditions)
+    lines.push(`  PRECONDITIONS: ${proc.preconditions}`);
+  if (proc.destructive && proc.caveats) {
+    lines.push(`  \u26D4 GATE: ${proc.caveats}`);
+    lines.push(`  STEPS (only after approval): ${proc.steps}`);
+  } else {
+    lines.push(`  STEPS: ${proc.steps}`);
+    if (proc.caveats)
+      lines.push(`  GATE: ${proc.caveats}`);
+  }
+  if (proc.endpoint)
+    lines.push(`  ENDPOINT (done when): ${proc.endpoint}`);
+  lines.push(
+    proc.destructive ? `  Follow the procedure's gate for effects outside ordinary repo delivery. For commit/merge/push/deploy/release, the current full-goal mission and Delivery Profile are the authority; Procedure adds no second approval.` : `  Use this recipe. If it no longer works, say so \u2014 that's a stale procedure to re-learn.`
+  );
+  return lines.join("\n");
+}
+var LIFECYCLE_SHADOW_PRECONDITION = "Shadow evidence only. The Delivery Profile and canonical lifecycle skills own active repo-boundary behavior.";
 var GIT_SEED_SET = [
   {
     verb: "commit",
     triggers: ["commit", "check in", "check it in", "checkpoint this", "land it"],
-    preconditions: REPO_BOUNDARY_PRECONDITION,
-    steps: 'git add -A && git commit -m "wip: <msg>"; then merge the feature branch into the default branch and run the repo-native cleanup/archive flow.',
-    caveats: "Scope = task-owned work only. Do not sweep a parallel workstream's pending changes. STOPS before push.",
-    endpoint: "changes committed and the feature branch merged into default",
+    preconditions: LIFECYCLE_SHADOW_PRECONDITION,
+    steps: "Shadow capture only. Active behavior resolves the repo Delivery Profile and canonical commit skill.",
+    caveats: "No lifecycle guidance is injected from Procedure while the announce-first pilot is active.",
+    endpoint: "observed checkpoint/integration span is no longer live",
     status: "seeded"
   },
   {
     verb: "merge",
     triggers: ["merge", "merge the branch", "merge to main", "merge into main"],
-    preconditions: REPO_BOUNDARY_PRECONDITION,
-    steps: "git checkout <default> && git merge <branch> (folded into the commit flow).",
-    caveats: "Do not treat a clean current checkout as whole-repo clearance.",
-    endpoint: "branch merged into the default branch with no conflicts",
+    preconditions: LIFECYCLE_SHADOW_PRECONDITION,
+    steps: "Shadow capture only. Active behavior resolves the profile integration strategy and coordinates peers through the harness adapter.",
+    caveats: "Procedure records evidence; it does not choose a branch or merge strategy.",
+    endpoint: "observed integration span is no longer live",
     status: "seeded"
   },
   {
     verb: "push",
     triggers: ["push", "git push", "push to remote", "push it up", "push upstream"],
-    preconditions: REPO_BOUNDARY_PRECONDITION,
-    steps: "git push",
-    caveats: "git push triggers a PRODUCTION deploy. STOP and get explicit fresh approval before pushing unless the current mission explicitly provisions release/deploy completion.",
-    endpoint: "operator approved the push AND it completed",
+    preconditions: LIFECYCLE_SHADOW_PRECONDITION,
+    steps: "Shadow capture only. Active behavior follows the repo profile's remote, default branch, and push/deploy coupling.",
+    caveats: "Seed-only destructive vocabulary; never learn or inject a push command.",
+    endpoint: "observed push span is no longer live",
     status: "seeded",
     destructive: true
   },
   {
     verb: "deploy",
     triggers: ["deploy", "deploy the api", "deploy the worker", "redeploy"],
-    preconditions: REPO_BOUNDARY_PRECONDITION,
-    steps: "Resolve the repo/target DeploySchema for this deploy intent; run only that schema's commands after preconditions are settled.",
-    caveats: "Method-agnostic: the global seed only routes to a learned repo/target DeploySchema. Do not infer provider/tooling from another repo. If the schema is missing, stale, or target-ambiguous, say so and capture the live resolution instead of guessing.",
-    endpoint: "the target DeploySchema success signal and verification pass; missing/stale schema is captured without registering a recipe",
+    preconditions: LIFECYCLE_SHADOW_PRECONDITION,
+    steps: "Shadow capture only. Active behavior resolves `.greprag/delivery.json` and its declared deploy document.",
+    caveats: "Procedure does not infer, learn, or inject provider commands during the pilot.",
+    endpoint: "observed deploy/verification span is no longer live",
     status: "seeded"
   },
   {
     verb: "release",
     triggers: ["release", "ship it", "ship a release", "cut a release", "publish the release", "do a release"],
-    preconditions: REPO_BOUNDARY_PRECONDITION,
-    steps: "Run the /release flow \u2014 greprag's actual ship path (version bump + publish).",
-    caveats: "greprag ships via /release \u2014 NOT /commit and NOT /deploy. Do not conflate the three: commit lands code, deploy pushes the worker, release publishes a version.",
-    endpoint: "the release is published (new version live)",
+    preconditions: LIFECYCLE_SHADOW_PRECONDITION,
+    steps: "Shadow capture only. Active behavior follows the repo profile's release document and canonical release skill.",
+    caveats: "Procedure does not infer package, tag, registry, provider, or version policy.",
+    endpoint: "observed release/verification span is no longer live",
     status: "seeded"
   }
 ];
@@ -2728,6 +2829,404 @@ function activeProcedureAnnounces(store) {
   return lines;
 }
 
+// src/procedure-runtime.ts
+var crypto4 = __toESM(require("crypto"));
+
+// src/project-anchor.ts
+var path3 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+var crypto2 = __toESM(require("crypto"));
+var os = __toESM(require("os"));
+var ANCHOR_DIR = ".greprag";
+var ANCHOR_FILE = "project.json";
+var LEGACY_ANCHOR_DIR = ".claude";
+function anchorPathIn(dir) {
+  return path3.join(dir, ANCHOR_DIR, ANCHOR_FILE);
+}
+function legacyAnchorPathIn(dir) {
+  return path3.join(dir, LEGACY_ANCHOR_DIR, ANCHOR_FILE);
+}
+function globalAnchorPath() {
+  return anchorPathIn(os.homedir());
+}
+function legacyGlobalAnchorPath() {
+  return legacyAnchorPathIn(os.homedir());
+}
+function findExistingAnchor(startDir) {
+  const homeAnchor = globalAnchorPath();
+  const legacyHomeAnchor = legacyGlobalAnchorPath();
+  let dir = path3.resolve(startDir);
+  while (true) {
+    const candidate = anchorPathIn(dir);
+    if (candidate !== homeAnchor && fs3.existsSync(candidate))
+      return candidate;
+    const legacyCandidate = legacyAnchorPathIn(dir);
+    if (legacyCandidate !== legacyHomeAnchor && fs3.existsSync(legacyCandidate))
+      return legacyCandidate;
+    const parent = path3.dirname(dir);
+    if (parent === dir)
+      return null;
+    dir = parent;
+  }
+}
+function isEphemeralCwd2(cwd) {
+  const norm = path3.resolve(cwd).replace(/\\/g, "/").toLowerCase();
+  if (norm.includes("/appdata/roaming/claude/local-agent-mode-sessions/"))
+    return true;
+  if (norm.includes("/appdata/local/claude/local-agent-mode-sessions/"))
+    return true;
+  if (norm.startsWith("/tmp/"))
+    return true;
+  if (norm.startsWith("/var/tmp/"))
+    return true;
+  if (norm.startsWith("/private/tmp/"))
+    return true;
+  return false;
+}
+function computeGitDerivedProjectId2(workingDir) {
+  try {
+    const out = safeExecSync("git rev-list --max-parents=0 HEAD", {
+      cwd: workingDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    const roots = out.trim().split(/\s+/).filter(Boolean).sort();
+    if (roots.length === 0)
+      return null;
+    const hash = crypto2.createHash("sha256").update(roots.join("\n")).digest("hex");
+    return [
+      hash.slice(0, 8),
+      hash.slice(8, 12),
+      "4" + hash.slice(13, 16),
+      // version 4 nibble
+      "8" + hash.slice(17, 20),
+      // variant nibble
+      hash.slice(20, 32)
+    ].join("-");
+  } catch {
+    return null;
+  }
+}
+function deterministicProjectId2(workingDir) {
+  const normalized = path3.resolve(workingDir).toLowerCase();
+  const hash = crypto2.createHash("sha256").update(normalized).digest("hex");
+  return [
+    hash.slice(0, 8),
+    hash.slice(8, 12),
+    "4" + hash.slice(13, 16),
+    // version 4 nibble
+    "8" + hash.slice(17, 20),
+    // variant nibble
+    hash.slice(20, 32)
+  ].join("-");
+}
+function tryReadAnchorFileContents(filePath) {
+  try {
+    const raw = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+    const notifyRaw = raw.inbox_notify;
+    const inboxNotify = notifyRaw === "off" || notifyRaw === "session_start_only" ? notifyRaw : "every_turn";
+    return {
+      projectId: raw.project_id,
+      projectName: raw.project_name,
+      created: raw.created,
+      memoryCapture: raw.memory_capture !== false,
+      sessionStartRecap: raw.session_start_recap !== false,
+      inboxNotify,
+      emailDir: typeof raw.email_dir === "string" ? raw.email_dir : void 0,
+      emailAutosave: raw.email_autosave === true,
+      role: typeof raw.role === "string" ? raw.role : void 0
+    };
+  } catch {
+    return null;
+  }
+}
+function readAnchor2(cwd) {
+  const existingPath = findExistingAnchor(cwd);
+  const fileContents = existingPath ? tryReadAnchorFileContents(existingPath) : null;
+  if (existingPath && fileContents && fileContents.projectId && fileContents.projectName) {
+    return {
+      projectId: fileContents.projectId,
+      projectName: fileContents.projectName,
+      initialized: true,
+      source: "file",
+      anchorPath: existingPath,
+      created: fileContents.created,
+      memoryCapture: fileContents.memoryCapture,
+      sessionStartRecap: fileContents.sessionStartRecap,
+      inboxNotify: fileContents.inboxNotify,
+      emailDir: fileContents.emailDir,
+      emailAutosave: fileContents.emailAutosave,
+      role: fileContents.role
+    };
+  }
+  const gitId = computeGitDerivedProjectId2(cwd);
+  if (gitId) {
+    const root2 = path3.resolve(cwd);
+    return {
+      projectId: gitId,
+      projectName: fileContents?.projectName || path3.basename(root2).toLowerCase(),
+      initialized: true,
+      source: "git",
+      anchorPath: existingPath || anchorPathIn(root2),
+      created: fileContents?.created,
+      memoryCapture: fileContents?.memoryCapture ?? true,
+      sessionStartRecap: fileContents?.sessionStartRecap ?? true,
+      inboxNotify: fileContents?.inboxNotify ?? "every_turn",
+      emailDir: fileContents?.emailDir,
+      emailAutosave: fileContents?.emailAutosave,
+      role: fileContents?.role
+    };
+  }
+  if (isEphemeralCwd2(cwd)) {
+    const globalPath = fs3.existsSync(globalAnchorPath()) ? globalAnchorPath() : legacyGlobalAnchorPath();
+    const globalContents = tryReadAnchorFileContents(globalPath);
+    if (globalContents && globalContents.projectId && globalContents.projectName) {
+      return {
+        projectId: globalContents.projectId,
+        projectName: globalContents.projectName,
+        initialized: true,
+        source: "global",
+        anchorPath: globalPath,
+        created: globalContents.created,
+        memoryCapture: globalContents.memoryCapture,
+        sessionStartRecap: globalContents.sessionStartRecap,
+        inboxNotify: globalContents.inboxNotify,
+        emailDir: globalContents.emailDir,
+        emailAutosave: globalContents.emailAutosave,
+        role: globalContents.role
+      };
+    }
+  }
+  const root = path3.resolve(cwd);
+  return {
+    projectId: deterministicProjectId2(root),
+    projectName: fileContents?.projectName || path3.basename(root).toLowerCase(),
+    initialized: false,
+    source: "hash",
+    anchorPath: existingPath || anchorPathIn(root),
+    created: fileContents?.created,
+    memoryCapture: fileContents?.memoryCapture ?? true,
+    sessionStartRecap: fileContents?.sessionStartRecap ?? true,
+    inboxNotify: fileContents?.inboxNotify ?? "every_turn",
+    emailDir: fileContents?.emailDir,
+    emailAutosave: fileContents?.emailAutosave,
+    role: fileContents?.role
+  };
+}
+
+// src/procedure-watch.ts
+var path4 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
+var 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" }
+];
+function matchLearnTrigger(prompt) {
+  return matchProcedure(prompt, {
+    version: PROCEDURE_STORE_VERSION,
+    procedures: TIER1_LEARN_TRIGGERS
+  });
+}
+function isDestructiveVerb(verb, store) {
+  if (store.procedures.some((p) => p.verb === verb && p.destructive))
+    return true;
+  return TIER1_LEARN_TRIGGERS.some((p) => p.verb === verb && p.destructive);
+}
+function openWatch(verb, phase, openedAt, shadowRunId) {
+  return {
+    verb,
+    phase,
+    shadowRunId,
+    openedAt: openedAt || (/* @__PURE__ */ new Date()).toISOString(),
+    turnCount: 0,
+    observations: [],
+    lastLiveTurn: 0,
+    offStreak: 0
+  };
+}
+function stateDir2() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return path4.join(home, ".greprag", "state");
+}
+function procedureWatchPath(projectId) {
+  return path4.join(stateDir2(), `procedure-watch-${projectId}.json`);
+}
+function hasProcedureWatch(projectId) {
+  try {
+    return fs4.existsSync(procedureWatchPath(projectId));
+  } catch {
+    return false;
+  }
+}
+function writeProcedureWatch(projectId, watch) {
+  const file = procedureWatchPath(projectId);
+  const dir = path4.dirname(file);
+  if (!fs4.existsSync(dir))
+    fs4.mkdirSync(dir, { recursive: true });
+  fs4.writeFileSync(file, JSON.stringify(watch, null, 2) + "\n");
+}
+function openWatchIfIdle(projectId, verb, phase, shadowRunId) {
+  if (hasProcedureWatch(projectId))
+    return false;
+  writeProcedureWatch(projectId, openWatch(verb, phase, void 0, shadowRunId));
+  return true;
+}
+
+// src/procedure-shadow.ts
+var crypto3 = __toESM(require("crypto"));
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+function stateDir3() {
+  const home = process.env.HOME || process.env.USERPROFILE || "";
+  return path5.join(home, ".greprag", "state");
+}
+function procedureShadowPath(projectId) {
+  return path5.join(stateDir3(), `procedure-shadow-${projectId}.jsonl`);
+}
+function appendShadowEvent(projectId, event) {
+  try {
+    const file = procedureShadowPath(projectId);
+    fs5.mkdirSync(path5.dirname(file), { recursive: true });
+    fs5.appendFileSync(file, JSON.stringify(event) + "\n");
+  } catch {
+  }
+}
+function createProcedureShadowRunId() {
+  return crypto3.randomUUID();
+}
+function procedureFingerprint(proc) {
+  const payload = JSON.stringify({
+    verb: proc.verb,
+    triggers: proc.triggers,
+    preconditions: proc.preconditions,
+    steps: proc.steps,
+    caveats: proc.caveats,
+    endpoint: proc.endpoint,
+    definitionVersion: proc.definitionVersion ?? 1
+  });
+  return crypto3.createHash("sha256").update(payload).digest("hex");
+}
+function recordProcedureShadowTrigger(params) {
+  appendShadowEvent(params.projectId, {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    kind: "would-have-fired",
+    runId: params.runId,
+    projectId: params.projectId,
+    verb: params.match.procedure.verb,
+    trigger: params.match.trigger,
+    procedureStatus: params.match.procedure.status,
+    definitionVersion: params.match.procedure.definitionVersion ?? 1,
+    configuredState: params.configuredState,
+    runtimeState: "shadow",
+    schemaFingerprint: procedureFingerprint(params.match.procedure),
+    watchOpened: params.watchOpened,
+    sessionId: params.sessionId || void 0
+  });
+}
+function recordMissingLifecycleShadowTrigger(params) {
+  appendShadowEvent(params.projectId, {
+    at: (/* @__PURE__ */ new Date()).toISOString(),
+    kind: "would-have-fired",
+    runId: params.runId,
+    projectId: params.projectId,
+    verb: params.verb,
+    trigger: params.trigger,
+    configuredState: "missing",
+    runtimeState: "shadow",
+    watchOpened: false,
+    sessionId: params.sessionId || void 0
+  });
+}
+
+// src/procedure-runtime.ts
+function extractLatestOpenCodeProcedurePrompt(messages) {
+  let userCount = 0;
+  let latest = null;
+  for (const raw of messages) {
+    if (!raw || typeof raw !== "object")
+      continue;
+    const msg = raw;
+    if (msg.info?.role !== "user" || !Array.isArray(msg.parts))
+      continue;
+    userCount++;
+    const parts = msg.parts;
+    const prompt = parts.filter((part) => !!part && typeof part === "object").filter((part) => part.type === "text" && typeof part.text === "string" && part.synthetic !== true && part.ignored !== true).map((part) => String(part.text)).join("\n").trim();
+    if (prompt)
+      latest = { prompt, parts };
+  }
+  if (!latest)
+    return null;
+  const digest = crypto4.createHash("sha256").update(latest.prompt).digest("hex");
+  return { ...latest, key: `${userCount}:${digest}` };
+}
+function procedureRuntimeState(configuredState, proc) {
+  if (configuredState === "disabled")
+    return "disabled";
+  return isDeliveryLifecycleVerb(proc.verb) ? "shadow" : configuredState;
+}
+function runProcedurePromptCheck(params) {
+  try {
+    if (!params.prompt.trim())
+      return { mode: "none" };
+    const anchor = readAnchor2(params.cwd);
+    if (!anchor.projectId)
+      return { mode: "none" };
+    const store = readProcedureStore(anchor.projectId);
+    const raw = store.procedures.length ? matchProcedure(params.prompt, store, { includeInactive: true }) : null;
+    if (raw) {
+      const configuredState = effectiveInstall(store, raw.procedure).state;
+      const runtimeState = procedureRuntimeState(configuredState, raw.procedure);
+      if (runtimeState === "disabled") {
+        return { mode: "disabled", verb: raw.procedure.verb };
+      }
+      if (runtimeState === "shadow") {
+        const runId = createProcedureShadowRunId();
+        const watchOpened = raw.procedure.status !== "stale" ? openWatchIfIdle(anchor.projectId, raw.procedure.verb, "SHADOW", runId) : false;
+        recordProcedureShadowTrigger({
+          projectId: anchor.projectId,
+          runId,
+          match: raw,
+          configuredState,
+          watchOpened,
+          sessionId: params.sessionId
+        });
+        return { mode: "shadow", verb: raw.procedure.verb };
+      }
+      if (raw.procedure.status !== "stale") {
+        openWatchIfIdle(anchor.projectId, raw.procedure.verb, "REPLAY");
+        return {
+          mode: "active",
+          verb: raw.procedure.verb,
+          additionalContext: buildProcedureInjection(raw.procedure)
+        };
+      }
+    }
+    const learned = raw || matchLearnTrigger(params.prompt);
+    if (!learned)
+      return { mode: "none" };
+    if (isDeliveryLifecycleVerb(learned.procedure.verb)) {
+      recordMissingLifecycleShadowTrigger({
+        projectId: anchor.projectId,
+        runId: createProcedureShadowRunId(),
+        verb: learned.procedure.verb,
+        trigger: learned.trigger,
+        sessionId: params.sessionId
+      });
+      return { mode: "shadow", verb: learned.procedure.verb };
+    }
+    if (isDestructiveVerb(learned.procedure.verb, store)) {
+      return { mode: "disabled", verb: learned.procedure.verb };
+    }
+    openWatchIfIdle(anchor.projectId, learned.procedure.verb, "LEARN");
+    return { mode: "learn", verb: learned.procedure.verb };
+  } catch {
+    return { mode: "none" };
+  }
+}
+
 // src/archive/glyph-font.ts
 var GLYPH_W = 8;
 var GLYPH_H = 8;
@@ -3311,29 +3810,29 @@ function recodeMessagesToPng(messages, opts) {
 }
 
 // src/skill-activation-manifest.ts
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
 var MAX_NATIVE_SKILL_FILES = 1500;
 var MAX_SCAN_DEPTH = 7;
 function homeRoots(homeDir, platform) {
   if (platform === "claude-code") {
-    return [path3.join(homeDir, ".claude", "skills")];
+    return [path6.join(homeDir, ".claude", "skills")];
   }
   if (platform === "codex") {
     return [
-      path3.join(homeDir, ".codex", "skills"),
-      path3.join(homeDir, ".agents", "skills"),
-      path3.join(homeDir, ".codex", "plugins", "cache")
+      path6.join(homeDir, ".codex", "skills"),
+      path6.join(homeDir, ".agents", "skills"),
+      path6.join(homeDir, ".codex", "plugins", "cache")
     ];
   }
-  return [path3.join(homeDir, ".config", "opencode", "skills")];
+  return [path6.join(homeDir, ".config", "opencode", "skills")];
 }
 function ancestorDirs(cwd) {
   const dirs = [];
-  let current = path3.resolve(cwd);
+  let current = path6.resolve(cwd);
   for (let depth = 0; depth < 16; depth++) {
     dirs.push(current);
-    const parent = path3.dirname(current);
+    const parent = path6.dirname(current);
     if (parent === current)
       break;
     current = parent;
@@ -3343,11 +3842,11 @@ function ancestorDirs(cwd) {
 function repoRoots(cwd, platform) {
   return ancestorDirs(cwd).flatMap((dir) => {
     if (platform === "claude-code")
-      return [path3.join(dir, ".claude", "skills")];
+      return [path6.join(dir, ".claude", "skills")];
     if (platform === "codex") {
-      return [path3.join(dir, ".codex", "skills"), path3.join(dir, ".agents", "skills")];
+      return [path6.join(dir, ".codex", "skills"), path6.join(dir, ".agents", "skills")];
     }
-    return [path3.join(dir, ".opencode", "skills")];
+    return [path6.join(dir, ".opencode", "skills")];
   });
 }
 function frontmatterName(content) {
@@ -3363,14 +3862,14 @@ function readNativeSkillNames(params) {
       return;
     let entries;
     try {
-      entries = fs3.readdirSync(dir, { withFileTypes: true });
+      entries = fs6.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
     for (const entry of entries) {
       if (visited >= MAX_NATIVE_SKILL_FILES)
         return;
-      const full = path3.join(dir, entry.name);
+      const full = path6.join(dir, entry.name);
       if (entry.isDirectory()) {
         walk(full, depth + 1);
         continue;
@@ -3378,9 +3877,9 @@ function readNativeSkillNames(params) {
       if (!entry.isFile() || entry.name.toLowerCase() !== "skill.md")
         continue;
       visited++;
-      names.add(path3.basename(path3.dirname(full)).toLowerCase());
+      names.add(path6.basename(path6.dirname(full)).toLowerCase());
       try {
-        const declared = frontmatterName(fs3.readFileSync(full, "utf8"));
+        const declared = frontmatterName(fs6.readFileSync(full, "utf8"));
         if (declared)
           names.add(declared.toLowerCase());
       } catch {
@@ -3412,14 +3911,14 @@ function activationFromApiRows(params) {
 }
 
 // src/opencode-plugin.ts
-var DEBUG_LOG_PATH = path4.join(os.homedir(), ".greprag", "opencode-plugin-debug.log");
+var DEBUG_LOG_PATH = path7.join(os2.homedir(), ".greprag", "opencode-plugin-debug.log");
 var _debugLogReady = false;
 function dlogInit() {
   if (_debugLogReady)
     return;
   _debugLogReady = true;
   try {
-    fs4.writeFileSync(DEBUG_LOG_PATH, "");
+    fs7.writeFileSync(DEBUG_LOG_PATH, "");
   } catch {
   }
 }
@@ -3428,7 +3927,7 @@ function dlog(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [greprag-memory] ${msg}
 `;
   try {
-    fs4.appendFileSync(DEBUG_LOG_PATH, line);
+    fs7.appendFileSync(DEBUG_LOG_PATH, line);
   } catch {
   }
 }
@@ -3436,9 +3935,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 (!fs4.existsSync(filePath))
+    if (!fs7.existsSync(filePath))
       return;
-    const raw = fs4.readFileSync(filePath, "utf-8");
+    const raw = fs7.readFileSync(filePath, "utf-8");
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#"))
@@ -3458,12 +3957,12 @@ function loadEnvFile(filePath) {
   }
 }
 function loadGrepragEnv() {
-  loadEnvFile(path4.join(HOME, ".greprag", ".env"));
+  loadEnvFile(path7.join(HOME, ".greprag", ".env"));
   try {
-    const p = path4.join(HOME, ".claude", "settings.json");
-    if (!fs4.existsSync(p))
+    const p = path7.join(HOME, ".claude", "settings.json");
+    if (!fs7.existsSync(p))
       return;
-    const data = JSON.parse(fs4.readFileSync(p, "utf-8"));
+    const data = JSON.parse(fs7.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") {
@@ -3476,11 +3975,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 = path4.join(HOME || os.homedir(), ".greprag", "opencode-watch.lock");
+var WATCHER_LOCK = path7.join(HOME || os2.homedir(), ".greprag", "opencode-watch.lock");
 var WATCHER_STALE_MS = 3e4;
 function findGrepragBinary() {
   const override = process.env.GREPRAG_BIN;
-  if (override && fs4.existsSync(override))
+  if (override && fs7.existsSync(override))
     return override;
   const binaryName = process.platform === "win32" ? "greprag.cmd" : "greprag";
   try {
@@ -3489,14 +3988,14 @@ function findGrepragBinary() {
       const candidate = line.trim();
       if (!candidate)
         continue;
-      if (!fs4.existsSync(candidate))
+      if (!fs7.existsSync(candidate))
         continue;
       if (process.platform === "win32") {
-        const ext = path4.extname(candidate).toLowerCase();
+        const ext = path7.extname(candidate).toLowerCase();
         if (ext === ".cmd" || ext === ".exe" || ext === ".bat")
           return candidate;
         const cmdSibling = candidate + ".cmd";
-        if (fs4.existsSync(cmdSibling))
+        if (fs7.existsSync(cmdSibling))
           return cmdSibling;
         continue;
       }
@@ -3505,19 +4004,19 @@ function findGrepragBinary() {
   } catch {
   }
   const candidates = process.platform === "win32" ? [
-    path4.join(HOME, "AppData", "Roaming", "npm", "greprag.cmd"),
-    path4.join(HOME, "AppData", "Roaming", "npm", "greprag"),
-    path4.join(HOME, "AppData", "Local", "Yarn", "bin", "greprag.cmd"),
-    path4.join(HOME, "AppData", "Local", "pnpm", "bin", "greprag.cmd")
+    path7.join(HOME, "AppData", "Roaming", "npm", "greprag.cmd"),
+    path7.join(HOME, "AppData", "Roaming", "npm", "greprag"),
+    path7.join(HOME, "AppData", "Local", "Yarn", "bin", "greprag.cmd"),
+    path7.join(HOME, "AppData", "Local", "pnpm", "bin", "greprag.cmd")
   ] : [
     "/usr/local/bin/greprag",
     "/opt/homebrew/bin/greprag",
-    path4.join(HOME || "", ".local", "bin", "greprag"),
-    path4.join(HOME || "", ".yarn", "bin", "greprag")
+    path7.join(HOME || "", ".local", "bin", "greprag"),
+    path7.join(HOME || "", ".yarn", "bin", "greprag")
   ];
   for (const c of candidates) {
     try {
-      if (c && fs4.existsSync(c))
+      if (c && fs7.existsSync(c))
         return c;
     } catch {
     }
@@ -3526,18 +4025,18 @@ function findGrepragBinary() {
 }
 function tryClaimWatcherLock() {
   try {
-    const fd = fs4.openSync(WATCHER_LOCK, "wx");
+    const fd = fs7.openSync(WATCHER_LOCK, "wx");
     return { ok: true, fd };
   } catch (err) {
     if (err.code !== "EEXIST") {
       return { ok: false, reason: "lock-create-failed" };
     }
     try {
-      const stat = fs4.statSync(WATCHER_LOCK);
+      const stat = fs7.statSync(WATCHER_LOCK);
       const ageMs = Date.now() - stat.mtimeMs;
       let pidAlive = false;
       try {
-        const pid = parseInt(fs4.readFileSync(WATCHER_LOCK, "utf-8").trim(), 10);
+        const pid = parseInt(fs7.readFileSync(WATCHER_LOCK, "utf-8").trim(), 10);
         pidAlive = pid > 0 && isPidAlive(pid);
       } catch {
       }
@@ -3545,10 +4044,10 @@ function tryClaimWatcherLock() {
         return { ok: false, reason: "busy" };
       }
       try {
-        fs4.unlinkSync(WATCHER_LOCK);
+        fs7.unlinkSync(WATCHER_LOCK);
       } catch {
       }
-      const fd = fs4.openSync(WATCHER_LOCK, "wx");
+      const fd = fs7.openSync(WATCHER_LOCK, "wx");
       return { ok: true, fd };
     } catch (err2) {
       return { ok: false, reason: "lock-stale-replace-failed" };
@@ -3589,11 +4088,11 @@ function startCaptureWatcher() {
     return;
   }
   try {
-    fs4.writeSync(claim.fd, String(process.pid));
-    fs4.closeSync(claim.fd);
+    fs7.writeSync(claim.fd, String(process.pid));
+    fs7.closeSync(claim.fd);
   } catch {
     try {
-      fs4.unlinkSync(WATCHER_LOCK);
+      fs7.unlinkSync(WATCHER_LOCK);
     } catch {
     }
     return;
@@ -3609,11 +4108,11 @@ function startCaptureWatcher() {
     const claim2 = tryClaimWatcherLock();
     if (claim2.ok) {
       try {
-        fs4.writeSync(claim2.fd, String(process.pid));
-        fs4.closeSync(claim2.fd);
+        fs7.writeSync(claim2.fd, String(process.pid));
+        fs7.closeSync(claim2.fd);
       } catch {
         try {
-          fs4.unlinkSync(WATCHER_LOCK);
+          fs7.unlinkSync(WATCHER_LOCK);
         } catch {
         }
         return false;
@@ -3656,7 +4155,7 @@ function startCaptureWatcher() {
     childStartTime = Date.now();
     dlog(`startCaptureWatcher: spawned 'greprag opencode watch' pid=${child.pid ?? "<none>"}`);
     try {
-      fs4.writeFileSync(WATCHER_LOCK, String(child.pid));
+      fs7.writeFileSync(WATCHER_LOCK, String(child.pid));
     } catch {
     }
     child.stderr?.on("data", (chunk2) => {
@@ -3668,9 +4167,9 @@ function startCaptureWatcher() {
     child.on("exit", (code, signal) => {
       dlog(`startCaptureWatcher: child pid=${child.pid ?? "<none>"} exited code=${code} signal=${signal || "none"}`);
       try {
-        const current = fs4.readFileSync(WATCHER_LOCK, "utf-8").trim();
+        const current = fs7.readFileSync(WATCHER_LOCK, "utf-8").trim();
         if (current === String(child.pid))
-          fs4.unlinkSync(WATCHER_LOCK);
+          fs7.unlinkSync(WATCHER_LOCK);
       } catch {
       }
       currentChild = null;
@@ -3699,7 +4198,7 @@ function startCaptureWatcher() {
 `
       );
       try {
-        fs4.unlinkSync(WATCHER_LOCK);
+        fs7.unlinkSync(WATCHER_LOCK);
       } catch {
       }
       return;
@@ -3731,7 +4230,7 @@ function startCaptureWatcher() {
       }, 2e3).unref();
     }
     try {
-      fs4.unlinkSync(WATCHER_LOCK);
+      fs7.unlinkSync(WATCHER_LOCK);
     } catch {
     }
   };
@@ -3768,6 +4267,7 @@ async function fetchRecapInbox(anchor) {
 var relayArmedBySession = /* @__PURE__ */ new Set();
 var announcedBySession = /* @__PURE__ */ new Set();
 var turnCountBySession = /* @__PURE__ */ new Map();
+var procedurePromptKeyBySession = /* @__PURE__ */ new Map();
 var cachedRecap = null;
 var RECAP_CACHE_TTL_MS = 5 * 6e4;
 var cachedSkillRows = null;
@@ -3839,11 +4339,11 @@ function startSessionRelay(sessionId, serverUrl) {
     return;
   }
   try {
-    fs4.writeSync(claim.fd, String(process.pid));
-    fs4.closeSync(claim.fd);
+    fs7.writeSync(claim.fd, String(process.pid));
+    fs7.closeSync(claim.fd);
   } catch {
     try {
-      fs4.unlinkSync(lockPath);
+      fs7.unlinkSync(lockPath);
     } catch {
     }
     return;
@@ -3858,11 +4358,11 @@ function startSessionRelay(sessionId, serverUrl) {
     const claim2 = tryClaimRelayLock(lockPath);
     if (claim2.ok) {
       try {
-        fs4.writeSync(claim2.fd, String(process.pid));
-        fs4.closeSync(claim2.fd);
+        fs7.writeSync(claim2.fd, String(process.pid));
+        fs7.closeSync(claim2.fd);
       } catch {
         try {
-          fs4.unlinkSync(lockPath);
+          fs7.unlinkSync(lockPath);
         } catch {
         }
         return false;
@@ -3898,7 +4398,7 @@ function startSessionRelay(sessionId, serverUrl) {
     childStartTime = Date.now();
     dlog(`startSessionRelay: spawned 'greprag opencode relay' pid=${child.pid ?? "<none>"}`);
     try {
-      fs4.writeFileSync(lockPath, String(child.pid));
+      fs7.writeFileSync(lockPath, String(child.pid));
     } catch {
     }
     child.stderr?.on("data", (chunk2) => {
@@ -3909,9 +4409,9 @@ function startSessionRelay(sessionId, serverUrl) {
     });
     child.on("exit", (code, signal) => {
       try {
-        const current = fs4.readFileSync(lockPath, "utf-8").trim();
+        const current = fs7.readFileSync(lockPath, "utf-8").trim();
         if (current === String(child.pid))
-          fs4.unlinkSync(lockPath);
+          fs7.unlinkSync(lockPath);
       } catch {
       }
       currentChild = null;
@@ -3938,7 +4438,7 @@ function startSessionRelay(sessionId, serverUrl) {
 `
       );
       try {
-        fs4.unlinkSync(lockPath);
+        fs7.unlinkSync(lockPath);
       } catch {
       }
       return;
@@ -3970,7 +4470,7 @@ function startSessionRelay(sessionId, serverUrl) {
       }, 2e3).unref();
     }
     try {
-      fs4.unlinkSync(lockPath);
+      fs7.unlinkSync(lockPath);
     } catch {
     }
   };
@@ -4030,7 +4530,7 @@ function runPngRecode(input, msgs) {
 }
 function makeCcrStash() {
   return (original, sourceType) => {
-    const hash = crypto2.createHash("sha256").update(original, "utf8").digest("hex").slice(0, 16);
+    const hash = crypto5.createHash("sha256").update(original, "utf8").digest("hex").slice(0, 16);
     const bin = grepragBinCached();
     if (bin) {
       try {
@@ -4181,6 +4681,31 @@ ALWAYS pass \`--from-session ${sid82}\` when you run \`greprag send\`, so recipi
     // never opencode's persisted session history. adr:
     // adr/opencode-context-compressor.md
     "experimental.chat.messages.transform": async (input, output) => {
+      try {
+        const prompt = extractLatestOpenCodeProcedurePrompt(output.messages);
+        if (prompt) {
+          const sid = input.sessionID || "<no-session>";
+          if (procedurePromptKeyBySession.get(sid) !== prompt.key) {
+            procedurePromptKeyBySession.set(sid, prompt.key);
+            const sessionContext = input.sessionID ? await resolveSessionContext(input.sessionID) : { anchor: fallbackAnchor, workingDir: fallbackWorkingDir };
+            const procedure = runProcedurePromptCheck({
+              cwd: sessionContext.workingDir,
+              prompt: prompt.prompt,
+              sessionId: input.sessionID
+            });
+            if (procedure.additionalContext) {
+              prompt.parts.push({
+                type: "text",
+                text: procedure.additionalContext,
+                synthetic: true
+              });
+            }
+            dlog(`procedure: ${procedure.mode}${procedure.verb ? ` ${procedure.verb}` : ""} sid=${sid}`);
+          }
+        }
+      } catch (e) {
+        dlog(`messages.transform procedure: swallowed error (turn unaffected): ${e.message}`);
+      }
       try {
         if (pngRecodeEnabled()) {
           const msgs0 = output && output.messages;