greprag 5.78.7 → 5.80.0

package/dist/hook.js

@@ -40,8 +40,10 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.announceCachePath = announceCachePath;
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const crypto = __importStar(require("crypto"));
 const proc_1 = require("./proc");
 const docptr_refs_1 = require("./docptr-refs");
@@ -1334,6 +1336,43 @@ function grokSidecarHead(short, full) {
         + 'Chip: `greprag load grok-chip-spawn` then `greprag grok spawn`. Helper: spawn_subagent. Parent keeps ONE watch. Peers: `greprag inbox watchers` then `greprag send`.\n'
         + 'If a greprag inbox monitor is already listed, do not start another. Instant exit = already armed.\n\n';
 }
+/** Where the full, unabridged announce is parked for on-demand reading.
+ *  adr: adr/announce-inline-budget.md */
+function announceCachePath(short) {
+    return path.join(os.homedir(), '.greprag', 'announce', `${short}.md`);
+}
+/** Assemble the SessionStart announce so it SURVIVES the harness's inline cap.
+ *
+ *  Writes the full text to the announce cache, inlines the highest-value blocks
+ *  that fit the budget, and — when anything was left out — appends one line that
+ *  NAMES the omitted sections and the command that prints them. The old behavior
+ *  emitted all 18.5KB and let the harness silently keep the first 2KB.
+ *
+ *  Returns null when there is nothing to announce. */
+function buildInlineAnnounce(blocks, short) {
+    if (!blocks.length)
+        return null;
+    const full = blocks.map(b => b.text).join('\n\n');
+    if (short) {
+        try {
+            const file = announceCachePath(short);
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+            fs.writeFileSync(file, full, 'utf-8');
+        }
+        catch { /* cache is a convenience; never block session start */ }
+    }
+    // Reserve room for the pointer line before fitting, so adding it can never be
+    // what pushes the payload over the cap.
+    const POINTER_RESERVE = 220;
+    const { kept, droppedIds } = (0, reminder_registry_1.fitAnnounceBudget)(blocks, reminder_registry_1.ANNOUNCE_INLINE_BUDGET, POINTER_RESERVE);
+    if (!droppedIds.length)
+        return kept.map(b => b.text).join('\n\n') || null;
+    const names = droppedIds.join(', ');
+    const pointer = `[greprag announce — ${droppedIds.length} more section(s) not inlined `
+        + `(harness caps SessionStart context at ${reminder_registry_1.ANNOUNCE_INLINE_BUDGET}b): ${names}. `
+        + `Read them with \`greprag announce\`.]`;
+    return [...kept.map(b => b.text), pointer].join('\n\n');
+}
 function writeRecapOutput(text, mode, grokShort, grokFull) {
     if (grokShort)
         (0, grok_session_1.writeGrokSidecar)(grokShort, grokSidecarHead(grokShort, grokFull) + (text || ''));
@@ -1737,7 +1776,12 @@ async function recap(input, mode = 'plain', opts = {}) {
     // adr: adr/monitor-resilience.md, docs/reminder-interrupt.md
     if (opts.compact)
         announceReg = (0, reminder_registry_1.compactReannounceModules)(announceReg);
-    const announceBlock = (0, reminder_registry_1.collectAnnounces)(announceEnv, announceReg).join('\n\n') || null;
+    // Fit the announce to what the harness will actually inline (2048 bytes; see
+    // ANNOUNCE_INLINE_BUDGET). The full text is persisted first and the overflow is
+    // NAMED, so nothing is lost silently — the failure this replaces was an 18.5KB
+    // announce of which only the first ~2KB ever reached a session, with no signal
+    // that the rest existed. adr: adr/announce-inline-budget.md
+    const announceBlock = buildInlineAnnounce((0, reminder_registry_1.collectAnnounceBlocks)(announceEnv, announceReg), (0, session_id_1.truncateSessionId)(input.session_id));
     if (opts.compact) {
         writeRecapOutput(announceBlock ? announceBlock + '\n' : '', mode, grokShort, input.session_id);
         return;
@@ -1773,7 +1817,17 @@ async function recap(input, mode = 'plain', opts = {}) {
         parts.push(announceBlock);
         parts.push('');
     }
-    parts.push(body);
+    // The memory recap shares the SAME inline cap as the announce — it is appended
+    // to the very payload the harness truncates. Inline it only if it fits in what
+    // the announce left; otherwise name the command that prints it. Silently
+    // emitting a body that pushes the payload over the cap is what made the whole
+    // announce disappear. adr: adr/announce-inline-budget.md
+    const usedSoFar = parts.join('\n').length;
+    const roomForBody = reminder_registry_1.ANNOUNCE_INLINE_BUDGET - usedSoFar;
+    parts.push(body.length <= roomForBody
+        ? body
+        : '[greprag memory — session recap not inlined (over the SessionStart cap). '
+            + 'Read it with `greprag memory recap`.]');
     writeRecapOutput(parts.join('\n') + '\n', mode, grokShort, input.session_id);
 }
 /** Arm-state detection moved LOCAL (2026-06-04). The former `isSessionArmed`
@@ -2084,12 +2138,11 @@ function validateChip(title, prompt) {
             `Block 1 requires the chip to open with: \`git worktree add .claude/worktrees/<slug> -b chip/<slug>\` ` +
             `then \`cd\` into it. Chips never edit the main checkout.`);
     }
-    if (!/\bgreprag\s+send\b/.test(prompt)) {
-        violations.push(`prompt missing report-back instruction. ` +
-            `Block 2 requires the chip to send a status message via: ` +
-            `\`greprag send "<status>: <commit> on chip/<slug>" --to <handle>@greprag.com/<parent-session-id> ` +
-            `--from-session <own-session-id> --artifact commit:<hash>\`.`);
-    }
+    // NO report-back check. Chips report to the parent with native
+    // `SendMessage to: "<parent-name>"`, which needs no greprag address and no
+    // armed watcher on the parent. Requiring `greprag send` here denied every
+    // correctly-composed native chip. See adr/prespawn-augmentation.md
+    // 2026-09-03 entry.
     return violations;
 }
 /** Validate the chip prompt at the PreToolUse boundary. Validation-only —
@@ -2118,6 +2171,25 @@ function handlePreSpawnCheck(input) {
         },
     }) + '\n');
 }
+/** A validator that receives no payload has validated nothing. Fail-open is
+ *  the worse failure here: the caller trusts the gate, so a silent exit 0
+ *  ALLOWS an unchecked chip. Only `pre-spawn-check` is a gate — every other
+ *  subcommand is additive (recap/store/notify), so a lost payload there is
+ *  correctly a no-op. Exits the process; never returns for the gate case. */
+function denyOnMissingPayload(subcommand, why) {
+    if (subcommand !== 'pre-spawn-check')
+        return;
+    process.stdout.write(JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: 'PreToolUse',
+            permissionDecision: 'deny',
+            permissionDecisionReason: `greprag pre-spawn validator received no payload (${why}), so the chip ` +
+                `prompt was never checked. Re-call spawn_task; if this repeats, the ` +
+                `greprag hook is misconfigured — run \`greprag doctor\`.`,
+        },
+    }) + '\n');
+    process.exit(0);
+}
 /** PreToolUse mechanic dispatcher (Chip B) — `greprag-hook guard`. All real
  *  logic lives in ./guard (runGuard); this wrapper resolves the projectId and
  *  emits the hook JSON. Hard fail-open posture: any error → emit nothing,
@@ -2202,9 +2274,12 @@ async function main() {
             chunks.push(chunk);
         }
         const raw = Buffer.concat(chunks).toString('utf-8').trim();
-        input = (0, hook_runtime_1.normalizeHookInput)(raw ? JSON.parse(raw) : {});
+        if (!raw)
+            denyOnMissingPayload(subcommand, 'empty stdin');
+        input = (0, hook_runtime_1.normalizeHookInput)(JSON.parse(raw));
     }
     catch {
+        denyOnMissingPayload(subcommand, 'unparseable stdin');
         process.exit(0);
     }
     if (!(0, hook_once_1.claimHookOnce)(input.session_id, input.hook_event_name, subcommand, input.turn_id)) {
@@ -2212,7 +2287,12 @@ async function main() {
     }
     const harness = (0, harness_1.inferCurrentHarness)();
     if (subcommand === 'recap') {
-        await recap(input, harness === 'grok' ? 'additionalContext' : 'plain', {
+        // ALWAYS additionalContext. Raw stdout is treated by the Claude Code harness
+        // like command output: past ~2KB it spills to a file and injects a preview,
+        // which silently ate ~89% of an 18.7KB announce (Persona sits at byte 10,841).
+        // additionalContext is the documented injection channel. Grok keeps its
+        // sidecar via the platform arg. adr: adr/announce-delivery-channel.md
+        await recap(input, 'additionalContext', {
             platform: harness === 'grok' ? 'grok' : undefined,
         });
     }

package/dist/index.js

@@ -299,6 +299,10 @@ function readProjectRegistry() {
  *    desk ensure   idempotently spawn a detached desk-line if none is running
  *    desk status   is a desk-line up + what local truth would it report now
  *  adr: adr/desk-line-relay.md */
