greprag 5.82.1 → 5.83.1

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 crypto5 = __toESM(require("crypto"));
-var fs9 = __toESM(require("fs"));
-var os3 = __toESM(require("os"));
-var path9 = __toESM(require("path"));
+var crypto6 = __toESM(require("crypto"));
+var fs12 = __toESM(require("fs"));
+var os5 = __toESM(require("os"));
+var path13 = __toESM(require("path"));
 
 // src/opencode-plugin-helpers.ts
 var crypto = __toESM(require("crypto"));
@@ -47,9 +47,9 @@ function safeSpawn(command, argsOrOptions, maybeOptions) {
 
 // src/opencode-plugin-helpers.ts
 var HOME = process.env.HOME || process.env.USERPROFILE || "";
-function readAnchorFile(filePath) {
+function readAnchorFile(filePath2) {
   try {
-    const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    const raw = JSON.parse(fs.readFileSync(filePath2, "utf-8"));
     if (!raw || typeof raw !== "object")
       return null;
     const notify = raw.inbox_notify;
@@ -127,8 +127,8 @@ function isEphemeralCwd(cwd) {
   return false;
 }
 function readAnchor(worktree) {
-  const filePath = findExistingAnchorFile(worktree);
-  const file = filePath ? readAnchorFile(filePath) : null;
+  const filePath2 = findExistingAnchorFile(worktree);
+  const file = filePath2 ? readAnchorFile(filePath2) : null;
   const root = path.resolve(worktree);
   if (file && file.projectId && file.projectName) {
     return {
@@ -1851,7 +1851,7 @@ var LOAD_PRIMER = [
 ].join("\n");
 var CHIP_SPAWN_POINTER = [
   "[greprag chips \u2014 agent coordination is built in (messaging plumbing in the inbox primer).]",
-  "\u2022 About to spawn a chip (`spawn_task`)? \u2192 run `greprag load chip-spawn` FIRST for the method (Block 1 worktree + Block 2 report-back); it carries the multi-chip upgrade path inline. Non-negotiable \u2014 the spawn validator rejects an unstructured chip."
+  "\u2022 About to spawn a chip (`spawn_task`)? \u2192 run `greprag load chip-spawn` FIRST for the method (Block 1 worktree + report-back); it carries the multi-chip upgrade path inline. Non-negotiable \u2014 the spawn validator rejects an unstructured chip."
 ].join("\n");
 var OPENCODE_CHIP_SPAWN_POINTER = [
   "[greprag chips \u2014 agent coordination is built in (messaging plumbing in the inbox primer).]",
@@ -2175,29 +2175,95 @@ var skillGainAnnounceModule = {
 };
 
 // src/skill-activation-manifest.ts
-var fs2 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
+var fs3 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+
+// src/skill-landing.ts
+var path3 = __toESM(require("path"));
+
+// src/skill-mirror-files.ts
+var crypto2 = __toESM(require("node:crypto"));
+var fs2 = __toESM(require("node:fs"));
+var path2 = __toESM(require("node:path"));
+function computeSkillFileHash(files) {
+  const hash = crypto2.createHash("sha256");
+  for (const file of [...files].sort((a, b) => a.path.localeCompare(b.path))) {
+    hash.update(file.path).update("\0").update(file.content).update("\0");
+  }
+  return hash.digest("hex");
+}
+var GENERATED_ADAPTER_MARKER = "## GENERATED ADAPTER \u2014 NEVER EDIT";
+function isGeneratedSkillAdapter(skillMdBody) {
+  const body = skillMdBody.replace(/^?---\r?\n[\s\S]*?\r?\n---\r?\n/, "");
+  return body.slice(0, 400).includes(GENERATED_ADAPTER_MARKER);
+}
+var INSTALLED_SKILL_HARNESS_DIRS = [".claude", ".agents", ".codex", ".opencode", "opencode"];
+function isLinkedSkillFolder(dir) {
+  try {
+    return fs2.lstatSync(dir).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function isSkillFolderOwnedElsewhere(dir) {
+  if (isLinkedSkillFolder(dir))
+    return true;
+  const root = path2.dirname(path2.resolve(dir));
+  const harnessDir = path2.basename(path2.dirname(root));
+  if (path2.basename(root) !== "skills" || !INSTALLED_SKILL_HARNESS_DIRS.includes(harnessDir))
+    return false;
+  let skillMd = "";
+  try {
+    skillMd = fs2.readFileSync(path2.join(dir, "SKILL.md"), "utf8");
+  } catch {
+  }
+  if (isGeneratedSkillAdapter(skillMd))
+    return false;
+  const frontmatter = /^?---\r?\n([\s\S]*?)\r?\n---/.exec(skillMd)?.[1] || "";
+  if (/^\s*repository:\s*\S/m.test(frontmatter))
+    return true;
+  if (harnessDir !== ".claude" && harnessDir !== ".agents")
+    return false;
+  try {
+    const lock = JSON.parse(fs2.readFileSync(path2.join(path2.dirname(path2.dirname(root)), ".agents", ".skill-lock.json"), "utf8"));
+    return Boolean(lock?.skills && Object.prototype.hasOwnProperty.call(lock.skills, path2.basename(dir)));
+  } catch {
+    return false;
+  }
+}
+function isSafeMirroredSkillFile(file) {
+  if (file.path === "SKILL.md")
+    return true;
+  return /^docs\/(?!.*(?:^|\/)\.\.(?:\/|$))[A-Za-z0-9._\/-]+\.md$/.test(file.path);
+}
+
+// src/skill-landing.ts
+var BUNDLED_SKILLS = ["greprag", "commander", "content-advisor", "mechanic"];
+var LEARNED_DIR_RELPATH = path3.join("docs", "learned");
+var LEARNINGS_RELPATH = path3.join("docs", "learnings.md");
+
+// src/skill-activation-manifest.ts
 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")];
+    return [path4.join(homeDir, ".claude", "skills")];
   }
   if (platform === "codex") {
     return [
-      path2.join(homeDir, ".codex", "skills"),
-      path2.join(homeDir, ".agents", "skills"),
-      path2.join(homeDir, ".codex", "plugins", "cache")
+      path4.join(homeDir, ".codex", "skills"),
+      path4.join(homeDir, ".agents", "skills"),
+      path4.join(homeDir, ".codex", "plugins", "cache")
     ];
   }
-  return [path2.join(homeDir, ".config", "opencode", "skills")];
+  return [path4.join(homeDir, ".config", "opencode", "skills")];
 }
 function ancestorDirs(cwd) {
   const dirs = [];
-  let current = path2.resolve(cwd);
+  let current = path4.resolve(cwd);
   for (let depth = 0; depth < 16; depth++) {
     dirs.push(current);
-    const parent = path2.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current)
       break;
     current = parent;
@@ -2207,11 +2273,11 @@ function ancestorDirs(cwd) {
 function repoRoots(cwd, platform) {
   return ancestorDirs(cwd).flatMap((dir) => {
     if (platform === "claude-code")
-      return [path2.join(dir, ".claude", "skills")];
+      return [path4.join(dir, ".claude", "skills")];
     if (platform === "codex") {
-      return [path2.join(dir, ".codex", "skills"), path2.join(dir, ".agents", "skills")];
+      return [path4.join(dir, ".codex", "skills"), path4.join(dir, ".agents", "skills")];
     }
-    return [path2.join(dir, ".opencode", "skills")];
+    return [path4.join(dir, ".opencode", "skills")];
   });
 }
 function frontmatterName(content) {
@@ -2220,34 +2286,50 @@ function frontmatterName(content) {
   return name?.[1]?.trim() || "";
 }
 function readNativeSkillNames(params) {
-  const names = /* @__PURE__ */ new Set();
+  const names = /* @__PURE__ */ new Map();
+  let rootNames = /* @__PURE__ */ new Map();
+  const rank = { adapter: 0, external: 1, local: 2 };
+  const note = (name, kind) => {
+    const held = rootNames.get(name);
+    if (!held || rank[kind] > rank[held])
+      rootNames.set(name, kind);
+  };
   let visited = 0;
+  const readPackage = (dir, fileName, linked) => {
+    visited++;
+    let content = "";
+    try {
+      content = fs3.readFileSync(path4.join(dir, fileName), "utf8");
+    } catch {
+    }
+    const kind = linked || isSkillFolderOwnedElsewhere(dir) ? "external" : isGeneratedSkillAdapter(content) ? "adapter" : "local";
+    note(path4.basename(dir).toLowerCase(), kind);
+    const declared = frontmatterName(content);
+    if (declared)
+      note(declared.toLowerCase(), kind);
+  };
   const walk = (dir, depth) => {
     if (depth > MAX_SCAN_DEPTH || visited >= MAX_NATIVE_SKILL_FILES)
       return;
     let entries;
     try {
-      entries = fs2.readdirSync(dir, { withFileTypes: true });
+      entries = fs3.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
+    const skillMd = depth > 0 ? entries.find((entry) => entry.isFile() && entry.name.toLowerCase() === "skill.md") : void 0;
+    if (skillMd) {
+      readPackage(dir, skillMd.name, false);
+      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 child = path4.join(dir, entry.name);
+      if (entry.isDirectory())
+        walk(child, depth + 1);
+      else if (isLinkedSkillFolder(child) && fs3.existsSync(path4.join(child, "SKILL.md"))) {
+        readPackage(child, "SKILL.md", true);
       }
     }
   };
@@ -2255,16 +2337,42 @@ function readNativeSkillNames(params) {
     ...homeRoots(params.homeDir, params.platform),
     ...repoRoots(params.cwd, params.platform)
   ];
-  for (const root of roots)
+  for (const root of roots) {
+    rootNames = /* @__PURE__ */ new Map();
     walk(root, 0);
+    for (const [name, kind] of rootNames)
+      if (!names.has(name))
+        names.set(name, kind);
+  }
   return names;
 }
-function buildMirroredSkillActivation(entries, nativeNames) {
+function nativeAdapterGap(platform, mirrored, native) {
+  const missing = [];
+  const localCopies = [];
+  if (!platform)
+    return { missing, localCopies };
+  for (const { skillName, scope } of mirrored) {
+    if (!skillName || BUNDLED_SKILLS.includes(skillName))
+      continue;
+    const kind = native.get(skillName.toLowerCase());
+    if (!kind)
+      missing.push(skillName);
+    else if (kind === "local" && platform === "claude-code" && scope !== "project")
+      localCopies.push(skillName);
+  }
+  return { missing, localCopies };
+}
+function buildMirroredSkillActivation(entries, native, platform) {
   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 };
+  const skills = valid.filter((entry) => !native.has(entry.skillName.toLowerCase()));
+  return {
+    count: valid.length,
+    skills,
+    nativeCount: valid.length - skills.length,
+    ...nativeAdapterGap(platform, valid, native)
+  };
 }
 function nativeAdapterInstallCommand(platform, missingNames) {
   if (missingNames.length === 0)
@@ -2277,13 +2385,17 @@ function nativeAdapterInstallCommand(platform, missingNames) {
   }
   return null;
 }
+function localCopyCutoverCommand(platform, localCopies) {
+  return localCopies.length > 0 ? nativeAdapterInstallCommand(platform, ["<name>"]) : 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
+    triggerDescription: row.triggerDescription,
+    scope: typeof row.scope === "string" ? row.scope : void 0
   }));
-  return buildMirroredSkillActivation(entries, readNativeSkillNames(params));
+  return buildMirroredSkillActivation(entries, readNativeSkillNames(params), params.platform);
 }
 
 // src/commands/skill-mirror-reminder.ts
@@ -2297,16 +2409,25 @@ function renderEntry(skill) {
 function buildSkillMirrorAnnounce(m, platform) {
   if (!m || m.count <= 0)
     return null;
+  const cutoverCommand = localCopyCutoverCommand(platform || "", m.localCopies);
+  const copies = m.localCopies.length === 1 ? "one mirrored skill" : `${m.localCopies.length} mirrored skills`;
+  const copySection = cutoverCommand ? [
+    "### Hand-Kept Copies",
+    `This harness lists ${copies} from a hand-kept copy instead of an adapter, so it keeps running that copy when the mirrored skill changes: ${m.localCopies.join(", ")}. Replacing a copy with its adapter is the user's call, one skill at a time (the old SKILL.md is backed up first):`,
+    "",
+    `    ${cutoverCommand}`,
+    "",
+    "Offer that command when the user asks why a skill behaves out of date, or when you needed one of them this session.",
+    ""
+  ] : [];
   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 line = "[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.]";
+    return [line, "", ...copySection].join("\n").trimEnd();
   }
-  const installCommand = nativeAdapterInstallCommand(
-    platform || "",
-    m.skills.map((s) => s.skillName)
-  );
+  const installCommand = nativeAdapterInstallCommand(platform || "", m.missing);
   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:`,
+    `${m.missing.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}`,
     "",
@@ -2319,6 +2440,7 @@ function buildSkillMirrorAnnounce(m, platform) {
     "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,
+    ...copySection,
     "### 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.",
     "",
@@ -2412,7 +2534,10 @@ var loadoutRegistrarModule = {
 
 // src/commands/delivery-reminder.ts
 function coordinationLine(platform) {
-  const how = platform === "codex" ? "codex_app.list_threads + codex_app.send_message_to_thread" : platform === "claude-code" ? "this harness's own session-list + send tools (never a greprag id)" : platform === "opencode" ? "the GrepRAG registry" : "your harness's own peer tools";
+  if (platform === "claude-code") {
+    return "Send same-repo peers no delivery notice: Git is the coordination. Never poll, wait on, or ask peer sessions for status.";
+  }
+  const how = platform === "codex" ? "codex_app.list_threads + codex_app.send_message_to_thread" : platform === "opencode" ? "the GrepRAG registry" : "your harness's own peer tools";
   const never = platform === "codex" ? "never poll, call wait_threads, ask for status, or follow up" : "never poll, wait, ask for status, or follow up";
   return `Notify same-repo peer sessions ONCE via ${how}, then continue. A \`Chip: \` session is not a peer. Silence is approval: ${never}.`;
 }
@@ -2585,23 +2710,23 @@ function collectAnnounces(env, registry = REGISTRY) {
 }
 
 // src/app-settings.ts
-var fs4 = __toESM(require("node:fs"));
+var fs5 = __toESM(require("node:fs"));
 var os2 = __toESM(require("node:os"));
-var path4 = __toESM(require("node:path"));
+var path6 = __toESM(require("node:path"));
 
 // src/project-anchor.ts
-var path3 = __toESM(require("path"));
-var fs3 = __toESM(require("fs"));
-var crypto2 = __toESM(require("crypto"));
+var path5 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
+var crypto3 = __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);
+  return path5.join(dir, ANCHOR_DIR, ANCHOR_FILE);
 }
 function legacyAnchorPathIn(dir) {
-  return path3.join(dir, LEGACY_ANCHOR_DIR, ANCHOR_FILE);
+  return path5.join(dir, LEGACY_ANCHOR_DIR, ANCHOR_FILE);
 }
 function globalAnchorPath() {
   return anchorPathIn(os.homedir());
@@ -2612,22 +2737,22 @@ function legacyGlobalAnchorPath() {
 function findExistingAnchor(startDir) {
   const homeAnchor = globalAnchorPath();
   const legacyHomeAnchor = legacyGlobalAnchorPath();
-  let dir = path3.resolve(startDir);
+  let dir = path5.resolve(startDir);
   while (true) {
     const candidate = anchorPathIn(dir);
-    if (candidate !== homeAnchor && fs3.existsSync(candidate))
+    if (candidate !== homeAnchor && fs4.existsSync(candidate))
       return candidate;
     const legacyCandidate = legacyAnchorPathIn(dir);
-    if (legacyCandidate !== legacyHomeAnchor && fs3.existsSync(legacyCandidate))
+    if (legacyCandidate !== legacyHomeAnchor && fs4.existsSync(legacyCandidate))
       return legacyCandidate;
-    const parent = path3.dirname(dir);
+    const parent = path5.dirname(dir);
     if (parent === dir)
       return null;
     dir = parent;
   }
 }
 function isEphemeralCwd2(cwd) {
-  const norm = path3.resolve(cwd).replace(/\\/g, "/").toLowerCase();
+  const norm = path5.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/"))
@@ -2650,7 +2775,7 @@ function computeGitDerivedProjectId2(workingDir) {
     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");
+    const hash = crypto3.createHash("sha256").update(roots.join("\n")).digest("hex");
     return [
       hash.slice(0, 8),
       hash.slice(8, 12),
@@ -2665,8 +2790,8 @@ function computeGitDerivedProjectId2(workingDir) {
   }
 }
 function deterministicProjectId2(workingDir) {
-  const normalized = path3.resolve(workingDir).toLowerCase();
-  const hash = crypto2.createHash("sha256").update(normalized).digest("hex");
+  const normalized = path5.resolve(workingDir).toLowerCase();
+  const hash = crypto3.createHash("sha256").update(normalized).digest("hex");
   return [
     hash.slice(0, 8),
     hash.slice(8, 12),
@@ -2677,9 +2802,9 @@ function deterministicProjectId2(workingDir) {
     hash.slice(20, 32)
   ].join("-");
 }
-function tryReadAnchorFileContents(filePath) {
+function tryReadAnchorFileContents(filePath2) {
   try {
-    const raw = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+    const raw = JSON.parse(fs4.readFileSync(filePath2, "utf-8"));
     const notifyRaw = raw.inbox_notify;
     const inboxNotify = notifyRaw === "off" || notifyRaw === "session_start_only" ? notifyRaw : "every_turn";
     return {
@@ -2718,10 +2843,10 @@ function readAnchor2(cwd) {
   }
   const gitId = computeGitDerivedProjectId2(cwd);
   if (gitId) {
-    const root2 = path3.resolve(cwd);
+    const root2 = path5.resolve(cwd);
     return {
       projectId: gitId,
-      projectName: fileContents?.projectName || path3.basename(root2).toLowerCase(),
+      projectName: fileContents?.projectName || path5.basename(root2).toLowerCase(),
       initialized: true,
       source: "git",
       anchorPath: existingPath || anchorPathIn(root2),
@@ -2735,7 +2860,7 @@ function readAnchor2(cwd) {
     };
   }
   if (isEphemeralCwd2(cwd)) {
-    const globalPath = fs3.existsSync(globalAnchorPath()) ? globalAnchorPath() : legacyGlobalAnchorPath();
+    const globalPath = fs4.existsSync(globalAnchorPath()) ? globalAnchorPath() : legacyGlobalAnchorPath();
     const globalContents = tryReadAnchorFileContents(globalPath);
     if (globalContents && globalContents.projectId && globalContents.projectName) {
       return {
@@ -2754,10 +2879,10 @@ function readAnchor2(cwd) {
       };
     }
   }
-  const root = path3.resolve(cwd);
+  const root = path5.resolve(cwd);
   return {
     projectId: deterministicProjectId2(root),
-    projectName: fileContents?.projectName || path3.basename(root).toLowerCase(),
+    projectName: fileContents?.projectName || path5.basename(root).toLowerCase(),
     initialized: false,
     source: "hash",
     anchorPath: existingPath || anchorPathIn(root),
@@ -2774,14 +2899,14 @@ function readAnchor2(cwd) {
 // src/app-settings.ts
 function readJson(file) {
   try {
-    const parsed = JSON.parse(fs4.readFileSync(file, "utf8"));
+    const parsed = JSON.parse(fs5.readFileSync(file, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
   } catch {
     return {};
   }
 }
 function localAppSettingsPath(homeDir = os2.homedir()) {
-  return path4.join(homeDir, ".greprag", "settings.json");
+  return path6.join(homeDir, ".greprag", "settings.json");
 }
 function readLocalAppSettings(homeDir = os2.homedir()) {
   const raw = readJson(localAppSettingsPath(homeDir));
@@ -2838,8 +2963,8 @@ function getOpenCodeReminders(env) {
 }
 
 // src/procedure.ts
-var path6 = __toESM(require("path"));
-var fs6 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+var fs7 = __toESM(require("fs"));
 
 // src/delivery-lifecycle.ts
 var DELIVERY_LIFECYCLE_VERBS = [
@@ -2863,8 +2988,8 @@ function isDeliveryOwnedVerb(verb) {
 }
 
 // src/procedure-scope.ts
-var path5 = __toESM(require("path"));
-var fs5 = __toESM(require("fs"));
+var path7 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
 var CD_TARGET_RE = /(?:^|[\s;&|(])(?:cd|pushd|chdir|set-location)\s+(?:\/d\s+|-path\s+)?("[^"]*"|'[^']*'|[^\s;&|)]+)/gi;
 var GIT_C_TARGET_RE = /(?:^|[\s;&|(])git\s+-C\s+("[^"]*"|'[^']*'|[^\s;&|)]+)/gi;
 function unquote(arg) {
@@ -2924,32 +3049,32 @@ function foreignCheckoutTarget(proc, roots) {
   return null;
 }
 function findCheckoutRoot(startDir) {
-  let dir = path5.resolve(startDir);
+  let dir = path7.resolve(startDir);
   for (; ; ) {
     try {
-      if (fs5.existsSync(path5.join(dir, ".git")))
+      if (fs6.existsSync(path7.join(dir, ".git")))
         return dir;
     } catch {
     }
-    const parent = path5.dirname(dir);
+    const parent = path7.dirname(dir);
     if (parent === dir)
       return null;
     dir = parent;
   }
 }
 function mainCheckoutRoot(checkoutRoot) {
-  const dotGit = path5.join(checkoutRoot, ".git");
+  const dotGit = path7.join(checkoutRoot, ".git");
   try {
-    if (!fs5.statSync(dotGit).isFile())
+    if (!fs6.statSync(dotGit).isFile())
       return null;
-    const m = /^\s*gitdir:\s*(.+?)\s*$/m.exec(fs5.readFileSync(dotGit, "utf-8"));
+    const m = /^\s*gitdir:\s*(.+?)\s*$/m.exec(fs6.readFileSync(dotGit, "utf-8"));
     if (!m)
       return null;
-    const gitDir = path5.resolve(checkoutRoot, m[1]);
+    const gitDir = path7.resolve(checkoutRoot, m[1]);
     const marker = normalizeCheckoutPath(gitDir).indexOf("/worktrees/");
     if (marker < 0)
       return null;
-    return path5.dirname(gitDir.slice(0, marker));
+    return path7.dirname(gitDir.slice(0, marker));
   } catch {
     return null;
   }
@@ -2957,7 +3082,7 @@ function mainCheckoutRoot(checkoutRoot) {
 function projectCheckoutRoots(startDir) {
   const root = findCheckoutRoot(startDir);
   if (!root)
-    return startDir ? [path5.resolve(startDir)] : [];
+    return startDir ? [path7.resolve(startDir)] : [];
   const main = mainCheckoutRoot(root);
   return main && normalizeCheckoutPath(main) !== normalizeCheckoutPath(root) ? [root, main] : [root];
 }
@@ -2966,14 +3091,14 @@ function projectCheckoutRoots(startDir) {
 var PROCEDURE_STORE_VERSION = "2";
 function stateDir() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path6.join(home, ".greprag", "state");
+  return path8.join(home, ".greprag", "state");
 }
 function procedureStorePath(projectId) {
-  return path6.join(stateDir(), `procedures-${projectId}.json`);
+  return path8.join(stateDir(), `procedures-${projectId}.json`);
 }
 function readProcedureStore(projectId) {
   try {
-    const raw = fs6.readFileSync(procedureStorePath(projectId), "utf-8");
+    const raw = fs7.readFileSync(procedureStorePath(projectId), "utf-8");
     const parsed = JSON.parse(raw);
     if (parsed && Array.isArray(parsed.procedures)) {
       const projectDir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
@@ -3256,11 +3381,11 @@ function activeProcedureAnnounces(store) {
 }
 
 // src/procedure-runtime.ts
-var crypto4 = __toESM(require("crypto"));
+var crypto5 = __toESM(require("crypto"));
 
 // src/procedure-watch.ts
-var path7 = __toESM(require("path"));
-var fs7 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+var fs8 = __toESM(require("fs"));
 var TIER1_LEARN_TRIGGERS = LEARN_TRIGGER_VOCABULARY;
 function matchLearnTrigger(prompt) {
   return matchProcedure(prompt, {
@@ -3287,24 +3412,24 @@ function openWatch(verb, phase, openedAt, shadowRunId) {
 }
 function stateDir2() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path7.join(home, ".greprag", "state");
+  return path9.join(home, ".greprag", "state");
 }
 function procedureWatchPath(projectId) {
-  return path7.join(stateDir2(), `procedure-watch-${projectId}.json`);
+  return path9.join(stateDir2(), `procedure-watch-${projectId}.json`);
 }
 function hasProcedureWatch(projectId) {
   try {
-    return fs7.existsSync(procedureWatchPath(projectId));
+    return fs8.existsSync(procedureWatchPath(projectId));
   } catch {
     return false;
   }
 }
 function writeProcedureWatch(projectId, watch) {
   const file = procedureWatchPath(projectId);
-  const dir = path7.dirname(file);
-  if (!fs7.existsSync(dir))
-    fs7.mkdirSync(dir, { recursive: true });
-  fs7.writeFileSync(file, JSON.stringify(watch, null, 2) + "\n");
+  const dir = path9.dirname(file);
+  if (!fs8.existsSync(dir))
+    fs8.mkdirSync(dir, { recursive: true });
+  fs8.writeFileSync(file, JSON.stringify(watch, null, 2) + "\n");
 }
 function openWatchIfIdle(projectId, verb, phase, shadowRunId) {
   if (hasProcedureWatch(projectId))
@@ -3317,26 +3442,26 @@ function openWatchIfIdle(projectId, verb, phase, shadowRunId) {
 var PROCEDURE_SYSTEM_ENABLED = false;
 
 // src/procedure-shadow.ts
-var crypto3 = __toESM(require("crypto"));
-var fs8 = __toESM(require("fs"));
-var path8 = __toESM(require("path"));
+var crypto4 = __toESM(require("crypto"));
+var fs9 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 function stateDir3() {
   const home = process.env.HOME || process.env.USERPROFILE || "";
-  return path8.join(home, ".greprag", "state");
+  return path10.join(home, ".greprag", "state");
 }
 function procedureShadowPath(projectId) {
-  return path8.join(stateDir3(), `procedure-shadow-${projectId}.jsonl`);
+  return path10.join(stateDir3(), `procedure-shadow-${projectId}.jsonl`);
 }
 function appendShadowEvent(projectId, event) {
   try {
     const file = procedureShadowPath(projectId);
-    fs8.mkdirSync(path8.dirname(file), { recursive: true });
-    fs8.appendFileSync(file, JSON.stringify(event) + "\n");
+    fs9.mkdirSync(path10.dirname(file), { recursive: true });
+    fs9.appendFileSync(file, JSON.stringify(event) + "\n");
   } catch {
   }
 }
 function createProcedureShadowRunId() {
-  return crypto3.randomUUID();
+  return crypto4.randomUUID();
 }
 function procedureFingerprint(proc) {
   const payload = JSON.stringify({
@@ -3348,7 +3473,7 @@ function procedureFingerprint(proc) {
     endpoint: proc.endpoint,
     definitionVersion: proc.definitionVersion ?? 1
   });
-  return crypto3.createHash("sha256").update(payload).digest("hex");
+  return crypto4.createHash("sha256").update(payload).digest("hex");
 }
 function recordProcedureShadowTrigger(params) {
   appendShadowEvent(params.projectId, {
@@ -3400,7 +3525,7 @@ function extractLatestOpenCodeProcedurePrompt(messages) {
   }
   if (!latest)
     return null;
-  const digest = crypto4.createHash("sha256").update(latest.prompt).digest("hex");
+  const digest = crypto5.createHash("sha256").update(latest.prompt).digest("hex");
   return { ...latest, key: `${userCount}:${digest}` };
 }
 function procedureRuntimeState(configuredState, proc) {
@@ -4052,15 +4177,805 @@ function recodeMessagesToPng(messages, opts) {
   return stats;
 }
 
+// src/claude-lifecycle-cutover.ts
+var fs11 = __toESM(require("fs"));
+var os4 = __toESM(require("os"));
+var path12 = __toESM(require("path"));
+
+// src/native-skill-mirror.ts
+var fs10 = __toESM(require("node:fs"));
+var os3 = __toESM(require("node:os"));
+var path11 = __toESM(require("node:path"));
+var SKILL_NAME_RE = /^[A-Za-z0-9._-]{1,64}$/;
+var NATIVE_SKILL_NAME_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+var PROJECT_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var NATIVE_DESCRIPTION_MAX_CHARS = 2500;
+var STATE_FILE = ".greprag-mirror.json";
+function nativeSkillMirrorEnabled(platform) {
+  return platform !== "claude-code";
+}
+function nativeSkillRoot(platform, homeDir = os3.homedir()) {
+  if (platform === "claude-code")
+    return path11.join(homeDir, ".claude", "skills");
+  if (platform === "codex")
+    return path11.join(homeDir, ".codex", "skills");
+  return path11.join(homeDir, ".config", "opencode", "skills");
+}
+function nativeProjectSkillRoot(platform, projectDir) {
+  if (platform === "claude-code")
+    return path11.join(projectDir, ".claude", "skills");
+  if (platform === "codex")
+    return path11.join(projectDir, ".agents", "skills");
+  return path11.join(projectDir, ".opencode", "skills");
+}
+function writerOwnedProjectSkillRoot(platform, projectDir, homeDir = os3.homedir()) {
+  if (path11.resolve(projectDir).toLowerCase() === path11.resolve(homeDir).toLowerCase())
+    return null;
+  return nativeProjectSkillRoot(platform, projectDir);
+}
+function skillScope(skill) {
+  return skill.scope === "project" ? "project" : "global";
+}
+function canonicalSkillId(skill) {
+  if (skill.skillId)
+    return skill.skillId;
+  const scope = skillScope(skill);
+  if (scope === "global")
+    return `global:${skill.skillName}`;
+  if (!skill.projectId || !PROJECT_ID_RE.test(skill.projectId)) {
+    throw new Error(`projectId required for project skill "${skill.skillName}"`);
+  }
+  return `project:${skill.projectId}:${skill.skillName}`;
+}
+function replacesGlobal(project, global) {
+  const replaces = project.replaces || [];
+  const globalId = canonicalSkillId(global);
+  return replaces.some((value) => value === globalId || value === `global:${global.skillName}` || value === global.skillName || value === "global" && project.skillName === global.skillName);
+}
+function assertNoNativeSkillCollision(skills) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const skill of skills) {
+    const key = skill.skillName.toLowerCase();
+    byName.set(key, [...byName.get(key) || [], skill]);
+  }
+  for (const group of byName.values()) {
+    const global = group.find((skill) => skillScope(skill) === "global");
+    if (!global)
+      continue;
+    for (const project of group.filter((skill) => skillScope(skill) === "project")) {
+      if (!replacesGlobal(project, global)) {
+        throw new Error(
+          `project skill "${project.skillName}" collides with global "${canonicalSkillId(global)}"; add replaces metadata`
+        );
+      }
+    }
+  }
+}
+function rootForSkill(platform, skill, homeDir, projectDir) {
+  if (skillScope(skill) === "global")
+    return nativeSkillRoot(platform, homeDir);
+  if (!projectDir)
+    return null;
+  return writerOwnedProjectSkillRoot(platform, projectDir, homeDir);
+}
+function emptyState() {
+  return { version: 1, skills: {} };
+}
+function readState(root) {
+  try {
+    const parsed = JSON.parse(fs10.readFileSync(path11.join(root, STATE_FILE), "utf8"));
+    if (parsed?.version === 1 && parsed.skills && typeof parsed.skills === "object")
+      return parsed;
+  } catch {
+  }
+  return emptyState();
+}
+function writeState(root, state) {
+  fs10.mkdirSync(root, { recursive: true });
+  fs10.writeFileSync(path11.join(root, STATE_FILE), JSON.stringify(state, null, 2) + "\n", "utf8");
+}
+function targetPath(root, skillName) {
+  const target = path11.resolve(root, skillName);
+  const prefix = path11.resolve(root) + path11.sep;
+  if (!target.startsWith(prefix))
+    throw new Error("skill target escapes native root");
+  return target;
+}
+function filePath(target, relative) {
+  const resolved = path11.resolve(target, ...relative.split("/"));
+  const prefix = path11.resolve(target) + path11.sep;
+  if (!resolved.startsWith(prefix))
+    throw new Error("skill file escapes target directory");
+  return resolved;
+}
+function readManagedFiles(target, managed) {
+  try {
+    return managed.files.map((relative) => ({
+      path: relative,
+      content: fs10.readFileSync(filePath(target, relative), "utf8")
+    }));
+  } catch {
+    return null;
+  }
+}
+function managedTargetExists(target) {
+  try {
+    fs10.statSync(target);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function unquote2(value) {
+  const v = value.trim();
+  if (v.length >= 2 && (v.startsWith('"') && v.endsWith('"') || v.startsWith("'") && v.endsWith("'")))
+    return v.slice(1, -1);
+  return v;
+}
+function parseDescriptionFromSkillMd(skillMd) {
+  const text = (skillMd || "").replace(/\r\n?/g, "\n");
+  const match = /^---\n([\s\S]*?)\n---(?:\n|$)/.exec(text);
+  const body = match ? text.slice(match[0].length) : text;
+  if (match) {
+    const lines = match[1].split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const key = /^(\s*)description:\s*(.*)$/.exec(lines[i]);
+      if (!key)
+        continue;
+      const scalar = key[2].trim();
+      if (!/^[>|][+-]?$/.test(scalar))
+        return unquote2(scalar).trim();
+      const keyIndent = key[1].length;
+      const block = [];
+      for (let j = i + 1; j < lines.length; j++) {
+        const line = lines[j];
+        const indent = /^\s*/.exec(line)?.[0].length ?? 0;
+        if (line.trim() && indent <= keyIndent)
+          break;
+        block.push(line);
+      }
+      const nonEmpty = block.filter((line) => line.trim());
+      const blockIndent = nonEmpty.length ? Math.min(...nonEmpty.map((line) => /^\s*/.exec(line)?.[0].length ?? 0)) : 0;
+      const dedented = block.map((line) => line.trim() ? line.slice(blockIndent).trimEnd() : "");
+      const description = scalar.startsWith(">") ? dedented.join("\n").split(/\n{2,}/).map((p) => p.replace(/\n/g, " ").trim()).join("\n\n") : dedented.join("\n").trim();
+      return description.trim();
+    }
+  }
+  const lead = body.split("\n").map((line) => line.trim()).find((line) => line && !line.startsWith("#") && !line.startsWith("```") && !line.startsWith("<!--")) || "";
+  return lead.trim();
+}
+function adapterDescription(skill) {
+  const direct = (skill.triggerDescription || skill.description || "").replace(/\r\n?/g, "\n").trim();
+  if (direct)
+    return boundedNativeDescription(skill.skillName, direct);
+  const skillMd = skill.files.find((file) => file.path === "SKILL.md")?.content || "";
+  return boundedNativeDescription(skill.skillName, parseDescriptionFromSkillMd(skillMd));
+}
+function collapseWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function trimWithMarker(value, max) {
+  const text = collapseWhitespace(value);
+  if (text.length <= max)
+    return text;
+  if (max <= 15)
+    return text.slice(0, Math.max(0, max)).trimEnd();
+  const head = text.slice(0, max - 3);
+  const boundary = Math.max(head.lastIndexOf(". "), head.lastIndexOf("; "), head.lastIndexOf(", "), head.lastIndexOf(" "));
+  return `${head.slice(0, boundary > 80 ? boundary : head.length).trimEnd()}...`;
+}
+function sectionFrom(value, label) {
+  const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const match = new RegExp(`${escaped}:?\\s*([\\s\\S]*)`, "i").exec(value);
+  if (!match)
+    return "";
+  return match[1].split(/\n\s*\n(?:NOT for|Requires|Built on|Does NOT|REQUIRES)\b/i)[0].trim();
+}
+function beforeSection(value, label) {
+  const index = value.toLowerCase().indexOf(label.toLowerCase());
+  return index >= 0 ? value.slice(0, index).trim() : value.trim();
+}
+function boundedNativeDescription(skillName, raw) {
+  const normalized = raw.replace(/\r\n?/g, "\n").trim();
+  if (!normalized || normalized.length <= NATIVE_DESCRIPTION_MAX_CHARS)
+    return normalized;
+  const prefix = `Condensed native trigger for ${skillName}; full description: greprag load ${skillName}.`;
+  const useWhen = sectionFrom(normalized, "Use when");
+  const notFor = sectionFrom(normalized, "NOT for");
+  const purposeSource = beforeSection(normalized, "Use when");
+  const fixedParts = [prefix];
+  const tailParts = [];
+  if (useWhen)
+    tailParts.push(["Use when", useWhen]);
+  if (notFor)
+    tailParts.push(["NOT for", notFor]);
+  const fixedLength = fixedParts.join("\n\n").length + tailParts.reduce((sum, [label, body]) => sum + `
+
+${label}: ${collapseWhitespace(body)}`.length, 0);
+  const purposeBudget = Math.max(160, NATIVE_DESCRIPTION_MAX_CHARS - fixedLength - 12);
+  const parts = [
+    ...fixedParts,
+    `Purpose: ${trimWithMarker(purposeSource, purposeBudget)}`,
+    ...tailParts.map(([label, body]) => `${label}: ${collapseWhitespace(body)}`)
+  ];
+  let rendered = parts.filter(Boolean).join("\n\n");
+  if (rendered.length <= NATIVE_DESCRIPTION_MAX_CHARS)
+    return rendered;
+  const prefixAndUse = [prefix];
+  const useBudget = NATIVE_DESCRIPTION_MAX_CHARS - prefix.length - 14;
+  if (useWhen)
+    prefixAndUse.push(`Use when: ${trimWithMarker(useWhen, useBudget)}`);
+  else
+    prefixAndUse.push(`Purpose: ${trimWithMarker(normalized, useBudget)}`);
+  rendered = prefixAndUse.join("\n\n");
+  return rendered.length <= NATIVE_DESCRIPTION_MAX_CHARS ? rendered : trimWithMarker(rendered, NATIVE_DESCRIPTION_MAX_CHARS);
+}
+function yamlLiteral(value) {
+  return value.replace(/\r\n?/g, "\n").split("\n").map((line) => `  ${line}`).join("\n");
+}
+function sourceBindingState(skill) {
+  const skillMd = skill.files.find((file) => file.path === "SKILL.md")?.content || "";
+  return /<!--\s*greprag-source-bindings\b/.test(skillMd) ? "bound" : "none";
+}
+function canonicalContentHash(skill) {
+  return skill.contentHash || computeSkillFileHash(skill.files);
+}
+function canonicalLookupArgs(skill) {
+  return `--skill-id ${canonicalSkillId(skill)}`;
+}
+function canonicalWriteArgs(skill) {
+  if (skill.scope !== "project" || !skill.projectId)
+    return "";
+  const replaces = (skill.replaces || []).map((id) => ` --replaces ${id}`).join("");
+  return `--scope project --project-id ${skill.projectId}${replaces}`;
+}
+function canonicalEditArgs(skill) {
+  return [canonicalLookupArgs(skill), canonicalWriteArgs(skill)].filter(Boolean).join(" ");
+}
+function nativeCreationLocations(platform) {
+  if (platform === "codex") {
+    return "`~/.codex/skills/<new-name>/SKILL.md` (global) or `<repo>/.agents/skills/<new-name>/SKILL.md` (project)";
+  }
+  if (platform === "opencode") {
+    return "`~/.config/opencode/skills/<new-name>/SKILL.md` (global) or `<repo>/.opencode/skills/<new-name>/SKILL.md` (project)";
+  }
+  return "`~/.claude/skills/<new-name>/SKILL.md` (global) or `<repo>/.claude/skills/<new-name>/SKILL.md` (project)";
+}
+function renderChangeSkillLine(params) {
+  const exportCommand = `greprag skill mirror export ${params.skillName} ${params.identityArg} --to <dir>`;
+  const applyCommand = `greprag skill mirror apply <dir> --skill ${params.skillName} ${params.editArgs} --expected-hash <exported-hash>`;
+  if (params.platform === "codex") {
+    return `- **Change this skill:** run \`greprag load skill-change\`, then \`${exportCommand}\`; patch the exported Markdown files non-interactively; run \`${applyCommand}\`; then \`${params.syncCommand}\`; then verify with \`${params.loadCommand}\`.`;
+  }
+  return `- **Change this skill:** run \`greprag load skill-change\`, then \`greprag skill edit ${params.skillName} ${params.editArgs}\`, then \`${params.syncCommand}\`, then verify with \`${params.loadCommand}\`.`;
+}
+function renderEditingSection(platform, params) {
+  const exportCommand = `greprag skill mirror export ${params.skillName} ${params.identityArg} --to <dir>`;
+  const applyCommand = `greprag skill mirror apply <dir> --skill ${params.skillName} ${params.editArgs} --expected-hash <exported-hash>`;
+  if (platform === "codex") {
+    return `## Editing
+
+Codex agents must use the non-interactive mirror path:
+
+\`\`\`bash
+${exportCommand}
+# patch the exported Markdown files with normal file edits
+${applyCommand}
+\`\`\`
+
+Do not launch an interactive editor from Codex. If using \`greprag skill edit\` as an export helper, include \`--no-open\` and run the printed apply command after patching.
+`;
+  }
+  return `## Editing
+
+To edit this skill, run the guarded editor flow:
+
+\`\`\`bash
+greprag skill edit ${params.skillName} ${params.editArgs}
+\`\`\`
+
+Manual path:
+
+\`\`\`bash
+${exportCommand}
+${applyCommand}
+\`\`\`
+`;
+}
+function renderAdapterBody(platform, skill) {
+  const skillName = skill.skillName;
+  const skillId = canonicalSkillId(skill);
+  const identityArg = canonicalLookupArgs(skill);
+  const editArgs = canonicalEditArgs(skill);
+  const creationLocations = nativeCreationLocations(platform);
+  const syncCommand = nativeAdapterInstallCommand(platform, [skillName]);
+  const creationLine = platform === "claude-code" ? "- **Create another skill:** use the normal native creation path and leave it unmanaged until a separate Claude cutover is approved." : `- **Create another skill:** create a normal native skill at ${creationLocations}; run \`${syncCommand} --dry-run\` and confirm it says \`adopt\`; then run \`${syncCommand}\`. GrepRAG adopts it as canon and replaces the native package with an adapter.`;
+  const companions = skill.files.map((file) => file.path).filter((relative) => relative !== "SKILL.md").sort();
+  const harnessArg = `--harness ${platform}`;
+  const loadCommand = `greprag load ${skillName} ${identityArg} ${harnessArg}`;
+  const changeSkillLine = renderChangeSkillLine({
+    platform,
+    skillName,
+    editArgs,
+    identityArg,
+    syncCommand,
+    loadCommand
+  });
+  const editingSection = renderEditingSection(platform, { skillName, editArgs, identityArg });
+  const companionLines = companions.length ? companions.map((relative) => `- \`greprag load ${skillName} ${relative} ${identityArg} ${harnessArg}\``).join("\n") : "- No companion docs are mirrored into this native adapter.";
+  return `# ${skillName}
+
+## GENERATED ADAPTER \u2014 NEVER EDIT
+
+This is a disposable GrepRAG launcher for ${platform}, not canonical skill content. Never edit or copy this adapter, and never use \`greprag skill install\` to create or change a mirrored skill.
+
+Do not add or maintain project-state/doc pointers here. Current project state belongs in repo docs and the GrepRAG doc mirror; \`greprag load ${skillName} ${identityArg} ${harnessArg}\` discovers relevant state docs dynamically.
+
+Required action chains:
+
+- **Use this skill:** run \`${loadCommand}\` before acting.
+${changeSkillLine}
+${creationLine}
+
+Authority: ${skillId}
+Source binding: ${sourceBindingState(skill)}
+Canonical content hash: ${canonicalContentHash(skill)}
+${typeof skill.revision === "number" ? `Mirror revision: ${skill.revision}` : "Mirror revision: unknown"}
+
+${editingSection}
+
+Snapshot rollback:
+
+\`\`\`bash
+greprag skill mirror snapshot list ${skillName} ${identityArg}
+greprag skill mirror snapshot promote ${skillName} --name <snapshot> ${editArgs} --expected-hash <current-hash>
+\`\`\`
+
+## Mandatory Invocation
+
+When this skill activates, run:
+
+\`\`\`bash
+greprag load ${skillName} ${identityArg} ${harnessArg}
+\`\`\`
+
+Read and follow that canonical payload before responding or taking action.
+
+## Companion Docs
+
+${companionLines}
+`;
+}
+function renderNativeSkillAdapter(platform, skill, stamps) {
+  if (!NATIVE_SKILL_NAME_RE.test(skill.skillName))
+    return null;
+  if (!skill.files.some((file) => file.path === "SKILL.md") || !skill.files.every(isSafeMirroredSkillFile))
+    return null;
+  const description = adapterDescription(skill);
+  if (!description || description.length > NATIVE_DESCRIPTION_MAX_CHARS)
+    return null;
+  const skillId = canonicalSkillId(skill);
+  const scope = skillScope(skill);
+  const extraFrontmatter = [
+    `greprag_skill_id: ${skillId}`,
+    `greprag_scope: ${scope}`,
+    `greprag_source_binding: ${sourceBindingState(skill)}`,
+    `greprag_content_hash: ${canonicalContentHash(skill)}`,
+    ...typeof skill.revision === "number" ? [`greprag_revision: ${skill.revision}`] : [],
+    ...scope === "project" && skill.projectId ? [`greprag_project_id: ${skill.projectId}`] : [],
+    ...skill.replaces?.length ? [`replaces: ${skill.replaces.join(", ")}`] : [],
+    ...stamps
+  ].join("\n");
+  return `---
+name: ${skill.skillName}
+description: |-
+${yamlLiteral(description)}
+${extraFrontmatter}
+---
+
+${renderAdapterBody(platform, skill)}`;
+}
+var PROBE_PROJECT_ID = "00000000-0000-4000-8000-000000000000";
+var ADAPTER_FORMAT_PROBES = [
+  {
+    skillName: "format-probe",
+    skillId: "global:format-probe",
+    contentHash: "0".repeat(64),
+    revision: 1,
+    triggerDescription: "Format probe.",
+    files: [{ path: "SKILL.md", content: "# Format probe\n" }, { path: "docs/probe.md", content: "" }]
+  },
+  {
+    skillName: "format-probe",
+    skillId: `project:${PROBE_PROJECT_ID}:format-probe`,
+    scope: "project",
+    projectId: PROBE_PROJECT_ID,
+    replaces: ["global:format-probe"],
+    triggerDescription: "Format probe.",
+    files: [{ path: "SKILL.md", content: "<!-- greprag-source-bindings -->\n" }]
+  }
+];
+var adapterFormats = /* @__PURE__ */ new Map();
+function nativeAdapterFormat(platform) {
+  let format = adapterFormats.get(platform);
+  if (!format) {
+    format = computeSkillFileHash(ADAPTER_FORMAT_PROBES.map((probe, index) => ({
+      path: String(index),
+      content: renderNativeSkillAdapter(platform, probe, []) || ""
+    }))).slice(0, 12);
+    adapterFormats.set(platform, format);
+  }
+  return format;
+}
+function buildNativeSkillAdapter(platform, skill, options = {}) {
+  if (!nativeSkillMirrorEnabled(platform) && !(platform === "claude-code" && options.allowClaudeCode))
+    return null;
+  const content = renderNativeSkillAdapter(platform, skill, [
+    `greprag_adapter_format: ${nativeAdapterFormat(platform)}`
+  ]);
+  return content === null ? null : [{ path: "SKILL.md", content }];
+}
+function removeTrackedFiles(target, relativeFiles) {
+  const directories = /* @__PURE__ */ new Set();
+  for (const relative of relativeFiles) {
+    const file = filePath(target, relative);
+    try {
+      fs10.unlinkSync(file);
+    } catch {
+    }
+    let dir = path11.dirname(file);
+    while (dir.startsWith(path11.resolve(target) + path11.sep)) {
+      directories.add(dir);
+      dir = path11.dirname(dir);
+    }
+  }
+  for (const dir of [...directories].sort((a, b) => b.length - a.length)) {
+    try {
+      fs10.rmdirSync(dir);
+    } catch {
+    }
+  }
+  try {
+    fs10.rmdirSync(target);
+  } catch {
+  }
+}
+function applyNativeSkillMirror(params) {
+  if (!nativeSkillMirrorEnabled(params.platform)) {
+    return {
+      installed: 0,
+      updated: 0,
+      current: 0,
+      removed: 0,
+      skipped: params.skills.length,
+      blocked: 0
+    };
+  }
+  assertNoNativeSkillCollision(params.skills);
+  const homeDir = params.homeDir || os3.homedir();
+  const projectDir = params.projectDir ? path11.resolve(params.projectDir) : void 0;
+  const result = {
+    installed: 0,
+    updated: 0,
+    current: 0,
+    removed: 0,
+    skipped: 0,
+    blocked: 0
+  };
+  const roots = /* @__PURE__ */ new Map();
+  const rootState = (root) => {
+    let state = roots.get(root);
+    if (!state) {
+      state = { state: readState(root), present: /* @__PURE__ */ new Set(), touched: false };
+      roots.set(root, state);
+    }
+    return state;
+  };
+  for (const skill of params.skills) {
+    if (!SKILL_NAME_RE.test(skill.skillName)) {
+      result.skipped++;
+      continue;
+    }
+    const root = rootForSkill(params.platform, skill, homeDir, projectDir);
+    if (!root) {
+      result.skipped++;
+      continue;
+    }
+    const rootEntry = rootState(root);
+    if (params.platform === "codex" && skillScope(skill) === "global" && skill.skillName === "greprag") {
+      if (rootEntry.state.skills[skill.skillName]) {
+        delete rootEntry.state.skills[skill.skillName];
+        rootEntry.touched = true;
+      }
+      continue;
+    }
+    rootEntry.present.add(skill.skillName);
+    const adapterFiles = buildNativeSkillAdapter(params.platform, skill);
+    if (!adapterFiles) {
+      result.skipped++;
+      continue;
+    }
+    const target = targetPath(root, skill.skillName);
+    const managed = rootEntry.state.skills[skill.skillName];
+    if (isSkillFolderOwnedElsewhere(target)) {
+      if (managed)
+        result.blocked++;
+      else
+        result.skipped++;
+      continue;
+    }
+    if (fs10.existsSync(target) && !managed) {
+      result.skipped++;
+      continue;
+    }
+    const nextHash = computeSkillFileHash(adapterFiles);
+    if (managed) {
+      const targetExists = managedTargetExists(target);
+      const currentFiles = targetExists ? readManagedFiles(target, managed) : null;
+      if (targetExists && (!currentFiles || computeSkillFileHash(currentFiles) !== managed.hash)) {
+        result.blocked++;
+        continue;
+      }
+      if (targetExists && managed.hash === nextHash) {
+        result.current++;
+        continue;
+      }
+    }
+    fs10.mkdirSync(target, { recursive: true });
+    for (const file of adapterFiles) {
+      const destination = filePath(target, file.path);
+      fs10.mkdirSync(path11.dirname(destination), { recursive: true });
+      fs10.writeFileSync(destination, file.content, "utf8");
+    }
+    if (managed) {
+      const nextPaths = new Set(adapterFiles.map((file) => file.path));
+      removeTrackedFiles(target, managed.files.filter((relative) => !nextPaths.has(relative)));
+      result.updated++;
+    } else {
+      result.installed++;
+    }
+    rootEntry.state.skills[skill.skillName] = {
+      hash: nextHash,
+      files: adapterFiles.map((file) => file.path).sort()
+    };
+    rootEntry.touched = true;
+  }
+  if (params.prune) {
+    const globalRoot = nativeSkillRoot(params.platform, homeDir);
+    if (params.pruneGlobalRoot !== false)
+      rootState(globalRoot);
+    const projectRoot = projectDir ? writerOwnedProjectSkillRoot(params.platform, projectDir, homeDir) : null;
+    if (projectRoot)
+      rootState(projectRoot);
+    for (const [root, entry] of roots) {
+      if (params.pruneGlobalRoot === false && root === globalRoot)
+        continue;
+      for (const [skillName, managed] of Object.entries(entry.state.skills)) {
+        if (entry.present.has(skillName))
+          continue;
+        const target = targetPath(root, skillName);
+        const currentFiles = isSkillFolderOwnedElsewhere(target) ? null : readManagedFiles(target, managed);
+        if (!currentFiles || computeSkillFileHash(currentFiles) !== managed.hash) {
+          result.blocked++;
+          continue;
+        }
+        removeTrackedFiles(target, managed.files);
+        delete entry.state.skills[skillName];
+        entry.touched = true;
+        result.removed++;
+      }
+    }
+  }
+  for (const [root, entry] of roots) {
+    if (entry.touched || fs10.existsSync(path11.join(root, STATE_FILE)))
+      writeState(root, entry.state);
+  }
+  return result;
+}
+async function fetchNativeMirroredSkill(apiUrl, apiKey, row) {
+  const skillQs = new URLSearchParams();
+  if (row.skillId)
+    skillQs.set("skillId", row.skillId);
+  else if (row.scope) {
+    skillQs.set("scope", row.scope);
+    if (row.projectId)
+      skillQs.set("projectId", row.projectId);
+  }
+  const response = await fetch(
+    `${apiUrl}/v1/skillmirror/${encodeURIComponent(row.skillName)}${skillQs.size ? `?${skillQs.toString()}` : ""}`,
+    { headers: { Authorization: `Bearer ${apiKey}` } }
+  );
+  if (!response.ok)
+    return null;
+  const body = await response.json();
+  return Array.isArray(body.files) ? {
+    skillName: row.skillName,
+    skillId: typeof row.skillId === "string" ? row.skillId : void 0,
+    scope: row.scope === "project" ? "project" : "global",
+    projectId: typeof row.projectId === "string" ? row.projectId : void 0,
+    projectName: typeof row.projectName === "string" ? row.projectName : void 0,
+    replaces: Array.isArray(row.replaces) ? row.replaces : [],
+    contentHash: typeof body.contentHash === "string" ? body.contentHash : typeof row.contentHash === "string" ? row.contentHash : void 0,
+    revision: typeof body.revision === "number" ? body.revision : typeof row.revision === "number" ? row.revision : void 0,
+    files: body.files,
+    description: typeof row.description === "string" ? row.description : void 0,
+    triggerDescription: typeof row.triggerDescription === "string" ? row.triggerDescription : void 0
+  } : null;
+}
+
+// src/claude-lifecycle-cutover.ts
+var CLAUDE_LIFECYCLE_SKILLS = ["commit", "deploy", "release"];
+function adapterFor(skill) {
+  const files = buildNativeSkillAdapter("claude-code", skill, { allowClaudeCode: true });
+  if (!files || files.length !== 1 || files[0].path !== "SKILL.md") {
+    throw new Error(`Claude lifecycle adapter is invalid for ${skill.skillName}.`);
+  }
+  return files;
+}
+function safeTimestamp(now) {
+  return now.toISOString().replace(/[:.]/g, "-");
+}
+function requiredSkills(skills, names) {
+  const byName = new Map(skills.filter((skill) => skill.scope !== "project").map((skill) => [skill.skillName, skill]));
+  return names.map((name) => {
+    const skill = byName.get(name);
+    if (!skill)
+      throw new Error(`Canonical Claude lifecycle skill missing: ${name}.`);
+    return skill;
+  });
+}
+function applyClaudeLifecycleCutover(params) {
+  const homeDir = params.homeDir || os4.homedir();
+  const root = nativeSkillRoot("claude-code", homeDir);
+  const state = readState(root);
+  const names = params.names?.length ? params.names : CLAUDE_LIFECYCLE_SKILLS;
+  const prepared = requiredSkills(params.skills, names).map((skill) => {
+    const target = path12.join(root, skill.skillName);
+    if (isSkillFolderOwnedElsewhere(target)) {
+      throw new Error(`Claude skill folder is owned elsewhere (a link or another installer's package): ${skill.skillName}; not written.`);
+    }
+    const skillMd = path12.join(target, "SKILL.md");
+    const adapterFiles = adapterFor(skill);
+    const nextHash = computeSkillFileHash(adapterFiles);
+    const managed = state.skills[skill.skillName];
+    let currentContent;
+    if (fs11.existsSync(skillMd))
+      currentContent = fs11.readFileSync(skillMd, "utf8");
+    if (managed) {
+      const currentFiles = currentContent === void 0 ? null : [{ path: "SKILL.md", content: currentContent }];
+      if (!currentFiles || computeSkillFileHash(currentFiles) !== managed.hash) {
+        throw new Error(`Claude lifecycle adapter diverged: ${skill.skillName}.`);
+      }
+    } else if (fs11.existsSync(target) && currentContent === void 0) {
+      throw new Error(`Claude lifecycle package has no SKILL.md: ${skill.skillName}.`);
+    }
+    return { skill, target, skillMd, adapterFiles, nextHash, managed, currentContent };
+  });
+  const replacements = prepared.filter((item) => !item.managed && item.currentContent !== void 0);
+  let backupDir;
+  if (replacements.length > 0) {
+    backupDir = path12.join(
+      homeDir,
+      ".greprag",
+      "backups",
+      "claude-lifecycle-cutover",
+      safeTimestamp(params.now || /* @__PURE__ */ new Date())
+    );
+    for (const item of replacements) {
+      const destination = path12.join(backupDir, item.skill.skillName, "SKILL.md");
+      fs11.mkdirSync(path12.dirname(destination), { recursive: true });
+      fs11.writeFileSync(destination, item.currentContent, "utf8");
+    }
+  }
+  const result = {
+    installed: 0,
+    updated: 0,
+    current: 0,
+    blocked: 0,
+    backupDir
+  };
+  for (const item of prepared) {
+    if (item.managed && item.managed.hash === item.nextHash) {
+      result.current++;
+      continue;
+    }
+    fs11.mkdirSync(item.target, { recursive: true });
+    fs11.writeFileSync(item.skillMd, item.adapterFiles[0].content, "utf8");
+    state.skills[item.skill.skillName] = { hash: item.nextHash, files: ["SKILL.md"] };
+    if (item.managed)
+      result.updated++;
+    else
+      result.installed++;
+  }
+  writeState(root, state);
+  return result;
+}
+
+// src/native-adapter-refresh.ts
+function readAdapterStamps(content) {
+  const frontmatter = /^---\n([\s\S]*?)\n---/.exec(content.replace(/\r\n?/g, "\n"))?.[1] || "";
+  const field = (key) => new RegExp(`^${key}:[ \\t]*(\\S+)`, "m").exec(frontmatter)?.[1];
+  const revision = field("greprag_revision");
+  return {
+    skillId: field("greprag_skill_id"),
+    contentHash: field("greprag_content_hash"),
+    revision: revision === void 0 ? void 0 : Number(revision),
+    format: field("greprag_adapter_format")
+  };
+}
+function staleNativeAdapters(params) {
+  const globalRoot = nativeSkillRoot(params.platform, params.homeDir);
+  const roots = [globalRoot];
+  const projectRoot = params.projectDir && params.platform !== "claude-code" ? writerOwnedProjectSkillRoot(params.platform, params.projectDir, params.homeDir) : null;
+  if (projectRoot)
+    roots.push(projectRoot);
+  const byId = /* @__PURE__ */ new Map();
+  for (const row of params.rows) {
+    if (typeof row.skillName === "string" && typeof row.skillId === "string") {
+      byId.set(row.skillId, row);
+    }
+  }
+  const format = nativeAdapterFormat(params.platform);
+  const stale = [];
+  for (const root of roots) {
+    for (const [skillName, managed] of Object.entries(readState(root).skills)) {
+      let files;
+      try {
+        files = readManagedFiles(targetPath(root, skillName), managed);
+      } catch {
+        continue;
+      }
+      if (!files?.length || computeSkillFileHash(files) !== managed.hash)
+        continue;
+      const stamps = readAdapterStamps(files.find((file) => file.path === "SKILL.md")?.content || "");
+      const row = byId.get(stamps.skillId || (root === globalRoot ? `global:${skillName}` : ""));
+      if (!row || row.skillName !== skillName)
+        continue;
+      const canonMoved = row.contentHash ? row.contentHash !== stamps.contentHash : typeof row.revision === "number" && row.revision !== stamps.revision;
+      if (canonMoved || stamps.format !== format)
+        stale.push({ root, row });
+    }
+  }
+  return stale;
+}
+async function refreshNativeAdapters(params) {
+  const platform = params.platform;
+  if (platform !== "claude-code" && platform !== "codex" && platform !== "opencode") {
+    return { refreshed: 0, blocked: 0 };
+  }
+  const stale = staleNativeAdapters({ ...params, platform });
+  const skills = await Promise.all(stale.map(({ row }) => fetchNativeMirroredSkill(params.apiUrl, params.apiKey, row).catch(() => null)));
+  let refreshed = 0;
+  let blocked = 0;
+  for (const skill of skills) {
+    if (!skill)
+      continue;
+    try {
+      const result = platform === "claude-code" ? applyClaudeLifecycleCutover({ skills: [skill], names: [skill.skillName], homeDir: params.homeDir }) : applyNativeSkillMirror({
+        platform,
+        skills: [skill],
+        homeDir: params.homeDir,
+        projectDir: params.projectDir,
+        prune: false
+      });
+      refreshed += result.updated;
+      blocked += result.blocked;
+    } catch {
+      blocked++;
+    }
+  }
+  return { refreshed, blocked };
+}
+
 // src/opencode-plugin.ts
-var DEBUG_LOG_PATH = path9.join(os3.homedir(), ".greprag", "opencode-plugin-debug.log");
+var DEBUG_LOG_PATH = path13.join(os5.homedir(), ".greprag", "opencode-plugin-debug.log");
 var _debugLogReady = false;
 function dlogInit() {
   if (_debugLogReady)
     return;
   _debugLogReady = true;
   try {
-    fs9.writeFileSync(DEBUG_LOG_PATH, "");
+    fs12.writeFileSync(DEBUG_LOG_PATH, "");
   } catch {
   }
 }
@@ -4069,17 +4984,17 @@ function dlog(msg) {
   const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] [greprag-memory] ${msg}
 `;
   try {
-    fs9.appendFileSync(DEBUG_LOG_PATH, line);
+    fs12.appendFileSync(DEBUG_LOG_PATH, line);
   } catch {
   }
 }
 dlog(`module top reached: pid=${process.pid} argv0=${process.argv[0]} distPath=${__filename}`);
 var API_URL = "https://api.greprag.com";
-function loadEnvFile(filePath) {
+function loadEnvFile(filePath2) {
   try {
-    if (!fs9.existsSync(filePath))
+    if (!fs12.existsSync(filePath2))
       return;
-    const raw = fs9.readFileSync(filePath, "utf-8");
+    const raw = fs12.readFileSync(filePath2, "utf-8");
     for (const line of raw.split(/\r?\n/)) {
       const trimmed = line.trim();
       if (!trimmed || trimmed.startsWith("#"))
@@ -4099,12 +5014,12 @@ function loadEnvFile(filePath) {
   }
 }
 function loadGrepragEnv() {
-  loadEnvFile(path9.join(HOME, ".greprag", ".env"));
+  loadEnvFile(path13.join(HOME, ".greprag", ".env"));
   try {
-    const p = path9.join(HOME, ".claude", "settings.json");
-    if (!fs9.existsSync(p))
+    const p = path13.join(HOME, ".claude", "settings.json");
+    if (!fs12.existsSync(p))
       return;
-    const data = JSON.parse(fs9.readFileSync(p, "utf-8"));
+    const data = JSON.parse(fs12.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") {
@@ -4117,11 +5032,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 = path9.join(HOME || os3.homedir(), ".greprag", "opencode-watch.lock");
+var WATCHER_LOCK = path13.join(HOME || os5.homedir(), ".greprag", "opencode-watch.lock");
 var WATCHER_STALE_MS = 3e4;
 function findGrepragBinary() {
   const override = process.env.GREPRAG_BIN;
-  if (override && fs9.existsSync(override))
+  if (override && fs12.existsSync(override))
     return override;
   const binaryName = process.platform === "win32" ? "greprag.cmd" : "greprag";
   try {
@@ -4130,14 +5045,14 @@ function findGrepragBinary() {
       const candidate = line.trim();
       if (!candidate)
         continue;
-      if (!fs9.existsSync(candidate))
+      if (!fs12.existsSync(candidate))
         continue;
       if (process.platform === "win32") {
-        const ext = path9.extname(candidate).toLowerCase();
+        const ext = path13.extname(candidate).toLowerCase();
         if (ext === ".cmd" || ext === ".exe" || ext === ".bat")
           return candidate;
         const cmdSibling = candidate + ".cmd";
-        if (fs9.existsSync(cmdSibling))
+        if (fs12.existsSync(cmdSibling))
           return cmdSibling;
         continue;
       }
@@ -4146,19 +5061,19 @@ function findGrepragBinary() {
   } catch {
   }
   const candidates = process.platform === "win32" ? [
-    path9.join(HOME, "AppData", "Roaming", "npm", "greprag.cmd"),
-    path9.join(HOME, "AppData", "Roaming", "npm", "greprag"),
-    path9.join(HOME, "AppData", "Local", "Yarn", "bin", "greprag.cmd"),
-    path9.join(HOME, "AppData", "Local", "pnpm", "bin", "greprag.cmd")
+    path13.join(HOME, "AppData", "Roaming", "npm", "greprag.cmd"),
+    path13.join(HOME, "AppData", "Roaming", "npm", "greprag"),
+    path13.join(HOME, "AppData", "Local", "Yarn", "bin", "greprag.cmd"),
+    path13.join(HOME, "AppData", "Local", "pnpm", "bin", "greprag.cmd")
   ] : [
     "/usr/local/bin/greprag",
     "/opt/homebrew/bin/greprag",
-    path9.join(HOME || "", ".local", "bin", "greprag"),
-    path9.join(HOME || "", ".yarn", "bin", "greprag")
+    path13.join(HOME || "", ".local", "bin", "greprag"),
+    path13.join(HOME || "", ".yarn", "bin", "greprag")
   ];
   for (const c of candidates) {
     try {
-      if (c && fs9.existsSync(c))
+      if (c && fs12.existsSync(c))
         return c;
     } catch {
     }
@@ -4167,18 +5082,18 @@ function findGrepragBinary() {
 }
 function tryClaimWatcherLock() {
   try {
-    const fd = fs9.openSync(WATCHER_LOCK, "wx");
+    const fd = fs12.openSync(WATCHER_LOCK, "wx");
     return { ok: true, fd };
   } catch (err) {
     if (err.code !== "EEXIST") {
       return { ok: false, reason: "lock-create-failed" };
     }
     try {
-      const stat = fs9.statSync(WATCHER_LOCK);
+      const stat = fs12.statSync(WATCHER_LOCK);
       const ageMs = Date.now() - stat.mtimeMs;
       let pidAlive = false;
       try {
-        const pid = parseInt(fs9.readFileSync(WATCHER_LOCK, "utf-8").trim(), 10);
+        const pid = parseInt(fs12.readFileSync(WATCHER_LOCK, "utf-8").trim(), 10);
         pidAlive = pid > 0 && isPidAlive(pid);
       } catch {
       }
@@ -4186,10 +5101,10 @@ function tryClaimWatcherLock() {
         return { ok: false, reason: "busy" };
       }
       try {
-        fs9.unlinkSync(WATCHER_LOCK);
+        fs12.unlinkSync(WATCHER_LOCK);
       } catch {
       }
-      const fd = fs9.openSync(WATCHER_LOCK, "wx");
+      const fd = fs12.openSync(WATCHER_LOCK, "wx");
       return { ok: true, fd };
     } catch (err2) {
       return { ok: false, reason: "lock-stale-replace-failed" };
@@ -4230,11 +5145,11 @@ function startCaptureWatcher() {
     return;
   }
   try {
-    fs9.writeSync(claim.fd, String(process.pid));
-    fs9.closeSync(claim.fd);
+    fs12.writeSync(claim.fd, String(process.pid));
+    fs12.closeSync(claim.fd);
   } catch {
     try {
-      fs9.unlinkSync(WATCHER_LOCK);
+      fs12.unlinkSync(WATCHER_LOCK);
     } catch {
     }
     return;
@@ -4250,11 +5165,11 @@ function startCaptureWatcher() {
     const claim2 = tryClaimWatcherLock();
     if (claim2.ok) {
       try {
-        fs9.writeSync(claim2.fd, String(process.pid));
-        fs9.closeSync(claim2.fd);
+        fs12.writeSync(claim2.fd, String(process.pid));
+        fs12.closeSync(claim2.fd);
       } catch {
         try {
-          fs9.unlinkSync(WATCHER_LOCK);
+          fs12.unlinkSync(WATCHER_LOCK);
         } catch {
         }
         return false;
@@ -4297,7 +5212,7 @@ function startCaptureWatcher() {
     childStartTime = Date.now();
     dlog(`startCaptureWatcher: spawned 'greprag opencode watch' pid=${child.pid ?? "<none>"}`);
     try {
-      fs9.writeFileSync(WATCHER_LOCK, String(child.pid));
+      fs12.writeFileSync(WATCHER_LOCK, String(child.pid));
     } catch {
     }
     child.stderr?.on("data", (chunk2) => {
@@ -4309,9 +5224,9 @@ function startCaptureWatcher() {
     child.on("exit", (code, signal) => {
       dlog(`startCaptureWatcher: child pid=${child.pid ?? "<none>"} exited code=${code} signal=${signal || "none"}`);
       try {
-        const current = fs9.readFileSync(WATCHER_LOCK, "utf-8").trim();
+        const current = fs12.readFileSync(WATCHER_LOCK, "utf-8").trim();
         if (current === String(child.pid))
-          fs9.unlinkSync(WATCHER_LOCK);
+          fs12.unlinkSync(WATCHER_LOCK);
       } catch {
       }
       currentChild = null;
@@ -4340,7 +5255,7 @@ function startCaptureWatcher() {
 `
       );
       try {
-        fs9.unlinkSync(WATCHER_LOCK);
+        fs12.unlinkSync(WATCHER_LOCK);
       } catch {
       }
       return;
@@ -4372,7 +5287,7 @@ function startCaptureWatcher() {
       }, 2e3).unref();
     }
     try {
-      fs9.unlinkSync(WATCHER_LOCK);
+      fs12.unlinkSync(WATCHER_LOCK);
     } catch {
     }
   };
@@ -4437,6 +5352,14 @@ async function fetchSkillActivation(apiKey, cwd) {
     const data = await response.json();
     const rows = data.skills || [];
     cachedSkillRows = { projectId: anchor.projectId, rows, fetchedAt: now };
+    await refreshNativeAdapters({
+      platform: "opencode",
+      rows,
+      apiUrl: API_URL,
+      apiKey,
+      homeDir: os5.homedir(),
+      projectDir: cwd
+    }).catch(() => void 0);
     return activationFromApiRows({
       rows,
       platform: "opencode",
@@ -4509,11 +5432,11 @@ function startSessionRelay(sessionId, serverUrl) {
     return;
   }
   try {
-    fs9.writeSync(claim.fd, String(process.pid));
-    fs9.closeSync(claim.fd);
+    fs12.writeSync(claim.fd, String(process.pid));
+    fs12.closeSync(claim.fd);
   } catch {
     try {
-      fs9.unlinkSync(lockPath);
+      fs12.unlinkSync(lockPath);
     } catch {
     }
     return;
@@ -4528,11 +5451,11 @@ function startSessionRelay(sessionId, serverUrl) {
     const claim2 = tryClaimRelayLock(lockPath);
     if (claim2.ok) {
       try {
-        fs9.writeSync(claim2.fd, String(process.pid));
-        fs9.closeSync(claim2.fd);
+        fs12.writeSync(claim2.fd, String(process.pid));
+        fs12.closeSync(claim2.fd);
       } catch {
         try {
-          fs9.unlinkSync(lockPath);
+          fs12.unlinkSync(lockPath);
         } catch {
         }
         return false;
@@ -4568,7 +5491,7 @@ function startSessionRelay(sessionId, serverUrl) {
     childStartTime = Date.now();
     dlog(`startSessionRelay: spawned 'greprag opencode relay' pid=${child.pid ?? "<none>"}`);
     try {
-      fs9.writeFileSync(lockPath, String(child.pid));
+      fs12.writeFileSync(lockPath, String(child.pid));
     } catch {
     }
     child.stderr?.on("data", (chunk2) => {
@@ -4579,9 +5502,9 @@ function startSessionRelay(sessionId, serverUrl) {
     });
     child.on("exit", (code, signal) => {
       try {
-        const current = fs9.readFileSync(lockPath, "utf-8").trim();
+        const current = fs12.readFileSync(lockPath, "utf-8").trim();
         if (current === String(child.pid))
-          fs9.unlinkSync(lockPath);
+          fs12.unlinkSync(lockPath);
       } catch {
       }
       currentChild = null;
@@ -4608,7 +5531,7 @@ function startSessionRelay(sessionId, serverUrl) {
 `
       );
       try {
-        fs9.unlinkSync(lockPath);
+        fs12.unlinkSync(lockPath);
       } catch {
       }
       return;
@@ -4640,7 +5563,7 @@ function startSessionRelay(sessionId, serverUrl) {
       }, 2e3).unref();
     }
     try {
-      fs9.unlinkSync(lockPath);
+      fs12.unlinkSync(lockPath);
     } catch {
     }
   };
@@ -4701,7 +5624,7 @@ function runPngRecode(input, msgs) {
 }
 function makeCcrStash() {
   return (original, sourceType) => {
-    const hash = crypto5.createHash("sha256").update(original, "utf8").digest("hex").slice(0, 16);
+    const hash = crypto6.createHash("sha256").update(original, "utf8").digest("hex").slice(0, 16);
     const bin = grepragBinCached();
     if (bin) {
       try {