opencode-swarm 7.112.2 → 7.113.1

package/dist/cli/{index-82v0d72f.js → index-h389ed8y.js}

@@ -19,6 +19,7 @@ import {
 } from "./index-bfwt3abw.js";
 import {
   init_logger,
+  log,
   warn
 } from "./index-zgwm4ryv.js";
 import {
@@ -27,34 +28,351 @@ import {
 
 // src/services/skill-generator.ts
 import { existsSync as existsSync2, unlinkSync } from "fs";
-import { mkdir as mkdir3, readFile as readFile3, rename as rename2, unlink, writeFile as writeFile3 } from "fs/promises";
-import * as path3 from "path";
+import { mkdir as mkdir4, readFile as readFile4, rename as rename3, unlink, writeFile as writeFile4 } from "fs/promises";
+import * as path4 from "path";
+
+// src/config/bundled-skills.ts
+import { randomUUID } from "crypto";
+import * as fsp from "fs/promises";
+import * as path from "path";
+
+// src/services/warning-buffer.ts
+init_logger();
+var deferredWarnings = [];
+var MAX_DEFERRED_WARNINGS = 50;
+var deferredWarningsTruncated = false;
+function addDeferredWarning(warning) {
+  if (deferredWarnings.length < MAX_DEFERRED_WARNINGS - 1) {
+    deferredWarnings.push(warning);
+    return;
+  }
+  if (!deferredWarningsTruncated) {
+    deferredWarnings.push(`[opencode-swarm] ${MAX_DEFERRED_WARNINGS - 1} deferred warnings buffered; additional advisories were dropped (cap reached). Run with OPENCODE_SWARM_DEBUG=1 to see all advisories in the debug log.`);
+    deferredWarningsTruncated = true;
+  }
+}
+function advisoryWarn(message, data) {
+  addDeferredWarning(message);
+  log(message, data);
+}
+function getDeferredWarnings() {
+  return [...deferredWarnings];
+}
+
+// src/config/bundled-skills.ts
+init_logger();
+var BUNDLED_PROJECT_SKILLS = [
+  "brainstorm",
+  "specify",
+  "clarify-spec",
+  "resume",
+  "clarify",
+  "discover",
+  "consult",
+  "pre-phase-briefing",
+  "council",
+  "deep-dive",
+  "deep-research",
+  "codebase-review-swarm",
+  "swarm-implement",
+  "design-docs",
+  "swarm-pr-review",
+  "swarm",
+  "swarm-pr-feedback",
+  "swarm-pr-subscribe",
+  "swarm-ci-monitor",
+  "issue-ingest",
+  "plan",
+  "critic-gate",
+  "execute",
+  "phase-wrap",
+  "loop",
+  "writing-tests",
+  "running-tests",
+  "engineering-conventions",
+  "commit-pr",
+  "ci-failure-batching",
+  "gate-attribution",
+  "merge-queue-readiness",
+  "skill-edit-validation",
+  "worktree-retry-cleanup",
+  "test-file-split",
+  "fork-pr-operations",
+  "parallel-work-check",
+  "ci-fix-monitor"
+];
+var BUNDLED_PROJECT_SKILL_ROOT = ".swarm/bundled-skills";
+function bundledProjectSkillFileReference(slug) {
+  return `file:${BUNDLED_PROJECT_SKILL_ROOT}/${slug}/SKILL.md`;
+}
+var MAX_SKILL_FILES = 64;
+var MAX_SKILL_BYTES = 512000;
+var MAX_IN_FLIGHT_SYNCS = 64;
+var inFlightSyncs = new Map;
+function describeBundledSkillSyncFailure(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  return `[opencode-swarm] Could not install bundled project skills; continuing without sync: ${message}`;
+}
+async function isSymbolicLinkAsync(p) {
+  try {
+    return (await fsp.lstat(p)).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+async function ensureNotSymlinkedDirectoryAsync(p) {
+  try {
+    const stat2 = await fsp.lstat(p);
+    return stat2.isDirectory() && !stat2.isSymbolicLink();
+  } catch (err) {
+    return err.code === "ENOENT";
+  }
+}
+async function pathExistsAsync(p) {
+  try {
+    await fsp.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function collectBundledSkillFilesBoundedAsync(sourceDir, state, relativeDir = "") {
+  const currentSource = path.join(sourceDir, relativeDir);
+  const entries = await fsp.readdir(currentSource, { withFileTypes: true });
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  const files = [];
+  for (const entry of entries) {
+    const relativeEntry = path.join(relativeDir, entry.name);
+    const sourcePath = path.join(sourceDir, relativeEntry);
+    if (entry.isSymbolicLink() || await isSymbolicLinkAsync(sourcePath)) {
+      throw new Error("refusing to copy symlinked bundled skill entry");
+    }
+    if (entry.isDirectory()) {
+      files.push(...await collectBundledSkillFilesBoundedAsync(sourceDir, state, relativeEntry));
+      continue;
+    }
+    if (!entry.isFile())
+      continue;
+    const stat2 = await fsp.stat(sourcePath);
+    const nextFiles = state.files + 1;
+    const nextBytes = state.bytes + stat2.size;
+    if (nextFiles > MAX_SKILL_FILES || nextBytes > MAX_SKILL_BYTES) {
+      throw new Error("bundled skill package exceeds copy bounds");
+    }
+    state.files = nextFiles;
+    state.bytes = nextBytes;
+    files.push({ relativePath: relativeEntry });
+  }
+  return files;
+}
+async function ensureContainedDirectoryAsync(rootDir, directory) {
+  const safeRoot = path.resolve(rootDir);
+  const safeDirectory = path.resolve(directory);
+  const relative2 = path.relative(safeRoot, safeDirectory);
+  if (relative2.startsWith("..") || path.isAbsolute(relative2)) {
+    throw new Error("bundled skill destination escaped its private root");
+  }
+  try {
+    const rootStat = await fsp.lstat(safeRoot);
+    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+      throw new Error("refusing to traverse unsafe bundled skill directory");
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT")
+      throw err;
+    await fsp.mkdir(safeRoot, { recursive: true });
+    const rootStat = await fsp.lstat(safeRoot);
+    if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) {
+      throw new Error("refusing to traverse unsafe bundled skill directory");
+    }
+  }
+  let current = safeRoot;
+  for (const segment of relative2.split(path.sep).filter(Boolean)) {
+    current = path.join(current, segment);
+    try {
+      const stat2 = await fsp.lstat(current);
+      if (stat2.isSymbolicLink() || !stat2.isDirectory()) {
+        throw new Error("refusing to traverse unsafe bundled skill directory");
+      }
+    } catch (err) {
+      if (err.code !== "ENOENT")
+        throw err;
+      try {
+        await fsp.mkdir(current);
+      } catch (mkdirErr) {
+        if (mkdirErr.code !== "EEXIST") {
+          throw mkdirErr;
+        }
+      }
+      const stat2 = await fsp.lstat(current);
+      if (stat2.isSymbolicLink() || !stat2.isDirectory()) {
+        throw new Error("refusing to traverse unsafe bundled skill directory");
+      }
+    }
+  }
+}
+async function rollbackCopiedFilesAsync(copiedFiles, destDir, overwrittenFiles = []) {
+  const safeDestDir = path.resolve(destDir);
+  const dirs = new Set;
+  for (const copiedFile of copiedFiles) {
+    const resolvedFile = path.resolve(copiedFile);
+    const relative2 = path.relative(safeDestDir, resolvedFile);
+    if (relative2.startsWith("..") || path.isAbsolute(relative2))
+      continue;
+    try {
+      await fsp.rm(resolvedFile, { force: true });
+    } catch {}
+    dirs.add(path.dirname(resolvedFile));
+  }
+  for (const overwritten of overwrittenFiles.reverse()) {
+    const resolvedFile = path.resolve(overwritten.path);
+    const relative2 = path.relative(safeDestDir, resolvedFile);
+    if (relative2.startsWith("..") || path.isAbsolute(relative2))
+      continue;
+    try {
+      await fsp.writeFile(resolvedFile, overwritten.contents);
+    } catch {}
+  }
+  for (const dir of [...dirs].sort((a, b) => b.length - a.length)) {
+    const relative2 = path.relative(safeDestDir, path.resolve(dir));
+    if (relative2.startsWith("..") || path.isAbsolute(relative2))
+      continue;
+    try {
+      await fsp.rmdir(dir);
+    } catch {}
+  }
+}
+async function copyFileAtomicAsync(sourcePath, destPath) {
+  const tempPath = path.join(path.dirname(destPath), `.${path.basename(destPath)}.tmp.${randomUUID()}`);
+  try {
+    await fsp.copyFile(sourcePath, tempPath);
+    await fsp.rename(tempPath, destPath);
+  } catch (err) {
+    try {
+      await fsp.rm(tempPath, { force: true });
+    } catch {}
+    throw err;
+  }
+}
+async function copyBundledDirectoryBoundedAsync(sourceDir, destDir) {
+  const files = await collectBundledSkillFilesBoundedAsync(sourceDir, {
+    files: 0,
+    bytes: 0
+  });
+  const copiedFiles = [];
+  const overwrittenFiles = [];
+  try {
+    for (const file of files) {
+      const sourcePath = path.join(sourceDir, file.relativePath);
+      const destPath = path.join(destDir, file.relativePath);
+      await ensureContainedDirectoryAsync(destDir, path.dirname(destPath));
+      if (await pathExistsAsync(destPath)) {
+        if (await isSymbolicLinkAsync(destPath)) {
+          throw new Error("refusing to overwrite symlinked bundled skill file");
+        }
+        const [sourceContents, destContents] = await Promise.all([
+          fsp.readFile(sourcePath),
+          fsp.readFile(destPath)
+        ]);
+        if (sourceContents.equals(destContents)) {
+          continue;
+        }
+        overwrittenFiles.push({ path: destPath, contents: destContents });
+        await copyFileAtomicAsync(sourcePath, destPath);
+      } else {
+        await copyFileAtomicAsync(sourcePath, destPath);
+        copiedFiles.push(destPath);
+      }
+    }
+  } catch (err) {
+    await rollbackCopiedFilesAsync(copiedFiles, destDir, overwrittenFiles);
+    throw err;
+  }
+}
+async function performBundledProjectSkillSyncAsync(projectDirectory, packageRoot, quiet) {
+  try {
+    const sourceRoot = path.join(packageRoot, ".opencode", "skills");
+    const swarmDir = path.join(projectDirectory, ".swarm");
+    const skillsDir = path.join(projectDirectory, BUNDLED_PROJECT_SKILL_ROOT);
+    if (!await ensureNotSymlinkedDirectoryAsync(sourceRoot)) {
+      throw new Error("refusing to copy symlinked bundled skill source root");
+    }
+    if (!await ensureNotSymlinkedDirectoryAsync(swarmDir))
+      return;
+    if (!await ensureNotSymlinkedDirectoryAsync(skillsDir))
+      return;
+    for (const slug of BUNDLED_PROJECT_SKILLS) {
+      const sourceDir = path.join(sourceRoot, slug);
+      const sourceSkill = path.join(sourceDir, "SKILL.md");
+      const destDir = path.join(skillsDir, slug);
+      if (!await pathExistsAsync(sourceSkill))
+        continue;
+      if (!await ensureNotSymlinkedDirectoryAsync(sourceDir)) {
+        throw new Error("refusing to copy symlinked bundled skill directory");
+      }
+      if (!await ensureNotSymlinkedDirectoryAsync(destDir))
+        continue;
+      await copyBundledDirectoryBoundedAsync(sourceDir, destDir);
+      log("synchronized bundled skill", {
+        slug: bundledProjectSkillFileReference(slug)
+      });
+    }
+  } catch (err) {
+    const failureMsg = describeBundledSkillSyncFailure(err);
+    if (quiet) {
+      advisoryWarn(failureMsg);
+    } else {
+      console.warn(failureMsg);
+    }
+  }
+}
+async function syncBundledProjectSkillsIfMissingAsync(projectDirectory, packageRoot, quiet = false) {
+  const syncKey = path.resolve(projectDirectory, BUNDLED_PROJECT_SKILL_ROOT);
+  const existing = inFlightSyncs.get(syncKey);
+  if (existing)
+    return existing;
+  if (inFlightSyncs.size >= MAX_IN_FLIGHT_SYNCS) {
+    log("skipping bundled skill sync because the in-flight limit was reached", {
+      limit: MAX_IN_FLIGHT_SYNCS
+    });
+    return;
+  }
+  const syncPromise = performBundledProjectSkillSyncAsync(projectDirectory, packageRoot, quiet).finally(() => {
+    if (inFlightSyncs.get(syncKey) === syncPromise) {
+      inFlightSyncs.delete(syncKey);
+    }
+  });
+  inFlightSyncs.set(syncKey, syncPromise);
+  return syncPromise;
+}
+
+// src/services/skill-generator.ts
 init_logger();
 
 // src/services/skill-changelog.ts
 init_logger();
-import { appendFile, mkdir, readFile, writeFile } from "fs/promises";
-import * as path from "path";
+import { appendFile, mkdir as mkdir2, readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import * as path2 from "path";
 var MAX_CHANGELOG_ENTRIES_PER_SKILL = 200;
 function resolveSkillChangelogPath(directory, slug) {
   if (slug.includes("..") || slug.includes("/") || slug.includes("\\")) {
     throw new Error(`Invalid skill slug: ${slug} \u2014 must not contain "..", "/" or "\\"`);
   }
-  return path.join(directory, ".swarm", "skill-changelogs", `${slug}.jsonl`);
+  return path2.join(directory, ".swarm", "skill-changelogs", `${slug}.jsonl`);
 }
 async function appendSkillChangelog(directory, slug, entry) {
   const filePath = resolveSkillChangelogPath(directory, slug);
-  const dirPath = path.dirname(filePath);
-  await mkdir(dirPath, { recursive: true });
+  const dirPath = path2.dirname(filePath);
+  await mkdir2(dirPath, { recursive: true });
   await appendFile(filePath, `${JSON.stringify(entry)}
 `, "utf-8");
   try {
-    const content = await readFile(filePath, "utf-8");
+    const content = await readFile2(filePath, "utf-8");
     const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
     if (lines.length > MAX_CHANGELOG_ENTRIES_PER_SKILL) {
       const trimmed = lines.slice(lines.length - MAX_CHANGELOG_ENTRIES_PER_SKILL);
-      await writeFile(filePath, `${trimmed.join(`
+      await writeFile2(filePath, `${trimmed.join(`
 `)}
 `, "utf-8");
     }
@@ -67,16 +385,16 @@ async function appendSkillChangelog(directory, slug, entry) {
 import { createHash } from "crypto";
 import { existsSync } from "fs";
 import {
-  lstat,
-  mkdir as mkdir2,
-  readdir,
-  readFile as readFile2,
+  lstat as lstat2,
+  mkdir as mkdir3,
+  readdir as readdir2,
+  readFile as readFile3,
   realpath,
-  rename,
-  stat,
-  writeFile as writeFile2
+  rename as rename2,
+  stat as stat2,
+  writeFile as writeFile3
 } from "fs/promises";
-import * as path2 from "path";
+import * as path3 from "path";
 var SLUG_PATTERN = /^[a-z0-9][a-z0-9-]{0,63}$/;
 var MAX_EVAL_FILES = 50;
 var MAX_EVAL_FILE_BYTES = 64 * 1024;
@@ -142,15 +460,15 @@ function casesFromParsedJson(parsed, fileLabel) {
   return cases;
 }
 function evalRoot(directory, slug) {
-  return path2.join(directory, ".swarm", "skills", "evals", slug);
+  return path3.join(directory, ".swarm", "skills", "evals", slug);
 }
 function isInsidePath(root, target) {
-  const resolvedRoot = path2.resolve(root);
-  const resolvedTarget = path2.resolve(target);
-  return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(resolvedRoot + path2.sep);
+  const resolvedRoot = path3.resolve(root);
+  const resolvedTarget = path3.resolve(target);
+  return resolvedTarget === resolvedRoot || resolvedTarget.startsWith(resolvedRoot + path3.sep);
 }
 function rejectedEditsPath(directory) {
-  return path2.join(directory, ".swarm", "skills", "rejected-edits.jsonl");
+  return path3.join(directory, ".swarm", "skills", "rejected-edits.jsonl");
 }
 async function loadEvalSet(directory, slug) {
   if (!isValidSlug(slug)) {
@@ -187,7 +505,7 @@ async function loadEvalSet(directory, slug) {
   }
   let entries;
   try {
-    entries = await readdir(root);
+    entries = await readdir2(root);
   } catch (err) {
     return {
       status: "invalid",
@@ -203,9 +521,9 @@ async function loadEvalSet(directory, slug) {
   const cases = [];
   const fileLabels = [];
   for (const file of files) {
-    const fullPath = path2.join(root, file);
-    const resolved = path2.resolve(fullPath);
-    const resolvedRoot = path2.resolve(root);
+    const fullPath = path3.join(root, file);
+    const resolved = path3.resolve(fullPath);
+    const resolvedRoot = path3.resolve(root);
     if (!isInsidePath(resolvedRoot, resolved)) {
       return {
         status: "invalid",
@@ -217,7 +535,7 @@ async function loadEvalSet(directory, slug) {
     let readPath = fullPath;
     let info;
     try {
-      const linkInfo = await lstat(fullPath);
+      const linkInfo = await lstat2(fullPath);
       if (linkInfo.isSymbolicLink()) {
         const realFile = await realpath(fullPath);
         if (!isInsidePath(realRoot, realFile)) {
@@ -229,7 +547,7 @@ async function loadEvalSet(directory, slug) {
           };
         }
         readPath = realFile;
-        info = await stat(realFile);
+        info = await stat2(realFile);
       } else {
         if (!linkInfo.isFile())
           continue;
@@ -255,7 +573,7 @@ async function loadEvalSet(directory, slug) {
     }
     let parsed;
     try {
-      parsed = JSON.parse(await readFile2(readPath, "utf-8"));
+      parsed = JSON.parse(await readFile3(readPath, "utf-8"));
     } catch (err) {
       return {
         status: "invalid",
@@ -264,7 +582,7 @@ async function loadEvalSet(directory, slug) {
         reason: `eval file invalid JSON: ${file}: ${err instanceof Error ? err.message : String(err)}`
       };
     }
-    fileLabels.push(path2.relative(directory, fullPath).replace(/\\/g, "/"));
+    fileLabels.push(path3.relative(directory, fullPath).replace(/\\/g, "/"));
     cases.push(...casesFromParsedJson(parsed, file));
     if (cases.length >= MAX_EVAL_CASES)
       break;
@@ -382,10 +700,10 @@ async function evaluateSkillChange(req) {
   };
 }
 async function atomicWrite(filePath, content) {
-  await mkdir2(path2.dirname(filePath), { recursive: true });
+  await mkdir3(path3.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile2(tmp, content, "utf-8");
-  await rename(tmp, filePath);
+  await writeFile3(tmp, content, "utf-8");
+  await rename2(tmp, filePath);
 }
 async function appendRejectedSkillEdit(req, evaluation) {
   const filePath = rejectedEditsPath(req.directory);
@@ -405,7 +723,7 @@ async function appendRejectedSkillEdit(req, evaluation) {
   };
   let prior = [];
   try {
-    prior = (await readFile2(filePath, "utf-8")).split(/\r?\n/).filter((line) => line.trim().length > 0);
+    prior = (await readFile3(filePath, "utf-8")).split(/\r?\n/).filter((line) => line.trim().length > 0);
   } catch {
     prior = [];
   }
@@ -422,7 +740,7 @@ async function isRejectedSkillContent(directory, slug, content) {
   const normalizedHash = hashNormalizedContent(content);
   let raw = "";
   try {
-    raw = await readFile2(rejectedEditsPath(directory), "utf-8");
+    raw = await readFile3(rejectedEditsPath(directory), "utf-8");
   } catch {
     return false;
   }
@@ -449,6 +767,10 @@ async function isRejectedSkillContent(directory, slug, content) {
 
 // src/services/skill-generator.ts
 var SLUG_PATTERN2 = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var RESERVED_ACTIVE_SKILL_SLUGS = new Set(BUNDLED_PROJECT_SKILLS);
+function reservedActiveSlugReason(slug) {
+  return `reserved bundled skill slug "${slug}" cannot be used for an active generated skill`;
+}
 function sanitizeSlug(input) {
   const lc = input.toLowerCase().trim();
   const mapped = lc.replace(/[^a-z0-9-]+/g, "-").replace(/-+/g, "-");
@@ -459,10 +781,10 @@ function isValidSlug2(slug) {
   return SLUG_PATTERN2.test(slug);
 }
 function proposalPath(directory, slug) {
-  return path3.join(directory, ".swarm", "skills", "proposals", `${slug}.md`);
+  return path4.join(directory, ".swarm", "skills", "proposals", `${slug}.md`);
 }
 function activePath(directory, slug) {
-  return path3.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
+  return path4.join(directory, ".opencode", "skills", "generated", slug, "SKILL.md");
 }
 function activeRepoRelativePath(slug) {
   return `.opencode/skills/generated/${slug}/SKILL.md`;
@@ -486,12 +808,12 @@ function generateEvalStub(cluster) {
   ];
 }
 async function writeEvalStub(directory, slug, cases) {
-  const stubPath = path3.join(directory, ".swarm", "skills", "evals", slug, "auto-stub.json");
+  const stubPath = path4.join(directory, ".swarm", "skills", "evals", slug, "auto-stub.json");
   if (cases.length === 0) {
     return { written: false, path: stubPath, reason: "no directive fields" };
   }
   try {
-    await mkdir3(path3.dirname(stubPath), { recursive: true });
+    await mkdir4(path4.dirname(stubPath), { recursive: true });
     await atomicWrite2(stubPath, `${JSON.stringify({ cases })}
 `);
     return { written: true, path: stubPath };
@@ -726,10 +1048,10 @@ function escapeMarkdown(s) {
   return s.replace(/[\r\n]+/g, " ").slice(0, 280);
 }
 async function atomicWrite2(p, content) {
-  await mkdir3(path3.dirname(p), { recursive: true });
+  await mkdir4(path4.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
-  await writeFile3(tmp, content, "utf-8");
-  await rename2(tmp, p);
+  await writeFile4(tmp, content, "utf-8");
+  await rename3(tmp, p);
 }
 async function generateSkills(req) {
   const minConfidence = req.minConfidence ?? DEFAULT_SKILL_MIN_CONFIDENCE;
@@ -778,8 +1100,15 @@ async function generateSkills(req) {
       });
       continue;
     }
+    if (req.mode === "active" && RESERVED_ACTIVE_SKILL_SLUGS.has(cluster.slug)) {
+      result.skipped.push({
+        slug: cluster.slug,
+        reason: reservedActiveSlugReason(cluster.slug)
+      });
+      continue;
+    }
     const targetPath = req.mode === "active" ? activePath(req.directory, cluster.slug) : proposalPath(req.directory, cluster.slug);
-    const repoRel = path3.relative(req.directory, targetPath).replace(/\\/g, "/");
+    const repoRel = path4.relative(req.directory, targetPath).replace(/\\/g, "/");
     if (!validateSkillPath(repoRel)) {
       result.skipped.push({
         slug: cluster.slug,
@@ -789,7 +1118,7 @@ async function generateSkills(req) {
     }
     let preserved = false;
     if (req.mode === "active" && existsSync2(targetPath) && !req.force) {
-      const existing = await readFile3(targetPath, "utf-8");
+      const existing = await readFile4(targetPath, "utf-8");
       if (!existing.includes("generated by opencode-swarm skill-generator")) {
         preserved = true;
         result.skipped.push({
@@ -814,7 +1143,7 @@ async function generateSkills(req) {
       const existingActivePath = activePath(req.directory, cluster.slug);
       if (existsSync2(existingActivePath)) {
         try {
-          incumbentContent = await readFile3(existingActivePath, "utf-8");
+          incumbentContent = await readFile4(existingActivePath, "utf-8");
         } catch {
           incumbentContent = undefined;
         }
@@ -1089,6 +1418,14 @@ async function activateProposal(directory, slug, force = false, options = {}) {
   }
   const from = proposalPath(directory, cleanSlug);
   const to = activePath(directory, cleanSlug);
+  if (RESERVED_ACTIVE_SKILL_SLUGS.has(cleanSlug)) {
+    return {
+      activated: false,
+      from,
+      to,
+      reason: reservedActiveSlugReason(cleanSlug)
+    };
+  }
   if (!existsSync2(from)) {
     return {
       activated: false,
@@ -1098,7 +1435,7 @@ async function activateProposal(directory, slug, force = false, options = {}) {
     };
   }
   if (existsSync2(to) && !force) {
-    const existing = await readFile3(to, "utf-8");
+    const existing = await readFile4(to, "utf-8");
     if (!existing.includes("generated by opencode-swarm skill-generator")) {
       return {
         activated: false,
@@ -1110,7 +1447,7 @@ async function activateProposal(directory, slug, force = false, options = {}) {
   }
   let proposalContent;
   try {
-    proposalContent = await readFile3(from, "utf-8");
+    proposalContent = await readFile4(from, "utf-8");
   } catch (readErr) {
     return {
       activated: false,
@@ -1133,7 +1470,7 @@ async function activateProposal(directory, slug, force = false, options = {}) {
     let incumbentContent;
     if (existsSync2(to)) {
       try {
-        incumbentContent = await readFile3(to, "utf-8");
+        incumbentContent = await readFile4(to, "utf-8");
       } catch {
         incumbentContent = undefined;
       }
@@ -1208,7 +1545,7 @@ async function activateProposal(directory, slug, force = false, options = {}) {
   }
 }
 async function findSkillsBySourceKnowledgeId(directory, sourceId) {
-  const activeDir = path3.join(directory, ".opencode", "skills", "generated");
+  const activeDir = path4.join(directory, ".opencode", "skills", "generated");
   const fs = await import("fs/promises");
   if (!existsSync2(activeDir))
     return [];
@@ -1217,14 +1554,14 @@ async function findSkillsBySourceKnowledgeId(directory, sourceId) {
   for (const e of entries) {
     if (!e.isDirectory())
       continue;
-    const skillDir = path3.join(activeDir, e.name);
-    const retiredMarker = path3.join(skillDir, "retired.marker");
+    const skillDir = path4.join(activeDir, e.name);
+    const retiredMarker = path4.join(skillDir, "retired.marker");
     if (existsSync2(retiredMarker))
       continue;
-    const staleMarker = path3.join(skillDir, "stale.marker");
+    const staleMarker = path4.join(skillDir, "stale.marker");
     if (existsSync2(staleMarker))
       continue;
-    const skillPath = path3.join(skillDir, "SKILL.md");
+    const skillPath = path4.join(skillDir, "SKILL.md");
     if (!existsSync2(skillPath))
       continue;
     let content;
@@ -1241,7 +1578,7 @@ async function findSkillsBySourceKnowledgeId(directory, sourceId) {
   return matches;
 }
 async function findStaleSkillsBySourceKnowledgeId(directory, archivedIds) {
-  const activeDir = path3.join(directory, ".opencode", "skills", "generated");
+  const activeDir = path4.join(directory, ".opencode", "skills", "generated");
   if (!existsSync2(activeDir))
     return [];
   const fs = await import("fs/promises");
@@ -1250,14 +1587,14 @@ async function findStaleSkillsBySourceKnowledgeId(directory, archivedIds) {
   for (const e of entries) {
     if (!e.isDirectory())
       continue;
-    const skillDir = path3.join(activeDir, e.name);
-    const retiredMarker = path3.join(skillDir, "retired.marker");
+    const skillDir = path4.join(activeDir, e.name);
+    const retiredMarker = path4.join(skillDir, "retired.marker");
     if (existsSync2(retiredMarker))
       continue;
-    const staleMarker = path3.join(skillDir, "stale.marker");
+    const staleMarker = path4.join(skillDir, "stale.marker");
     if (!existsSync2(staleMarker))
       continue;
-    const skillPath = path3.join(skillDir, "SKILL.md");
+    const skillPath = path4.join(skillDir, "SKILL.md");
     if (!existsSync2(skillPath))
       continue;
     let content;
@@ -1283,8 +1620,8 @@ async function listSkills(directory) {
     active: [],
     stale: []
   };
-  const proposalsDir = path3.join(directory, ".swarm", "skills", "proposals");
-  const activeDir = path3.join(directory, ".opencode", "skills", "generated");
+  const proposalsDir = path4.join(directory, ".swarm", "skills", "proposals");
+  const activeDir = path4.join(directory, ".opencode", "skills", "generated");
   const fs = await import("fs/promises");
   if (existsSync2(proposalsDir)) {
     const entries = await fs.readdir(proposalsDir);
@@ -1294,7 +1631,7 @@ async function listSkills(directory) {
       const slug = f.replace(/\.md$/, "");
       result.proposals.push({
         slug,
-        path: path3.join(proposalsDir, f)
+        path: path4.join(proposalsDir, f)
       });
     }
   }
@@ -1303,10 +1640,10 @@ async function listSkills(directory) {
     for (const e of entries) {
       if (!e.isDirectory())
         continue;
-      const retiredMarker = path3.join(activeDir, e.name, "retired.marker");
+      const retiredMarker = path4.join(activeDir, e.name, "retired.marker");
       if (existsSync2(retiredMarker))
         continue;
-      const staleMarker = path3.join(activeDir, e.name, "stale.marker");
+      const staleMarker = path4.join(activeDir, e.name, "stale.marker");
       if (existsSync2(staleMarker)) {
         let reason = "stale";
         try {
@@ -1316,7 +1653,7 @@ async function listSkills(directory) {
         result.stale.push({ slug: e.name, reason });
         continue;
       }
-      const skillPath = path3.join(activeDir, e.name, "SKILL.md");
+      const skillPath = path4.join(activeDir, e.name, "SKILL.md");
       if (existsSync2(skillPath)) {
         result.active.push({
           slug: e.name,
@@ -1341,7 +1678,7 @@ async function autoApplyProposals(directory, llmDelegate) {
     }
     let content;
     try {
-      content = await readFile3(proposal.path, "utf-8");
+      content = await readFile4(proposal.path, "utf-8");
     } catch {
       result.skipped.push(proposal.slug);
       continue;
@@ -1407,7 +1744,7 @@ async function inspectSkill(directory, slug, prefer = "auto") {
     candidates.push({ p: proposalPath(directory, cleanSlug), m: "draft" });
   for (const c of candidates) {
     if (existsSync2(c.p)) {
-      const content = await readFile3(c.p, "utf-8");
+      const content = await readFile4(c.p, "utf-8");
       const result = { found: true, path: c.p, content, mode: c.m };
       const fm = parseDraftFrontmatter(content);
       if (fm && fm.sourceKnowledgeIds.length > 0) {
@@ -1427,11 +1764,11 @@ async function inspectSkill(directory, slug, prefer = "auto") {
         });
       }
       if (c.m === "active") {
-        const skillDir = path3.join(directory, ".opencode", "skills", "generated", cleanSlug);
-        const staleMarker = path3.join(skillDir, "stale.marker");
+        const skillDir = path4.join(directory, ".opencode", "skills", "generated", cleanSlug);
+        const staleMarker = path4.join(skillDir, "stale.marker");
         if (existsSync2(staleMarker)) {
           try {
-            result.stale_reason = await readFile3(staleMarker, "utf-8");
+            result.stale_reason = await readFile4(staleMarker, "utf-8");
           } catch {}
         }
       }
@@ -1446,7 +1783,7 @@ async function retireSkill(directory, slug, reason) {
     return {
       retired: false,
       path: activePath(directory, cleanSlug),
-      markerPath: path3.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
+      markerPath: path4.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
       reason: "invalid slug"
     };
   }
@@ -1455,18 +1792,18 @@ async function retireSkill(directory, slug, reason) {
     return {
       retired: false,
       path: skillPath,
-      markerPath: path3.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
+      markerPath: path4.join(directory, ".opencode", "skills", "generated", cleanSlug, "retired.marker"),
       reason: "active skill not found"
     };
   }
-  const markerDir = path3.join(directory, ".opencode", "skills", "generated", cleanSlug);
-  const markerPath = path3.join(markerDir, "retired.marker");
+  const markerDir = path4.join(directory, ".opencode", "skills", "generated", cleanSlug);
+  const markerPath = path4.join(markerDir, "retired.marker");
   const markerContent = JSON.stringify({
     retiredAt: new Date().toISOString(),
     reason: reason ?? "manual_retire"
   });
-  await mkdir3(markerDir, { recursive: true });
-  await writeFile3(markerPath, markerContent, "utf-8");
+  await mkdir4(markerDir, { recursive: true });
+  await writeFile4(markerPath, markerContent, "utf-8");
   let clearedLinks = [];
   try {
     clearedLinks = await clearRetiredSkillLinks(directory, skillPath, cleanSlug);
@@ -1490,7 +1827,7 @@ async function clearRetiredSkillLinks(directory, skillFilePath, slug) {
 async function clearSkillLinks(directory, skillFilePath, slug, mode) {
   let content;
   try {
-    content = await readFile3(skillFilePath, "utf-8");
+    content = await readFile4(skillFilePath, "utf-8");
   } catch (err) {
     warn(`[skill-generator] clearSkillLinks: failed to read '${skillFilePath}' for slug '${slug}': ${err instanceof Error ? err.message : String(err)}`);
     return [];
@@ -1555,11 +1892,11 @@ async function clearSkillLinks(directory, skillFilePath, slug, mode) {
   return cleared;
 }
 async function markSkillStale(skillDir, reason) {
-  await mkdir3(skillDir, { recursive: true });
-  await writeFile3(path3.join(skillDir, "stale.marker"), reason, "utf-8");
+  await mkdir4(skillDir, { recursive: true });
+  await writeFile4(path4.join(skillDir, "stale.marker"), reason, "utf-8");
 }
 async function clearSkillStale(skillDir) {
-  const markerPath = path3.join(skillDir, "stale.marker");
+  const markerPath = path4.join(skillDir, "stale.marker");
   try {
     await unlink(markerPath);
   } catch (err) {
@@ -1571,10 +1908,10 @@ async function clearSkillStale(skillDir) {
 }
 async function retireOrMarkStale(directory, skillDir, archivedKnowledgeIds) {
   const fs = await import("fs/promises");
-  const skillPath = path3.join(skillDir, "SKILL.md");
+  const skillPath = path4.join(skillDir, "SKILL.md");
   if (!existsSync2(skillPath)) {
     await markSkillStale(skillDir, "source knowledge archived, SKILL.md missing");
-    const slug2 = path3.basename(skillDir);
+    const slug2 = path4.basename(skillDir);
     return { action: "stale", slug: slug2, skillDir };
   }
   let content;
@@ -1582,18 +1919,18 @@ async function retireOrMarkStale(directory, skillDir, archivedKnowledgeIds) {
     content = await fs.readFile(skillPath, "utf-8");
   } catch {
     await markSkillStale(skillDir, "source knowledge archived, SKILL.md unreadable");
-    const slug2 = path3.basename(skillDir);
+    const slug2 = path4.basename(skillDir);
     return { action: "stale", slug: slug2, skillDir };
   }
   const fm = parseDraftFrontmatter(content);
   const sourceIds = fm?.sourceKnowledgeIds ?? [];
   if (sourceIds.length === 0) {
     await markSkillStale(skillDir, "source knowledge archived, no source_knowledge_ids in frontmatter");
-    const slug2 = path3.basename(skillDir);
+    const slug2 = path4.basename(skillDir);
     return { action: "stale", slug: slug2, skillDir };
   }
   const allArchived = sourceIds.every((id) => archivedKnowledgeIds.has(id));
-  const slug = path3.basename(skillDir);
+  const slug = path4.basename(skillDir);
   if (allArchived) {
     await retireSkill(directory, slug, "all source knowledge entries archived or deleted");
     return { action: "retire", slug, skillDir };
@@ -1623,7 +1960,7 @@ async function regenerateSkill(directory, slug, options = {}) {
   }
   let existingContent;
   try {
-    existingContent = await readFile3(skillPath, "utf-8");
+    existingContent = await readFile4(skillPath, "utf-8");
   } catch (err) {
     return {
       regenerated: false,
@@ -1762,7 +2099,7 @@ async function regenerateSkill(directory, slug, options = {}) {
   try {
     await atomicWrite2(skillPath, content);
     await stampSourceEntries(directory, cleanSlug, matchedEntries.map((e) => e.id));
-    await clearSkillStale(path3.dirname(activePath(directory, cleanSlug)));
+    await clearSkillStale(path4.dirname(activePath(directory, cleanSlug)));
   } catch (writeErr) {
     return {
       regenerated: false,
@@ -1815,4 +2152,4 @@ var _internals = {
   clearRetiredSkillLinks
 };
 
-export { appendSkillChangelog, evaluateSkillChange, appendRejectedSkillEdit, sanitizeSlug, isValidSlug2 as isValidSlug, proposalPath, activePath, activeRepoRelativePath, proposalRepoRelativePath, generateEvalStub, writeEvalStub, DEFAULT_SKILL_MIN_CONFIDENCE, DEFAULT_SKILL_MIN_CONFIRMATIONS, STRONG_SKILL_OUTCOME_COUNT, HIGH_PRIORITY_SKILL_MIN_CONFIDENCE, selectCandidateEntries, isSkillMaturityEligible, clusterEntries, buildKnowledgeCluster, renderSkillMarkdown, generateSkills, parseDraftFrontmatter, activateProposal, findSkillsBySourceKnowledgeId, findStaleSkillsBySourceKnowledgeId, listSkills, autoApplyProposals, inspectSkill, retireSkill, clearDraftSkillLinks, clearRetiredSkillLinks, markSkillStale, clearSkillStale, retireOrMarkStale, regenerateSkill, _internals };
+export { advisoryWarn, getDeferredWarnings, BUNDLED_PROJECT_SKILL_ROOT, bundledProjectSkillFileReference, syncBundledProjectSkillsIfMissingAsync, appendSkillChangelog, evaluateSkillChange, appendRejectedSkillEdit, sanitizeSlug, isValidSlug2 as isValidSlug, proposalPath, activePath, activeRepoRelativePath, proposalRepoRelativePath, generateEvalStub, writeEvalStub, DEFAULT_SKILL_MIN_CONFIDENCE, DEFAULT_SKILL_MIN_CONFIRMATIONS, STRONG_SKILL_OUTCOME_COUNT, HIGH_PRIORITY_SKILL_MIN_CONFIDENCE, selectCandidateEntries, isSkillMaturityEligible, clusterEntries, buildKnowledgeCluster, renderSkillMarkdown, generateSkills, parseDraftFrontmatter, activateProposal, findSkillsBySourceKnowledgeId, findStaleSkillsBySourceKnowledgeId, listSkills, autoApplyProposals, inspectSkill, retireSkill, clearDraftSkillLinks, clearRetiredSkillLinks, markSkillStale, clearSkillStale, retireOrMarkStale, regenerateSkill, _internals };