opencode-swarm 7.76.1 → 7.76.2

package/dist/index.js

@@ -69,7 +69,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "opencode-swarm",
-    version: "7.76.1",
+    version: "7.76.2",
     description: "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
     main: "dist/index.js",
     types: "dist/index.d.ts",
@@ -17016,43 +17016,56 @@ var init_warning_buffer = __esm(() => {
 
 // src/config/bundled-skills.ts
 import * as fs3 from "node:fs";
+import * as fsp from "node:fs/promises";
 import * as path2 from "node:path";
-function isSymbolicLink(p) {
+function getSyncCacheKey(projectDirectory, packageRoot) {
+  return `${path2.resolve(projectDirectory)}\x00${path2.resolve(packageRoot)}`;
+}
+function warnBundledSkillSyncFailure(err2) {
+  const message = err2 instanceof Error ? err2.message : String(err2);
+  console.warn(`[opencode-swarm] Could not install bundled project skills; continuing without sync: ${message}`);
+}
+async function isSymbolicLinkAsync(p) {
   try {
-    return fs3.lstatSync(p).isSymbolicLink();
+    return (await fsp.lstat(p)).isSymbolicLink();
   } catch {
     return false;
   }
 }
-function ensureNotSymlinkedDirectory(p) {
+async function ensureNotSymlinkedDirectoryAsync(p) {
   try {
-    const stat2 = fs3.lstatSync(p);
-    return stat2.isDirectory() && !stat2.isSymbolicLink();
+    const stat3 = await fsp.lstat(p);
+    return stat3.isDirectory() && !stat3.isSymbolicLink();
   } catch (err2) {
     return err2.code === "ENOENT";
   }
 }
-function getSyncCacheKey(projectDirectory, packageRoot) {
-  return `${path2.resolve(projectDirectory)}\x00${path2.resolve(packageRoot)}`;
+async function pathExistsAsync(p) {
+  try {
+    await fsp.access(p);
+    return true;
+  } catch {
+    return false;
+  }
 }
-function collectBundledSkillFilesBounded(sourceDir, state, relativeDir = "") {
+async function collectBundledSkillFilesBoundedAsync(sourceDir, state, relativeDir = "") {
   const currentSource = path2.join(sourceDir, relativeDir);
-  const entries = fs3.readdirSync(currentSource, { withFileTypes: true });
+  const entries = await fsp.readdir(currentSource, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const relativeEntry = path2.join(relativeDir, entry.name);
     const sourcePath = path2.join(sourceDir, relativeEntry);
-    if (entry.isSymbolicLink() || isSymbolicLink(sourcePath))
+    if (entry.isSymbolicLink() || await isSymbolicLinkAsync(sourcePath))
       continue;
     if (entry.isDirectory()) {
-      files.push(...collectBundledSkillFilesBounded(sourceDir, state, relativeEntry));
+      files.push(...await collectBundledSkillFilesBoundedAsync(sourceDir, state, relativeEntry));
       continue;
     }
     if (!entry.isFile())
       continue;
-    const stat2 = fs3.statSync(sourcePath);
+    const stat3 = await fsp.stat(sourcePath);
     const nextFiles = state.files + 1;
-    const nextBytes = state.bytes + stat2.size;
+    const nextBytes = state.bytes + stat3.size;
     if (nextFiles > MAX_SKILL_FILES || nextBytes > MAX_SKILL_BYTES) {
       throw new Error("bundled skill package exceeds copy bounds");
     }
@@ -17062,7 +17075,7 @@ function collectBundledSkillFilesBounded(sourceDir, state, relativeDir = "") {
   }
   return files;
 }
-function rollbackCopiedFiles(copiedFiles, destDir) {
+async function rollbackCopiedFilesAsync(copiedFiles, destDir) {
   const safeDestDir = path2.resolve(destDir);
   const dirs = new Set;
   for (const copiedFile of copiedFiles) {
@@ -17071,7 +17084,7 @@ function rollbackCopiedFiles(copiedFiles, destDir) {
     if (relative2.startsWith("..") || path2.isAbsolute(relative2))
       continue;
     try {
-      fs3.rmSync(resolvedFile, { force: true });
+      await fsp.rm(resolvedFile, { force: true });
     } catch {}
     dirs.add(path2.dirname(resolvedFile));
   }
@@ -17080,12 +17093,12 @@ function rollbackCopiedFiles(copiedFiles, destDir) {
     if (relative2.startsWith("..") || path2.isAbsolute(relative2))
       continue;
     try {
-      fs3.rmdirSync(dir);
+      await fsp.rmdir(dir);
     } catch {}
   }
 }
-function copyBundledDirectoryBounded(sourceDir, destDir) {
-  const files = collectBundledSkillFilesBounded(sourceDir, {
+async function copyBundledDirectoryBoundedAsync(sourceDir, destDir) {
+  const files = await collectBundledSkillFilesBoundedAsync(sourceDir, {
     files: 0,
     bytes: 0
   });
@@ -17094,9 +17107,9 @@ function copyBundledDirectoryBounded(sourceDir, destDir) {
     for (const file2 of files) {
       const sourcePath = path2.join(sourceDir, file2.relativePath);
       const destPath = path2.join(destDir, file2.relativePath);
-      fs3.mkdirSync(path2.dirname(destPath), { recursive: true });
+      await fsp.mkdir(path2.dirname(destPath), { recursive: true });
       try {
-        fs3.copyFileSync(sourcePath, destPath, fs3.constants.COPYFILE_EXCL);
+        await fsp.copyFile(sourcePath, destPath, fs3.constants.COPYFILE_EXCL);
         copiedFiles.push(destPath);
       } catch (err2) {
         if (err2.code !== "EEXIST")
@@ -17104,15 +17117,11 @@ function copyBundledDirectoryBounded(sourceDir, destDir) {
       }
     }
   } catch (err2) {
-    rollbackCopiedFiles(copiedFiles, destDir);
+    await rollbackCopiedFilesAsync(copiedFiles, destDir);
     throw err2;
   }
 }
-function warnBundledSkillSyncFailure(err2) {
-  const message = err2 instanceof Error ? err2.message : String(err2);
-  console.warn(`[opencode-swarm] Could not install bundled project skills; continuing without sync: ${message}`);
-}
-function syncBundledProjectSkillsIfMissing(projectDirectory, packageRoot, quiet = false) {
+async function syncBundledProjectSkillsIfMissingAsync(projectDirectory, packageRoot, quiet = false) {
   try {
     const cacheKey = getSyncCacheKey(projectDirectory, packageRoot);
     if (syncedProjectSkillTargets.has(cacheKey))
@@ -17121,23 +17130,23 @@ function syncBundledProjectSkillsIfMissing(projectDirectory, packageRoot, quiet
     const opencodeDir = path2.join(projectDirectory, ".opencode");
     const skillsDir = path2.join(opencodeDir, "skills");
     let sawBundledSource = false;
-    if (!ensureNotSymlinkedDirectory(opencodeDir))
+    if (!await ensureNotSymlinkedDirectoryAsync(opencodeDir))
       return;
-    if (!ensureNotSymlinkedDirectory(skillsDir))
+    if (!await ensureNotSymlinkedDirectoryAsync(skillsDir))
       return;
     for (const slug of BUNDLED_PROJECT_SKILLS) {
       const sourceDir = path2.join(sourceRoot, slug);
       const sourceSkill = path2.join(sourceDir, "SKILL.md");
       const destDir = path2.join(skillsDir, slug);
       const destSkill = path2.join(destDir, "SKILL.md");
-      if (!fs3.existsSync(sourceSkill))
+      if (!await pathExistsAsync(sourceSkill))
         continue;
       sawBundledSource = true;
-      if (fs3.existsSync(destSkill))
+      if (await pathExistsAsync(destSkill))
         continue;
-      if (!ensureNotSymlinkedDirectory(destDir))
+      if (!await ensureNotSymlinkedDirectoryAsync(destDir))
         continue;
-      copyBundledDirectoryBounded(sourceDir, destDir);
+      await copyBundledDirectoryBoundedAsync(sourceDir, destDir);
       if (!quiet) {
         console.warn(`[opencode-swarm] Installed bundled skill .opencode/skills/${slug}/SKILL.md for first-class /swarm command support`);
       }
@@ -17918,21 +17927,21 @@ function hash2(content) {
   return createHash("sha256").update(content, "utf-8").digest("hex");
 }
 function readTextBounded(absPath) {
-  const stat3 = fs5.lstatSync(absPath);
-  if (!stat3.isFile() || stat3.size > MAX_SOURCE_BYTES) {
+  const stat4 = fs5.lstatSync(absPath);
+  if (!stat4.isFile() || stat4.size > MAX_SOURCE_BYTES) {
     return null;
   }
   return fs5.readFileSync(absPath, "utf-8");
 }
 function fileArtifact(root, absPath) {
   try {
-    const stat3 = fs5.lstatSync(absPath);
-    if (!stat3.isFile() || stat3.size > MAX_SOURCE_BYTES)
+    const stat4 = fs5.lstatSync(absPath);
+    if (!stat4.isFile() || stat4.size > MAX_SOURCE_BYTES)
       return null;
     return {
       relPath: toPosix(path6.relative(root, absPath)),
-      bytes: stat3.size,
-      mtimeMs: stat3.mtimeMs
+      bytes: stat4.size,
+      mtimeMs: stat4.mtimeMs
     };
   } catch {
     return null;
@@ -18223,14 +18232,14 @@ function readEffectiveSpecSync(directory) {
   const root = path6.resolve(directory);
   const swSpecPath = path6.join(root, SWARM_SPEC_REL);
   try {
-    const stat3 = fs5.lstatSync(swSpecPath);
-    if (stat3.isFile() && stat3.size <= MAX_SPEC_BYTES) {
+    const stat4 = fs5.lstatSync(swSpecPath);
+    if (stat4.isFile() && stat4.size <= MAX_SPEC_BYTES) {
       const content = fs5.readFileSync(swSpecPath, "utf-8");
       return {
         source: "swarm",
         content,
         hash: hash2(content),
-        mtime: stat3.mtime.toISOString(),
+        mtime: stat4.mtime.toISOString(),
         sourcePaths: [toPosix(SWARM_SPEC_REL)],
         warnings: []
       };
@@ -18769,9 +18778,9 @@ var init_ledger = __esm(() => {
 
 // src/plan/manager.ts
 import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync6,
-  readdirSync as readdirSync3,
+  copyFileSync,
+  existsSync as existsSync5,
+  readdirSync as readdirSync2,
   renameSync as renameSync4,
   unlinkSync
 } from "node:fs";
@@ -19215,7 +19224,7 @@ async function savePlan(directory, plan, options) {
       const oldLedgerPath = path8.join(swarmDir2, "plan-ledger.jsonl");
       const oldLedgerBackupPath = path8.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
       let backupExists = false;
-      if (existsSync6(oldLedgerPath)) {
+      if (existsSync5(oldLedgerPath)) {
         try {
           renameSync4(oldLedgerPath, oldLedgerBackupPath);
           backupExists = true;
@@ -19232,15 +19241,15 @@ async function savePlan(directory, plan, options) {
           const errorMessage = String(initErr);
           if (errorMessage.includes("already initialized")) {
             try {
-              if (existsSync6(oldLedgerBackupPath))
+              if (existsSync5(oldLedgerBackupPath))
                 unlinkSync(oldLedgerBackupPath);
             } catch {}
           } else {
-            if (existsSync6(oldLedgerBackupPath)) {
+            if (existsSync5(oldLedgerBackupPath)) {
               try {
                 renameSync4(oldLedgerBackupPath, oldLedgerPath);
               } catch {
-                copyFileSync2(oldLedgerBackupPath, oldLedgerPath);
+                copyFileSync(oldLedgerBackupPath, oldLedgerPath);
                 try {
                   unlinkSync(oldLedgerBackupPath);
                 } catch {}
@@ -19258,19 +19267,19 @@ async function savePlan(directory, plan, options) {
         } catch (renameErr) {
           warn(`[savePlan] Could not archive old ledger (rename failed: ${renameErr instanceof Error ? renameErr.message : String(renameErr)}). Old ledger may still exist at ${oldLedgerBackupPath}.`);
           try {
-            if (existsSync6(oldLedgerBackupPath))
+            if (existsSync5(oldLedgerBackupPath))
               unlinkSync(oldLedgerBackupPath);
           } catch {}
         }
       } else if (!initSucceeded && backupExists) {
         try {
-          if (existsSync6(oldLedgerBackupPath))
+          if (existsSync5(oldLedgerBackupPath))
             unlinkSync(oldLedgerBackupPath);
         } catch {}
       }
       const MAX_ARCHIVED_SIBLINGS = 5;
       try {
-        const allFiles = readdirSync3(swarmDir2);
+        const allFiles = readdirSync2(swarmDir2);
         const archivedSiblings = allFiles.filter((f) => f.startsWith("plan-ledger.archived-") && f.endsWith(".jsonl")).sort();
         if (archivedSiblings.length > MAX_ARCHIVED_SIBLINGS) {
           const toRemove = archivedSiblings.slice(0, archivedSiblings.length - MAX_ARCHIVED_SIBLINGS);
@@ -20067,11 +20076,11 @@ function handleAgentsCommand(agents, guardrails) {
     const temp = agent.config.temperature !== undefined ? agent.config.temperature.toString() : "default";
     const tools = agent.config.tools || {};
     const isReadOnly = tools.write === false || tools.edit === false;
-    const access2 = isReadOnly ? "\uD83D\uDD12 read-only" : "✏️ read-write";
+    const access3 = isReadOnly ? "\uD83D\uDD12 read-only" : "✏️ read-write";
     const desc = agent.description || agent.config.description || "";
     const hasCustomProfile = guardrails?.profiles?.[key] !== undefined;
     const profileIndicator = hasCustomProfile ? " | ⚡ custom limits" : "";
-    lines.push(`- **${key}** | model: \`${model}\` | temp: ${temp} | ${access2}${profileIndicator}`);
+    lines.push(`- **${key}** | model: \`${model}\` | temp: ${temp} | ${access3}${profileIndicator}`);
     if (desc) {
       lines.push(`  ${desc}`);
     }
@@ -20679,8 +20688,8 @@ GFS4: `);
     }
     var fs$copyFile = fs8.copyFile;
     if (fs$copyFile)
-      fs8.copyFile = copyFile;
-    function copyFile(src, dest, flags2, cb) {
+      fs8.copyFile = copyFile2;
+    function copyFile2(src, dest, flags2, cb) {
       if (typeof flags2 === "function") {
         cb = flags2;
         flags2 = 0;
@@ -20698,9 +20707,9 @@ GFS4: `);
       }
     }
     var fs$readdir = fs8.readdir;
-    fs8.readdir = readdir;
+    fs8.readdir = readdir2;
     var noReaddirOptionVersions = /^v[0-5]\./;
-    function readdir(path9, options, cb) {
+    function readdir2(path9, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
       var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path10, options2, cb2, startTime) {
@@ -21289,11 +21298,11 @@ var require_mtime_precision = __commonJS((exports, module2) => {
   function probe(file2, fs7, callback) {
     const cachedPrecision = fs7[cacheSymbol];
     if (cachedPrecision) {
-      return fs7.stat(file2, (err2, stat3) => {
+      return fs7.stat(file2, (err2, stat4) => {
         if (err2) {
           return callback(err2);
         }
-        callback(null, stat3.mtime, cachedPrecision);
+        callback(null, stat4.mtime, cachedPrecision);
       });
     }
     const mtime = new Date(Math.ceil(Date.now() / 1000) * 1000 + 5);
@@ -21301,13 +21310,13 @@ var require_mtime_precision = __commonJS((exports, module2) => {
       if (err2) {
         return callback(err2);
       }
-      fs7.stat(file2, (err3, stat3) => {
+      fs7.stat(file2, (err3, stat4) => {
         if (err3) {
           return callback(err3);
         }
-        const precision = stat3.mtime.getTime() % 1000 === 0 ? "s" : "ms";
+        const precision = stat4.mtime.getTime() % 1000 === 0 ? "s" : "ms";
         Object.defineProperty(fs7, cacheSymbol, { value: precision });
-        callback(null, stat3.mtime, precision);
+        callback(null, stat4.mtime, precision);
       });
     });
   }
@@ -21357,14 +21366,14 @@ var require_lockfile = __commonJS((exports, module2) => {
       if (options.stale <= 0) {
         return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file: file2 }));
       }
-      options.fs.stat(lockfilePath, (err3, stat3) => {
+      options.fs.stat(lockfilePath, (err3, stat4) => {
         if (err3) {
           if (err3.code === "ENOENT") {
             return acquireLock(file2, { ...options, stale: 0 }, callback);
           }
           return callback(err3);
         }
-        if (!isLockStale(stat3, options)) {
+        if (!isLockStale(stat4, options)) {
           return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file: file2 }));
         }
         removeLock(file2, options, (err4) => {
@@ -21376,8 +21385,8 @@ var require_lockfile = __commonJS((exports, module2) => {
       });
     });
   }
-  function isLockStale(stat3, options) {
-    return stat3.mtime.getTime() < Date.now() - options.stale;
+  function isLockStale(stat4, options) {
+    return stat4.mtime.getTime() < Date.now() - options.stale;
   }
   function removeLock(file2, options, callback) {
     options.fs.rmdir(getLockFile(file2, options), (err2) => {
@@ -21395,7 +21404,7 @@ var require_lockfile = __commonJS((exports, module2) => {
     lock2.updateDelay = lock2.updateDelay || options.update;
     lock2.updateTimeout = setTimeout(() => {
       lock2.updateTimeout = null;
-      options.fs.stat(lock2.lockfilePath, (err2, stat3) => {
+      options.fs.stat(lock2.lockfilePath, (err2, stat4) => {
         const isOverThreshold = lock2.lastUpdate + options.stale < Date.now();
         if (err2) {
           if (err2.code === "ENOENT" || isOverThreshold) {
@@ -21404,7 +21413,7 @@ var require_lockfile = __commonJS((exports, module2) => {
           lock2.updateDelay = 1000;
           return updateLock(file2, options);
         }
-        const isMtimeOurs = lock2.mtime.getTime() === stat3.mtime.getTime();
+        const isMtimeOurs = lock2.mtime.getTime() === stat4.mtime.getTime();
         if (!isMtimeOurs) {
           return setLockAsCompromised(file2, lock2, Object.assign(new Error("Unable to update lock within the stale threshold"), { code: "ECOMPROMISED" }));
         }
@@ -21522,11 +21531,11 @@ var require_lockfile = __commonJS((exports, module2) => {
       if (err2) {
         return callback(err2);
       }
-      options.fs.stat(getLockFile(file3, options), (err3, stat3) => {
+      options.fs.stat(getLockFile(file3, options), (err3, stat4) => {
         if (err3) {
           return err3.code === "ENOENT" ? callback(null, false) : callback(err3);
         }
-        return callback(null, !isLockStale(stat3, options));
+        return callback(null, !isLockStale(stat4, options));
       });
     });
   }
@@ -21733,8 +21742,8 @@ function listActiveLocks(directory) {
       continue;
     const lockPath = path9.join(locksDir, file2);
     try {
-      const stat3 = fs7.statSync(lockPath);
-      if (stat3.isFile()) {
+      const stat4 = fs7.statSync(lockPath);
+      if (stat4.isFile()) {
         const plLockDir = `${lockPath}.lock`;
         if (fs7.existsSync(plLockDir)) {
           const metaPath = getMetaPath(lockPath);
@@ -22013,11 +22022,11 @@ var init_task_id = __esm(() => {
 
 // src/evidence/manager.ts
 import {
-  mkdirSync as mkdirSync6,
-  readdirSync as readdirSync5,
+  mkdirSync as mkdirSync5,
+  readdirSync as readdirSync4,
   realpathSync,
-  rmSync as rmSync2,
-  statSync as statSync6
+  rmSync,
+  statSync as statSync5
 } from "node:fs";
 import * as fs8 from "node:fs/promises";
 import * as path10 from "node:path";
@@ -22046,11 +22055,11 @@ function validateProjectRoot(directory) {
       break;
     const parentSwarm = path10.join(parent, ".swarm");
     try {
-      if (statSync6(parentSwarm).isDirectory()) {
+      if (statSync5(parentSwarm).isDirectory()) {
         let hasProjectIndicator = false;
         for (const indicator of PROJECT_INDICATORS) {
           try {
-            const indicatorStat = statSync6(path10.join(parent, indicator));
+            const indicatorStat = statSync5(path10.join(parent, indicator));
             if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
               hasProjectIndicator = true;
               break;
@@ -22124,14 +22133,14 @@ async function saveEvidence(directory, taskId, evidence) {
     if (bundleJson.length > EVIDENCE_MAX_JSON_BYTES) {
       throw new Error(`Evidence bundle size (${bundleJson.length} bytes) exceeds maximum (${EVIDENCE_MAX_JSON_BYTES} bytes)`);
     }
-    mkdirSync6(evidenceDir, { recursive: true });
+    mkdirSync5(evidenceDir, { recursive: true });
     const tempPath = path10.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
       await fs8.rename(tempPath, evidencePath);
     } catch (error49) {
       try {
-        rmSync2(tempPath, { force: true });
+        rmSync(tempPath, { force: true });
       } catch {}
       throw error49;
     }
@@ -22190,7 +22199,7 @@ async function loadEvidence(directory, taskId) {
             await fs8.rename(tempPath, evidencePath);
           } catch (writeError) {
             try {
-              rmSync2(tempPath, { force: true });
+              rmSync(tempPath, { force: true });
             } catch {}
             warn(`Failed to persist repaired flat retrospective for task ${sanitizedTaskId}: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
           }
@@ -22217,13 +22226,13 @@ async function loadEvidence(directory, taskId) {
 async function listEvidenceTaskIds(directory) {
   const evidenceBasePath = validateSwarmPath(directory, "evidence");
   try {
-    statSync6(evidenceBasePath);
+    statSync5(evidenceBasePath);
   } catch {
     return [];
   }
   let entries;
   try {
-    entries = readdirSync5(evidenceBasePath);
+    entries = readdirSync4(evidenceBasePath);
   } catch {
     return [];
   }
@@ -22231,7 +22240,7 @@ async function listEvidenceTaskIds(directory) {
   for (const entry of entries) {
     const entryPath = path10.join(evidenceBasePath, entry);
     try {
-      const stats = statSync6(entryPath);
+      const stats = statSync5(entryPath);
       if (!stats.isDirectory()) {
         continue;
       }
@@ -22250,12 +22259,12 @@ async function deleteEvidence(directory, taskId) {
   const relativePath = path10.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
-    statSync6(evidenceDir);
+    statSync5(evidenceDir);
   } catch {
     return false;
   }
   try {
-    rmSync2(evidenceDir, { recursive: true, force: true });
+    rmSync(evidenceDir, { recursive: true, force: true });
     return true;
   } catch (error49) {
     warn(`Failed to delete evidence for task ${sanitizedTaskId}: ${error49 instanceof Error ? error49.message : String(error49)}`);
@@ -22441,7 +22450,7 @@ var init_archive = __esm(() => {
 });
 
 // src/db/project-db.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync7 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync6 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import { join as join10, resolve as resolve7 } from "node:path";
 function loadDatabaseCtor() {
@@ -22476,7 +22485,7 @@ function projectDbPath(directory) {
   return join10(resolve7(directory), ".swarm", "swarm.db");
 }
 function projectDbExists(directory) {
-  return existsSync8(projectDbPath(directory));
+  return existsSync7(projectDbPath(directory));
 }
 function getProjectDb(directory) {
   const key = resolve7(directory);
@@ -22484,7 +22493,7 @@ function getProjectDb(directory) {
   if (existing)
     return existing;
   const swarmDir = join10(key, ".swarm");
-  mkdirSync7(swarmDir, { recursive: true });
+  mkdirSync6(swarmDir, { recursive: true });
   const Db = loadDatabaseCtor();
   const db = new Db(join10(swarmDir, "swarm.db"));
   db.run("PRAGMA journal_mode = WAL;");
@@ -25557,16 +25566,16 @@ function checkWriteTargetForSymlink(targetPath, cwd) {
     current = parent;
   }
   for (const ancestor of ancestors) {
-    let stat3 = null;
+    let stat4 = null;
     try {
-      stat3 = fsSync2.lstatSync(ancestor);
+      stat4 = fsSync2.lstatSync(ancestor);
     } catch (err2) {
       const code = err2.code;
       if (code === "ENOENT")
         continue;
       return `WRITE BLOCKED: lstat failed on "${ancestor}": ${String(err2)} — refusing write on unverifiable path`;
     }
-    if (stat3.isSymbolicLink()) {
+    if (stat4.isSymbolicLink()) {
       return `WRITE BLOCKED: "${ancestor}" is a symlink — writing through a symlink could redirect the write outside the working directory`;
     }
   }
@@ -26359,9 +26368,9 @@ function dcLstatAncestorWalk(targetPath, cwd) {
     current = parent;
   }
   for (const ancestor of ancestors) {
-    let stat3 = null;
+    let stat4 = null;
     try {
-      stat3 = fsSync3.lstatSync(ancestor);
+      stat4 = fsSync3.lstatSync(ancestor);
     } catch (err2) {
       const code = err2.code;
       if (code === "ENOENT") {
@@ -26369,7 +26378,7 @@ function dcLstatAncestorWalk(targetPath, cwd) {
       }
       return `lstat failed on "${ancestor}": ${String(err2)} — refusing to allow destructive operation on unverifiable path`;
     }
-    if (stat3.isSymbolicLink()) {
+    if (stat4.isSymbolicLink()) {
       return `BLOCKED: "${ancestor}" is a symlink/junction — deleting recursively through it would destroy the link target. Use platform-specific junction deletion (fsutil reparsepoint delete, Remove-Item without -Recurse) instead.`;
     }
   }
@@ -28458,13 +28467,13 @@ function readScopeFromDisk(directory, taskId) {
   }
   let raw;
   try {
-    const stat3 = fs12.fstatSync(fd);
-    if (!stat3.isFile())
+    const stat4 = fs12.fstatSync(fd);
+    if (!stat4.isFile())
       return null;
-    if (stat3.size > MAX_SCOPE_BYTES)
+    if (stat4.size > MAX_SCOPE_BYTES)
       return null;
-    const buf = Buffer.alloc(stat3.size);
-    fs12.readSync(fd, buf, 0, stat3.size, 0);
+    const buf = Buffer.alloc(stat4.size);
+    fs12.readSync(fd, buf, 0, stat4.size, 0);
     raw = buf.toString("utf-8");
   } catch {
     return null;
@@ -28504,10 +28513,10 @@ function readPlanScope(directory, taskId) {
     return null;
   try {
     const planPath = path19.join(directory, ".swarm", "plan.json");
-    const stat3 = fs12.statSync(planPath);
-    if (!stat3.isFile())
+    const stat4 = fs12.statSync(planPath);
+    if (!stat4.isFile())
       return null;
-    if (stat3.size > MAX_PLAN_BYTES)
+    if (stat4.size > MAX_PLAN_BYTES)
       return null;
     const raw = fs12.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
@@ -42397,7 +42406,7 @@ __export(exports_gate_evidence, {
   deriveRequiredGates: () => deriveRequiredGates,
   DEFAULT_REQUIRED_GATES: () => DEFAULT_REQUIRED_GATES
 });
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync7, realpathSync as realpathSync5 } from "node:fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync7, realpathSync as realpathSync5 } from "node:fs";
 import * as path26 from "node:path";
 function isValidTaskId(taskId) {
   return isStrictTaskId(taskId);
@@ -42435,7 +42444,7 @@ function expandRequiredGates(existingGates, newAgentType) {
 function getEvidenceDir(directory) {
   const swarmDir = path26.resolve(directory, ".swarm");
   const evidenceDir = path26.join(swarmDir, "evidence");
-  mkdirSync11(evidenceDir, { recursive: true });
+  mkdirSync10(evidenceDir, { recursive: true });
   let resolvedSwarmDir;
   let resolvedEvidenceDir;
   try {
@@ -59361,8 +59370,8 @@ __export(exports_knowledge_store, {
   _internals: () => _internals22,
   OUTCOME_SIGNAL_SMOOTHING: () => OUTCOME_SIGNAL_SMOOTHING
 });
-import { existsSync as existsSync14 } from "node:fs";
-import { appendFile as appendFile3, mkdir as mkdir3, readFile as readFile4 } from "node:fs/promises";
+import { existsSync as existsSync13 } from "node:fs";
+import { appendFile as appendFile3, mkdir as mkdir4, readFile as readFile4 } from "node:fs/promises";
 import * as os9 from "node:os";
 import * as path31 from "node:path";
 function getPlatformConfigDir() {
@@ -59403,7 +59412,7 @@ function resolveHiveRejectedPath() {
   return path31.join(path31.dirname(hivePath), "shared-learnings-rejected.jsonl");
 }
 async function readKnowledge(filePath) {
-  if (!existsSync14(filePath))
+  if (!existsSync13(filePath))
     return [];
   const content = await readFile4(filePath, "utf-8");
   const results = [];
@@ -59498,7 +59507,7 @@ async function appendRetractionRecord(directory, record3) {
 }
 async function appendKnowledge(filePath, entry) {
   const dir = path31.dirname(filePath);
-  await mkdir3(dir, { recursive: true });
+  await mkdir4(dir, { recursive: true });
   let release = null;
   try {
     release = await import_proper_lockfile3.default.lock(dir, {
@@ -59517,7 +59526,7 @@ async function appendKnowledge(filePath, entry) {
 }
 async function rewriteKnowledge(filePath, entries) {
   const dir = path31.dirname(filePath);
-  await mkdir3(dir, { recursive: true });
+  await mkdir4(dir, { recursive: true });
   let release = null;
   try {
     release = await import_proper_lockfile3.default.lock(dir, {
@@ -59539,7 +59548,7 @@ async function rewriteKnowledge(filePath, entries) {
 async function transactFile(filePath, read, write, mutate) {
   const dir = path31.dirname(filePath);
   try {
-    await mkdir3(dir, { recursive: true });
+    await mkdir4(dir, { recursive: true });
   } catch {
     return false;
   }
@@ -59800,7 +59809,7 @@ async function applyConfidenceDeltas(filePath, deltas) {
   let release = null;
   try {
     const dir = path31.dirname(filePath);
-    await mkdir3(dir, { recursive: true });
+    await mkdir4(dir, { recursive: true });
     release = await import_proper_lockfile3.default.lock(dir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
       stale: 5000
@@ -59890,8 +59899,8 @@ __export(exports_knowledge_events, {
   KNOWLEDGE_EVENT_SCHEMA_VERSION: () => KNOWLEDGE_EVENT_SCHEMA_VERSION
 });
 import { randomUUID as randomUUID2 } from "node:crypto";
-import { existsSync as existsSync15 } from "node:fs";
-import { appendFile as appendFile4, mkdir as mkdir4, readFile as readFile5, stat as stat3 } from "node:fs/promises";
+import { existsSync as existsSync14 } from "node:fs";
+import { appendFile as appendFile4, mkdir as mkdir5, readFile as readFile5, stat as stat4 } from "node:fs/promises";
 import * as path32 from "node:path";
 function resolveKnowledgeEventsPath(directory) {
   return path32.join(directory, ".swarm", "knowledge-events.jsonl");
@@ -59920,7 +59929,7 @@ async function appendKnowledgeEvent(directory, event) {
   const populated = withDefaults(event);
   const filePath = resolveKnowledgeEventsPath(directory);
   const dirPath = path32.dirname(filePath);
-  await mkdir4(dirPath, { recursive: true });
+  await mkdir5(dirPath, { recursive: true });
   let release;
   try {
     release = await import_proper_lockfile4.default.lock(dirPath, {
@@ -59959,7 +59968,7 @@ async function recordKnowledgeEvent(directory, event) {
 }
 async function readKnowledgeEvents(directory) {
   const filePath = resolveKnowledgeEventsPath(directory);
-  if (!existsSync15(filePath))
+  if (!existsSync14(filePath))
     return [];
   const content = await readFile5(filePath, "utf-8");
   return parseEventLines(content.split(`
@@ -59967,7 +59976,7 @@ async function readKnowledgeEvents(directory) {
 }
 async function readLegacyApplicationRecords(directory) {
   const filePath = resolveLegacyApplicationLogPath(directory);
-  if (!existsSync15(filePath))
+  if (!existsSync14(filePath))
     return [];
   const content = await readFile5(filePath, "utf-8");
   const out2 = [];
@@ -60057,7 +60066,7 @@ function maxIso(current, candidate) {
 }
 async function readCounterBaseline(directory) {
   const filePath = resolveKnowledgeCounterBaselinePath(directory);
-  if (!existsSync15(filePath))
+  if (!existsSync14(filePath))
     return new Map;
   const raw = JSON.parse(await readFile5(filePath, "utf-8"));
   const map3 = new Map;
@@ -60077,7 +60086,7 @@ async function writeCounterBaseline(directory, baseline) {
 }
 async function statCacheKey(filePath) {
   try {
-    const fileStat = await stat3(filePath);
+    const fileStat = await stat4(filePath);
     return `${fileStat.mtimeMs}:${fileStat.ctimeMs}:${fileStat.size}`;
   } catch (err2) {
     if (err2?.code === "ENOENT")
@@ -60372,7 +60381,7 @@ var init_knowledge_events = __esm(() => {
 });
 
 // src/hooks/knowledge-escalator.ts
-import { existsSync as existsSync16 } from "node:fs";
+import { existsSync as existsSync15 } from "node:fs";
 function isFullyEscalated(e) {
   return e.directive_priority === "critical" && e.enforcement_mode === "enforce";
 }
@@ -60384,7 +60393,7 @@ async function maybeEscalateOnViolation(directory, entryId, now = new Date) {
         const allEntries = [];
         allEntries.push(...await readKnowledge(resolveSwarmKnowledgePath(directory)));
         const hivePath = resolveHiveKnowledgePath();
-        if (existsSync16(hivePath)) {
+        if (existsSync15(hivePath)) {
           allEntries.push(...await readKnowledge(hivePath));
         }
         const target = allEntries.find((e) => e.id === entryId);
@@ -60439,7 +60448,7 @@ async function maybeEscalateOnViolation(directory, entryId, now = new Date) {
     await transactKnowledge(resolveSwarmKnowledgePath(directory), mutate);
     if (state.outcome.kind === "not_found") {
       const hivePath = resolveHiveKnowledgePath();
-      if (existsSync16(hivePath)) {
+      if (existsSync15(hivePath)) {
         await transactKnowledge(hivePath, mutate);
       }
     }
@@ -60911,7 +60920,7 @@ var init_learning_metrics = __esm(() => {
 });
 
 // src/hooks/knowledge-validator.ts
-import { appendFile as appendFile5, mkdir as mkdir5 } from "node:fs/promises";
+import { appendFile as appendFile5, mkdir as mkdir6 } from "node:fs/promises";
 import * as path33 from "node:path";
 function normalizeText(text) {
   return text.normalize("NFKC").toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
@@ -61182,7 +61191,7 @@ function resolveUnactionablePath(directory) {
 async function appendUnactionable(directory, entry, reason) {
   const filePath = resolveUnactionablePath(directory);
   const dirPath = path33.dirname(filePath);
-  await mkdir5(dirPath, { recursive: true });
+  await mkdir6(dirPath, { recursive: true });
   await transactKnowledge(filePath, (existing) => {
     const record3 = {
       ...entry,
@@ -61219,7 +61228,7 @@ async function quarantineEntry(directory, entryId, reason, reportedBy) {
   const quarantinePath = path33.join(directory, ".swarm", "knowledge-quarantined.jsonl");
   const rejectedPath = path33.join(directory, ".swarm", "knowledge-rejected.jsonl");
   const swarmDir = path33.join(directory, ".swarm");
-  await mkdir5(swarmDir, { recursive: true });
+  await mkdir6(swarmDir, { recursive: true });
   let release;
   try {
     release = await import_proper_lockfile5.default.lock(swarmDir, {
@@ -61283,7 +61292,7 @@ async function restoreEntry(directory, entryId) {
   const quarantinePath = path33.join(directory, ".swarm", "knowledge-quarantined.jsonl");
   const rejectedPath = path33.join(directory, ".swarm", "knowledge-rejected.jsonl");
   const swarmDir = path33.join(directory, ".swarm");
-  await mkdir5(swarmDir, { recursive: true });
+  await mkdir6(swarmDir, { recursive: true });
   let release;
   try {
     release = await import_proper_lockfile5.default.lock(swarmDir, {
@@ -61461,7 +61470,7 @@ var init_knowledge_validator = __esm(() => {
 });
 
 // src/services/skill-changelog.ts
-import { appendFile as appendFile6, mkdir as mkdir6, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
+import { appendFile as appendFile6, mkdir as mkdir7, readFile as readFile6, writeFile as writeFile3 } from "node:fs/promises";
 import * as path34 from "node:path";
 function resolveSkillChangelogPath(directory, slug) {
   if (slug.includes("..") || slug.includes("/") || slug.includes("\\")) {
@@ -61472,7 +61481,7 @@ function resolveSkillChangelogPath(directory, slug) {
 async function appendSkillChangelog(directory, slug, entry) {
   const filePath = resolveSkillChangelogPath(directory, slug);
   const dirPath = path34.dirname(filePath);
-  await mkdir6(dirPath, { recursive: true });
+  await mkdir7(dirPath, { recursive: true });
   await appendFile6(filePath, `${JSON.stringify(entry)}
 `, "utf-8");
   try {
@@ -61519,8 +61528,8 @@ __export(exports_skill_generator, {
   DEFAULT_SKILL_MIN_CONFIRMATIONS: () => DEFAULT_SKILL_MIN_CONFIRMATIONS,
   DEFAULT_SKILL_MIN_CONFIDENCE: () => DEFAULT_SKILL_MIN_CONFIDENCE
 });
-import { existsSync as existsSync17, unlinkSync as unlinkSync5 } from "node:fs";
-import { mkdir as mkdir7, readFile as readFile7, rename as rename3, writeFile as writeFile4 } from "node:fs/promises";
+import { existsSync as existsSync16, unlinkSync as unlinkSync5 } from "node:fs";
+import { mkdir as mkdir8, readFile as readFile7, rename as rename3, writeFile as writeFile4 } from "node:fs/promises";
 import * as path35 from "node:path";
 function sanitizeSlug(input) {
   const lc = input.toLowerCase().trim();
@@ -61543,7 +61552,7 @@ function activeRepoRelativePath(slug) {
 async function selectCandidateEntries(directory, opts) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync17(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync16(hivePath) ? await readKnowledge(hivePath) : [];
   const all = [...swarm, ...hive];
   const counterRollups = await readKnowledgeCounterRollups(directory);
   const selected = [];
@@ -61744,7 +61753,7 @@ function escapeMarkdown(s) {
   return s.replace(/[\r\n]+/g, " ").slice(0, 280);
 }
 async function atomicWrite2(p, content) {
-  await mkdir7(path35.dirname(p), { recursive: true });
+  await mkdir8(path35.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmp, content, "utf-8");
   await rename3(tmp, p);
@@ -61761,7 +61770,7 @@ async function generateSkills(req) {
     const idSet = new Set(req.sourceKnowledgeIds);
     const swarm = await readKnowledge(resolveSwarmKnowledgePath(req.directory));
     const hivePath = resolveHiveKnowledgePath();
-    const hive = existsSync17(hivePath) ? await readKnowledge(hivePath) : [];
+    const hive = existsSync16(hivePath) ? await readKnowledge(hivePath) : [];
     pool = [...swarm, ...hive].filter((e) => idSet.has(e.id) && e.status !== "archived");
   } else {
     pool = candidates;
@@ -61798,7 +61807,7 @@ async function generateSkills(req) {
       continue;
     }
     let preserved = false;
-    if (req.mode === "active" && existsSync17(targetPath) && !req.force) {
+    if (req.mode === "active" && existsSync16(targetPath) && !req.force) {
       const existing = await readFile7(targetPath, "utf-8");
       if (!existing.includes("generated by opencode-swarm skill-generator")) {
         preserved = true;
@@ -61843,7 +61852,7 @@ async function stampSourceEntries(directory, slug, ids) {
   if (touched)
     await rewriteKnowledge(swarmPath, swarm);
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync17(hivePath))
+  if (!existsSync16(hivePath))
     return;
   const hive = await readKnowledge(hivePath);
   let touchedHive = false;
@@ -61941,7 +61950,7 @@ async function activateProposal(directory, slug, force = false) {
   }
   const from = proposalPath(directory, cleanSlug);
   const to = activePath(directory, cleanSlug);
-  if (!existsSync17(from)) {
+  if (!existsSync16(from)) {
     return {
       activated: false,
       from,
@@ -61949,7 +61958,7 @@ async function activateProposal(directory, slug, force = false) {
       reason: `proposal not found: ${from}`
     };
   }
-  if (existsSync17(to) && !force) {
+  if (existsSync16(to) && !force) {
     const existing = await readFile7(to, "utf-8");
     if (!existing.includes("generated by opencode-swarm skill-generator")) {
       return {
@@ -62013,7 +62022,7 @@ async function listSkills(directory) {
   const proposalsDir = path35.join(directory, ".swarm", "skills", "proposals");
   const activeDir = path35.join(directory, ".opencode", "skills", "generated");
   const fs19 = await import("node:fs/promises");
-  if (existsSync17(proposalsDir)) {
+  if (existsSync16(proposalsDir)) {
     const entries = await fs19.readdir(proposalsDir);
     for (const f of entries) {
       if (!f.endsWith(".md"))
@@ -62025,16 +62034,16 @@ async function listSkills(directory) {
       });
     }
   }
-  if (existsSync17(activeDir)) {
+  if (existsSync16(activeDir)) {
     const entries = await fs19.readdir(activeDir, { withFileTypes: true });
     for (const e of entries) {
       if (!e.isDirectory())
         continue;
       const retiredMarker = path35.join(activeDir, e.name, "retired.marker");
-      if (existsSync17(retiredMarker))
+      if (existsSync16(retiredMarker))
         continue;
       const skillPath = path35.join(activeDir, e.name, "SKILL.md");
-      if (existsSync17(skillPath)) {
+      if (existsSync16(skillPath)) {
         result.active.push({
           slug: e.name,
           path: skillPath
@@ -62113,7 +62122,7 @@ async function inspectSkill(directory, slug, prefer = "auto") {
   if (prefer === "proposal" || prefer === "auto")
     candidates.push({ p: proposalPath(directory, cleanSlug), m: "draft" });
   for (const c of candidates) {
-    if (existsSync17(c.p)) {
+    if (existsSync16(c.p)) {
       const content = await readFile7(c.p, "utf-8");
       return { found: true, path: c.p, content, mode: c.m };
     }
@@ -62131,7 +62140,7 @@ async function retireSkill(directory, slug, reason) {
     };
   }
   const skillPath = activePath(directory, cleanSlug);
-  if (!existsSync17(skillPath)) {
+  if (!existsSync16(skillPath)) {
     return {
       retired: false,
       path: skillPath,
@@ -62145,7 +62154,7 @@ async function retireSkill(directory, slug, reason) {
     retiredAt: new Date().toISOString(),
     reason: reason ?? "manual_retire"
   });
-  await mkdir7(markerDir, { recursive: true });
+  await mkdir8(markerDir, { recursive: true });
   await writeFile4(markerPath, markerContent, "utf-8");
   return {
     retired: true,
@@ -62165,7 +62174,7 @@ async function regenerateSkill(directory, slug) {
     };
   }
   const skillPath = activePath(directory, cleanSlug);
-  if (!existsSync17(skillPath)) {
+  if (!existsSync16(skillPath)) {
     return {
       regenerated: false,
       path: skillPath,
@@ -62190,7 +62199,7 @@ async function regenerateSkill(directory, slug) {
     try {
       const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
       const hivePath = resolveHiveKnowledgePath();
-      const hive = existsSync17(hivePath) ? await readKnowledge(hivePath) : [];
+      const hive = existsSync16(hivePath) ? await readKnowledge(hivePath) : [];
       const all = [...swarm, ...hive];
       const idSet = new Set(fm.sourceKnowledgeIds);
       matchedEntries = all.filter((e) => idSet.has(e.id));
@@ -62339,8 +62348,8 @@ var init_skill_generator = __esm(() => {
 });
 
 // src/services/skill-improver-quota.ts
-import { existsSync as existsSync18 } from "node:fs";
-import { mkdir as mkdir8, readFile as readFile8, rename as rename4, writeFile as writeFile5 } from "node:fs/promises";
+import { existsSync as existsSync17 } from "node:fs";
+import { mkdir as mkdir9, readFile as readFile8, rename as rename4, writeFile as writeFile5 } from "node:fs/promises";
 import * as path36 from "node:path";
 async function acquireLock(dir) {
   const acquire = import_proper_lockfile6.default.lock(dir, LOCK_RETRY_OPTS);
@@ -62372,7 +62381,7 @@ function todayKey(window2, now = new Date) {
   return `${yr}-${m}-${d}`;
 }
 async function readState(filePath) {
-  if (!existsSync18(filePath))
+  if (!existsSync17(filePath))
     return null;
   try {
     const raw = await readFile8(filePath, "utf-8");
@@ -62386,7 +62395,7 @@ async function readState(filePath) {
   }
 }
 async function writeState(filePath, state) {
-  await mkdir8(path36.dirname(filePath), { recursive: true });
+  await mkdir9(path36.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}`;
   await writeFile5(tmp, JSON.stringify(state, null, 2), "utf-8");
   await rename4(tmp, filePath);
@@ -62409,7 +62418,7 @@ async function getQuotaState(directory, opts) {
 }
 async function reserveQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir8(path36.dirname(filePath), { recursive: true });
+  await mkdir9(path36.dirname(filePath), { recursive: true });
   let release = null;
   try {
     release = await acquireLock(path36.dirname(filePath));
@@ -62439,7 +62448,7 @@ async function reserveQuota(directory, opts) {
 }
 async function releaseQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir8(path36.dirname(filePath), { recursive: true });
+  await mkdir9(path36.dirname(filePath), { recursive: true });
   let release = null;
   try {
     release = await acquireLock(path36.dirname(filePath));
@@ -62848,8 +62857,8 @@ function appendSkillUsageEntry(directory, entry) {
   _internals26.appendFileSync(resolved, `${JSON.stringify(fullEntry)}
 `, "utf-8");
   try {
-    const stat4 = _internals26.statSync(resolved);
-    if (stat4.size > SKILL_USAGE_LOG_ROTATE_BYTES) {
+    const stat5 = _internals26.statSync(resolved);
+    if (stat5.size > SKILL_USAGE_LOG_ROTATE_BYTES) {
       _internals26.pruneSkillUsageLog(directory, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL);
     }
   } catch {}
@@ -62903,11 +62912,11 @@ function readSkillUsageEntriesTail(directory, filters, maxBytes = TAIL_BYTES_DEF
   try {
     const normalizedMaxBytes = Number.isFinite(maxBytes) ? maxBytes : TAIL_BYTES_DEFAULT;
     const boundedMaxBytes = Math.min(Math.max(1, normalizedMaxBytes), MAX_TAIL_BYTES);
-    const stat4 = _internals26.statSync(logPath);
-    const start2 = Math.max(0, stat4.size - boundedMaxBytes);
+    const stat5 = _internals26.statSync(logPath);
+    const start2 = Math.max(0, stat5.size - boundedMaxBytes);
     const fd = _internals26.openSync(logPath, "r");
     try {
-      const readLen = stat4.size - start2;
+      const readLen = stat5.size - start2;
       if (readLen === 0)
         return [];
       const buf = Buffer.alloc(readLen);
@@ -64428,10 +64437,10 @@ var init_hive_promoter = __esm(() => {
 
 // src/services/synonym-map.ts
 import {
-  mkdir as mkdir9,
+  mkdir as mkdir10,
   readFile as readFile10,
   rename as rename6,
-  stat as stat4,
+  stat as stat5,
   unlink as unlink2,
   writeFile as writeFile7
 } from "node:fs/promises";
@@ -64620,7 +64629,7 @@ async function readSynonymMap(directory, maxPairs = DEFAULT_MAX_PAIRS) {
   }
   try {
     const ceiling = Math.max(MIN_READ_CEILING_BYTES, Math.floor(maxPairs) * APPROX_BYTES_PER_PAIR);
-    const st = await stat4(filePath);
+    const st = await stat5(filePath);
     if (st.size > ceiling)
       return emptySynonymMap();
     const raw = await readFile10(filePath, "utf-8");
@@ -64630,7 +64639,7 @@ async function readSynonymMap(directory, maxPairs = DEFAULT_MAX_PAIRS) {
   }
 }
 async function writeSynonymMapAtomic(filePath, map3) {
-  await mkdir9(path40.dirname(filePath), { recursive: true });
+  await mkdir10(path40.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
     await writeFile7(tmp, JSON.stringify(map3, null, 2), "utf-8");
@@ -64644,7 +64653,7 @@ async function writeSynonymMapAtomic(filePath, map3) {
 async function rebuildSynonymMap(directory, entries, maxPairs = DEFAULT_MAX_PAIRS) {
   const filePath = resolveSynonymMapPath(directory);
   const dir = path40.dirname(filePath);
-  await mkdir9(dir, { recursive: true });
+  await mkdir10(dir, { recursive: true });
   let release = null;
   try {
     release = await import_proper_lockfile7.default.lock(dir, {
@@ -64933,8 +64942,8 @@ function formatSkillIndexWithContext(skills, directory) {
   const usageLogPath = path41.join(directory, ".swarm", "skill-usage.jsonl");
   let hasHistory = false;
   try {
-    const stat5 = fs21.statSync(usageLogPath);
-    hasHistory = stat5.size > 0;
+    const stat6 = fs21.statSync(usageLogPath);
+    hasHistory = stat6.size > 0;
   } catch {}
   if (!hasHistory) {
     return skills.map((sp) => {
@@ -65630,7 +65639,7 @@ var init_skill_propagation_gate = __esm(() => {
 });
 
 // src/hooks/micro-reflector.ts
-import { existsSync as existsSync22 } from "node:fs";
+import { existsSync as existsSync21 } from "node:fs";
 import { readFile as readFile11, writeFile as writeFile8 } from "node:fs/promises";
 import * as path43 from "node:path";
 function resolveInsightCandidatesPath(directory) {
@@ -65665,7 +65674,7 @@ async function readTaskTrajectory(directory, taskId) {
   try {
     const rel = path43.join("evidence", sanitizeTaskId2(taskId), "trajectory.jsonl");
     const filePath = validateSwarmPath(directory, rel);
-    if (!existsSync22(filePath))
+    if (!existsSync21(filePath))
       return [];
     const content = await readFile11(filePath, "utf-8");
     const out2 = [];
@@ -65908,8 +65917,8 @@ var init_micro_reflector = __esm(() => {
 });
 
 // src/hooks/knowledge-curator.ts
-import { existsSync as existsSync23 } from "node:fs";
-import { appendFile as appendFile7, mkdir as mkdir10, readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
+import { existsSync as existsSync22 } from "node:fs";
+import { appendFile as appendFile7, mkdir as mkdir11, readFile as readFile12, writeFile as writeFile9 } from "node:fs/promises";
 import * as path44 from "node:path";
 function pruneSeenRetroSections() {
   const cutoff = Date.now() - 86400000;
@@ -66171,7 +66180,7 @@ RETRY: your last output was missing ${result.missing.join("; ")}; produce valid
 async function appendCuratorSkippedEvent(directory, record3) {
   try {
     const filePath = path44.join(directory, ".swarm", "events.jsonl");
-    await mkdir10(path44.dirname(filePath), { recursive: true });
+    await mkdir11(path44.dirname(filePath), { recursive: true });
     await appendFile7(filePath, `${JSON.stringify({
       timestamp: new Date().toISOString(),
       event: "curator_skipped",
@@ -66198,7 +66207,7 @@ function readInsightJsonl2(content) {
 async function consumeInsightCandidates(directory, batchLimit = MESO_INSIGHT_BATCH_LIMIT) {
   try {
     const filePath = resolveInsightCandidatesPath(directory);
-    if (!existsSync23(filePath))
+    if (!existsSync22(filePath))
       return [];
     const consumed = [];
     await transactFile(filePath, async (p) => readInsightJsonl2(await readFile12(p, "utf-8").catch(() => "")), async (p, data) => {
@@ -66728,7 +66737,7 @@ var init_skill_improver_llm_factory = __esm(() => {
 });
 
 // src/services/trajectory-cluster.ts
-import { mkdir as mkdir11, writeFile as writeFile10 } from "node:fs/promises";
+import { mkdir as mkdir12, writeFile as writeFile10 } from "node:fs/promises";
 import * as path45 from "node:path";
 function failureKind(e) {
   const tool3 = (e.tool ?? "").toLowerCase();
@@ -66859,7 +66868,7 @@ async function writeMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const proposalsDir = validateSwarmPath(directory, path45.join("skills", "proposals"));
-    await mkdir11(proposalsDir, { recursive: true });
+    await mkdir12(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = `motif-${slugify2(motif.signature)}`;
       const filePath = path45.join(proposalsDir, `${slug}.md`);
@@ -67003,7 +67012,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const proposalsDir = validateSwarmPath(directory, path45.join("skills", "proposals"));
-    await mkdir11(proposalsDir, { recursive: true });
+    await mkdir12(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = workflowSlug(motif.signature);
       const filePath = path45.join(proposalsDir, `${slug}.md`);
@@ -67025,12 +67034,12 @@ var init_trajectory_cluster = __esm(() => {
 });
 
 // src/services/unactionable-hardening.ts
-import { existsSync as existsSync24 } from "node:fs";
+import { existsSync as existsSync23 } from "node:fs";
 async function hardenUnactionableEntries(params) {
   const result = { hardened: 0, retired: 0, remaining: 0 };
   try {
     const queuePath = resolveUnactionablePath(params.directory);
-    if (!existsSync24(queuePath))
+    if (!existsSync23(queuePath))
       return result;
     const limit = params.batchLimit ?? HARDENING_BATCH_LIMIT;
     const dedupThreshold = params.dedupThreshold ?? 0.6;
@@ -67137,14 +67146,14 @@ var init_unactionable_hardening = __esm(() => {
 });
 
 // src/services/skill-improver.ts
-import { existsSync as existsSync25 } from "node:fs";
-import { mkdir as mkdir12, readFile as readFile13, rename as rename7, writeFile as writeFile11 } from "node:fs/promises";
+import { existsSync as existsSync24 } from "node:fs";
+import { mkdir as mkdir13, readFile as readFile13, rename as rename7, writeFile as writeFile11 } from "node:fs/promises";
 import * as path46 from "node:path";
 function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
 }
 async function atomicWrite3(p, content) {
-  await mkdir12(path46.dirname(p), { recursive: true });
+  await mkdir13(path46.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   await writeFile11(tmp, content, "utf-8");
   await rename7(tmp, p);
@@ -67152,7 +67161,7 @@ async function atomicWrite3(p, content) {
 async function gatherInventory(directory) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync25(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync24(hivePath) ? await readKnowledge(hivePath) : [];
   const archived = [...swarm, ...hive].filter((e) => e.status === "archived").length;
   const skills = await listSkills(directory);
   const knowledgeById = new Map([...swarm, ...hive].map((entry) => [entry.id, entry]));
@@ -67918,7 +67927,7 @@ __export(exports_curator_postmortem, {
   runCuratorPostMortem: () => runCuratorPostMortem,
   _internals: () => _internals32
 });
-import { existsSync as existsSync26, readdirSync as readdirSync7, readFileSync as readFileSync12 } from "node:fs";
+import { existsSync as existsSync25, readdirSync as readdirSync6, readFileSync as readFileSync12 } from "node:fs";
 import * as path47 from "node:path";
 async function collectKnowledgeSummary(directory) {
   const entries = await readKnowledge(resolveSwarmKnowledgePath(directory));
@@ -67958,7 +67967,7 @@ async function collectKnowledgeSummary(directory) {
 }
 function readJsonlFile(filePath) {
   try {
-    if (!existsSync26(filePath))
+    if (!existsSync25(filePath))
       return [];
     const content = readFileSync12(filePath, "utf-8");
     const results = [];
@@ -67979,12 +67988,12 @@ function collectRetrospectives(directory) {
   const results = [];
   const evidenceDir = path47.join(directory, ".swarm", "evidence");
   try {
-    if (!existsSync26(evidenceDir))
+    if (!existsSync25(evidenceDir))
       return results;
-    for (const entry of readdirSync7(evidenceDir, { withFileTypes: true })) {
+    for (const entry of readdirSync6(evidenceDir, { withFileTypes: true })) {
       if (entry.isDirectory() && entry.name.startsWith("retro-")) {
         const retroPath = path47.join(evidenceDir, entry.name, "evidence.json");
-        if (existsSync26(retroPath)) {
+        if (existsSync25(retroPath)) {
           try {
             results.push(readFileSync12(retroPath, "utf-8"));
           } catch {}
@@ -67998,9 +68007,9 @@ function collectDriftReports(directory) {
   const results = [];
   const swarmDir = path47.join(directory, ".swarm");
   try {
-    if (!existsSync26(swarmDir))
+    if (!existsSync25(swarmDir))
       return results;
-    for (const entry of readdirSync7(swarmDir)) {
+    for (const entry of readdirSync6(swarmDir)) {
       if (entry.startsWith("drift-report-phase-") && entry.endsWith(".json")) {
         try {
           results.push(readFileSync12(path47.join(swarmDir, entry), "utf-8"));
@@ -68013,7 +68022,7 @@ function collectDriftReports(directory) {
 function collectPendingProposals(directory) {
   const results = [];
   const insightPath = path47.join(directory, ".swarm", "insight-candidates.jsonl");
-  if (existsSync26(insightPath)) {
+  if (existsSync25(insightPath)) {
     try {
       results.push({
         source: "insight-candidates",
@@ -68023,8 +68032,8 @@ function collectPendingProposals(directory) {
   }
   const proposalsDir = path47.join(directory, ".swarm", "skills", "proposals");
   try {
-    if (existsSync26(proposalsDir)) {
-      for (const entry of readdirSync7(proposalsDir)) {
+    if (existsSync25(proposalsDir)) {
+      for (const entry of readdirSync6(proposalsDir)) {
         if (entry.endsWith(".md") || entry.endsWith(".json")) {
           try {
             results.push({
@@ -68178,7 +68187,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings: [...warnings, "Invalid report path."]
     };
   }
-  if (!options.force && existsSync26(reportPath)) {
+  if (!options.force && existsSync25(reportPath)) {
     return {
       success: true,
       planId,
@@ -68241,8 +68250,8 @@ ${llmOutput}`;
     reportContent = buildDataOnlyReport(planId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
   }
   try {
-    const { mkdirSync: mkdirSync17, writeFileSync: writeFileSync10 } = await import("node:fs");
-    mkdirSync17(path47.dirname(reportPath), { recursive: true });
+    const { mkdirSync: mkdirSync16, writeFileSync: writeFileSync10 } = await import("node:fs");
+    mkdirSync16(path47.dirname(reportPath), { recursive: true });
     writeFileSync10(reportPath, reportContent, "utf-8");
   } catch (err2) {
     const msg = err2 instanceof Error ? err2.message : String(err2);
@@ -68332,8 +68341,8 @@ async function copyDirRecursive(src, dest) {
     const srcEntry = path48.join(src, entry);
     const destEntry = path48.join(dest, entry);
     try {
-      const stat5 = await fs23.stat(srcEntry);
-      if (stat5.isDirectory()) {
+      const stat6 = await fs23.stat(srcEntry);
+      if (stat6.isDirectory()) {
         const subCount = await copyDirRecursive(srcEntry, destEntry).catch(() => 0);
         count += subCount;
       } else {
@@ -68369,8 +68378,8 @@ function guaranteeAllPlansComplete(planData) {
 async function handleCloseCommand(directory, args2, options = {}) {
   const swarmDir = path48.join(directory, ".swarm");
   try {
-    const stat5 = fsSync5.lstatSync(swarmDir);
-    if (stat5.isSymbolicLink()) {
+    const stat6 = fsSync5.lstatSync(swarmDir);
+    if (stat6.isSymbolicLink()) {
       return `❌ Refused: .swarm/ is a symlink or junction. Refusing to operate on a redirected directory for safety.`;
     }
   } catch (err2) {
@@ -69366,7 +69375,7 @@ __export(exports_co_change_analyzer, {
 });
 import * as child_process3 from "node:child_process";
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { readdir as readdir2, readFile as readFile14, stat as stat5 } from "node:fs/promises";
+import { readdir as readdir3, readFile as readFile14, stat as stat6 } from "node:fs/promises";
 import * as path50 from "node:path";
 import { promisify } from "node:util";
 function getExecFileAsync() {
@@ -69469,7 +69478,7 @@ async function scanSourceFiles(dir) {
   const results = [];
   const skipDirs = new Set(["node_modules", ".swarm", "dist", "build"]);
   try {
-    const entries = await readdir2(dir, { withFileTypes: true });
+    const entries = await readdir3(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path50.join(dir, entry.name);
       if (entry.isDirectory()) {
@@ -69517,7 +69526,7 @@ async function getStaticEdges(directory) {
           for (const ext of extensions) {
             const testPath = resolvedPath + ext;
             try {
-              const testStat = await stat5(testPath);
+              const testStat = await stat6(testPath);
               if (testStat.isFile()) {
                 targetFile = testPath;
                 break;
@@ -70263,7 +70272,7 @@ var init_gate_bridge = __esm(() => {
 });
 
 // src/services/version-check.ts
-import { existsSync as existsSync27, mkdirSync as mkdirSync17, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "node:fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync16, readFileSync as readFileSync13, writeFileSync as writeFileSync10 } from "node:fs";
 import { homedir as homedir6 } from "node:os";
 import { join as join41 } from "node:path";
 function cacheDir() {
@@ -70277,7 +70286,7 @@ function cacheFile() {
 function readVersionCache() {
   try {
     const path53 = cacheFile();
-    if (!existsSync27(path53))
+    if (!existsSync26(path53))
       return null;
     const raw = readFileSync13(path53, "utf-8");
     const parsed = JSON.parse(raw);
@@ -70292,7 +70301,7 @@ function readVersionCache() {
 function writeVersionCache(entry) {
   try {
     const dir = cacheDir();
-    mkdirSync17(dir, { recursive: true });
+    mkdirSync16(dir, { recursive: true });
     writeFileSync10(cacheFile(), JSON.stringify(entry, null, 2), "utf-8");
   } catch {}
 }
@@ -70375,10 +70384,10 @@ var init_version_check = __esm(() => {
 });
 
 // src/services/knowledge-diagnostics.ts
-import { existsSync as existsSync28 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { readFile as readFile15 } from "node:fs/promises";
 async function readRawLines(filePath) {
-  if (!existsSync28(filePath))
+  if (!existsSync27(filePath))
     return { entries: [], corrupt: 0 };
   const content = await readFile15(filePath, "utf-8");
   const entries = [];
@@ -70503,7 +70512,7 @@ async function computeKnowledgeDebug(directory) {
   };
 }
 async function safeJsonlCount(filePath) {
-  if (!filePath || !existsSync28(filePath))
+  if (!filePath || !existsSync27(filePath))
     return 0;
   try {
     const content = await readFile15(filePath, "utf-8");
@@ -70586,7 +70595,7 @@ var init_knowledge_diagnostics = __esm(() => {
 
 // src/services/diagnose-service.ts
 import * as child_process4 from "node:child_process";
-import { existsSync as existsSync29, readdirSync as readdirSync8, readFileSync as readFileSync14, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync28, readdirSync as readdirSync7, readFileSync as readFileSync14, statSync as statSync10 } from "node:fs";
 import path53 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 function validateTaskDag(plan) {
@@ -70803,7 +70812,7 @@ async function checkPlanSync(directory, plan) {
 }
 async function checkConfigBackups(directory) {
   try {
-    const files = readdirSync8(directory);
+    const files = readdirSync7(directory);
     const backupCount = files.filter((f) => /\.opencode-swarm\.yaml\.bak/.test(f)).length;
     if (backupCount <= 5) {
       return {
@@ -70834,7 +70843,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync29(directory) || !statSync11(directory).isDirectory()) {
+    if (!existsSync28(directory) || !statSync10(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "❌",
@@ -70899,7 +70908,7 @@ async function checkSpecStaleness(directory, plan) {
 }
 async function checkConfigParseability(directory) {
   const configPath = path53.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync29(configPath)) {
+  if (!existsSync28(configPath)) {
     return {
       name: "Config Parseability",
       status: "✅",
@@ -70954,11 +70963,11 @@ async function checkGrammarWasmFiles() {
   const thisDir = path53.dirname(fileURLToPath2(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync29(path53.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync28(path53.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync29(path53.join(grammarDir, file3))) {
+    if (!existsSync28(path53.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -70977,7 +70986,7 @@ async function checkGrammarWasmFiles() {
 }
 async function checkCheckpointManifest(directory) {
   const manifestPath = path53.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync29(manifestPath)) {
+  if (!existsSync28(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "✅",
@@ -71029,7 +71038,7 @@ async function checkCheckpointManifest(directory) {
 }
 async function checkEventStreamIntegrity(directory) {
   const eventsPath = path53.join(directory, ".swarm/events.jsonl");
-  if (!existsSync29(eventsPath)) {
+  if (!existsSync28(eventsPath)) {
     return {
       name: "Event Stream",
       status: "✅",
@@ -71070,7 +71079,7 @@ async function checkEventStreamIntegrity(directory) {
 }
 async function checkSteeringDirectives(directory) {
   const eventsPath = path53.join(directory, ".swarm/events.jsonl");
-  if (!existsSync29(eventsPath)) {
+  if (!existsSync28(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "✅",
@@ -71126,7 +71135,7 @@ async function checkCurator(directory) {
       };
     }
     const summaryPath = path53.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync29(summaryPath)) {
+    if (!existsSync28(summaryPath)) {
       return {
         name: "Curator",
         status: "✅",
@@ -71293,7 +71302,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkKnowledgeHealth(directory));
   try {
     const evidenceDir = path53.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync29(evidenceDir) ? readdirSync8(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const snapshotFiles = existsSync28(evidenceDir) ? readdirSync7(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks5.push({
@@ -71326,7 +71335,7 @@ async function getDiagnoseData(directory) {
   const cacheRows = [];
   for (const cachePath of cachePaths) {
     try {
-      if (!existsSync29(cachePath)) {
+      if (!existsSync28(cachePath)) {
         cacheRows.push(`⬜ ${cachePath} — absent`);
         continue;
       }
@@ -73703,7 +73712,7 @@ var init_profiles = __esm(() => {
 });
 
 // src/lang/detector.ts
-import { access as access3, readdir as readdir3 } from "node:fs/promises";
+import { access as access4, readdir as readdir4 } from "node:fs/promises";
 import { extname as extname3, join as join43 } from "node:path";
 function getProfileForFile(filePath) {
   const ext = extname3(filePath);
@@ -73717,7 +73726,7 @@ async function detectProjectLanguages(projectDir) {
     let dirEntries;
     let entries;
     try {
-      dirEntries = await readdir3(dir, { withFileTypes: true });
+      dirEntries = await readdir4(dir, { withFileTypes: true });
       entries = dirEntries.map((e) => e.name);
     } catch {
       return;
@@ -73733,7 +73742,7 @@ async function detectProjectLanguages(projectDir) {
           continue;
         }
         try {
-          await access3(join43(dir, detectFile));
+          await access4(join43(dir, detectFile));
           detected.add(profile.id);
           break;
         } catch {}
@@ -73751,7 +73760,7 @@ async function detectProjectLanguages(projectDir) {
   }
   await scanDir(projectDir);
   try {
-    const topEntries = await readdir3(projectDir, { withFileTypes: true });
+    const topEntries = await readdir4(projectDir, { withFileTypes: true });
     for (const entry of topEntries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
         await scanDir(join43(projectDir, entry.name));
@@ -75894,7 +75903,7 @@ var init_handoff_service = __esm(() => {
 });
 
 // src/session/snapshot-writer.ts
-import { closeSync as closeSync5, fsyncSync as fsyncSync2, mkdirSync as mkdirSync20, openSync as openSync5, renameSync as renameSync12 } from "node:fs";
+import { closeSync as closeSync5, fsyncSync as fsyncSync2, mkdirSync as mkdirSync19, openSync as openSync5, renameSync as renameSync12 } from "node:fs";
 import * as path57 from "node:path";
 function serializeAgentSession(s) {
   const gateLog = {};
@@ -76002,7 +76011,7 @@ async function writeSnapshot(directory, state) {
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
     const dir = path57.dirname(resolvedPath);
-    mkdirSync20(dir, { recursive: true });
+    mkdirSync19(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
     try {
@@ -76541,8 +76550,8 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID6 } from "node:crypto";
-import { existsSync as existsSync33, readFileSync as readFileSync18 } from "node:fs";
-import { mkdir as mkdir13, readFile as readFile16, writeFile as writeFile12 } from "node:fs/promises";
+import { existsSync as existsSync32, readFileSync as readFileSync18 } from "node:fs";
+import { mkdir as mkdir14, readFile as readFile16, writeFile as writeFile12 } from "node:fs/promises";
 import * as os13 from "node:os";
 import * as path58 from "node:path";
 async function migrateKnowledgeToExternal(_directory, _config) {
@@ -76558,7 +76567,7 @@ async function migrateContextToKnowledge(directory, config3) {
   const sentinelPath = path58.join(directory, ".swarm", ".knowledge-migrated");
   const contextPath = path58.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync33(sentinelPath)) {
+  if (existsSync32(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -76567,7 +76576,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync33(contextPath)) {
+  if (!existsSync32(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -76659,7 +76668,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
   const legacyHivePath = _internals40.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
   const sentinelPath = path58.join(path58.dirname(canonicalHivePath), ".hive-knowledge-migrated");
-  if (existsSync33(sentinelPath)) {
+  if (existsSync32(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -76668,7 +76677,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync33(legacyHivePath)) {
+  if (!existsSync32(legacyHivePath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -76870,7 +76879,7 @@ function truncateLesson2(text) {
 }
 function inferProjectName(directory) {
   const packageJsonPath = path58.join(directory, "package.json");
-  if (existsSync33(packageJsonPath)) {
+  if (existsSync32(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync18(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
@@ -76890,7 +76899,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir13(path58.dirname(sentinelPath), { recursive: true });
+  await mkdir14(path58.dirname(sentinelPath), { recursive: true });
   await writeFile12(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
@@ -78107,10 +78116,10 @@ var init_scoring = __esm(() => {
 
 // src/memory/local-jsonl-provider.ts
 import { randomUUID as randomUUID7 } from "node:crypto";
-import { existsSync as existsSync34 } from "node:fs";
+import { existsSync as existsSync33 } from "node:fs";
 import {
   appendFile as appendFile8,
-  mkdir as mkdir14,
+  mkdir as mkdir15,
   readFile as readFile17,
   rename as rename8,
   writeFile as writeFile13
@@ -78458,7 +78467,7 @@ function validateLoadedProposals(values, config3) {
   return { records, invalidCount };
 }
 async function readJsonl(filePath) {
-  if (!existsSync34(filePath))
+  if (!existsSync33(filePath))
     return [];
   const content = await readFile17(filePath, "utf-8");
   const records = [];
@@ -78514,12 +78523,12 @@ function parseRecallUsageEvent(event) {
   }
 }
 async function appendJsonl(filePath, value) {
-  await mkdir14(path59.dirname(filePath), { recursive: true });
+  await mkdir15(path59.dirname(filePath), { recursive: true });
   await appendFile8(filePath, `${JSON.stringify(value)}
 `, "utf-8");
 }
 async function writeJsonlAtomic(filePath, values) {
-  await mkdir14(path59.dirname(filePath), { recursive: true });
+  await mkdir15(path59.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${randomUUID7()}`;
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
@@ -78618,8 +78627,8 @@ var init_prompt_block = __esm(() => {
 });
 
 // src/memory/jsonl-migration.ts
-import { existsSync as existsSync35 } from "node:fs";
-import { copyFile, mkdir as mkdir15, readFile as readFile18, stat as stat6, writeFile as writeFile14 } from "node:fs/promises";
+import { existsSync as existsSync34 } from "node:fs";
+import { copyFile as copyFile2, mkdir as mkdir16, readFile as readFile18, stat as stat7, writeFile as writeFile14 } from "node:fs/promises";
 import * as path60 from "node:path";
 function resolveMemoryStorageDir(rootDirectory, config3 = {}) {
   const resolved = resolveConfig(config3);
@@ -78646,25 +78655,25 @@ async function readLegacyJsonl(rootDirectory, config3 = {}) {
 async function backupLegacyJsonl(rootDirectory, config3 = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config3);
   const backupDir = path60.join(storageDir, "backups");
-  await mkdir15(backupDir, { recursive: true });
+  await mkdir16(backupDir, { recursive: true });
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
     const source = path60.join(storageDir, filename);
-    if (!existsSync35(source))
+    if (!existsSync34(source))
       continue;
     const backup = path60.join(backupDir, `${filename}.pre-sqlite-migration`);
-    if (existsSync35(backup)) {
+    if (existsSync34(backup)) {
       results.push({ source, backup, created: false });
       continue;
     }
-    await copyFile(source, backup);
+    await copyFile2(source, backup);
     results.push({ source, backup, created: true });
   }
   return results;
 }
 async function writeJsonlExport(rootDirectory, config3, memories, proposals) {
   const exportDir = path60.join(resolveMemoryStorageDir(rootDirectory, config3), "export");
-  await mkdir15(exportDir, { recursive: true });
+  await mkdir16(exportDir, { recursive: true });
   const memoriesPath = path60.join(exportDir, "memories.jsonl");
   const proposalsPath = path60.join(exportDir, "proposals.jsonl");
   await writeFile14(memoriesPath, toJsonl(memories), "utf-8");
@@ -78673,14 +78682,14 @@ async function writeJsonlExport(rootDirectory, config3, memories, proposals) {
 }
 async function writeMigrationReport(rootDirectory, report, config3 = {}) {
   const reportPath = path60.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
-  await mkdir15(path60.dirname(reportPath), { recursive: true });
+  await mkdir16(path60.dirname(reportPath), { recursive: true });
   await writeFile14(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   return reportPath;
 }
 async function readMigrationReport(rootDirectory, config3 = {}) {
   const reportPath = path60.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
-  if (!existsSync35(reportPath))
+  if (!existsSync34(reportPath))
     return null;
   try {
     return JSON.parse(await readFile18(reportPath, "utf-8"));
@@ -78694,13 +78703,13 @@ async function getLegacyJsonlFileStatus(rootDirectory, config3 = {}) {
   for (const file3 of ["memories.jsonl", "proposals.jsonl"]) {
     const filePath = path60.join(storageDir, file3);
     let sizeBytes = 0;
-    if (existsSync35(filePath)) {
-      sizeBytes = (await stat6(filePath)).size;
+    if (existsSync34(filePath)) {
+      sizeBytes = (await stat7(filePath)).size;
     }
     statuses.push({
       file: file3,
       path: filePath,
-      exists: existsSync35(filePath),
+      exists: existsSync34(filePath),
       sizeBytes
     });
   }
@@ -78781,7 +78790,7 @@ async function readProposalJsonl(filePath, config3) {
   return { records, invalidRows, totalRows: rows.totalRows };
 }
 async function readJsonlRows(filePath) {
-  if (!existsSync35(filePath)) {
+  if (!existsSync34(filePath)) {
     return { rows: [], invalidRows: [], totalRows: 0 };
   }
   const content = await readFile18(filePath, "utf-8");
@@ -78819,7 +78828,7 @@ var init_jsonl_migration = __esm(() => {
 
 // src/memory/sqlite-provider.ts
 import { randomUUID as randomUUID8 } from "node:crypto";
-import { mkdirSync as mkdirSync21 } from "node:fs";
+import { mkdirSync as mkdirSync20 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import * as path61 from "node:path";
 function loadDatabaseCtor2() {
@@ -78879,7 +78888,7 @@ class SQLiteMemoryProvider {
     if (this.initialized)
       return;
     const dbPath = this.databasePath();
-    mkdirSync21(path61.dirname(dbPath), { recursive: true });
+    mkdirSync20(path61.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor2();
     this.db = new Db(dbPath);
     this.db.run("PRAGMA journal_mode = WAL;");
@@ -79745,7 +79754,7 @@ var init_sqlite_provider = __esm(() => {
 
 // src/memory/gateway.ts
 import { createHash as createHash8 } from "node:crypto";
-import { existsSync as existsSync36, readFileSync as readFileSync19 } from "node:fs";
+import { existsSync as existsSync35, readFileSync as readFileSync19 } from "node:fs";
 import * as path62 from "node:path";
 
 class MemoryGateway {
@@ -80070,7 +80079,7 @@ function readGitRemoteUrl(directory) {
   if (gitRemoteUrlCache.has(directory))
     return gitRemoteUrlCache.get(directory);
   const gitConfigPath = path62.join(directory, ".git", "config");
-  if (!existsSync36(gitConfigPath)) {
+  if (!existsSync35(gitConfigPath)) {
     gitRemoteUrlCache.set(directory, undefined);
     return;
   }
@@ -80639,13 +80648,13 @@ var init_recall_planner = __esm(() => {
 });
 
 // src/memory/run-log.ts
-import { appendFile as appendFile9, mkdir as mkdir16 } from "node:fs/promises";
+import { appendFile as appendFile9, mkdir as mkdir17 } from "node:fs/promises";
 import * as path64 from "node:path";
 async function appendMemoryRunLog(directory, runId, event) {
   const safeRunId = sanitizeRunId(runId);
   const relativePath = path64.join("runs", safeRunId, "memory.jsonl");
   const filePath = validateSwarmPath(directory, relativePath);
-  await mkdir16(path64.dirname(filePath), { recursive: true });
+  await mkdir17(path64.dirname(filePath), { recursive: true });
   await appendFile9(filePath, `${JSON.stringify({
     ...event,
     runId: safeRunId,
@@ -81046,7 +81055,7 @@ var init_memory = __esm(() => {
 });
 
 // src/commands/memory.ts
-import { existsSync as existsSync37 } from "node:fs";
+import { existsSync as existsSync36 } from "node:fs";
 import * as path65 from "node:path";
 import { fileURLToPath as fileURLToPath3 } from "node:url";
 async function handleMemoryCommand(_directory, _args) {
@@ -81078,7 +81087,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Provider: \`${config3.provider}\``,
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
-    `- SQLite database exists: \`${existsSync37(sqlitePath)}\``,
+    `- SQLite database exists: \`${existsSync36(sqlitePath)}\``,
     `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
@@ -82776,11 +82785,11 @@ function createRedactedContext(line, findings) {
 function scanFileForSecrets(filePath) {
   const findings = [];
   try {
-    const lstat = fs30.lstatSync(filePath);
-    if (lstat.isSymbolicLink()) {
+    const lstat2 = fs30.lstatSync(filePath);
+    if (lstat2.isSymbolicLink()) {
       return findings;
     }
-    if (lstat.size > MAX_FILE_SIZE_BYTES) {
+    if (lstat2.size > MAX_FILE_SIZE_BYTES) {
       return findings;
     }
     let buffer;
@@ -82868,18 +82877,18 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       stats.skippedDirs++;
       continue;
     }
-    let lstat;
+    let lstat2;
     try {
-      lstat = fs30.lstatSync(fullPath);
+      lstat2 = fs30.lstatSync(fullPath);
     } catch {
       stats.fileErrors++;
       continue;
     }
-    if (lstat.isSymbolicLink()) {
+    if (lstat2.isSymbolicLink()) {
       stats.symlinkSkipped++;
       continue;
     }
-    if (lstat.isDirectory()) {
+    if (lstat2.isDirectory()) {
       let realPath;
       try {
         realPath = fs30.realpathSync(fullPath);
@@ -82897,7 +82906,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       }
       const subFiles = findScannableFiles(fullPath, excludeExact, excludeGlobs, scanDir, visited, stats);
       files.push(...subFiles);
-    } else if (lstat.isFile()) {
+    } else if (lstat2.isFile()) {
       const ext = path68.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
@@ -83228,8 +83237,8 @@ var init_secretscan = __esm(() => {
             break;
           const fileFindings = scanFileForSecrets(filePath);
           try {
-            const stat7 = fs30.statSync(filePath);
-            if (stat7.size > MAX_FILE_SIZE_BYTES) {
+            const stat8 = fs30.statSync(filePath);
+            if (stat8.size > MAX_FILE_SIZE_BYTES) {
               skippedFiles++;
               continue;
             }
@@ -84039,8 +84048,8 @@ function sharedTrailingSegments(a, b) {
 function isCacheStale(impactMap, generatedAtMs) {
   for (const sourcePath of Object.keys(impactMap)) {
     try {
-      const stat7 = fs34.statSync(sourcePath);
-      if (stat7.mtimeMs > generatedAtMs) {
+      const stat8 = fs34.statSync(sourcePath);
+      if (stat8.mtimeMs > generatedAtMs) {
         return true;
       }
     } catch {
@@ -85386,8 +85395,8 @@ function manifestHash(dir) {
     if (!entries.has(name2))
       continue;
     try {
-      const stat7 = fs39.statSync(path77.join(dir, name2));
-      parts2.push(`${name2}:${stat7.size}:${stat7.mtimeMs}:${stat7.ino}`);
+      const stat8 = fs39.statSync(path77.join(dir, name2));
+      parts2.push(`${name2}:${stat8.size}:${stat8.mtimeMs}:${stat8.ino}`);
     } catch {}
   }
   return parts2.join("|");
@@ -88942,7 +88951,7 @@ var init_reset_session = __esm(() => {
 });
 
 // src/summaries/manager.ts
-import { mkdirSync as mkdirSync23, readdirSync as readdirSync18, renameSync as renameSync14, rmSync as rmSync6, statSync as statSync19 } from "node:fs";
+import { mkdirSync as mkdirSync22, readdirSync as readdirSync17, renameSync as renameSync14, rmSync as rmSync5, statSync as statSync18 } from "node:fs";
 import * as path82 from "node:path";
 function sanitizeSummaryId(id) {
   if (!id || id.length === 0) {
@@ -88988,14 +88997,14 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
     originalBytes: Buffer.byteLength(fullOutput, "utf8")
   };
   const entryJson = JSON.stringify(entry);
-  mkdirSync23(summaryDir, { recursive: true });
+  mkdirSync22(summaryDir, { recursive: true });
   const tempPath = path82.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
   try {
     await bunWrite(tempPath, entryJson);
     renameSync14(tempPath, summaryPath);
   } catch (error93) {
     try {
-      rmSync6(tempPath, { force: true });
+      rmSync5(tempPath, { force: true });
     } catch {}
     throw error93;
   }
@@ -90141,8 +90150,8 @@ async function countProposals(directory) {
     const proposalsDir = validateSwarmPath(directory, "skills/proposals");
     if (!fsSync6.existsSync(proposalsDir))
       return 0;
-    const { readdir: readdir5 } = await import("node:fs/promises");
-    const entries = await readdir5(proposalsDir);
+    const { readdir: readdir6 } = await import("node:fs/promises");
+    const entries = await readdir6(proposalsDir);
     return entries.filter((f) => f.endsWith(".md")).length;
   } catch {
     return 0;
@@ -91249,7 +91258,7 @@ Showing full help:
 }
 async function handleModeCommandWithBundledSkills(ctx, handler) {
   if (ctx.packageRoot) {
-    syncBundledProjectSkillsIfMissing(ctx.directory, ctx.packageRoot);
+    await syncBundledProjectSkillsIfMissingAsync(ctx.directory, ctx.packageRoot);
   }
   return Promise.resolve(handler(ctx.directory, ctx.args));
 }
@@ -91449,6 +91458,13 @@ var init_registry = __esm(() => {
       description: "Run tool registration coherence check",
       category: "diagnostics"
     },
+    "doctor-tools": {
+      handler: (ctx) => handleDoctorToolsCommand(ctx.directory, ctx.args),
+      description: "Run tool registration coherence check",
+      category: "diagnostics",
+      aliasOf: "doctor tools",
+      deprecated: true
+    },
     diagnose: {
       handler: (ctx) => handleDiagnoseCommand(ctx.directory, ctx.args),
       description: "Run health check on swarm state",
@@ -95941,7 +95957,7 @@ COVERAGE REPORTING:
 `;
 
 // src/agents/index.ts
-import { mkdir as mkdir17, writeFile as writeFile15 } from "node:fs/promises";
+import { mkdir as mkdir18, writeFile as writeFile15 } from "node:fs/promises";
 import * as path87 from "node:path";
 function stripSwarmPrefix(agentName, swarmPrefix) {
   if (!swarmPrefix || !agentName)
@@ -96421,7 +96437,7 @@ function getAgentConfigs(config3, directory, sessionId, projectContext) {
       generatedAt: new Date().toISOString(),
       agents: agentToolSnapshot
     }, null, 2);
-    mkdir17(evidenceDir, { recursive: true }).then(() => writeFile15(path87.join(evidenceDir, filename), snapshotData)).catch(() => {});
+    mkdir18(evidenceDir, { recursive: true }).then(() => writeFile15(path87.join(evidenceDir, filename), snapshotData)).catch(() => {});
   }
   return result;
 }
@@ -96461,12 +96477,12 @@ __export(exports_evidence_summary_integration, {
   createEvidenceSummaryIntegration: () => createEvidenceSummaryIntegration,
   EvidenceSummaryIntegration: () => EvidenceSummaryIntegration
 });
-import { existsSync as existsSync49, mkdirSync as mkdirSync25, writeFileSync as writeFileSync14 } from "node:fs";
+import { existsSync as existsSync48, mkdirSync as mkdirSync24, writeFileSync as writeFileSync14 } from "node:fs";
 import * as path88 from "node:path";
 function persistSummary(projectDir, artifact, filename) {
   const swarmPath = path88.join(projectDir, ".swarm");
-  if (!existsSync49(swarmPath)) {
-    mkdirSync25(swarmPath, { recursive: true });
+  if (!existsSync48(swarmPath)) {
+    mkdirSync24(swarmPath, { recursive: true });
   }
   const artifactPath = path88.join(swarmPath, filename);
   const content = JSON.stringify(artifact, null, 2);
@@ -97477,8 +97493,8 @@ var init_schema3 = __esm(() => {
 
 // src/summaries/store.ts
 import {
-  existsSync as existsSync61,
-  mkdirSync as mkdirSync32,
+  existsSync as existsSync60,
+  mkdirSync as mkdirSync31,
   readFileSync as readFileSync41,
   renameSync as renameSync20,
   unlinkSync as unlinkSync15,
@@ -97486,13 +97502,13 @@ import {
 } from "node:fs";
 import * as path101 from "node:path";
 function writeRawSidecar(absPath, bundle) {
-  mkdirSync32(path101.dirname(absPath), { recursive: true });
+  mkdirSync31(path101.dirname(absPath), { recursive: true });
   const tempFile = `${absPath}.tmp-${Date.now()}-${process.pid}`;
   try {
     writeFileSync21(tempFile, JSON.stringify(bundle, null, 2), "utf-8");
     renameSync20(tempFile, absPath);
   } finally {
-    if (existsSync61(tempFile)) {
+    if (existsSync60(tempFile)) {
       try {
         unlinkSync15(tempFile);
       } catch {}
@@ -97579,7 +97595,7 @@ function readSupervisorReportRaw(directory, phase) {
   } catch {
     return null;
   }
-  if (!existsSync61(abs))
+  if (!existsSync60(abs))
     return null;
   try {
     const parsed = JSON.parse(readFileSync41(abs, "utf-8"));
@@ -100976,7 +100992,7 @@ __export(exports_runtime, {
   clearParserCache: () => clearParserCache,
   _internals: () => _internals68
 });
-import { existsSync as existsSync66, statSync as statSync27 } from "node:fs";
+import { existsSync as existsSync65, statSync as statSync26 } from "node:fs";
 import * as path114 from "node:path";
 import { fileURLToPath as fileURLToPath4 } from "node:url";
 async function initTreeSitter() {
@@ -101044,7 +101060,7 @@ async function loadGrammar(languageId) {
     const parser = new Parser;
     const wasmFileName = getWasmFileName(normalizedId);
     const wasmPath = path114.join(getGrammarsDirAbsolute(), wasmFileName);
-    if (!existsSync66(wasmPath)) {
+    if (!existsSync65(wasmPath)) {
       throw new Error(`Grammar file not found for ${languageId}: ${wasmPath}
 ` + `Make sure to run 'bun run build' to copy grammar files to dist/lang/grammars/`);
     }
@@ -101085,7 +101101,7 @@ async function isGrammarAvailable(languageId) {
   try {
     const wasmFileName = getWasmFileName(normalizedId);
     const wasmPath = path114.join(getGrammarsDirAbsolute(), wasmFileName);
-    statSync27(wasmPath);
+    statSync26(wasmPath);
     return true;
   } catch {
     return false;
@@ -101147,11 +101163,11 @@ __export(exports_doc_scan, {
 import * as crypto9 from "node:crypto";
 import * as fs67 from "node:fs";
 import {
-  mkdir as mkdir20,
-  readdir as readdir6,
+  mkdir as mkdir21,
+  readdir as readdir7,
   readFile as readFile22,
   realpath as realpath3,
-  stat as stat9,
+  stat as stat10,
   writeFile as writeFile17
 } from "node:fs/promises";
 import * as path116 from "node:path";
@@ -101234,8 +101250,8 @@ async function scanDocIndex(directory) {
       for (const file3 of existingManifest.files) {
         try {
           const fullPath = path116.join(directory, file3.path);
-          const stat10 = fs67.statSync(fullPath);
-          if (stat10.mtimeMs > file3.mtime) {
+          const stat11 = fs67.statSync(fullPath);
+          if (stat11.mtimeMs > file3.mtime) {
             cacheValid = false;
             break;
           }
@@ -101255,7 +101271,7 @@ async function scanDocIndex(directory) {
   const walkDir2 = async (dir) => {
     let entries;
     try {
-      entries = await readdir6(dir, { withFileTypes: true });
+      entries = await readdir7(dir, { withFileTypes: true });
       if (dir === directory)
         rootReadable = true;
     } catch {
@@ -101273,7 +101289,7 @@ async function scanDocIndex(directory) {
           const rel = path116.relative(resolvedDirectory, resolved);
           if (rel.startsWith("..") || path116.isAbsolute(rel))
             continue;
-          const targetStat = await stat9(symlinkPath);
+          const targetStat = await stat10(symlinkPath);
           isFile = targetStat.isFile();
         } catch {
           continue;
@@ -101302,7 +101318,7 @@ async function scanDocIndex(directory) {
         continue;
       let fileStat;
       try {
-        fileStat = await stat9(fullPath);
+        fileStat = await stat10(fullPath);
       } catch {
         continue;
       }
@@ -101349,7 +101365,7 @@ async function scanDocIndex(directory) {
     files: discoveredFiles
   };
   try {
-    await mkdir20(path116.dirname(manifestPath), { recursive: true });
+    await mkdir21(path116.dirname(manifestPath), { recursive: true });
     await writeFile17(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
   } catch {}
   return { manifest, cached: false };
@@ -101563,7 +101579,7 @@ var init_doc_scan = __esm(() => {
 });
 
 // src/hooks/knowledge-reader.ts
-import { existsSync as existsSync67 } from "node:fs";
+import { existsSync as existsSync66 } from "node:fs";
 import { readFile as readFile23 } from "node:fs/promises";
 import * as path117 from "node:path";
 function inferCategoriesFromPhase(phaseDescription) {
@@ -101611,7 +101627,7 @@ function inferCategoriesFromPhase(phaseDescription) {
 }
 async function transactShownFile(shownFile, mutate) {
   return transactFile(shownFile, async (filePath) => {
-    if (!existsSync67(filePath))
+    if (!existsSync66(filePath))
       return {};
     try {
       const content = await readFile23(filePath, "utf-8");
@@ -101741,7 +101757,7 @@ async function readMergedKnowledge(directory, config3, context, opts) {
 async function updateRetrievalOutcome(directory, phaseInfo, phaseSucceeded) {
   const shownFile = path117.join(directory, ".swarm", ".knowledge-shown.json");
   try {
-    if (!existsSync67(shownFile)) {
+    if (!existsSync66(shownFile)) {
       return;
     }
     let shownIds;
@@ -102521,8 +102537,8 @@ async function runDesignDocDriftCheck(directory, phase, outDir) {
     const traceabilityAbs = path162.join(outAbs, TRACEABILITY_REL);
     let registry3 = null;
     try {
-      const stat11 = await fs109.promises.stat(traceabilityAbs);
-      if (stat11.size <= MAX_TRACEABILITY_BYTES) {
+      const stat12 = await fs109.promises.stat(traceabilityAbs);
+      if (stat12.size <= MAX_TRACEABILITY_BYTES) {
         const raw = await fs109.promises.readFile(traceabilityAbs, "utf-8");
         const parsed = JSON.parse(raw);
         registry3 = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
@@ -103821,6 +103837,7 @@ function createBackgroundCompletionObserver(opts) {
 init_pr_subscriptions();
 init_commands();
 init_config();
+init_bundled_skills();
 init_constants();
 
 // src/config/project-init.ts
@@ -103835,8 +103852,8 @@ function writeProjectConfigIfNew(directory, quiet = false) {
     const dest = path91.join(opencodeDir, "opencode-swarm.json");
     const normalizePathForCompare = (p) => process.platform === "win32" ? p.toLowerCase() : p;
     try {
-      const stat7 = fs49.lstatSync(opencodeDir);
-      if (stat7.isSymbolicLink())
+      const stat8 = fs49.lstatSync(opencodeDir);
+      if (stat8.isSymbolicLink())
         return;
       const resolvedDir = fs49.realpathSync(opencodeDir);
       const canonicalOpencode = path91.join(fs49.realpathSync(directory), ".opencode");
@@ -104009,8 +104026,8 @@ function extractFileSummary(filePath, content, absolutePath, existingEntry) {
   let mtimeMs = 0;
   if (absolutePath) {
     try {
-      const stat7 = fs51.statSync(absolutePath);
-      mtimeMs = stat7.mtimeMs;
+      const stat8 = fs51.statSync(absolutePath);
+      mtimeMs = stat8.mtimeMs;
     } catch {}
   }
   const base = {
@@ -106962,8 +106979,8 @@ function createPhaseMonitorHook(directory, preflightManager, curatorRunner, dele
           const initResult = await runner(directory, curatorConfig, llmDelegate);
           if (initResult.briefing) {
             const briefingPath = path102.join(directory, ".swarm", "curator-briefing.md");
-            const { mkdir: mkdir18, writeFile: writeFile16 } = await import("node:fs/promises");
-            await mkdir18(path102.dirname(briefingPath), { recursive: true });
+            const { mkdir: mkdir19, writeFile: writeFile16 } = await import("node:fs/promises");
+            await mkdir19(path102.dirname(briefingPath), { recursive: true });
             await writeFile16(briefingPath, initResult.briefing, "utf-8");
             const { buildApprovedReceipt: buildApprovedReceipt2, persistReviewReceipt: persistReviewReceipt2 } = await Promise.resolve().then(() => (init_review_receipt(), exports_review_receipt));
             const initReceipt = buildApprovedReceipt2({
@@ -107105,7 +107122,7 @@ import * as path111 from "node:path";
 init_logger();
 init_path_security();
 import * as fsSync7 from "node:fs";
-import { existsSync as existsSync62, realpathSync as realpathSync13 } from "node:fs";
+import { existsSync as existsSync61, realpathSync as realpathSync13 } from "node:fs";
 import * as fsPromises5 from "node:fs/promises";
 import * as os15 from "node:os";
 import * as path106 from "node:path";
@@ -107778,15 +107795,15 @@ function classifyDataOperation(line) {
   const lower = trimmed.toLowerCase();
   const evidence = trimmed.slice(0, 160);
   let operation = null;
-  let access4 = "unknown";
+  let access5 = "unknown";
   let entity;
   if (/\b(transaction|begintransaction|commit|rollback)\b/i.test(trimmed)) {
     operation = "transaction";
-    access4 = "database";
+    access5 = "database";
   }
   if (/\b(migrate|migration|schema\.alter|createTable|dropTable)\b/i.test(trimmed)) {
     operation = "migration";
-    access4 = "database";
+    access5 = "database";
   }
   if (/\b(findMany|findUnique|findFirst|select|query|count|aggregate)\b/.test(trimmed)) {
     operation ??= "read";
@@ -107798,17 +107815,17 @@ function classifyDataOperation(line) {
     operation = "delete";
   }
   if (/\b(sql`|\bselect\b|\binsert\b|\bupdate\b|\bdelete\b|\bfrom\b)/i.test(trimmed)) {
-    access4 = "sql";
+    access5 = "sql";
   }
   if (/\b(prisma|drizzle|sequelize|knex|db\.|database\.|repository\.)/i.test(trimmed)) {
-    access4 = access4 === "sql" ? "sql" : "orm";
+    access5 = access5 === "sql" ? "sql" : "orm";
   }
   if (/\b(readFile|writeFile|appendFile|rmSync|unlink)\b/.test(trimmed)) {
-    access4 = "filesystem";
+    access5 = "filesystem";
     operation ??= lower.includes("read") ? "read" : "write";
   }
   if (/\b(fetch|axios|http\.|https\.)\b/.test(trimmed)) {
-    access4 = "network";
+    access5 = "network";
     operation ??= "read";
   }
   const entityMatch = trimmed.match(/\b(?:prisma|db|database)\.(\w+)/i);
@@ -107816,7 +107833,7 @@ function classifyDataOperation(line) {
     entity = entityMatch[1];
   if (!operation)
     return null;
-  return { operation, access: access4, entity, line: 0, evidence };
+  return { operation, access: access5, entity, line: 0, evidence };
 }
 function extractDataOperations(content) {
   const facts = [];
@@ -108355,7 +108372,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
       if (realRoot === null) {
         return null;
       }
-      if (!existsSync62(resolved)) {
+      if (!existsSync61(resolved)) {
         const EXTENSIONS = [
           ".ts",
           ".tsx",
@@ -108369,7 +108386,7 @@ function resolveModuleSpecifier(workspaceRoot, sourceFile, specifier) {
         let found = null;
         for (const ext of EXTENSIONS) {
           const candidate = resolved + ext;
-          if (existsSync62(candidate)) {
+          if (existsSync61(candidate)) {
             found = candidate;
             break;
           }
@@ -108754,7 +108771,7 @@ async function buildWorkspaceGraphAsync(workspaceRoot, options) {
   const walkBudgetMs = options?.walkBudgetMs ?? DEFAULT_WALK_BUDGET_MS;
   const followSymlinks = options?.followSymlinks ?? false;
   const absoluteRoot = path106.resolve(workspaceRoot);
-  if (!existsSync62(absoluteRoot)) {
+  if (!existsSync61(absoluteRoot)) {
     throw new Error(`Workspace directory does not exist: ${workspaceRoot}`);
   }
   if (isRefusedWorkspaceRoot(absoluteRoot)) {
@@ -108839,7 +108856,7 @@ function getCachedMtime(workspace) {
 }
 // src/tools/repo-graph/incremental.ts
 init_logger();
-import { existsSync as existsSync64 } from "node:fs";
+import { existsSync as existsSync63 } from "node:fs";
 import * as fsPromises7 from "node:fs/promises";
 import * as path110 from "node:path";
 
@@ -109298,7 +109315,7 @@ function buildOntologyPreflightPacket(graph, filePaths = [], options = {}) {
 init_utils2();
 init_logger();
 init_path_security();
-import { constants as constants5, existsSync as existsSync63, readFileSync as readFileSync44, statSync as statSync25 } from "node:fs";
+import { constants as constants5, existsSync as existsSync62, readFileSync as readFileSync44, statSync as statSync24 } from "node:fs";
 import * as fsPromises6 from "node:fs/promises";
 import * as path109 from "node:path";
 var _internals67 = {
@@ -109358,7 +109375,7 @@ async function loadGraph(workspace) {
   if (cached3 && !isDirty(normalized)) {
     try {
       const graphPath = getGraphPath(workspace);
-      if (existsSync63(graphPath)) {
+      if (existsSync62(graphPath)) {
         const stats = await fsPromises6.stat(graphPath);
         const cachedMtime = getCachedMtime(normalized);
         if (cachedMtime !== undefined && stats.mtimeMs !== cachedMtime) {
@@ -109375,7 +109392,7 @@ async function loadGraph(workspace) {
   }
   try {
     const graphPath = getGraphPath(workspace);
-    if (!existsSync63(graphPath)) {
+    if (!existsSync62(graphPath)) {
       return null;
     }
     const stats = await fsPromises6.stat(graphPath);
@@ -109409,9 +109426,9 @@ function loadGraphSync(workspace) {
   const normalized = path109.normalize(workspace);
   try {
     const graphPath = getGraphPath(workspace);
-    if (!existsSync63(graphPath))
+    if (!existsSync62(graphPath))
       return null;
-    const stats = statSync25(graphPath);
+    const stats = statSync24(graphPath);
     const content = readFileSync44(graphPath, "utf-8");
     if (content.includes("\x00") || content.includes("�")) {
       throw Object.assign(new Error("repo-graph.json contains null bytes or invalid encoding"), { code: "CORRUPTION" });
@@ -109535,7 +109552,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
   const updatedPaths = new Set;
   for (const rawFilePath of filePaths) {
     const normalizedPath = normalizeGraphPath(rawFilePath);
-    const fileExists = existsSync64(rawFilePath);
+    const fileExists = existsSync63(rawFilePath);
     if (fileExists) {
       graph.edges = graph.edges.filter((e) => normalizeGraphPath(e.source) !== normalizedPath);
       const result = scanFile(rawFilePath, absoluteRoot, maxFileSize);
@@ -109575,7 +109592,7 @@ async function updateGraphForFiles(workspaceRoot, filePaths, options) {
   if (loadedMtime !== undefined) {
     try {
       const graphPath = getGraphPath(workspaceRoot);
-      if (existsSync64(graphPath)) {
+      if (existsSync63(graphPath)) {
         const currentStats = await fsPromises7.stat(graphPath);
         if (currentStats.mtimeMs !== loadedMtime) {
           warn(`[repo-graph] Concurrent modification detected — falling back to full rebuild`);
@@ -110411,15 +110428,15 @@ import * as fs65 from "node:fs";
 var cache2 = new Map;
 function getCachedGraph2(directory) {
   const file3 = getGraphPath(directory);
-  let stat9;
+  let stat10;
   try {
-    stat9 = fs65.statSync(file3);
+    stat10 = fs65.statSync(file3);
   } catch {
     cache2.delete(directory);
     return null;
   }
   const cached3 = cache2.get(directory);
-  if (cached3 && cached3.mtimeMs === stat9.mtimeMs && cached3.size === stat9.size) {
+  if (cached3 && cached3.mtimeMs === stat10.mtimeMs && cached3.size === stat10.size) {
     return cached3.graph;
   }
   let graph;
@@ -110433,7 +110450,7 @@ function getCachedGraph2(directory) {
     cache2.delete(directory);
     return null;
   }
-  cache2.set(directory, { graph, mtimeMs: stat9.mtimeMs, size: stat9.size });
+  cache2.set(directory, { graph, mtimeMs: stat10.mtimeMs, size: stat10.size });
   return graph;
 }
 function buildCoderLocalizationBlock(directory, targetFile) {
@@ -112870,7 +112887,7 @@ import * as path120 from "node:path";
 
 // src/turbo/lean/evidence.ts
 init_bun_compat();
-import { rmSync as rmSync7 } from "node:fs";
+import { rmSync as rmSync6 } from "node:fs";
 import * as fs69 from "node:fs/promises";
 import * as path119 from "node:path";
 function leanTurboEvidenceDir(directory, phase) {
@@ -112913,7 +112930,7 @@ async function atomicWriteJson(filePath, data) {
     await fs69.rename(tempPath, filePath);
   } catch (error93) {
     try {
-      rmSync7(tempPath, { force: true });
+      rmSync6(tempPath, { force: true });
     } catch {}
     throw error93;
   }
@@ -113822,7 +113839,7 @@ function createDarkMatterDetectorHook(directory) {
 }
 
 // src/hooks/delegate-ack-collector.ts
-import { appendFile as appendFile13, mkdir as mkdir24 } from "node:fs/promises";
+import { appendFile as appendFile13, mkdir as mkdir25 } from "node:fs/promises";
 import * as path123 from "node:path";
 
 // src/hooks/knowledge-application.ts
@@ -113830,8 +113847,8 @@ init_task_file();
 init_logger();
 init_knowledge_store();
 var import_proper_lockfile9 = __toESM(require_proper_lockfile(), 1);
-import { existsSync as existsSync70 } from "node:fs";
-import { appendFile as appendFile11, mkdir as mkdir23, readFile as readFile25 } from "node:fs/promises";
+import { existsSync as existsSync69 } from "node:fs";
+import { appendFile as appendFile11, mkdir as mkdir24, readFile as readFile25 } from "node:fs/promises";
 import * as path121 from "node:path";
 function resolveApplicationLogPath(directory) {
   return path121.join(directory, ".swarm", "knowledge-application.jsonl");
@@ -113854,7 +113871,7 @@ function parseAcknowledgments(text) {
 async function appendAudit(directory, record3) {
   const filePath = resolveApplicationLogPath(directory);
   const dirPath = path121.dirname(filePath);
-  await mkdir23(dirPath, { recursive: true });
+  await mkdir24(dirPath, { recursive: true });
   let release;
   try {
     release = await import_proper_lockfile9.default.lock(dirPath, {
@@ -113915,7 +113932,7 @@ async function bumpCountersBatch(directory, bumps) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
   await transactKnowledge(swarmPath, (swarm) => applyOne(swarm) ? swarm : null);
   const hivePath = resolveHiveKnowledgePath();
-  if (existsSync70(hivePath)) {
+  if (existsSync69(hivePath)) {
     await transactKnowledge(hivePath, (hive) => applyOne(hive) ? hive : null);
   }
 }
@@ -114714,7 +114731,7 @@ function extractTaskId2(prompt) {
 }
 async function appendUnacknowledgedCritical(directory, record3) {
   const filePath = validateSwarmPath(directory, "unacknowledged-criticals.jsonl");
-  await mkdir24(path123.dirname(filePath), { recursive: true });
+  await mkdir25(path123.dirname(filePath), { recursive: true });
   await appendFile13(filePath, `${JSON.stringify(record3)}
 `, "utf-8");
 }
@@ -114889,7 +114906,7 @@ init_extractors();
 // src/hooks/phase-directives.ts
 init_knowledge_events();
 init_knowledge_store();
-import { existsSync as existsSync71 } from "node:fs";
+import { existsSync as existsSync70 } from "node:fs";
 async function collectPhaseDirectiveIds(directory, phaseLabel) {
   const events = await readKnowledgeEvents(directory);
   const ids = new Set;
@@ -114909,7 +114926,7 @@ async function readEntriesById(directory) {
   for (const e of swarm)
     map3.set(e.id, e);
   const hivePath = resolveHiveKnowledgePath();
-  if (existsSync71(hivePath)) {
+  if (existsSync70(hivePath)) {
     const hive = await readKnowledge(hivePath);
     for (const e of hive)
       if (!map3.has(e.id))
@@ -116670,7 +116687,7 @@ ${errorSummary}`);
 init_schema();
 init_state();
 init_logger();
-import { appendFile as appendFile14, mkdir as mkdir25 } from "node:fs/promises";
+import { appendFile as appendFile14, mkdir as mkdir26 } from "node:fs/promises";
 import * as path126 from "node:path";
 var HIGH_RISK_TOOLS = new Set([
   "save_plan",
@@ -116742,7 +116759,7 @@ async function knowledgeApplicationGateBefore(directory, input, config3) {
 }
 async function writeWarnEvent2(directory, record3) {
   const filePath = path126.join(directory, ".swarm", "events.jsonl");
-  await mkdir25(path126.dirname(filePath), { recursive: true });
+  await mkdir26(path126.dirname(filePath), { recursive: true });
   await appendFile14(filePath, `${JSON.stringify(record3)}
 `, "utf-8");
 }
@@ -116800,7 +116817,7 @@ init_schema();
 // src/services/directive-predicate-runner.ts
 init_bun_compat();
 init_logger();
-import { existsSync as existsSync74 } from "node:fs";
+import { existsSync as existsSync73 } from "node:fs";
 import * as path127 from "node:path";
 var PREDICATE_TIMEOUT_MS = 15000;
 var TOOL_BINARY_ALLOWLIST = new Set([
@@ -116842,7 +116859,7 @@ function findBinaryInPath(binary2) {
     if (!dir)
       continue;
     const candidate = path127.join(dir, exeName);
-    if (existsSync74(candidate))
+    if (existsSync73(candidate))
       return candidate;
   }
   return null;
@@ -117731,8 +117748,8 @@ async function cleanupOldTrajectoryFiles(directory, maxAgeDays = 7) {
           continue;
         const filePath = path130.join(dirPath, entry.name);
         try {
-          const stat11 = await fs80.stat(filePath);
-          if (now - stat11.mtimeMs > cutoffMs) {
+          const stat12 = await fs80.stat(filePath);
+          if (now - stat12.mtimeMs > cutoffMs) {
             await fs80.unlink(filePath);
           }
         } catch {}
@@ -118918,13 +118935,13 @@ init_zod();
 init_path_security();
 init_create_tool();
 import {
-  existsSync as existsSync76,
-  mkdirSync as mkdirSync33,
+  existsSync as existsSync75,
+  mkdirSync as mkdirSync32,
   mkdtempSync as mkdtempSync2,
   readFileSync as readFileSync50,
   realpathSync as realpathSync16,
   renameSync as renameSync24,
-  rmdirSync as rmdirSync2,
+  rmdirSync,
   unlinkSync as unlinkSync18,
   writeFileSync as writeFileSync23
 } from "node:fs";
@@ -119268,7 +119285,7 @@ function applyHunks(content, fileDiff) {
 }
 function atomicWriteFileSync2(targetPath, content) {
   const dir = path133.dirname(targetPath);
-  mkdirSync33(dir, { recursive: true });
+  mkdirSync32(dir, { recursive: true });
   const tempPrefix = `.apply-patch-${Date.now()}-${process.pid}`;
   let tempPath;
   try {
@@ -119281,15 +119298,15 @@ function atomicWriteFileSync2(targetPath, content) {
     writeFileSync23(tempPath, content, "utf-8");
     renameSync24(tempPath, targetPath);
   } finally {
-    if (existsSync76(tempPath)) {
+    if (existsSync75(tempPath)) {
       try {
         unlinkSync18(tempPath);
       } catch {}
     }
     const tempDir = path133.dirname(tempPath);
-    if (tempDir !== dir && existsSync76(tempDir)) {
+    if (tempDir !== dir && existsSync75(tempDir)) {
       try {
-        rmdirSync2(tempDir);
+        rmdirSync(tempDir);
       } catch {}
     }
   }
@@ -119364,7 +119381,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
       };
     }
     const parentDir = path133.dirname(fullPath);
-    if (!existsSync76(parentDir)) {
+    if (!existsSync75(parentDir)) {
       return {
         file: targetPath,
         status: "error",
@@ -119380,7 +119397,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
         ]
       };
     }
-    if (existsSync76(fullPath)) {
+    if (existsSync75(fullPath)) {
       return {
         file: targetPath,
         status: "error",
@@ -119455,7 +119472,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
         ]
       };
     }
-    if (!existsSync76(fullPath)) {
+    if (!existsSync75(fullPath)) {
       return {
         file: targetPath,
         status: "error",
@@ -119499,7 +119516,7 @@ function processFileDiff(fileDiff, targetPath, fullPath, workspace, dryRun, allo
       hunksFailed: 0
     };
   }
-  if (!existsSync76(fullPath)) {
+  if (!existsSync75(fullPath)) {
     return {
       file: targetPath,
       status: "error",
@@ -119650,7 +119667,7 @@ var applyPatch = createSwarmTool({
     const dryRun = obj.dryRun ?? false;
     const allowCreates = obj.allowCreates ?? false;
     const allowDeletes = obj.allowDeletes ?? false;
-    if (!existsSync76(directory)) {
+    if (!existsSync75(directory)) {
       return JSON.stringify(buildErrorResult("Workspace directory does not exist"), null, 2);
     }
     if (files.length === 0) {
@@ -120610,8 +120627,8 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat11 = fs86.statSync(filePath);
-    if (stat11.size > MAX_FILE_SIZE_BYTES3) {
+    const stat12 = fs86.statSync(filePath);
+    if (stat12.size > MAX_FILE_SIZE_BYTES3) {
       return null;
     }
     const content = fs86.readFileSync(filePath, "utf-8");
@@ -120812,8 +120829,8 @@ async function computeDuplicationRatio(files, workingDir) {
       continue;
     }
     try {
-      const stat11 = fs86.statSync(fullPath);
-      if (stat11.size > MAX_FILE_SIZE_BYTES3) {
+      const stat12 = fs86.statSync(fullPath);
+      if (stat12.size > MAX_FILE_SIZE_BYTES3) {
         continue;
       }
       const content = fs86.readFileSync(fullPath, "utf-8");
@@ -121273,8 +121290,8 @@ async function getGitChurn(days, directory) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat11 = fs87.statSync(filePath);
-    if (stat11.size > MAX_FILE_SIZE_BYTES4) {
+    const stat12 = fs87.statSync(filePath);
+    if (stat12.size > MAX_FILE_SIZE_BYTES4) {
       return null;
     }
     const content = fs87.readFileSync(filePath, "utf-8");
@@ -121469,7 +121486,7 @@ ${body2}`);
 // src/council/council-evidence-writer.ts
 init_zod();
 init_task_file();
-import { appendFileSync as appendFileSync15, existsSync as existsSync81, mkdirSync as mkdirSync35, readFileSync as readFileSync56 } from "node:fs";
+import { appendFileSync as appendFileSync15, existsSync as existsSync80, mkdirSync as mkdirSync34, readFileSync as readFileSync56 } from "node:fs";
 import { join as join111 } from "node:path";
 var EVIDENCE_DIR2 = ".swarm/evidence";
 var VALID_TASK_ID = /^\d+\.\d+(\.\d+)*$/;
@@ -121509,11 +121526,11 @@ async function writeCouncilEvidence(workingDir, synthesis) {
     throw new Error(`writeCouncilEvidence: invalid taskId "${synthesis.taskId}" — must match N.M or N.M.P format`);
   }
   const dir = join111(workingDir, EVIDENCE_DIR2);
-  mkdirSync35(dir, { recursive: true });
+  mkdirSync34(dir, { recursive: true });
   const filePath = taskEvidencePath(workingDir, synthesis.taskId);
   await _internals77.withTaskEvidenceLock(workingDir, synthesis.taskId, COUNCIL_AGENT_ID, async () => {
     const existingRoot = Object.create(null);
-    if (existsSync81(filePath)) {
+    if (existsSync80(filePath)) {
       try {
         const parsed = EvidenceFileSchema.parse(JSON.parse(readFileSync56(filePath, "utf-8")));
         safeAssignOwnProps(existingRoot, parsed);
@@ -121545,7 +121562,7 @@ async function writeCouncilEvidence(workingDir, synthesis) {
   });
   try {
     const councilDir = join111(workingDir, ".swarm", "council");
-    mkdirSync35(councilDir, { recursive: true });
+    mkdirSync34(councilDir, { recursive: true });
     const auditLine = JSON.stringify({
       round: synthesis.roundNumber,
       verdict: synthesis.overallVerdict,
@@ -121907,7 +121924,7 @@ function buildFinalCouncilFeedback(projectSummary, verdict, vetoedBy, requiredFi
 
 // src/council/criteria-store.ts
 init_zod();
-import { existsSync as existsSync82, mkdirSync as mkdirSync36, readFileSync as readFileSync57, writeFileSync as writeFileSync25 } from "node:fs";
+import { existsSync as existsSync81, mkdirSync as mkdirSync35, readFileSync as readFileSync57, writeFileSync as writeFileSync25 } from "node:fs";
 import { join as join112 } from "node:path";
 var COUNCIL_DIR = ".swarm/council";
 var CouncilCriteriaSchema = exports_external.object({
@@ -121921,7 +121938,7 @@ var CouncilCriteriaSchema = exports_external.object({
 });
 function writeCriteria(workingDir, taskId, criteria) {
   const dir = join112(workingDir, COUNCIL_DIR);
-  mkdirSync36(dir, { recursive: true });
+  mkdirSync35(dir, { recursive: true });
   const payload = {
     taskId,
     criteria,
@@ -121931,7 +121948,7 @@ function writeCriteria(workingDir, taskId, criteria) {
 }
 function readCriteria(workingDir, taskId) {
   const filePath = join112(workingDir, COUNCIL_DIR, `${safeId(taskId)}.json`);
-  if (!existsSync82(filePath))
+  if (!existsSync81(filePath))
     return null;
   try {
     return CouncilCriteriaSchema.parse(JSON.parse(readFileSync57(filePath, "utf-8")));
@@ -123743,8 +123760,8 @@ function readEvidenceFiles(evidenceDir, _cwd) {
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat11 = fs92.lstatSync(filePath);
-      if (!stat11.isFile()) {
+      const stat12 = fs92.lstatSync(filePath);
+      if (!stat12.isFile()) {
         continue;
       }
     } catch {
@@ -126253,8 +126270,8 @@ var git_blame = createSwarmTool({
         lines: []
       });
     }
-    const stat11 = fs96.statSync(resolvedPath);
-    if (stat11.isDirectory()) {
+    const stat12 = fs96.statSync(resolvedPath);
+    if (stat12.isDirectory()) {
       return JSON.stringify({
         error: "path is a directory, not a file",
         file: file3,
@@ -126774,9 +126791,9 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
       continue;
     }
     const fullPath = path149.join(dir, entry);
-    let stat11;
+    let stat12;
     try {
-      stat11 = fs97.statSync(fullPath);
+      stat12 = fs97.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -126784,9 +126801,9 @@ function findSourceFiles2(dir, files = [], stats = { skippedDirs: [], skippedFil
       });
       continue;
     }
-    if (stat11.isDirectory()) {
+    if (stat12.isDirectory()) {
       findSourceFiles2(fullPath, files, stats);
-    } else if (stat11.isFile()) {
+    } else if (stat12.isFile()) {
       const ext = path149.extname(fullPath).toLowerCase();
       if (SUPPORTED_EXTENSIONS3.includes(ext)) {
         files.push(fullPath);
@@ -126881,8 +126898,8 @@ var imports = createSwarmTool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat11 = fs97.statSync(filePath);
-          if (stat11.size > MAX_FILE_SIZE_BYTES6) {
+          const stat12 = fs97.statSync(filePath);
+          if (stat12.size > MAX_FILE_SIZE_BYTES6) {
             skippedFileCount++;
             continue;
           }
@@ -127336,7 +127353,7 @@ init_zod();
 init_config();
 init_knowledge_store();
 init_create_tool();
-import { existsSync as existsSync88 } from "node:fs";
+import { existsSync as existsSync87 } from "node:fs";
 var DEFAULT_LIMIT = 10;
 var MAX_LESSON_LENGTH = 200;
 var VALID_CATEGORIES3 = [
@@ -127412,14 +127429,14 @@ function validateLimit(limit) {
 }
 async function readSwarmKnowledge(directory) {
   const swarmPath = resolveSwarmKnowledgePath(directory);
-  if (!existsSync88(swarmPath)) {
+  if (!existsSync87(swarmPath)) {
     return [];
   }
   return readKnowledge(swarmPath);
 }
 async function readHiveKnowledge() {
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync88(hivePath)) {
+  if (!existsSync87(hivePath)) {
     return [];
   }
   return readKnowledge(hivePath);
@@ -134025,8 +134042,8 @@ async function placeholderScan(input, directory) {
     }
     let content;
     try {
-      const stat11 = fs112.statSync(fullPath);
-      if (stat11.size > MAX_FILE_SIZE) {
+      const stat12 = fs112.statSync(fullPath);
+      if (stat12.size > MAX_FILE_SIZE) {
         continue;
       }
       content = fs112.readFileSync(fullPath, "utf-8");
@@ -136365,14 +136382,14 @@ async function runSecretscanWithFiles(files, directory) {
         skippedFiles++;
         continue;
       }
-      let stat11;
+      let stat12;
       try {
-        stat11 = fs116.statSync(file3);
+        stat12 = fs116.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
       }
-      if (stat11.size > MAX_FILE_SIZE_BYTES8) {
+      if (stat12.size > MAX_FILE_SIZE_BYTES8) {
         skippedFiles++;
         continue;
       }
@@ -137199,8 +137216,8 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
   for (const entry of entries) {
     const entryPath = path171.join(evidenceDir, entry);
     try {
-      const stat11 = fs117.statSync(entryPath);
-      if (!stat11.isDirectory()) {
+      const stat12 = fs117.statSync(entryPath);
+      if (!stat12.isDirectory()) {
         continue;
       }
     } catch {
@@ -137220,11 +137237,11 @@ function readTouchedFiles(evidenceDir, phase, cwd) {
       if (!resolvedPath.startsWith(evidenceDirResolved + path171.sep)) {
         continue;
       }
-      const stat11 = fs117.lstatSync(evidenceFilePath);
-      if (!stat11.isFile()) {
+      const stat12 = fs117.lstatSync(evidenceFilePath);
+      if (!stat12.isFile()) {
         continue;
       }
-      if (stat11.size > MAX_FILE_SIZE_BYTES8) {
+      if (stat12.size > MAX_FILE_SIZE_BYTES8) {
         continue;
       }
     } catch {
@@ -140078,7 +140095,7 @@ init_zod();
 init_config();
 init_schema();
 init_create_tool();
-import { mkdir as mkdir30, rename as rename12, writeFile as writeFile21 } from "node:fs/promises";
+import { mkdir as mkdir31, rename as rename12, writeFile as writeFile21 } from "node:fs/promises";
 import * as path176 from "node:path";
 var MAX_SPEC_BYTES2 = 256 * 1024;
 var spec_write = createSwarmTool({
@@ -140121,7 +140138,7 @@ var spec_write = createSwarmTool({
       }, null, 2);
     }
     const target = path176.join(directory, ".swarm", "spec.md");
-    await mkdir30(path176.dirname(target), { recursive: true });
+    await mkdir31(path176.dirname(target), { recursive: true });
     const tmp = `${target}.tmp-${process.pid}-${Date.now()}`;
     let finalContent = content;
     if (mode === "append") {
@@ -140150,8 +140167,8 @@ ${content}
 init_zod();
 init_loader();
 import {
-  existsSync as existsSync103,
-  mkdirSync as mkdirSync42,
+  existsSync as existsSync102,
+  mkdirSync as mkdirSync41,
   readFileSync as readFileSync82,
   renameSync as renameSync26,
   unlinkSync as unlinkSync21,
@@ -140387,7 +140404,7 @@ function getPhaseMutationGapFinding(phaseNumber, workingDir) {
 }
 function writePhaseCouncilEvidence(workingDir, synthesis, provenance) {
   const evidenceDir = path177.join(workingDir, ".swarm", "evidence", String(synthesis.phaseNumber));
-  mkdirSync42(evidenceDir, { recursive: true });
+  mkdirSync41(evidenceDir, { recursive: true });
   const evidenceFile = path177.join(evidenceDir, "phase-council.json");
   const evidenceBundle = {
     entries: [
@@ -140425,7 +140442,7 @@ function writePhaseCouncilEvidence(workingDir, synthesis, provenance) {
     writeFileSync33(tempFile, JSON.stringify(evidenceBundle, null, 2), "utf-8");
     renameSync26(tempFile, evidenceFile);
   } finally {
-    if (existsSync103(tempFile)) {
+    if (existsSync102(tempFile)) {
       unlinkSync21(tempFile);
     }
   }
@@ -141359,8 +141376,8 @@ async function syntaxCheck(input, directory, config3) {
         return { result, counted: false, failed: false, skipped: true };
       }
       try {
-        const stat11 = fs123.statSync(fullPath);
-        if (stat11.size >= MAX_FILE_SIZE2) {
+        const stat12 = fs123.statSync(fullPath);
+        if (stat12.size >= MAX_FILE_SIZE2) {
           result.skipped_reason = "file_too_large";
           return { result, counted: false, failed: false, skipped: true };
         }
@@ -141592,15 +141609,15 @@ function findSourceFiles3(dir, files = []) {
       continue;
     }
     const fullPath = path180.join(dir, entry);
-    let stat11;
+    let stat12;
     try {
-      stat11 = fs124.statSync(fullPath);
+      stat12 = fs124.statSync(fullPath);
     } catch {
       continue;
     }
-    if (stat11.isDirectory()) {
+    if (stat12.isDirectory()) {
       findSourceFiles3(fullPath, files);
-    } else if (stat11.isFile()) {
+    } else if (stat12.isFile()) {
       if (isSupportedExtension(fullPath)) {
         files.push(fullPath);
       }
@@ -141697,8 +141714,8 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat11 = fs124.statSync(scanPath);
-    if (stat11.isFile()) {
+    const stat12 = fs124.statSync(scanPath);
+    if (stat12.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
       } else {
@@ -142819,7 +142836,7 @@ import * as zlib from "node:zlib";
 init_utils2();
 init_redaction();
 import { createHash as createHash17 } from "node:crypto";
-import { appendFile as appendFile17, mkdir as mkdir31 } from "node:fs/promises";
+import { appendFile as appendFile17, mkdir as mkdir32 } from "node:fs/promises";
 import * as path185 from "node:path";
 var EVIDENCE_CACHE_FILE = "evidence-cache/documents.jsonl";
 var MAX_EVIDENCE_TEXT_LENGTH = 4000;
@@ -142828,7 +142845,7 @@ async function writeEvidenceDocuments(directory, inputs, now = () => new Date) {
   const capturedAt = now().toISOString();
   const records = inputs.map((input) => createEvidenceDocumentRecord(input, capturedAt)).filter((record3) => record3 !== null);
   if (records.length > 0) {
-    await mkdir31(path185.dirname(filePath), { recursive: true });
+    await mkdir32(path185.dirname(filePath), { recursive: true });
     await appendFile17(filePath, `${records.map((record3) => JSON.stringify(record3)).join(`
 `)}
 `, "utf-8");
@@ -144729,6 +144746,7 @@ init_warning_buffer();
 var _heartbeatTimers = new Map;
 var SWARM_COMMAND_SYSTEM_RULE_TAG = "[opencode-swarm:swarm-command-rule]";
 var PACKAGE_ROOT2 = path192.resolve(path192.dirname(fileURLToPath5(import.meta.url)), "..");
+var SYNC_BUNDLED_SKILLS_TIMEOUT_MS = 2000;
 function createSwarmCommandSystemRuleHook(agentDefinitions, registeredAgents) {
   return async (input, output) => {
     const { sessionID } = input;
@@ -144827,6 +144845,14 @@ async function initializeOpenCodeSwarm(ctx) {
   });
   writeSwarmConfigExampleIfNew(ctx.directory);
   writeProjectConfigIfNew(ctx.directory, config3.quiet);
+  queueMicrotask(() => {
+    withTimeout(syncBundledProjectSkillsIfMissingAsync(ctx.directory, PACKAGE_ROOT2, config3.quiet), SYNC_BUNDLED_SKILLS_TIMEOUT_MS, new Error(`syncBundledProjectSkillsIfMissingAsync exceeded ${SYNC_BUNDLED_SKILLS_TIMEOUT_MS}ms budget; continuing without skill materialization (command-path sync remains a backstop)`)).catch((err3) => {
+      const msg = err3 instanceof Error ? err3.message : String(err3);
+      log("bundled skill materialization timed out or failed (non-fatal)", {
+        error: msg
+      });
+    });
+  });
   if (config3.version_check !== false) {
     scheduleVersionCheck(package_default.version, (msg) => {
       if (config3.quiet) {