+async function runAnnounce(args) {
+    const { runAnnounce: run } = await Promise.resolve().then(() => __importStar(require('./commands/announce')));
+    run(args);
+}
 async function runDesk(args) {
     ensureEnv(); // load ~/.greprag/.env so GREPRAG_API_KEY is present (self-heals in the detached child)
     const sub = args[0] || 'status';
@@ -1906,6 +1910,10 @@ async function main() {
             return;
         }
         case 'inbox': return inbox(subArgs);
+        // The full SessionStart announce. The harness inlines only ~2KB of it, so the
+        // overflow is parked here and the inline pointer names this command.
+        // adr: adr/announce-inline-budget.md
+        case 'announce': return runAnnounce(subArgs);
         case 'desk': return runDesk(subArgs);
         case 'email': return (0, email_1.runEmail)(subArgs);
         case 'send': return send(subArgs);

package/dist/opencode-plugin.bundle.js

@@ -2183,6 +2183,118 @@ var skillGainAnnounceModule = {
   reminder: () => null
 };
 
+// src/skill-activation-manifest.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var MAX_NATIVE_SKILL_FILES = 1500;
+var MAX_SCAN_DEPTH = 7;
+function homeRoots(homeDir, platform) {
+  if (platform === "claude-code") {
+    return [path2.join(homeDir, ".claude", "skills")];
+  }
+  if (platform === "codex") {
+    return [
+      path2.join(homeDir, ".codex", "skills"),
+      path2.join(homeDir, ".agents", "skills"),
+      path2.join(homeDir, ".codex", "plugins", "cache")
+    ];
+  }
+  return [path2.join(homeDir, ".config", "opencode", "skills")];
+}
+function ancestorDirs(cwd) {
+  const dirs = [];
+  let current = path2.resolve(cwd);
+  for (let depth = 0; depth < 16; depth++) {
+    dirs.push(current);
+    const parent = path2.dirname(current);
+    if (parent === current)
+      break;
+    current = parent;
+  }
+  return dirs;
+}
+function repoRoots(cwd, platform) {
+  return ancestorDirs(cwd).flatMap((dir) => {
+    if (platform === "claude-code")
+      return [path2.join(dir, ".claude", "skills")];
+    if (platform === "codex") {
+      return [path2.join(dir, ".codex", "skills"), path2.join(dir, ".agents", "skills")];
+    }
+    return [path2.join(dir, ".opencode", "skills")];
+  });
+}
+function frontmatterName(content) {
+  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
+  const name = fm && /(?:^|\r?\n)name:\s*["']?([^\r\n"']+)/.exec(fm[1]);
+  return name?.[1]?.trim() || "";
+}
+function readNativeSkillNames(params) {
+  const names = /* @__PURE__ */ new Set();
+  let visited = 0;
+  const walk = (dir, depth) => {
+    if (depth > MAX_SCAN_DEPTH || visited >= MAX_NATIVE_SKILL_FILES)
+      return;
+    let entries;
+    try {
+      entries = fs2.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (visited >= MAX_NATIVE_SKILL_FILES)
+        return;
+      const full = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(full, depth + 1);
+        continue;
+      }
+      if (!entry.isFile() || entry.name.toLowerCase() !== "skill.md")
+        continue;
+      visited++;
+      names.add(path2.basename(path2.dirname(full)).toLowerCase());
+      try {
+        const declared = frontmatterName(fs2.readFileSync(full, "utf8"));
+        if (declared)
+          names.add(declared.toLowerCase());
+      } catch {
+      }
+    }
+  };
+  const roots = [
+    ...homeRoots(params.homeDir, params.platform),
+    ...repoRoots(params.cwd, params.platform)
+  ];
+  for (const root of roots)
+    walk(root, 0);
+  return names;
+}
+function buildMirroredSkillActivation(entries, nativeNames) {
+  const valid = entries.filter((entry) => entry.skillName && entry.triggerDescription);
+  if (valid.length === 0)
+    return void 0;
+  const skills = valid.filter((entry) => !nativeNames.has(entry.skillName.toLowerCase()));
+  return { count: valid.length, skills, nativeCount: valid.length - skills.length };
+}
+function nativeAdapterInstallCommand(platform, missingNames) {
+  if (missingNames.length === 0)
+    return null;
+  if (platform === "claude-code") {
+    return `greprag skill mirror sync claude-code --only ${[...missingNames].sort().join(",")}`;
+  }
+  if (platform === "codex" || platform === "opencode") {
+    return `greprag skill mirror sync ${platform}`;
+  }
+  return null;
+}
+function activationFromApiRows(params) {
+  const entries = params.rows.filter((row) => typeof row.skillName === "string" && !!row.skillName && typeof row.triggerDescription === "string" && !!row.triggerDescription).map((row) => ({
+    skillName: row.skillName,
+    description: typeof row.description === "string" ? row.description : "",
+    triggerDescription: row.triggerDescription
+  }));
+  return buildMirroredSkillActivation(entries, readNativeSkillNames(params));
+}
+
 // src/commands/skill-mirror-reminder.ts
 var SKILL_ACTIVATION_MANIFEST_MAX_CHARS = 64e3;
 function renderEntry(skill) {
@@ -2191,17 +2303,31 @@ function renderEntry(skill) {
   return `- ${skill.skillName}: ${lines[0]}${lines.slice(1).map((line) => `
   ${line}`).join("")}`;
 }
-function buildSkillMirrorAnnounce(m) {
+function buildSkillMirrorAnnounce(m, platform) {
   if (!m || m.count <= 0)
     return null;
   if (m.skills.length === 0) {
     return "[greprag skills: slash skills are available. When discussing skills with the user, say use/create/update/refresh `/skill`; keep storage mechanics internal unless diagnosing a failure or the user asks how it works. Use `greprag load <skill>` to read skill instructions.]";
   }
+  const installCommand = nativeAdapterInstallCommand(
+    platform || "",
+    m.skills.map((s) => s.skillName)
+  );
+  const gapSection = installCommand ? [
+    "### Missing Native Adapters",
+    `${m.skills.length} of these skills are in your GrepRAG mirror but have NO adapter installed in this harness, so they never appear in the native skill list. Install the adapters once with:`,
+    "",
+    `    ${installCommand}`,
+    "",
+    "Offer that command when the user asks why a skill is missing, or when you needed one of them this session. Until adapters are installed, the trigger rules below are the only way these skills activate.",
+    ""
+  ] : [];
   const header = [
     "## GrepRAG Skills",
     `Slash skills are available through \`greprag load\`; ${m.skills.length} skills need this startup trigger list` + (m.nativeCount > 0 ? ` (${m.nativeCount} already-listed duplicate${m.nativeCount === 1 ? "" : "s"} omitted)` : "") + ".",
     "When discussing skills with the user, say use/create/update/refresh `/skill`; keep storage mechanics internal unless diagnosing a failure or the user asks how it works.",
     "",
+    ...gapSection,
     "### Trigger Rules",
     "If the user names a skill (with or without `/`) OR the request clearly matches a skill's description below, you MUST activate that skill for the current turn. Match meaning, not exact keywords.",
     "",
@@ -2232,7 +2358,7 @@ var skillMirrorAnnounceModule = {
   // references `greprag load` — the primer establishes it
   detect: (_env) => ({ tier: "silent" }),
   // announce-only
-  announce: (env) => buildSkillMirrorAnnounce(env.mirroredSkills),
+  announce: (env) => buildSkillMirrorAnnounce(env.mirroredSkills, env.platform),
   reminder: () => null
 };
 
@@ -2430,23 +2556,23 @@ function collectAnnounces(env, registry = REGISTRY) {
 }
 
 // src/app-settings.ts
-var fs3 = __toESM(require("node:fs"));
+var fs4 = __toESM(require("node:fs"));
 var os2 = __toESM(require("node:os"));
-var path3 = __toESM(require("node:path"));
+var path4 = __toESM(require("node:path"));
 
 // src/project-anchor.ts
-var path2 = __toESM(require("path"));
-var fs2 = __toESM(require("fs"));
+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 path2.join(dir, ANCHOR_DIR, ANCHOR_FILE);
+  return path3.join(dir, ANCHOR_DIR, ANCHOR_FILE);
 }
 function legacyAnchorPathIn(dir) {
-  return path2.join(dir, LEGACY_ANCHOR_DIR, ANCHOR_FILE);
+  return path3.join(dir, LEGACY_ANCHOR_DIR, ANCHOR_FILE);
 }
 function globalAnchorPath() {
   return anchorPathIn(os.homedir());
@@ -2457,22 +2583,22 @@ function legacyGlobalAnchorPath() {
 function findExistingAnchor(startDir) {
   const homeAnchor = globalAnchorPath();
   const legacyHomeAnchor = legacyGlobalAnchorPath();
-  let dir = path2.resolve(startDir);
+  let dir = path3.resolve(startDir);
   while (true) {
     const candidate = anchorPathIn(dir);
-    if (candidate !== homeAnchor && fs2.existsSync(candidate))
+    if (candidate !== homeAnchor && fs3.existsSync(candidate))
       return candidate;
     const legacyCandidate = legacyAnchorPathIn(dir);
-    if (legacyCandidate !== legacyHomeAnchor && fs2.existsSync(legacyCandidate))
+    if (legacyCandidate !== legacyHomeAnchor && fs3.existsSync(legacyCandidate))
       return legacyCandidate;
-    const parent = path2.dirname(dir);
+    const parent = path3.dirname(dir);
     if (parent === dir)
       return null;
     dir = parent;
   }
 }
 function isEphemeralCwd2(cwd) {
-  const norm = path2.resolve(cwd).replace(/\\/g, "/").toLowerCase();
+  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/"))
@@ -2510,7 +2636,7 @@ function computeGitDerivedProjectId2(workingDir) {
   }
 }
 function deterministicProjectId2(workingDir) {
-  const normalized = path2.resolve(workingDir).toLowerCase();
+  const normalized = path3.resolve(workingDir).toLowerCase();
   const hash = crypto2.createHash("sha256").update(normalized).digest("hex");
   return [
     hash.slice(0, 8),
@@ -2524,7 +2650,7 @@ function deterministicProjectId2(workingDir) {
 }
 function tryReadAnchorFileContents(filePath) {
   try {
-    const raw = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    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 {
@@ -2563,10 +2689,10 @@ function readAnchor2(cwd) {
   }
   const gitId = computeGitDerivedProjectId2(cwd);
   if (gitId) {
-    const root2 = path2.resolve(cwd);
+    const root2 = path3.resolve(cwd);
     return {
       projectId: gitId,
-      projectName: fileContents?.projectName || path2.basename(root2).toLowerCase(),
+      projectName: fileContents?.projectName || path3.basename(root2).toLowerCase(),
       initialized: true,
       source: "git",
       anchorPath: existingPath || anchorPathIn(root2),
@@ -2580,7 +2706,7 @@ function readAnchor2(cwd) {
     };
   }
   if (isEphemeralCwd2(cwd)) {
-    const globalPath = fs2.existsSync(globalAnchorPath()) ? globalAnchorPath() : legacyGlobalAnchorPath();
+    const globalPath = fs3.existsSync(globalAnchorPath()) ? globalAnchorPath() : legacyGlobalAnchorPath();
     const globalContents = tryReadAnchorFileContents(globalPath);
     if (globalContents && globalContents.projectId && globalContents.projectName) {
       return {
@@ -2599,10 +2725,10 @@ function readAnchor2(cwd) {
       };
     }
   }
-  const root = path2.resolve(cwd);
+  const root = path3.resolve(cwd);
   return {
     projectId: deterministicProjectId2(root),
-    projectName: fileContents?.projectName || path2.basename(root).toLowerCase(),
+    projectName: fileContents?.projectName || path3.basename(root).toLowerCase(),
     initialized: false,
     source: "hash",
     anchorPath: existingPath || anchorPathIn(root),
@@ -2619,14 +2745,14 @@ function readAnchor2(cwd) {
 // src/app-settings.ts
 function readJson(file) {
   try {
-    const parsed = JSON.parse(fs3.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs4.readFileSync(file, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
   }
 }
 function localAppSettingsPath(homeDir = os2.homedir()) {
-  return path3.join(homeDir, ".greprag", "settings.json");
+  return path4.join(homeDir, ".greprag", "settings.json");
 }
 function readLocalAppSettings(homeDir = os2.homedir()) {
   const raw = readJson(localAppSettingsPath(homeDir));
@@ -2683,8 +2809,8 @@ function getOpenCodeReminders(env) {
 }
 
 // src/procedure.ts
-var path4 = __toESM(require("path"));
-var fs4 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
 
 // src/delivery-lifecycle.ts
 var DELIVERY_LIFECYCLE_VERBS = [
@@ -2703,14 +2829,14 @@ function isDeliveryLifecycleVerb(verb) {
 var PROCEDURE_STORE_VERSION = "2";
 function stateDir() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path4.join(home, ".greprag", "state");
+  return path5.join(home, ".greprag", "state");
 }
 function procedureStorePath(projectId) {
-  return path4.join(stateDir(), `procedures-${projectId}.json`);
+  return path5.join(stateDir(), `procedures-${projectId}.json`);
 }
 function readProcedureStore(projectId) {
   try {
-    const raw = fs4.readFileSync(procedureStorePath(projectId), "utf-8");
+    const raw = fs5.readFileSync(procedureStorePath(projectId), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && Array.isArray(parsed.procedures)) {
       return normalizeProcedureStore({
@@ -2944,8 +3070,8 @@ function activeProcedureAnnounces(store) {
 var crypto4 = __toESM(require("crypto"));
 
 // src/procedure-watch.ts
-var path5 = __toESM(require("path"));
-var fs5 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var fs6 = __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 },
@@ -2978,24 +3104,24 @@ function openWatch(verb, phase, openedAt, shadowRunId) {
 }
 function stateDir2() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path5.join(home, ".greprag", "state");
+  return path6.join(home, ".greprag", "state");
 }
 function procedureWatchPath(projectId) {
-  return path5.join(stateDir2(), `procedure-watch-${projectId}.json`);
+  return path6.join(stateDir2(), `procedure-watch-${projectId}.json`);
 }
 function hasProcedureWatch(projectId) {
   try {
-    return fs5.existsSync(procedureWatchPath(projectId));
+    return fs6.existsSync(procedureWatchPath(projectId));
   } catch {
     return false;
   }
 }
 function writeProcedureWatch(projectId, watch) {
   const file = procedureWatchPath(projectId);
-  const dir = path5.dirname(file);
-  if (!fs5.existsSync(dir))
-    fs5.mkdirSync(dir, { recursive: true });
-  fs5.writeFileSync(file, JSON.stringify(watch, null, 2) + "\n");
+  const dir = path6.dirname(file);
+  if (!fs6.existsSync(dir))
+    fs6.mkdirSync(dir, { recursive: true });
+  fs6.writeFileSync(file, JSON.stringify(watch, null, 2) + "\n");
 }
 function openWatchIfIdle(projectId, verb, phase, shadowRunId) {
   if (hasProcedureWatch(projectId))
@@ -3006,20 +3132,20 @@ function openWatchIfIdle(projectId, verb, phase, shadowRunId) {
 
 // src/procedure-shadow.ts
 var crypto3 = __toESM(require("crypto"));
-var fs6 = __toESM(require("fs"));
-var path6 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
 function stateDir3() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path6.join(home, ".greprag", "state");
+  return path7.join(home, ".greprag", "state");
 }
 function procedureShadowPath(projectId) {
-  return path6.join(stateDir3(), `procedure-shadow-${projectId}.jsonl`);
+  return path7.join(stateDir3(), `procedure-shadow-${projectId}.jsonl`);
 }
 function appendShadowEvent(projectId, event) {
   try {
     const file = procedureShadowPath(projectId);
-    fs6.mkdirSync(path6.dirname(file), { recursive: true });
-    fs6.appendFileSync(file, JSON.stringify(event) + "\n");
+    fs7.mkdirSync(path7.dirname(file), { recursive: true });
+    fs7.appendFileSync(file, JSON.stringify(event) + "\n");
   } catch {
   }
 }
@@ -3738,107 +3864,6 @@ function recodeMessagesToPng(messages, opts) {
   return stats;
 }
 
-// src/skill-activation-manifest.ts
-var fs7 = __toESM(require("fs"));
-var path7 = __toESM(require("path"));
-var MAX_NATIVE_SKILL_FILES = 1500;
-var MAX_SCAN_DEPTH = 7;
-function homeRoots(homeDir, platform) {
-  if (platform === "claude-code") {
-    return [path7.join(homeDir, ".claude", "skills")];
-  }
-  if (platform === "codex") {
-    return [
-      path7.join(homeDir, ".codex", "skills"),
-      path7.join(homeDir, ".agents", "skills"),
-      path7.join(homeDir, ".codex", "plugins", "cache")
-    ];
-  }
-  return [path7.join(homeDir, ".config", "opencode", "skills")];
-}
-function ancestorDirs(cwd) {
-  const dirs = [];
-  let current = path7.resolve(cwd);
-  for (let depth = 0; depth < 16; depth++) {
-    dirs.push(current);
-    const parent = path7.dirname(current);
-    if (parent === current)
-      break;
-    current = parent;
-  }
-  return dirs;
-}
-function repoRoots(cwd, platform) {
-  return ancestorDirs(cwd).flatMap((dir) => {
-    if (platform === "claude-code")
-      return [path7.join(dir, ".claude", "skills")];
-    if (platform === "codex") {
-      return [path7.join(dir, ".codex", "skills"), path7.join(dir, ".agents", "skills")];
-    }
-    return [path7.join(dir, ".opencode", "skills")];
-  });
-}
-function frontmatterName(content) {
-  const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(content);
-  const name = fm && /(?:^|\r?\n)name:\s*["']?([^\r\n"']+)/.exec(fm[1]);
-  return name?.[1]?.trim() || "";
-}
-function readNativeSkillNames(params) {
-  const names = /* @__PURE__ */ new Set();
-  let visited = 0;
-  const walk = (dir, depth) => {
-    if (depth > MAX_SCAN_DEPTH || visited >= MAX_NATIVE_SKILL_FILES)
-      return;
-    let entries;
-    try {
-      entries = fs7.readdirSync(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (visited >= MAX_NATIVE_SKILL_FILES)
-        return;
-      const full = path7.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        walk(full, depth + 1);
-        continue;
-      }
-      if (!entry.isFile() || entry.name.toLowerCase() !== "skill.md")
-        continue;
-      visited++;
-      names.add(path7.basename(path7.dirname(full)).toLowerCase());
-      try {
-        const declared = frontmatterName(fs7.readFileSync(full, "utf8"));
-        if (declared)
-          names.add(declared.toLowerCase());
-      } catch {
-      }
-    }
-  };
-  const roots = [
-    ...homeRoots(params.homeDir, params.platform),
-    ...repoRoots(params.cwd, params.platform)
-  ];
-  for (const root of roots)
-    walk(root, 0);
-  return names;
-}
-function buildMirroredSkillActivation(entries, nativeNames) {
-  const valid = entries.filter((entry) => entry.skillName && entry.triggerDescription);
-  if (valid.length === 0)
-    return void 0;
-  const skills = valid.filter((entry) => !nativeNames.has(entry.skillName.toLowerCase()));
-  return { count: valid.length, skills, nativeCount: valid.length - skills.length };
-}
-function activationFromApiRows(params) {
-  const entries = params.rows.filter((row) => typeof row.skillName === "string" && !!row.skillName && typeof row.triggerDescription === "string" && !!row.triggerDescription).map((row) => ({
-    skillName: row.skillName,
-    description: typeof row.description === "string" ? row.description : "",
-    triggerDescription: row.triggerDescription
-  }));
-  return buildMirroredSkillActivation(entries, readNativeSkillNames(params));
-}
-
 // src/opencode-plugin.ts
 var DEBUG_LOG_PATH = path8.join(os3.homedir(), ".greprag", "opencode-plugin-debug.log");
 var _debugLogReady = false;