opencode-swarm 7.76.1 → 7.76.2

package/dist/cli/index.js

@@ -52,7 +52,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",
@@ -154,43 +154,56 @@ var init_package = __esm(() => {
 
 // src/config/bundled-skills.ts
 import * as fs from "fs";
+import * as fsp from "fs/promises";
 import * as path from "path";
-function isSymbolicLink(p) {
+function getSyncCacheKey(projectDirectory, packageRoot) {
+  return `${path.resolve(projectDirectory)}\x00${path.resolve(packageRoot)}`;
+}
+function warnBundledSkillSyncFailure(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  console.warn(`[opencode-swarm] Could not install bundled project skills; continuing without sync: ${message}`);
+}
+async function isSymbolicLinkAsync(p) {
   try {
-    return fs.lstatSync(p).isSymbolicLink();
+    return (await fsp.lstat(p)).isSymbolicLink();
   } catch {
     return false;
   }
 }
-function ensureNotSymlinkedDirectory(p) {
+async function ensureNotSymlinkedDirectoryAsync(p) {
   try {
-    const stat = fs.lstatSync(p);
-    return stat.isDirectory() && !stat.isSymbolicLink();
+    const stat2 = await fsp.lstat(p);
+    return stat2.isDirectory() && !stat2.isSymbolicLink();
   } catch (err) {
     return err.code === "ENOENT";
   }
 }
-function getSyncCacheKey(projectDirectory, packageRoot) {
-  return `${path.resolve(projectDirectory)}\x00${path.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 = path.join(sourceDir, relativeDir);
-  const entries = fs.readdirSync(currentSource, { withFileTypes: true });
+  const entries = await fsp.readdir(currentSource, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const relativeEntry = path.join(relativeDir, entry.name);
     const sourcePath = path.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 stat = fs.statSync(sourcePath);
+    const stat2 = await fsp.stat(sourcePath);
     const nextFiles = state.files + 1;
-    const nextBytes = state.bytes + stat.size;
+    const nextBytes = state.bytes + stat2.size;
     if (nextFiles > MAX_SKILL_FILES || nextBytes > MAX_SKILL_BYTES) {
       throw new Error("bundled skill package exceeds copy bounds");
     }
@@ -200,7 +213,7 @@ function collectBundledSkillFilesBounded(sourceDir, state, relativeDir = "") {
   }
   return files;
 }
-function rollbackCopiedFiles(copiedFiles, destDir) {
+async function rollbackCopiedFilesAsync(copiedFiles, destDir) {
   const safeDestDir = path.resolve(destDir);
   const dirs = new Set;
   for (const copiedFile of copiedFiles) {
@@ -209,7 +222,7 @@ function rollbackCopiedFiles(copiedFiles, destDir) {
     if (relative2.startsWith("..") || path.isAbsolute(relative2))
       continue;
     try {
-      fs.rmSync(resolvedFile, { force: true });
+      await fsp.rm(resolvedFile, { force: true });
     } catch {}
     dirs.add(path.dirname(resolvedFile));
   }
@@ -218,12 +231,12 @@ function rollbackCopiedFiles(copiedFiles, destDir) {
     if (relative2.startsWith("..") || path.isAbsolute(relative2))
       continue;
     try {
-      fs.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
   });
@@ -232,9 +245,9 @@ function copyBundledDirectoryBounded(sourceDir, destDir) {
     for (const file of files) {
       const sourcePath = path.join(sourceDir, file.relativePath);
       const destPath = path.join(destDir, file.relativePath);
-      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      await fsp.mkdir(path.dirname(destPath), { recursive: true });
       try {
-        fs.copyFileSync(sourcePath, destPath, fs.constants.COPYFILE_EXCL);
+        await fsp.copyFile(sourcePath, destPath, fs.constants.COPYFILE_EXCL);
         copiedFiles.push(destPath);
       } catch (err) {
         if (err.code !== "EEXIST")
@@ -242,15 +255,11 @@ function copyBundledDirectoryBounded(sourceDir, destDir) {
       }
     }
   } catch (err) {
-    rollbackCopiedFiles(copiedFiles, destDir);
+    await rollbackCopiedFilesAsync(copiedFiles, destDir);
     throw err;
   }
 }
-function warnBundledSkillSyncFailure(err) {
-  const message = err instanceof Error ? err.message : String(err);
-  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))
@@ -259,23 +268,23 @@ function syncBundledProjectSkillsIfMissing(projectDirectory, packageRoot, quiet
     const opencodeDir = path.join(projectDirectory, ".opencode");
     const skillsDir = path.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 = path.join(sourceRoot, slug);
       const sourceSkill = path.join(sourceDir, "SKILL.md");
       const destDir = path.join(skillsDir, slug);
       const destSkill = path.join(destDir, "SKILL.md");
-      if (!fs.existsSync(sourceSkill))
+      if (!await pathExistsAsync(sourceSkill))
         continue;
       sawBundledSource = true;
-      if (fs.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`);
       }
@@ -15027,21 +15036,21 @@ function hash2(content) {
   return createHash("sha256").update(content, "utf-8").digest("hex");
 }
 function readTextBounded(absPath) {
-  const stat2 = fs2.lstatSync(absPath);
-  if (!stat2.isFile() || stat2.size > MAX_SOURCE_BYTES) {
+  const stat3 = fs2.lstatSync(absPath);
+  if (!stat3.isFile() || stat3.size > MAX_SOURCE_BYTES) {
     return null;
   }
   return fs2.readFileSync(absPath, "utf-8");
 }
 function fileArtifact(root, absPath) {
   try {
-    const stat2 = fs2.lstatSync(absPath);
-    if (!stat2.isFile() || stat2.size > MAX_SOURCE_BYTES)
+    const stat3 = fs2.lstatSync(absPath);
+    if (!stat3.isFile() || stat3.size > MAX_SOURCE_BYTES)
       return null;
     return {
       relPath: toPosix(path4.relative(root, absPath)),
-      bytes: stat2.size,
-      mtimeMs: stat2.mtimeMs
+      bytes: stat3.size,
+      mtimeMs: stat3.mtimeMs
     };
   } catch {
     return null;
@@ -15332,14 +15341,14 @@ function readEffectiveSpecSync(directory) {
   const root = path4.resolve(directory);
   const swSpecPath = path4.join(root, SWARM_SPEC_REL);
   try {
-    const stat2 = fs2.lstatSync(swSpecPath);
-    if (stat2.isFile() && stat2.size <= MAX_SPEC_BYTES) {
+    const stat3 = fs2.lstatSync(swSpecPath);
+    if (stat3.isFile() && stat3.size <= MAX_SPEC_BYTES) {
       const content = fs2.readFileSync(swSpecPath, "utf-8");
       return {
         source: "swarm",
         content,
         hash: hash2(content),
-        mtime: stat2.mtime.toISOString(),
+        mtime: stat3.mtime.toISOString(),
         sourcePaths: [toPosix(SWARM_SPEC_REL)],
         warnings: []
       };
@@ -15878,9 +15887,9 @@ var init_ledger = __esm(() => {
 
 // src/plan/manager.ts
 import {
-  copyFileSync as copyFileSync2,
-  existsSync as existsSync4,
-  readdirSync as readdirSync3,
+  copyFileSync,
+  existsSync as existsSync3,
+  readdirSync as readdirSync2,
   renameSync as renameSync3,
   unlinkSync
 } from "fs";
@@ -16324,7 +16333,7 @@ async function savePlan(directory, plan, options) {
       const oldLedgerPath = path6.join(swarmDir2, "plan-ledger.jsonl");
       const oldLedgerBackupPath = path6.join(swarmDir2, `plan-ledger.backup-${Date.now()}-${Math.floor(Math.random() * 1e9)}.jsonl`);
       let backupExists = false;
-      if (existsSync4(oldLedgerPath)) {
+      if (existsSync3(oldLedgerPath)) {
         try {
           renameSync3(oldLedgerPath, oldLedgerBackupPath);
           backupExists = true;
@@ -16341,15 +16350,15 @@ async function savePlan(directory, plan, options) {
           const errorMessage = String(initErr);
           if (errorMessage.includes("already initialized")) {
             try {
-              if (existsSync4(oldLedgerBackupPath))
+              if (existsSync3(oldLedgerBackupPath))
                 unlinkSync(oldLedgerBackupPath);
             } catch {}
           } else {
-            if (existsSync4(oldLedgerBackupPath)) {
+            if (existsSync3(oldLedgerBackupPath)) {
               try {
                 renameSync3(oldLedgerBackupPath, oldLedgerPath);
               } catch {
-                copyFileSync2(oldLedgerBackupPath, oldLedgerPath);
+                copyFileSync(oldLedgerBackupPath, oldLedgerPath);
                 try {
                   unlinkSync(oldLedgerBackupPath);
                 } catch {}
@@ -16367,19 +16376,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 (existsSync4(oldLedgerBackupPath))
+            if (existsSync3(oldLedgerBackupPath))
               unlinkSync(oldLedgerBackupPath);
           } catch {}
         }
       } else if (!initSucceeded && backupExists) {
         try {
-          if (existsSync4(oldLedgerBackupPath))
+          if (existsSync3(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);
@@ -19203,11 +19212,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" : "\u270F\uFE0F read-write";
+    const access3 = isReadOnly ? "\uD83D\uDD12 read-only" : "\u270F\uFE0F read-write";
     const desc = agent.description || agent.config.description || "";
     const hasCustomProfile = guardrails?.profiles?.[key] !== undefined;
     const profileIndicator = hasCustomProfile ? " | \u26A1 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}`);
     }
@@ -20252,8 +20261,8 @@ GFS4: `);
     }
     var fs$copyFile = fs6.copyFile;
     if (fs$copyFile)
-      fs6.copyFile = copyFile;
-    function copyFile(src, dest, flags, cb) {
+      fs6.copyFile = copyFile2;
+    function copyFile2(src, dest, flags, cb) {
       if (typeof flags === "function") {
         cb = flags;
         flags = 0;
@@ -20271,9 +20280,9 @@ GFS4: `);
       }
     }
     var fs$readdir = fs6.readdir;
-    fs6.readdir = readdir;
+    fs6.readdir = readdir2;
     var noReaddirOptionVersions = /^v[0-5]\./;
-    function readdir(path8, options, cb) {
+    function readdir2(path8, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
       var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path9, options2, cb2, startTime) {
@@ -20862,11 +20871,11 @@ var require_mtime_precision = __commonJS((exports, module) => {
   function probe(file2, fs5, callback) {
     const cachedPrecision = fs5[cacheSymbol];
     if (cachedPrecision) {
-      return fs5.stat(file2, (err, stat2) => {
+      return fs5.stat(file2, (err, stat3) => {
         if (err) {
           return callback(err);
         }
-        callback(null, stat2.mtime, cachedPrecision);
+        callback(null, stat3.mtime, cachedPrecision);
       });
     }
     const mtime = new Date(Math.ceil(Date.now() / 1000) * 1000 + 5);
@@ -20874,13 +20883,13 @@ var require_mtime_precision = __commonJS((exports, module) => {
       if (err) {
         return callback(err);
       }
-      fs5.stat(file2, (err2, stat2) => {
+      fs5.stat(file2, (err2, stat3) => {
         if (err2) {
           return callback(err2);
         }
-        const precision = stat2.mtime.getTime() % 1000 === 0 ? "s" : "ms";
+        const precision = stat3.mtime.getTime() % 1000 === 0 ? "s" : "ms";
         Object.defineProperty(fs5, cacheSymbol, { value: precision });
-        callback(null, stat2.mtime, precision);
+        callback(null, stat3.mtime, precision);
       });
     });
   }
@@ -20930,14 +20939,14 @@ var require_lockfile = __commonJS((exports, module) => {
       if (options.stale <= 0) {
         return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file: file2 }));
       }
-      options.fs.stat(lockfilePath, (err2, stat2) => {
+      options.fs.stat(lockfilePath, (err2, stat3) => {
         if (err2) {
           if (err2.code === "ENOENT") {
             return acquireLock(file2, { ...options, stale: 0 }, callback);
           }
           return callback(err2);
         }
-        if (!isLockStale(stat2, options)) {
+        if (!isLockStale(stat3, options)) {
           return callback(Object.assign(new Error("Lock file is already being held"), { code: "ELOCKED", file: file2 }));
         }
         removeLock(file2, options, (err3) => {
@@ -20949,8 +20958,8 @@ var require_lockfile = __commonJS((exports, module) => {
       });
     });
   }
-  function isLockStale(stat2, options) {
-    return stat2.mtime.getTime() < Date.now() - options.stale;
+  function isLockStale(stat3, options) {
+    return stat3.mtime.getTime() < Date.now() - options.stale;
   }
   function removeLock(file2, options, callback) {
     options.fs.rmdir(getLockFile(file2, options), (err) => {
@@ -20968,7 +20977,7 @@ var require_lockfile = __commonJS((exports, module) => {
     lock2.updateDelay = lock2.updateDelay || options.update;
     lock2.updateTimeout = setTimeout(() => {
       lock2.updateTimeout = null;
-      options.fs.stat(lock2.lockfilePath, (err, stat2) => {
+      options.fs.stat(lock2.lockfilePath, (err, stat3) => {
         const isOverThreshold = lock2.lastUpdate + options.stale < Date.now();
         if (err) {
           if (err.code === "ENOENT" || isOverThreshold) {
@@ -20977,7 +20986,7 @@ var require_lockfile = __commonJS((exports, module) => {
           lock2.updateDelay = 1000;
           return updateLock(file2, options);
         }
-        const isMtimeOurs = lock2.mtime.getTime() === stat2.mtime.getTime();
+        const isMtimeOurs = lock2.mtime.getTime() === stat3.mtime.getTime();
         if (!isMtimeOurs) {
           return setLockAsCompromised(file2, lock2, Object.assign(new Error("Unable to update lock within the stale threshold"), { code: "ECOMPROMISED" }));
         }
@@ -21095,11 +21104,11 @@ var require_lockfile = __commonJS((exports, module) => {
       if (err) {
         return callback(err);
       }
-      options.fs.stat(getLockFile(file3, options), (err2, stat2) => {
+      options.fs.stat(getLockFile(file3, options), (err2, stat3) => {
         if (err2) {
           return err2.code === "ENOENT" ? callback(null, false) : callback(err2);
         }
-        return callback(null, !isLockStale(stat2, options));
+        return callback(null, !isLockStale(stat3, options));
       });
     });
   }
@@ -21407,11 +21416,11 @@ var init_task_id = __esm(() => {
 
 // src/evidence/manager.ts
 import {
-  mkdirSync as mkdirSync5,
-  readdirSync as readdirSync5,
+  mkdirSync as mkdirSync4,
+  readdirSync as readdirSync4,
   realpathSync,
-  rmSync as rmSync2,
-  statSync as statSync5
+  rmSync,
+  statSync as statSync4
 } from "fs";
 import * as fs6 from "fs/promises";
 import * as path9 from "path";
@@ -21437,11 +21446,11 @@ function validateProjectRoot(directory) {
       break;
     const parentSwarm = path9.join(parent, ".swarm");
     try {
-      if (statSync5(parentSwarm).isDirectory()) {
+      if (statSync4(parentSwarm).isDirectory()) {
         let hasProjectIndicator = false;
         for (const indicator of PROJECT_INDICATORS) {
           try {
-            const indicatorStat = statSync5(path9.join(parent, indicator));
+            const indicatorStat = statSync4(path9.join(parent, indicator));
             if (indicatorStat.isFile() || indicatorStat.isDirectory()) {
               hasProjectIndicator = true;
               break;
@@ -21515,14 +21524,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)`);
     }
-    mkdirSync5(evidenceDir, { recursive: true });
+    mkdirSync4(evidenceDir, { recursive: true });
     const tempPath = path9.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
     try {
       await bunWrite(tempPath, bundleJson);
       await fs6.rename(tempPath, evidencePath);
     } catch (error49) {
       try {
-        rmSync2(tempPath, { force: true });
+        rmSync(tempPath, { force: true });
       } catch {}
       throw error49;
     }
@@ -21581,7 +21590,7 @@ async function loadEvidence(directory, taskId) {
             await fs6.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)}`);
           }
@@ -21608,13 +21617,13 @@ async function loadEvidence(directory, taskId) {
 async function listEvidenceTaskIds(directory) {
   const evidenceBasePath = validateSwarmPath(directory, "evidence");
   try {
-    statSync5(evidenceBasePath);
+    statSync4(evidenceBasePath);
   } catch {
     return [];
   }
   let entries;
   try {
-    entries = readdirSync5(evidenceBasePath);
+    entries = readdirSync4(evidenceBasePath);
   } catch {
     return [];
   }
@@ -21622,7 +21631,7 @@ async function listEvidenceTaskIds(directory) {
   for (const entry of entries) {
     const entryPath = path9.join(evidenceBasePath, entry);
     try {
-      const stats = statSync5(entryPath);
+      const stats = statSync4(entryPath);
       if (!stats.isDirectory()) {
         continue;
       }
@@ -21641,12 +21650,12 @@ async function deleteEvidence(directory, taskId) {
   const relativePath = path9.join("evidence", sanitizedTaskId);
   const evidenceDir = validateSwarmPath(directory, relativePath);
   try {
-    statSync5(evidenceDir);
+    statSync4(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)}`);
@@ -21832,7 +21841,7 @@ var init_archive = __esm(() => {
 });
 
 // src/db/project-db.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync5 } from "fs";
 import { createRequire } from "module";
 import { join as join9, resolve as resolve7 } from "path";
 function loadDatabaseCtor() {
@@ -21867,7 +21876,7 @@ function projectDbPath(directory) {
   return join9(resolve7(directory), ".swarm", "swarm.db");
 }
 function projectDbExists(directory) {
-  return existsSync7(projectDbPath(directory));
+  return existsSync6(projectDbPath(directory));
 }
 function getProjectDb(directory) {
   const key = resolve7(directory);
@@ -21875,7 +21884,7 @@ function getProjectDb(directory) {
   if (existing)
     return existing;
   const swarmDir = join9(key, ".swarm");
-  mkdirSync6(swarmDir, { recursive: true });
+  mkdirSync5(swarmDir, { recursive: true });
   const Db = loadDatabaseCtor();
   const db = new Db(join9(swarmDir, "swarm.db"));
   db.run("PRAGMA journal_mode = WAL;");
@@ -37644,8 +37653,8 @@ var init_task_file = __esm(() => {
 });
 
 // src/hooks/knowledge-events.ts
-import { existsSync as existsSync9 } from "fs";
-import { appendFile as appendFile2, mkdir as mkdir2, readFile as readFile2, stat as stat2 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { appendFile as appendFile2, mkdir as mkdir3, readFile as readFile2, stat as stat3 } from "fs/promises";
 import * as path13 from "path";
 function resolveKnowledgeEventsPath(directory) {
   return path13.join(directory, ".swarm", "knowledge-events.jsonl");
@@ -37658,7 +37667,7 @@ function resolveLegacyApplicationLogPath(directory) {
 }
 async function readKnowledgeEvents(directory) {
   const filePath = resolveKnowledgeEventsPath(directory);
-  if (!existsSync9(filePath))
+  if (!existsSync8(filePath))
     return [];
   const content = await readFile2(filePath, "utf-8");
   return parseEventLines(content.split(`
@@ -37666,7 +37675,7 @@ async function readKnowledgeEvents(directory) {
 }
 async function readLegacyApplicationRecords(directory) {
   const filePath = resolveLegacyApplicationLogPath(directory);
-  if (!existsSync9(filePath))
+  if (!existsSync8(filePath))
     return [];
   const content = await readFile2(filePath, "utf-8");
   const out = [];
@@ -37736,7 +37745,7 @@ function maxIso(current, candidate) {
 }
 async function readCounterBaseline(directory) {
   const filePath = resolveKnowledgeCounterBaselinePath(directory);
-  if (!existsSync9(filePath))
+  if (!existsSync8(filePath))
     return new Map;
   const raw = JSON.parse(await readFile2(filePath, "utf-8"));
   const map3 = new Map;
@@ -37747,7 +37756,7 @@ async function readCounterBaseline(directory) {
 }
 async function statCacheKey(filePath) {
   try {
-    const fileStat = await stat2(filePath);
+    const fileStat = await stat3(filePath);
     return `${fileStat.mtimeMs}:${fileStat.ctimeMs}:${fileStat.size}`;
   } catch (err) {
     if (err?.code === "ENOENT")
@@ -37932,8 +37941,8 @@ var init_knowledge_events = __esm(() => {
 });
 
 // src/hooks/knowledge-store.ts
-import { existsSync as existsSync10 } from "fs";
-import { appendFile as appendFile3, mkdir as mkdir3, readFile as readFile3 } from "fs/promises";
+import { existsSync as existsSync9 } from "fs";
+import { appendFile as appendFile3, mkdir as mkdir4, readFile as readFile3 } from "fs/promises";
 import * as os4 from "os";
 import * as path14 from "path";
 function resolveSwarmKnowledgePath(directory) {
@@ -37963,7 +37972,7 @@ function resolveHiveRejectedPath() {
   return path14.join(path14.dirname(hivePath), "shared-learnings-rejected.jsonl");
 }
 async function readKnowledge(filePath) {
-  if (!existsSync10(filePath))
+  if (!existsSync9(filePath))
     return [];
   const content = await readFile3(filePath, "utf-8");
   const results = [];
@@ -38058,7 +38067,7 @@ async function appendRetractionRecord(directory, record3) {
 }
 async function appendKnowledge(filePath, entry) {
   const dir = path14.dirname(filePath);
-  await mkdir3(dir, { recursive: true });
+  await mkdir4(dir, { recursive: true });
   let release = null;
   try {
     release = await import_proper_lockfile4.default.lock(dir, {
@@ -38077,7 +38086,7 @@ async function appendKnowledge(filePath, entry) {
 }
 async function rewriteKnowledge(filePath, entries) {
   const dir = path14.dirname(filePath);
-  await mkdir3(dir, { recursive: true });
+  await mkdir4(dir, { recursive: true });
   let release = null;
   try {
     release = await import_proper_lockfile4.default.lock(dir, {
@@ -38099,7 +38108,7 @@ async function rewriteKnowledge(filePath, entries) {
 async function transactFile(filePath, read, write, mutate) {
   const dir = path14.dirname(filePath);
   try {
-    await mkdir3(dir, { recursive: true });
+    await mkdir4(dir, { recursive: true });
   } catch {
     return false;
   }
@@ -38290,7 +38299,7 @@ async function applyConfidenceDeltas(filePath, deltas) {
   let release = null;
   try {
     const dir = path14.dirname(filePath);
-    await mkdir3(dir, { recursive: true });
+    await mkdir4(dir, { recursive: true });
     release = await import_proper_lockfile4.default.lock(dir, {
       retries: { retries: 5, minTimeout: 100, maxTimeout: 500 },
       stale: 5000
@@ -38748,7 +38757,7 @@ var init_learning_metrics = __esm(() => {
 });
 
 // src/hooks/knowledge-validator.ts
-import { appendFile as appendFile4, mkdir as mkdir4 } from "fs/promises";
+import { appendFile as appendFile4, mkdir as mkdir5 } from "fs/promises";
 import * as path15 from "path";
 function normalizeText(text) {
   return text.normalize("NFKC").toLowerCase().replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim();
@@ -39019,7 +39028,7 @@ function resolveUnactionablePath(directory) {
 async function appendUnactionable(directory, entry, reason) {
   const filePath = resolveUnactionablePath(directory);
   const dirPath = path15.dirname(filePath);
-  await mkdir4(dirPath, { recursive: true });
+  await mkdir5(dirPath, { recursive: true });
   await transactKnowledge(filePath, (existing) => {
     const record3 = {
       ...entry,
@@ -39056,7 +39065,7 @@ async function quarantineEntry(directory, entryId, reason, reportedBy) {
   const quarantinePath = path15.join(directory, ".swarm", "knowledge-quarantined.jsonl");
   const rejectedPath = path15.join(directory, ".swarm", "knowledge-rejected.jsonl");
   const swarmDir = path15.join(directory, ".swarm");
-  await mkdir4(swarmDir, { recursive: true });
+  await mkdir5(swarmDir, { recursive: true });
   let release;
   try {
     release = await import_proper_lockfile5.default.lock(swarmDir, {
@@ -39120,7 +39129,7 @@ async function restoreEntry(directory, entryId) {
   const quarantinePath = path15.join(directory, ".swarm", "knowledge-quarantined.jsonl");
   const rejectedPath = path15.join(directory, ".swarm", "knowledge-rejected.jsonl");
   const swarmDir = path15.join(directory, ".swarm");
-  await mkdir4(swarmDir, { recursive: true });
+  await mkdir5(swarmDir, { recursive: true });
   let release;
   try {
     release = await import_proper_lockfile5.default.lock(swarmDir, {
@@ -39298,7 +39307,7 @@ var init_knowledge_validator = __esm(() => {
 });
 
 // src/services/skill-changelog.ts
-import { appendFile as appendFile5, mkdir as mkdir5, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
+import { appendFile as appendFile5, mkdir as mkdir6, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 import * as path16 from "path";
 function resolveSkillChangelogPath(directory, slug) {
   if (slug.includes("..") || slug.includes("/") || slug.includes("\\")) {
@@ -39309,7 +39318,7 @@ function resolveSkillChangelogPath(directory, slug) {
 async function appendSkillChangelog(directory, slug, entry) {
   const filePath = resolveSkillChangelogPath(directory, slug);
   const dirPath = path16.dirname(filePath);
-  await mkdir5(dirPath, { recursive: true });
+  await mkdir6(dirPath, { recursive: true });
   await appendFile5(filePath, `${JSON.stringify(entry)}
 `, "utf-8");
   try {
@@ -39332,8 +39341,8 @@ var init_skill_changelog = __esm(() => {
 });
 
 // src/services/skill-generator.ts
-import { existsSync as existsSync11, unlinkSync as unlinkSync5 } from "fs";
-import { mkdir as mkdir6, readFile as readFile5, rename as rename3, writeFile as writeFile4 } from "fs/promises";
+import { existsSync as existsSync10, unlinkSync as unlinkSync5 } from "fs";
+import { mkdir as mkdir7, readFile as readFile5, rename as rename3, writeFile as writeFile4 } from "fs/promises";
 import * as path17 from "path";
 function sanitizeSlug(input) {
   const lc = input.toLowerCase().trim();
@@ -39356,7 +39365,7 @@ function activeRepoRelativePath(slug) {
 async function selectCandidateEntries(directory, opts) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync11(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync10(hivePath) ? await readKnowledge(hivePath) : [];
   const all = [...swarm, ...hive];
   const counterRollups = await readKnowledgeCounterRollups(directory);
   const selected = [];
@@ -39557,7 +39566,7 @@ function escapeMarkdown(s) {
   return s.replace(/[\r\n]+/g, " ").slice(0, 280);
 }
 async function atomicWrite(p, content) {
-  await mkdir6(path17.dirname(p), { recursive: true });
+  await mkdir7(path17.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   await writeFile4(tmp, content, "utf-8");
   await rename3(tmp, p);
@@ -39574,7 +39583,7 @@ async function generateSkills(req) {
     const idSet = new Set(req.sourceKnowledgeIds);
     const swarm = await readKnowledge(resolveSwarmKnowledgePath(req.directory));
     const hivePath = resolveHiveKnowledgePath();
-    const hive = existsSync11(hivePath) ? await readKnowledge(hivePath) : [];
+    const hive = existsSync10(hivePath) ? await readKnowledge(hivePath) : [];
     pool = [...swarm, ...hive].filter((e) => idSet.has(e.id) && e.status !== "archived");
   } else {
     pool = candidates;
@@ -39611,7 +39620,7 @@ async function generateSkills(req) {
       continue;
     }
     let preserved = false;
-    if (req.mode === "active" && existsSync11(targetPath) && !req.force) {
+    if (req.mode === "active" && existsSync10(targetPath) && !req.force) {
       const existing = await readFile5(targetPath, "utf-8");
       if (!existing.includes("generated by opencode-swarm skill-generator")) {
         preserved = true;
@@ -39656,7 +39665,7 @@ async function stampSourceEntries(directory, slug, ids) {
   if (touched)
     await rewriteKnowledge(swarmPath, swarm);
   const hivePath = resolveHiveKnowledgePath();
-  if (!existsSync11(hivePath))
+  if (!existsSync10(hivePath))
     return;
   const hive = await readKnowledge(hivePath);
   let touchedHive = false;
@@ -39754,7 +39763,7 @@ async function activateProposal(directory, slug, force = false) {
   }
   const from = proposalPath(directory, cleanSlug);
   const to = activePath(directory, cleanSlug);
-  if (!existsSync11(from)) {
+  if (!existsSync10(from)) {
     return {
       activated: false,
       from,
@@ -39762,7 +39771,7 @@ async function activateProposal(directory, slug, force = false) {
       reason: `proposal not found: ${from}`
     };
   }
-  if (existsSync11(to) && !force) {
+  if (existsSync10(to) && !force) {
     const existing = await readFile5(to, "utf-8");
     if (!existing.includes("generated by opencode-swarm skill-generator")) {
       return {
@@ -39826,7 +39835,7 @@ async function listSkills(directory) {
   const proposalsDir = path17.join(directory, ".swarm", "skills", "proposals");
   const activeDir = path17.join(directory, ".opencode", "skills", "generated");
   const fs9 = await import("fs/promises");
-  if (existsSync11(proposalsDir)) {
+  if (existsSync10(proposalsDir)) {
     const entries = await fs9.readdir(proposalsDir);
     for (const f of entries) {
       if (!f.endsWith(".md"))
@@ -39838,16 +39847,16 @@ async function listSkills(directory) {
       });
     }
   }
-  if (existsSync11(activeDir)) {
+  if (existsSync10(activeDir)) {
     const entries = await fs9.readdir(activeDir, { withFileTypes: true });
     for (const e of entries) {
       if (!e.isDirectory())
         continue;
       const retiredMarker = path17.join(activeDir, e.name, "retired.marker");
-      if (existsSync11(retiredMarker))
+      if (existsSync10(retiredMarker))
         continue;
       const skillPath = path17.join(activeDir, e.name, "SKILL.md");
-      if (existsSync11(skillPath)) {
+      if (existsSync10(skillPath)) {
         result.active.push({
           slug: e.name,
           path: skillPath
@@ -39926,7 +39935,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 (existsSync11(c.p)) {
+    if (existsSync10(c.p)) {
       const content = await readFile5(c.p, "utf-8");
       return { found: true, path: c.p, content, mode: c.m };
     }
@@ -39944,7 +39953,7 @@ async function retireSkill(directory, slug, reason) {
     };
   }
   const skillPath = activePath(directory, cleanSlug);
-  if (!existsSync11(skillPath)) {
+  if (!existsSync10(skillPath)) {
     return {
       retired: false,
       path: skillPath,
@@ -39958,7 +39967,7 @@ async function retireSkill(directory, slug, reason) {
     retiredAt: new Date().toISOString(),
     reason: reason ?? "manual_retire"
   });
-  await mkdir6(markerDir, { recursive: true });
+  await mkdir7(markerDir, { recursive: true });
   await writeFile4(markerPath, markerContent, "utf-8");
   return {
     retired: true,
@@ -39978,7 +39987,7 @@ async function regenerateSkill(directory, slug) {
     };
   }
   const skillPath = activePath(directory, cleanSlug);
-  if (!existsSync11(skillPath)) {
+  if (!existsSync10(skillPath)) {
     return {
       regenerated: false,
       path: skillPath,
@@ -40003,7 +40012,7 @@ async function regenerateSkill(directory, slug) {
     try {
       const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
       const hivePath = resolveHiveKnowledgePath();
-      const hive = existsSync11(hivePath) ? await readKnowledge(hivePath) : [];
+      const hive = existsSync10(hivePath) ? await readKnowledge(hivePath) : [];
       const all = [...swarm, ...hive];
       const idSet = new Set(fm.sourceKnowledgeIds);
       matchedEntries = all.filter((e) => idSet.has(e.id));
@@ -40152,8 +40161,8 @@ var init_skill_generator = __esm(() => {
 });
 
 // src/services/skill-improver-quota.ts
-import { existsSync as existsSync12 } from "fs";
-import { mkdir as mkdir7, readFile as readFile6, rename as rename4, writeFile as writeFile5 } from "fs/promises";
+import { existsSync as existsSync11 } from "fs";
+import { mkdir as mkdir8, readFile as readFile6, rename as rename4, writeFile as writeFile5 } from "fs/promises";
 import * as path18 from "path";
 async function acquireLock(dir) {
   const acquire = import_proper_lockfile6.default.lock(dir, LOCK_RETRY_OPTS);
@@ -40185,7 +40194,7 @@ function todayKey(window, now = new Date) {
   return `${yr}-${m}-${d}`;
 }
 async function readState(filePath) {
-  if (!existsSync12(filePath))
+  if (!existsSync11(filePath))
     return null;
   try {
     const raw = await readFile6(filePath, "utf-8");
@@ -40199,7 +40208,7 @@ async function readState(filePath) {
   }
 }
 async function writeState(filePath, state) {
-  await mkdir7(path18.dirname(filePath), { recursive: true });
+  await mkdir8(path18.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp-${process.pid}`;
   await writeFile5(tmp, JSON.stringify(state, null, 2), "utf-8");
   await rename4(tmp, filePath);
@@ -40222,7 +40231,7 @@ async function getQuotaState(directory, opts) {
 }
 async function reserveQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir7(path18.dirname(filePath), { recursive: true });
+  await mkdir8(path18.dirname(filePath), { recursive: true });
   let release = null;
   try {
     release = await acquireLock(path18.dirname(filePath));
@@ -40252,7 +40261,7 @@ async function reserveQuota(directory, opts) {
 }
 async function releaseQuota(directory, opts) {
   const filePath = resolveQuotaPath(directory, opts.scope);
-  await mkdir7(path18.dirname(filePath), { recursive: true });
+  await mkdir8(path18.dirname(filePath), { recursive: true });
   let release = null;
   try {
     release = await acquireLock(path18.dirname(filePath));
@@ -40437,8 +40446,8 @@ function appendSkillUsageEntry(directory, entry) {
   _internals16.appendFileSync(resolved, `${JSON.stringify(fullEntry)}
 `, "utf-8");
   try {
-    const stat3 = _internals16.statSync(resolved);
-    if (stat3.size > SKILL_USAGE_LOG_ROTATE_BYTES) {
+    const stat4 = _internals16.statSync(resolved);
+    if (stat4.size > SKILL_USAGE_LOG_ROTATE_BYTES) {
       _internals16.pruneSkillUsageLog(directory, SKILL_USAGE_LOG_MAX_ENTRIES_PER_SKILL);
     }
   } catch {}
@@ -40492,11 +40501,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 stat3 = _internals16.statSync(logPath);
-    const start = Math.max(0, stat3.size - boundedMaxBytes);
+    const stat4 = _internals16.statSync(logPath);
+    const start = Math.max(0, stat4.size - boundedMaxBytes);
     const fd = _internals16.openSync(logPath, "r");
     try {
-      const readLen = stat3.size - start;
+      const readLen = stat4.size - start;
       if (readLen === 0)
         return [];
       const buf = Buffer.alloc(readLen);
@@ -41039,10 +41048,10 @@ var init_hive_promoter = __esm(() => {
 
 // src/services/synonym-map.ts
 import {
-  mkdir as mkdir8,
+  mkdir as mkdir9,
   readFile as readFile7,
   rename as rename5,
-  stat as stat3,
+  stat as stat4,
   unlink as unlink2,
   writeFile as writeFile6
 } from "fs/promises";
@@ -41185,7 +41194,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 stat3(filePath);
+    const st = await stat4(filePath);
     if (st.size > ceiling)
       return emptySynonymMap();
     const raw = await readFile7(filePath, "utf-8");
@@ -41195,7 +41204,7 @@ async function readSynonymMap(directory, maxPairs = DEFAULT_MAX_PAIRS) {
   }
 }
 async function writeSynonymMapAtomic(filePath, map3) {
-  await mkdir8(path21.dirname(filePath), { recursive: true });
+  await mkdir9(path21.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
     await writeFile6(tmp, JSON.stringify(map3, null, 2), "utf-8");
@@ -41209,7 +41218,7 @@ async function writeSynonymMapAtomic(filePath, map3) {
 async function rebuildSynonymMap(directory, entries, maxPairs = DEFAULT_MAX_PAIRS) {
   const filePath = resolveSynonymMapPath(directory);
   const dir = path21.dirname(filePath);
-  await mkdir8(dir, { recursive: true });
+  await mkdir9(dir, { recursive: true });
   let release = null;
   try {
     release = await import_proper_lockfile7.default.lock(dir, {
@@ -41498,8 +41507,8 @@ function formatSkillIndexWithContext(skills, directory) {
   const usageLogPath = path22.join(directory, ".swarm", "skill-usage.jsonl");
   let hasHistory = false;
   try {
-    const stat4 = fs10.statSync(usageLogPath);
-    hasHistory = stat4.size > 0;
+    const stat5 = fs10.statSync(usageLogPath);
+    hasHistory = stat5.size > 0;
   } catch {}
   if (!hasHistory) {
     return skills.map((sp) => {
@@ -42195,7 +42204,7 @@ var init_skill_propagation_gate = __esm(() => {
 });
 
 // src/hooks/micro-reflector.ts
-import { existsSync as existsSync15 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { readFile as readFile8, writeFile as writeFile7 } from "fs/promises";
 import * as path24 from "path";
 function resolveInsightCandidatesPath(directory) {
@@ -42205,7 +42214,7 @@ async function readTaskTrajectory(directory, taskId) {
   try {
     const rel = path24.join("evidence", sanitizeTaskId2(taskId), "trajectory.jsonl");
     const filePath = validateSwarmPath(directory, rel);
-    if (!existsSync15(filePath))
+    if (!existsSync14(filePath))
       return [];
     const content = await readFile8(filePath, "utf-8");
     const out = [];
@@ -42242,8 +42251,8 @@ var init_micro_reflector = __esm(() => {
 });
 
 // src/hooks/knowledge-curator.ts
-import { existsSync as existsSync16 } from "fs";
-import { appendFile as appendFile6, mkdir as mkdir9, readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
+import { existsSync as existsSync15 } from "fs";
+import { appendFile as appendFile6, mkdir as mkdir10, readFile as readFile9, writeFile as writeFile8 } from "fs/promises";
 import * as path25 from "path";
 function pruneSeenRetroSections() {
   const cutoff = Date.now() - 86400000;
@@ -42505,7 +42514,7 @@ RETRY: your last output was missing ${result.missing.join("; ")}; produce valid
 async function appendCuratorSkippedEvent(directory, record3) {
   try {
     const filePath = path25.join(directory, ".swarm", "events.jsonl");
-    await mkdir9(path25.dirname(filePath), { recursive: true });
+    await mkdir10(path25.dirname(filePath), { recursive: true });
     await appendFile6(filePath, `${JSON.stringify({
       timestamp: new Date().toISOString(),
       event: "curator_skipped",
@@ -42532,7 +42541,7 @@ function readInsightJsonl(content) {
 async function consumeInsightCandidates(directory, batchLimit = MESO_INSIGHT_BATCH_LIMIT) {
   try {
     const filePath = resolveInsightCandidatesPath(directory);
-    if (!existsSync16(filePath))
+    if (!existsSync15(filePath))
       return [];
     const consumed = [];
     await transactFile(filePath, async (p) => readInsightJsonl(await readFile9(p, "utf-8").catch(() => "")), async (p, data) => {
@@ -43062,7 +43071,7 @@ var init_skill_improver_llm_factory = __esm(() => {
 });
 
 // src/services/trajectory-cluster.ts
-import { mkdir as mkdir10, writeFile as writeFile9 } from "fs/promises";
+import { mkdir as mkdir11, writeFile as writeFile9 } from "fs/promises";
 import * as path26 from "path";
 function failureKind(e) {
   const tool3 = (e.tool ?? "").toLowerCase();
@@ -43193,7 +43202,7 @@ async function writeMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const proposalsDir = validateSwarmPath(directory, path26.join("skills", "proposals"));
-    await mkdir10(proposalsDir, { recursive: true });
+    await mkdir11(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = `motif-${slugify2(motif.signature)}`;
       const filePath = path26.join(proposalsDir, `${slug}.md`);
@@ -43337,7 +43346,7 @@ async function writeSuccessMotifProposals(directory, opts = {}) {
       return result;
     const max = opts.maxProposals ?? 10;
     const proposalsDir = validateSwarmPath(directory, path26.join("skills", "proposals"));
-    await mkdir10(proposalsDir, { recursive: true });
+    await mkdir11(proposalsDir, { recursive: true });
     for (const motif of motifs.slice(0, max)) {
       const slug = workflowSlug(motif.signature);
       const filePath = path26.join(proposalsDir, `${slug}.md`);
@@ -43359,12 +43368,12 @@ var init_trajectory_cluster = __esm(() => {
 });
 
 // src/services/unactionable-hardening.ts
-import { existsSync as existsSync17 } from "fs";
+import { existsSync as existsSync16 } from "fs";
 async function hardenUnactionableEntries(params) {
   const result = { hardened: 0, retired: 0, remaining: 0 };
   try {
     const queuePath = resolveUnactionablePath(params.directory);
-    if (!existsSync17(queuePath))
+    if (!existsSync16(queuePath))
       return result;
     const limit = params.batchLimit ?? HARDENING_BATCH_LIMIT;
     const dedupThreshold = params.dedupThreshold ?? 0.6;
@@ -43471,14 +43480,14 @@ var init_unactionable_hardening = __esm(() => {
 });
 
 // src/services/skill-improver.ts
-import { existsSync as existsSync18 } from "fs";
-import { mkdir as mkdir11, readFile as readFile10, rename as rename6, writeFile as writeFile10 } from "fs/promises";
+import { existsSync as existsSync17 } from "fs";
+import { mkdir as mkdir12, readFile as readFile10, rename as rename6, writeFile as writeFile10 } from "fs/promises";
 import * as path27 from "path";
 function timestampSlug(d) {
   return d.toISOString().replace(/[:.]/g, "-");
 }
 async function atomicWrite2(p, content) {
-  await mkdir11(path27.dirname(p), { recursive: true });
+  await mkdir12(path27.dirname(p), { recursive: true });
   const tmp = `${p}.tmp-${process.pid}-${Date.now()}`;
   await writeFile10(tmp, content, "utf-8");
   await rename6(tmp, p);
@@ -43486,7 +43495,7 @@ async function atomicWrite2(p, content) {
 async function gatherInventory(directory) {
   const swarm = await readKnowledge(resolveSwarmKnowledgePath(directory));
   const hivePath = resolveHiveKnowledgePath();
-  const hive = existsSync18(hivePath) ? await readKnowledge(hivePath) : [];
+  const hive = existsSync17(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]));
@@ -44252,7 +44261,7 @@ __export(exports_curator_postmortem, {
   runCuratorPostMortem: () => runCuratorPostMortem,
   _internals: () => _internals21
 });
-import { existsSync as existsSync19, readdirSync as readdirSync7, readFileSync as readFileSync9 } from "fs";
+import { existsSync as existsSync18, readdirSync as readdirSync6, readFileSync as readFileSync9 } from "fs";
 import * as path28 from "path";
 async function collectKnowledgeSummary(directory) {
   const entries = await readKnowledge(resolveSwarmKnowledgePath(directory));
@@ -44292,7 +44301,7 @@ async function collectKnowledgeSummary(directory) {
 }
 function readJsonlFile(filePath) {
   try {
-    if (!existsSync19(filePath))
+    if (!existsSync18(filePath))
       return [];
     const content = readFileSync9(filePath, "utf-8");
     const results = [];
@@ -44313,12 +44322,12 @@ function collectRetrospectives(directory) {
   const results = [];
   const evidenceDir = path28.join(directory, ".swarm", "evidence");
   try {
-    if (!existsSync19(evidenceDir))
+    if (!existsSync18(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 = path28.join(evidenceDir, entry.name, "evidence.json");
-        if (existsSync19(retroPath)) {
+        if (existsSync18(retroPath)) {
           try {
             results.push(readFileSync9(retroPath, "utf-8"));
           } catch {}
@@ -44332,9 +44341,9 @@ function collectDriftReports(directory) {
   const results = [];
   const swarmDir = path28.join(directory, ".swarm");
   try {
-    if (!existsSync19(swarmDir))
+    if (!existsSync18(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(readFileSync9(path28.join(swarmDir, entry), "utf-8"));
@@ -44347,7 +44356,7 @@ function collectDriftReports(directory) {
 function collectPendingProposals(directory) {
   const results = [];
   const insightPath = path28.join(directory, ".swarm", "insight-candidates.jsonl");
-  if (existsSync19(insightPath)) {
+  if (existsSync18(insightPath)) {
     try {
       results.push({
         source: "insight-candidates",
@@ -44357,8 +44366,8 @@ function collectPendingProposals(directory) {
   }
   const proposalsDir = path28.join(directory, ".swarm", "skills", "proposals");
   try {
-    if (existsSync19(proposalsDir)) {
-      for (const entry of readdirSync7(proposalsDir)) {
+    if (existsSync18(proposalsDir)) {
+      for (const entry of readdirSync6(proposalsDir)) {
         if (entry.endsWith(".md") || entry.endsWith(".json")) {
           try {
             results.push({
@@ -44512,7 +44521,7 @@ async function runCuratorPostMortem(directory, options = {}) {
       warnings: [...warnings, "Invalid report path."]
     };
   }
-  if (!options.force && existsSync19(reportPath)) {
+  if (!options.force && existsSync18(reportPath)) {
     return {
       success: true,
       planId,
@@ -44575,8 +44584,8 @@ ${llmOutput}`;
     reportContent = buildDataOnlyReport(planId, planSummary, knowledgeSummary, curatorDigest, proposals, unactionable, retrospectives, driftReports);
   }
   try {
-    const { mkdirSync: mkdirSync11, writeFileSync: writeFileSync7 } = await import("fs");
-    mkdirSync11(path28.dirname(reportPath), { recursive: true });
+    const { mkdirSync: mkdirSync10, writeFileSync: writeFileSync7 } = await import("fs");
+    mkdirSync10(path28.dirname(reportPath), { recursive: true });
     writeFileSync7(reportPath, reportContent, "utf-8");
   } catch (err) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -44666,8 +44675,8 @@ async function copyDirRecursive(src, dest) {
     const srcEntry = path29.join(src, entry);
     const destEntry = path29.join(dest, entry);
     try {
-      const stat4 = await fs12.stat(srcEntry);
-      if (stat4.isDirectory()) {
+      const stat5 = await fs12.stat(srcEntry);
+      if (stat5.isDirectory()) {
         const subCount = await copyDirRecursive(srcEntry, destEntry).catch(() => 0);
         count += subCount;
       } else {
@@ -44703,8 +44712,8 @@ function guaranteeAllPlansComplete(planData) {
 async function handleCloseCommand(directory, args, options = {}) {
   const swarmDir = path29.join(directory, ".swarm");
   try {
-    const stat4 = fsSync2.lstatSync(swarmDir);
-    if (stat4.isSymbolicLink()) {
+    const stat5 = fsSync2.lstatSync(swarmDir);
+    if (stat5.isSymbolicLink()) {
       return `\u274C Refused: .swarm/ is a symlink or junction. Refusing to operate on a redirected directory for safety.`;
     }
   } catch (err) {
@@ -45689,7 +45698,7 @@ var init_curate = __esm(() => {
 // src/tools/co-change-analyzer.ts
 import * as child_process3 from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
-import { readdir, readFile as readFile11, stat as stat4 } from "fs/promises";
+import { readdir as readdir2, readFile as readFile11, stat as stat5 } from "fs/promises";
 import * as path31 from "path";
 import { promisify } from "util";
 function getExecFileAsync() {
@@ -45792,7 +45801,7 @@ async function scanSourceFiles(dir) {
   const results = [];
   const skipDirs = new Set(["node_modules", ".swarm", "dist", "build"]);
   try {
-    const entries = await readdir(dir, { withFileTypes: true });
+    const entries = await readdir2(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path31.join(dir, entry.name);
       if (entry.isDirectory()) {
@@ -45840,7 +45849,7 @@ async function getStaticEdges(directory) {
           for (const ext of extensions) {
             const testPath = resolvedPath + ext;
             try {
-              const testStat = await stat4(testPath);
+              const testStat = await stat5(testPath);
               if (testStat.isFile()) {
                 targetFile = testPath;
                 break;
@@ -46490,7 +46499,7 @@ function getPluginLockFilePaths() {
 var init_cache_paths = () => {};
 
 // src/gate-evidence.ts
-import { mkdirSync as mkdirSync11, readFileSync as readFileSync10, realpathSync as realpathSync3 } from "fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync10, realpathSync as realpathSync3 } from "fs";
 function isValidTaskId(taskId) {
   return isStrictTaskId(taskId);
 }
@@ -46666,7 +46675,7 @@ var init_gate_bridge = __esm(() => {
 });
 
 // src/services/version-check.ts
-import { existsSync as existsSync20, mkdirSync as mkdirSync12, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
+import { existsSync as existsSync19, mkdirSync as mkdirSync11, readFileSync as readFileSync11, writeFileSync as writeFileSync7 } from "fs";
 import { homedir as homedir5 } from "os";
 import { join as join30 } from "path";
 function cacheDir() {
@@ -46680,7 +46689,7 @@ function cacheFile() {
 function readVersionCache() {
   try {
     const path34 = cacheFile();
-    if (!existsSync20(path34))
+    if (!existsSync19(path34))
       return null;
     const raw = readFileSync11(path34, "utf-8");
     const parsed = JSON.parse(raw);
@@ -46720,10 +46729,10 @@ var init_version_check = __esm(() => {
 });
 
 // src/services/knowledge-diagnostics.ts
-import { existsSync as existsSync21 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { readFile as readFile12 } from "fs/promises";
 async function readRawLines(filePath) {
-  if (!existsSync21(filePath))
+  if (!existsSync20(filePath))
     return { entries: [], corrupt: 0 };
   const content = await readFile12(filePath, "utf-8");
   const entries = [];
@@ -46848,7 +46857,7 @@ async function computeKnowledgeDebug(directory) {
   };
 }
 async function safeJsonlCount(filePath) {
-  if (!filePath || !existsSync21(filePath))
+  if (!filePath || !existsSync20(filePath))
     return 0;
   try {
     const content = await readFile12(filePath, "utf-8");
@@ -46931,7 +46940,7 @@ var init_knowledge_diagnostics = __esm(() => {
 
 // src/services/diagnose-service.ts
 import * as child_process4 from "child_process";
-import { existsSync as existsSync22, readdirSync as readdirSync8, readFileSync as readFileSync12, statSync as statSync10 } from "fs";
+import { existsSync as existsSync21, readdirSync as readdirSync7, readFileSync as readFileSync12, statSync as statSync9 } from "fs";
 import path34 from "path";
 import { fileURLToPath } from "url";
 function validateTaskDag(plan) {
@@ -47148,7 +47157,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 {
@@ -47179,7 +47188,7 @@ async function checkConfigBackups(directory) {
 }
 async function checkGitRepository(directory) {
   try {
-    if (!existsSync22(directory) || !statSync10(directory).isDirectory()) {
+    if (!existsSync21(directory) || !statSync9(directory).isDirectory()) {
       return {
         name: "Git Repository",
         status: "\u274C",
@@ -47244,7 +47253,7 @@ async function checkSpecStaleness(directory, plan) {
 }
 async function checkConfigParseability(directory) {
   const configPath = path34.join(directory, ".opencode/opencode-swarm.json");
-  if (!existsSync22(configPath)) {
+  if (!existsSync21(configPath)) {
     return {
       name: "Config Parseability",
       status: "\u2705",
@@ -47299,11 +47308,11 @@ async function checkGrammarWasmFiles() {
   const thisDir = path34.dirname(fileURLToPath(import.meta.url));
   const grammarDir = resolveGrammarDir(thisDir);
   const missing = [];
-  if (!existsSync22(path34.join(grammarDir, "tree-sitter.wasm"))) {
+  if (!existsSync21(path34.join(grammarDir, "tree-sitter.wasm"))) {
     missing.push("tree-sitter.wasm (core runtime)");
   }
   for (const file3 of grammarFiles) {
-    if (!existsSync22(path34.join(grammarDir, file3))) {
+    if (!existsSync21(path34.join(grammarDir, file3))) {
       missing.push(file3);
     }
   }
@@ -47322,7 +47331,7 @@ async function checkGrammarWasmFiles() {
 }
 async function checkCheckpointManifest(directory) {
   const manifestPath = path34.join(directory, ".swarm/checkpoints.json");
-  if (!existsSync22(manifestPath)) {
+  if (!existsSync21(manifestPath)) {
     return {
       name: "Checkpoint Manifest",
       status: "\u2705",
@@ -47374,7 +47383,7 @@ async function checkCheckpointManifest(directory) {
 }
 async function checkEventStreamIntegrity(directory) {
   const eventsPath = path34.join(directory, ".swarm/events.jsonl");
-  if (!existsSync22(eventsPath)) {
+  if (!existsSync21(eventsPath)) {
     return {
       name: "Event Stream",
       status: "\u2705",
@@ -47415,7 +47424,7 @@ async function checkEventStreamIntegrity(directory) {
 }
 async function checkSteeringDirectives(directory) {
   const eventsPath = path34.join(directory, ".swarm/events.jsonl");
-  if (!existsSync22(eventsPath)) {
+  if (!existsSync21(eventsPath)) {
     return {
       name: "Steering Directives",
       status: "\u2705",
@@ -47471,7 +47480,7 @@ async function checkCurator(directory) {
       };
     }
     const summaryPath = path34.join(directory, ".swarm/curator-summary.json");
-    if (!existsSync22(summaryPath)) {
+    if (!existsSync21(summaryPath)) {
       return {
         name: "Curator",
         status: "\u2705",
@@ -47638,7 +47647,7 @@ async function getDiagnoseData(directory) {
   checks5.push(await checkKnowledgeHealth(directory));
   try {
     const evidenceDir = path34.join(directory, ".swarm", "evidence");
-    const snapshotFiles = existsSync22(evidenceDir) ? readdirSync8(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
+    const snapshotFiles = existsSync21(evidenceDir) ? readdirSync7(evidenceDir).filter((f) => f.startsWith("agent-tools-") && f.endsWith(".json")) : [];
     if (snapshotFiles.length > 0) {
       const latest = snapshotFiles.sort().pop();
       checks5.push({
@@ -47671,7 +47680,7 @@ async function getDiagnoseData(directory) {
   const cacheRows = [];
   for (const cachePath of cachePaths) {
     try {
-      if (!existsSync22(cachePath)) {
+      if (!existsSync21(cachePath)) {
         cacheRows.push(`\u2B1C ${cachePath} \u2014 absent`);
         continue;
       }
@@ -50048,7 +50057,7 @@ var init_profiles = __esm(() => {
 });
 
 // src/lang/detector.ts
-import { access as access3, readdir as readdir2 } from "fs/promises";
+import { access as access4, readdir as readdir3 } from "fs/promises";
 import { extname as extname3, join as join32 } from "path";
 async function detectProjectLanguages(projectDir) {
   const detected = new Set;
@@ -50056,7 +50065,7 @@ async function detectProjectLanguages(projectDir) {
     let dirEntries;
     let entries;
     try {
-      dirEntries = await readdir2(dir, { withFileTypes: true });
+      dirEntries = await readdir3(dir, { withFileTypes: true });
       entries = dirEntries.map((e) => e.name);
     } catch {
       return;
@@ -50072,7 +50081,7 @@ async function detectProjectLanguages(projectDir) {
           continue;
         }
         try {
-          await access3(join32(dir, detectFile));
+          await access4(join32(dir, detectFile));
           detected.add(profile.id);
           break;
         } catch {}
@@ -50090,7 +50099,7 @@ async function detectProjectLanguages(projectDir) {
   }
   await scanDir(projectDir);
   try {
-    const topEntries = await readdir2(projectDir, { withFileTypes: true });
+    const topEntries = await readdir3(projectDir, { withFileTypes: true });
     for (const entry of topEntries) {
       if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
         await scanDir(join32(projectDir, entry.name));
@@ -52094,7 +52103,7 @@ var init_handoff_service = __esm(() => {
 });
 
 // src/session/snapshot-writer.ts
-import { closeSync as closeSync5, fsyncSync as fsyncSync2, mkdirSync as mkdirSync15, openSync as openSync5, renameSync as renameSync10 } from "fs";
+import { closeSync as closeSync5, fsyncSync as fsyncSync2, mkdirSync as mkdirSync14, openSync as openSync5, renameSync as renameSync10 } from "fs";
 import * as path38 from "path";
 function serializeAgentSession(s) {
   const gateLog = {};
@@ -52202,7 +52211,7 @@ async function writeSnapshot(directory, state) {
     const content = JSON.stringify(snapshot, null, 2);
     const resolvedPath = validateSwarmPath(directory, "session/state.json");
     const dir = path38.dirname(resolvedPath);
-    mkdirSync15(dir, { recursive: true });
+    mkdirSync14(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await bunWrite(tempPath, content);
     try {
@@ -52741,8 +52750,8 @@ var KNOWLEDGE_SCHEMA_VERSION = 2;
 
 // src/hooks/knowledge-migrator.ts
 import { randomUUID as randomUUID3 } from "crypto";
-import { existsSync as existsSync26, readFileSync as readFileSync16 } from "fs";
-import { mkdir as mkdir12, readFile as readFile13, writeFile as writeFile11 } from "fs/promises";
+import { existsSync as existsSync25, readFileSync as readFileSync16 } from "fs";
+import { mkdir as mkdir13, readFile as readFile13, writeFile as writeFile11 } from "fs/promises";
 import * as os8 from "os";
 import * as path39 from "path";
 async function migrateKnowledgeToExternal(_directory, _config) {
@@ -52758,7 +52767,7 @@ async function migrateContextToKnowledge(directory, config3) {
   const sentinelPath = path39.join(directory, ".swarm", ".knowledge-migrated");
   const contextPath = path39.join(directory, ".swarm", "context.md");
   const knowledgePath = resolveSwarmKnowledgePath(directory);
-  if (existsSync26(sentinelPath)) {
+  if (existsSync25(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -52767,7 +52776,7 @@ async function migrateContextToKnowledge(directory, config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync26(contextPath)) {
+  if (!existsSync25(contextPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -52859,7 +52868,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
   const legacyHivePath = _internals29.resolveLegacyHiveKnowledgePath();
   const canonicalHivePath = resolveHiveKnowledgePath();
   const sentinelPath = path39.join(path39.dirname(canonicalHivePath), ".hive-knowledge-migrated");
-  if (existsSync26(sentinelPath)) {
+  if (existsSync25(sentinelPath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -52868,7 +52877,7 @@ async function migrateHiveKnowledgeLegacy(config3) {
       skippedReason: "sentinel-exists"
     };
   }
-  if (!existsSync26(legacyHivePath)) {
+  if (!existsSync25(legacyHivePath)) {
     return {
       migrated: false,
       entriesMigrated: 0,
@@ -53070,7 +53079,7 @@ function truncateLesson2(text) {
 }
 function inferProjectName(directory) {
   const packageJsonPath = path39.join(directory, "package.json");
-  if (existsSync26(packageJsonPath)) {
+  if (existsSync25(packageJsonPath)) {
     try {
       const pkg = JSON.parse(readFileSync16(packageJsonPath, "utf-8"));
       if (pkg.name && typeof pkg.name === "string") {
@@ -53090,7 +53099,7 @@ async function writeSentinel(sentinelPath, migrated, dropped) {
     schema_version: 1,
     migration_tool: "knowledge-migrator.ts"
   };
-  await mkdir12(path39.dirname(sentinelPath), { recursive: true });
+  await mkdir13(path39.dirname(sentinelPath), { recursive: true });
   await writeFile11(sentinelPath, JSON.stringify(sentinel, null, 2), "utf-8");
 }
 function resolveLegacyHiveKnowledgePath() {
@@ -54278,10 +54287,10 @@ var init_scoring = __esm(() => {
 
 // src/memory/local-jsonl-provider.ts
 import { randomUUID as randomUUID4 } from "crypto";
-import { existsSync as existsSync27 } from "fs";
+import { existsSync as existsSync26 } from "fs";
 import {
   appendFile as appendFile7,
-  mkdir as mkdir13,
+  mkdir as mkdir14,
   readFile as readFile14,
   rename as rename7,
   writeFile as writeFile12
@@ -54629,7 +54638,7 @@ function validateLoadedProposals(values, config3) {
   return { records, invalidCount };
 }
 async function readJsonl(filePath) {
-  if (!existsSync27(filePath))
+  if (!existsSync26(filePath))
     return [];
   const content = await readFile14(filePath, "utf-8");
   const records = [];
@@ -54685,12 +54694,12 @@ function parseRecallUsageEvent(event) {
   }
 }
 async function appendJsonl(filePath, value) {
-  await mkdir13(path40.dirname(filePath), { recursive: true });
+  await mkdir14(path40.dirname(filePath), { recursive: true });
   await appendFile7(filePath, `${JSON.stringify(value)}
 `, "utf-8");
 }
 async function writeJsonlAtomic(filePath, values) {
-  await mkdir13(path40.dirname(filePath), { recursive: true });
+  await mkdir14(path40.dirname(filePath), { recursive: true });
   const tmp = `${filePath}.tmp.${randomUUID4()}`;
   const content = values.map((value) => JSON.stringify(value)).join(`
 `) + (values.length > 0 ? `
@@ -54715,8 +54724,8 @@ var init_prompt_block = __esm(() => {
 });
 
 // src/memory/jsonl-migration.ts
-import { existsSync as existsSync28 } from "fs";
-import { copyFile, mkdir as mkdir14, readFile as readFile15, stat as stat5, writeFile as writeFile13 } from "fs/promises";
+import { existsSync as existsSync27 } from "fs";
+import { copyFile as copyFile2, mkdir as mkdir15, readFile as readFile15, stat as stat6, writeFile as writeFile13 } from "fs/promises";
 import * as path41 from "path";
 function resolveMemoryStorageDir(rootDirectory, config3 = {}) {
   const resolved = resolveConfig(config3);
@@ -54743,25 +54752,25 @@ async function readLegacyJsonl(rootDirectory, config3 = {}) {
 async function backupLegacyJsonl(rootDirectory, config3 = {}) {
   const storageDir = resolveMemoryStorageDir(rootDirectory, config3);
   const backupDir = path41.join(storageDir, "backups");
-  await mkdir14(backupDir, { recursive: true });
+  await mkdir15(backupDir, { recursive: true });
   const results = [];
   for (const filename of ["memories.jsonl", "proposals.jsonl"]) {
     const source = path41.join(storageDir, filename);
-    if (!existsSync28(source))
+    if (!existsSync27(source))
       continue;
     const backup = path41.join(backupDir, `${filename}.pre-sqlite-migration`);
-    if (existsSync28(backup)) {
+    if (existsSync27(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 = path41.join(resolveMemoryStorageDir(rootDirectory, config3), "export");
-  await mkdir14(exportDir, { recursive: true });
+  await mkdir15(exportDir, { recursive: true });
   const memoriesPath = path41.join(exportDir, "memories.jsonl");
   const proposalsPath = path41.join(exportDir, "proposals.jsonl");
   await writeFile13(memoriesPath, toJsonl(memories), "utf-8");
@@ -54770,14 +54779,14 @@ async function writeJsonlExport(rootDirectory, config3, memories, proposals) {
 }
 async function writeMigrationReport(rootDirectory, report, config3 = {}) {
   const reportPath = path41.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
-  await mkdir14(path41.dirname(reportPath), { recursive: true });
+  await mkdir15(path41.dirname(reportPath), { recursive: true });
   await writeFile13(reportPath, `${JSON.stringify(report, null, 2)}
 `, "utf-8");
   return reportPath;
 }
 async function readMigrationReport(rootDirectory, config3 = {}) {
   const reportPath = path41.join(resolveMemoryStorageDir(rootDirectory, config3), "migration-report.json");
-  if (!existsSync28(reportPath))
+  if (!existsSync27(reportPath))
     return null;
   try {
     return JSON.parse(await readFile15(reportPath, "utf-8"));
@@ -54791,13 +54800,13 @@ async function getLegacyJsonlFileStatus(rootDirectory, config3 = {}) {
   for (const file3 of ["memories.jsonl", "proposals.jsonl"]) {
     const filePath = path41.join(storageDir, file3);
     let sizeBytes = 0;
-    if (existsSync28(filePath)) {
-      sizeBytes = (await stat5(filePath)).size;
+    if (existsSync27(filePath)) {
+      sizeBytes = (await stat6(filePath)).size;
     }
     statuses.push({
       file: file3,
       path: filePath,
-      exists: existsSync28(filePath),
+      exists: existsSync27(filePath),
       sizeBytes
     });
   }
@@ -54878,7 +54887,7 @@ async function readProposalJsonl(filePath, config3) {
   return { records, invalidRows, totalRows: rows.totalRows };
 }
 async function readJsonlRows(filePath) {
-  if (!existsSync28(filePath)) {
+  if (!existsSync27(filePath)) {
     return { rows: [], invalidRows: [], totalRows: 0 };
   }
   const content = await readFile15(filePath, "utf-8");
@@ -54916,7 +54925,7 @@ var init_jsonl_migration = __esm(() => {
 
 // src/memory/sqlite-provider.ts
 import { randomUUID as randomUUID5 } from "crypto";
-import { mkdirSync as mkdirSync16 } from "fs";
+import { mkdirSync as mkdirSync15 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import * as path42 from "path";
 function loadDatabaseCtor2() {
@@ -54976,7 +54985,7 @@ class SQLiteMemoryProvider {
     if (this.initialized)
       return;
     const dbPath = this.databasePath();
-    mkdirSync16(path42.dirname(dbPath), { recursive: true });
+    mkdirSync15(path42.dirname(dbPath), { recursive: true });
     const Db = loadDatabaseCtor2();
     this.db = new Db(dbPath);
     this.db.run("PRAGMA journal_mode = WAL;");
@@ -56255,7 +56264,7 @@ var init_memory = __esm(() => {
 });
 
 // src/commands/memory.ts
-import { existsSync as existsSync29 } from "fs";
+import { existsSync as existsSync28 } from "fs";
 import * as path44 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 async function handleMemoryCommand(_directory, _args) {
@@ -56287,7 +56296,7 @@ async function handleMemoryStatusCommand(directory, _args) {
     `- Provider: \`${config3.provider}\``,
     `- Storage: \`${storageDir}\``,
     `- SQLite path: \`${sqlitePath}\``,
-    `- SQLite database exists: \`${existsSync29(sqlitePath)}\``,
+    `- SQLite database exists: \`${existsSync28(sqlitePath)}\``,
     `- Automatic destructive cleanup: \`disabled\``,
     "",
     "### Legacy JSONL"
@@ -58086,11 +58095,11 @@ function createRedactedContext(line, findings) {
 function scanFileForSecrets(filePath) {
   const findings = [];
   try {
-    const lstat = fs19.lstatSync(filePath);
-    if (lstat.isSymbolicLink()) {
+    const lstat2 = fs19.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;
@@ -58178,18 +58187,18 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
       stats.skippedDirs++;
       continue;
     }
-    let lstat;
+    let lstat2;
     try {
-      lstat = fs19.lstatSync(fullPath);
+      lstat2 = fs19.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 = fs19.realpathSync(fullPath);
@@ -58207,7 +58216,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 = path47.extname(fullPath).toLowerCase();
       if (!DEFAULT_EXCLUDE_EXTENSIONS.has(ext)) {
         files.push(fullPath);
@@ -58538,8 +58547,8 @@ var init_secretscan = __esm(() => {
             break;
           const fileFindings = scanFileForSecrets(filePath);
           try {
-            const stat6 = fs19.statSync(filePath);
-            if (stat6.size > MAX_FILE_SIZE_BYTES) {
+            const stat7 = fs19.statSync(filePath);
+            if (stat7.size > MAX_FILE_SIZE_BYTES) {
               skippedFiles++;
               continue;
             }
@@ -59349,8 +59358,8 @@ function sharedTrailingSegments(a, b) {
 function isCacheStale(impactMap, generatedAtMs) {
   for (const sourcePath of Object.keys(impactMap)) {
     try {
-      const stat6 = fs23.statSync(sourcePath);
-      if (stat6.mtimeMs > generatedAtMs) {
+      const stat7 = fs23.statSync(sourcePath);
+      if (stat7.mtimeMs > generatedAtMs) {
         return true;
       }
     } catch {
@@ -60651,8 +60660,8 @@ function manifestHash(dir) {
     if (!entries.has(name))
       continue;
     try {
-      const stat6 = fs28.statSync(path56.join(dir, name));
-      parts.push(`${name}:${stat6.size}:${stat6.mtimeMs}:${stat6.ino}`);
+      const stat7 = fs28.statSync(path56.join(dir, name));
+      parts.push(`${name}:${stat7.size}:${stat7.mtimeMs}:${stat7.ino}`);
     } catch {}
   }
   return parts.join("|");
@@ -65133,8 +65142,8 @@ async function countProposals(directory) {
     const proposalsDir = validateSwarmPath(directory, "skills/proposals");
     if (!fsSync3.existsSync(proposalsDir))
       return 0;
-    const { readdir: readdir4 } = await import("fs/promises");
-    const entries = await readdir4(proposalsDir);
+    const { readdir: readdir5 } = await import("fs/promises");
+    const entries = await readdir5(proposalsDir);
     return entries.filter((f) => f.endsWith(".md")).length;
   } catch {
     return 0;
@@ -66241,7 +66250,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));
 }
@@ -66441,6 +66450,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",