opencode-swarm 6.33.7 → 6.33.9

package/dist/index.js

@@ -15413,7 +15413,8 @@ var init_utils2 = __esm(() => {
 });
 
 // src/evidence/manager.ts
-import { mkdirSync, readdirSync, renameSync, rmSync, statSync as statSync2 } from "fs";
+import { mkdirSync, readdirSync, rmSync, statSync as statSync2 } from "fs";
+import * as fs4 from "fs/promises";
 import * as path4 from "path";
 function isValidEvidenceType(type) {
   return VALID_EVIDENCE_TYPES.includes(type);
@@ -15492,7 +15493,7 @@ async function saveEvidence(directory, taskId, evidence) {
   const tempPath = path4.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
   try {
     await Bun.write(tempPath, bundleJson);
-    renameSync(tempPath, evidencePath);
+    await fs4.rename(tempPath, evidencePath);
   } catch (error49) {
     try {
       rmSync(tempPath, { force: true });
@@ -15548,7 +15549,7 @@ async function loadEvidence(directory, taskId) {
       const tempPath = path4.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
       try {
         await Bun.write(tempPath, bundleJson);
-        renameSync(tempPath, evidencePath);
+        await fs4.rename(tempPath, evidencePath);
       } catch (writeError) {
         try {
           rmSync(tempPath, { force: true });
@@ -15687,7 +15688,7 @@ var init_manager = __esm(() => {
 });
 
 // src/plan/manager.ts
-import { renameSync as renameSync2, unlinkSync } from "fs";
+import { renameSync, unlinkSync } from "fs";
 import * as path5 from "path";
 async function loadPlanJsonOnly(directory) {
   const planJsonContent = await readSwarmFileAsync(directory, "plan.json");
@@ -15779,7 +15780,7 @@ ${markdown}`;
   const mdTempPath = path5.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await Bun.write(mdTempPath, markdownWithHash);
-    renameSync2(mdTempPath, mdPath);
+    renameSync(mdTempPath, mdPath);
   } finally {
     try {
       unlinkSync(mdTempPath);
@@ -15868,7 +15869,7 @@ async function savePlan(directory, plan, options) {
   const tempPath = path5.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await Bun.write(tempPath, JSON.stringify(validated, null, 2));
-    renameSync2(tempPath, planPath);
+    renameSync(tempPath, planPath);
   } finally {
     try {
       unlinkSync(tempPath);
@@ -15882,7 +15883,7 @@ ${markdown}`;
   const mdTempPath = path5.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await Bun.write(mdTempPath, markdownWithHash);
-    renameSync2(mdTempPath, mdPath);
+    renameSync(mdTempPath, mdPath);
   } finally {
     try {
       unlinkSync(mdTempPath);
@@ -16768,7 +16769,7 @@ var exports_status_artifact = {};
 __export(exports_status_artifact, {
   AutomationStatusArtifact: () => AutomationStatusArtifact
 });
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path8 from "path";
 function createEmptySnapshot(mode, capabilities) {
   return {
@@ -16833,8 +16834,8 @@ class AutomationStatusArtifact {
   load() {
     const filePath = this.getFilePath();
     try {
-      if (fs5.existsSync(filePath)) {
-        const content = fs5.readFileSync(filePath, "utf-8");
+      if (fs6.existsSync(filePath)) {
+        const content = fs6.readFileSync(filePath, "utf-8");
         return JSON.parse(content);
       }
     } catch {}
@@ -16842,10 +16843,10 @@ class AutomationStatusArtifact {
   }
   write() {
     const filePath = this.getFilePath();
-    if (!fs5.existsSync(this.swarmDir)) {
-      fs5.mkdirSync(this.swarmDir, { recursive: true });
+    if (!fs6.existsSync(this.swarmDir)) {
+      fs6.mkdirSync(this.swarmDir, { recursive: true });
     }
-    fs5.writeFileSync(filePath, JSON.stringify(this.currentSnapshot, null, 2), "utf-8");
+    fs6.writeFileSync(filePath, JSON.stringify(this.currentSnapshot, null, 2), "utf-8");
   }
   getSnapshot() {
     return { ...this.currentSnapshot };
@@ -29902,7 +29903,7 @@ var init_create_tool = __esm(() => {
 
 // src/tools/checkpoint.ts
 import { spawnSync } from "child_process";
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path9 from "path";
 function containsNonAsciiChars(label) {
   for (let i2 = 0;i2 < label.length; i2++) {
@@ -29952,8 +29953,8 @@ function getCheckpointLogPath(directory) {
 function readCheckpointLog(directory) {
   const logPath = getCheckpointLogPath(directory);
   try {
-    if (fs6.existsSync(logPath)) {
-      const content = fs6.readFileSync(logPath, "utf-8");
+    if (fs7.existsSync(logPath)) {
+      const content = fs7.readFileSync(logPath, "utf-8");
       const parsed = JSON.parse(content);
       if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
         return { version: 1, checkpoints: [] };
@@ -29966,12 +29967,12 @@ function readCheckpointLog(directory) {
 function writeCheckpointLog(log2, directory) {
   const logPath = getCheckpointLogPath(directory);
   const dir = path9.dirname(logPath);
-  if (!fs6.existsSync(dir)) {
-    fs6.mkdirSync(dir, { recursive: true });
+  if (!fs7.existsSync(dir)) {
+    fs7.mkdirSync(dir, { recursive: true });
   }
   const tempPath = `${logPath}.tmp`;
-  fs6.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
-  fs6.renameSync(tempPath, logPath);
+  fs7.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
+  fs7.renameSync(tempPath, logPath);
 }
 function gitExec(args2) {
   const result = spawnSync("git", args2, {
@@ -30204,54 +30205,54 @@ var require_polyfills = __commonJS((exports, module2) => {
   }
   var chdir;
   module2.exports = patch;
-  function patch(fs7) {
+  function patch(fs8) {
     if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-      patchLchmod(fs7);
-    }
-    if (!fs7.lutimes) {
-      patchLutimes(fs7);
-    }
-    fs7.chown = chownFix(fs7.chown);
-    fs7.fchown = chownFix(fs7.fchown);
-    fs7.lchown = chownFix(fs7.lchown);
-    fs7.chmod = chmodFix(fs7.chmod);
-    fs7.fchmod = chmodFix(fs7.fchmod);
-    fs7.lchmod = chmodFix(fs7.lchmod);
-    fs7.chownSync = chownFixSync(fs7.chownSync);
-    fs7.fchownSync = chownFixSync(fs7.fchownSync);
-    fs7.lchownSync = chownFixSync(fs7.lchownSync);
-    fs7.chmodSync = chmodFixSync(fs7.chmodSync);
-    fs7.fchmodSync = chmodFixSync(fs7.fchmodSync);
-    fs7.lchmodSync = chmodFixSync(fs7.lchmodSync);
-    fs7.stat = statFix(fs7.stat);
-    fs7.fstat = statFix(fs7.fstat);
-    fs7.lstat = statFix(fs7.lstat);
-    fs7.statSync = statFixSync(fs7.statSync);
-    fs7.fstatSync = statFixSync(fs7.fstatSync);
-    fs7.lstatSync = statFixSync(fs7.lstatSync);
-    if (fs7.chmod && !fs7.lchmod) {
-      fs7.lchmod = function(path11, mode, cb) {
+      patchLchmod(fs8);
+    }
+    if (!fs8.lutimes) {
+      patchLutimes(fs8);
+    }
+    fs8.chown = chownFix(fs8.chown);
+    fs8.fchown = chownFix(fs8.fchown);
+    fs8.lchown = chownFix(fs8.lchown);
+    fs8.chmod = chmodFix(fs8.chmod);
+    fs8.fchmod = chmodFix(fs8.fchmod);
+    fs8.lchmod = chmodFix(fs8.lchmod);
+    fs8.chownSync = chownFixSync(fs8.chownSync);
+    fs8.fchownSync = chownFixSync(fs8.fchownSync);
+    fs8.lchownSync = chownFixSync(fs8.lchownSync);
+    fs8.chmodSync = chmodFixSync(fs8.chmodSync);
+    fs8.fchmodSync = chmodFixSync(fs8.fchmodSync);
+    fs8.lchmodSync = chmodFixSync(fs8.lchmodSync);
+    fs8.stat = statFix(fs8.stat);
+    fs8.fstat = statFix(fs8.fstat);
+    fs8.lstat = statFix(fs8.lstat);
+    fs8.statSync = statFixSync(fs8.statSync);
+    fs8.fstatSync = statFixSync(fs8.fstatSync);
+    fs8.lstatSync = statFixSync(fs8.lstatSync);
+    if (fs8.chmod && !fs8.lchmod) {
+      fs8.lchmod = function(path11, mode, cb) {
         if (cb)
           process.nextTick(cb);
       };
-      fs7.lchmodSync = function() {};
+      fs8.lchmodSync = function() {};
     }
-    if (fs7.chown && !fs7.lchown) {
-      fs7.lchown = function(path11, uid, gid, cb) {
+    if (fs8.chown && !fs8.lchown) {
+      fs8.lchown = function(path11, uid, gid, cb) {
         if (cb)
           process.nextTick(cb);
       };
-      fs7.lchownSync = function() {};
+      fs8.lchownSync = function() {};
     }
     if (platform === "win32") {
-      fs7.rename = typeof fs7.rename !== "function" ? fs7.rename : function(fs$rename) {
-        function rename(from, to, cb) {
+      fs8.rename = typeof fs8.rename !== "function" ? fs8.rename : function(fs$rename) {
+        function rename2(from, to, cb) {
           var start2 = Date.now();
           var backoff = 0;
           fs$rename(from, to, function CB(er) {
             if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start2 < 60000) {
               setTimeout(function() {
-                fs7.stat(to, function(stater, st) {
+                fs8.stat(to, function(stater, st) {
                   if (stater && stater.code === "ENOENT")
                     fs$rename(from, to, CB);
                   else
@@ -30267,11 +30268,11 @@ var require_polyfills = __commonJS((exports, module2) => {
           });
         }
         if (Object.setPrototypeOf)
-          Object.setPrototypeOf(rename, fs$rename);
-        return rename;
-      }(fs7.rename);
+          Object.setPrototypeOf(rename2, fs$rename);
+        return rename2;
+      }(fs8.rename);
     }
-    fs7.read = typeof fs7.read !== "function" ? fs7.read : function(fs$read) {
+    fs8.read = typeof fs8.read !== "function" ? fs8.read : function(fs$read) {
       function read(fd, buffer, offset, length, position, callback_) {
         var callback;
         if (callback_ && typeof callback_ === "function") {
@@ -30279,23 +30280,23 @@ var require_polyfills = __commonJS((exports, module2) => {
           callback = function(er, _, __) {
             if (er && er.code === "EAGAIN" && eagCounter < 10) {
               eagCounter++;
-              return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
+              return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
             }
             callback_.apply(this, arguments);
           };
         }
-        return fs$read.call(fs7, fd, buffer, offset, length, position, callback);
+        return fs$read.call(fs8, fd, buffer, offset, length, position, callback);
       }
       if (Object.setPrototypeOf)
         Object.setPrototypeOf(read, fs$read);
       return read;
-    }(fs7.read);
-    fs7.readSync = typeof fs7.readSync !== "function" ? fs7.readSync : function(fs$readSync) {
+    }(fs8.read);
+    fs8.readSync = typeof fs8.readSync !== "function" ? fs8.readSync : function(fs$readSync) {
       return function(fd, buffer, offset, length, position) {
         var eagCounter = 0;
         while (true) {
           try {
-            return fs$readSync.call(fs7, fd, buffer, offset, length, position);
+            return fs$readSync.call(fs8, fd, buffer, offset, length, position);
           } catch (er) {
             if (er.code === "EAGAIN" && eagCounter < 10) {
               eagCounter++;
@@ -30305,90 +30306,90 @@ var require_polyfills = __commonJS((exports, module2) => {
           }
         }
       };
-    }(fs7.readSync);
-    function patchLchmod(fs8) {
-      fs8.lchmod = function(path11, mode, callback) {
-        fs8.open(path11, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err2, fd) {
+    }(fs8.readSync);
+    function patchLchmod(fs9) {
+      fs9.lchmod = function(path11, mode, callback) {
+        fs9.open(path11, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err2, fd) {
           if (err2) {
             if (callback)
               callback(err2);
             return;
           }
-          fs8.fchmod(fd, mode, function(err3) {
-            fs8.close(fd, function(err22) {
+          fs9.fchmod(fd, mode, function(err3) {
+            fs9.close(fd, function(err22) {
               if (callback)
                 callback(err3 || err22);
             });
           });
         });
       };
-      fs8.lchmodSync = function(path11, mode) {
-        var fd = fs8.openSync(path11, constants.O_WRONLY | constants.O_SYMLINK, mode);
+      fs9.lchmodSync = function(path11, mode) {
+        var fd = fs9.openSync(path11, constants.O_WRONLY | constants.O_SYMLINK, mode);
         var threw = true;
         var ret;
         try {
-          ret = fs8.fchmodSync(fd, mode);
+          ret = fs9.fchmodSync(fd, mode);
           threw = false;
         } finally {
           if (threw) {
             try {
-              fs8.closeSync(fd);
+              fs9.closeSync(fd);
             } catch (er) {}
           } else {
-            fs8.closeSync(fd);
+            fs9.closeSync(fd);
           }
         }
         return ret;
       };
     }
-    function patchLutimes(fs8) {
-      if (constants.hasOwnProperty("O_SYMLINK") && fs8.futimes) {
-        fs8.lutimes = function(path11, at, mt, cb) {
-          fs8.open(path11, constants.O_SYMLINK, function(er, fd) {
+    function patchLutimes(fs9) {
+      if (constants.hasOwnProperty("O_SYMLINK") && fs9.futimes) {
+        fs9.lutimes = function(path11, at, mt, cb) {
+          fs9.open(path11, constants.O_SYMLINK, function(er, fd) {
             if (er) {
               if (cb)
                 cb(er);
               return;
             }
-            fs8.futimes(fd, at, mt, function(er2) {
-              fs8.close(fd, function(er22) {
+            fs9.futimes(fd, at, mt, function(er2) {
+              fs9.close(fd, function(er22) {
                 if (cb)
                   cb(er2 || er22);
               });
             });
           });
         };
-        fs8.lutimesSync = function(path11, at, mt) {
-          var fd = fs8.openSync(path11, constants.O_SYMLINK);
+        fs9.lutimesSync = function(path11, at, mt) {
+          var fd = fs9.openSync(path11, constants.O_SYMLINK);
           var ret;
           var threw = true;
           try {
-            ret = fs8.futimesSync(fd, at, mt);
+            ret = fs9.futimesSync(fd, at, mt);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs8.closeSync(fd);
+                fs9.closeSync(fd);
               } catch (er) {}
             } else {
-              fs8.closeSync(fd);
+              fs9.closeSync(fd);
             }
           }
           return ret;
         };
-      } else if (fs8.futimes) {
-        fs8.lutimes = function(_a2, _b, _c, cb) {
+      } else if (fs9.futimes) {
+        fs9.lutimes = function(_a2, _b, _c, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs8.lutimesSync = function() {};
+        fs9.lutimesSync = function() {};
       }
     }
     function chmodFix(orig) {
       if (!orig)
         return orig;
       return function(target, mode, cb) {
-        return orig.call(fs7, target, mode, function(er) {
+        return orig.call(fs8, target, mode, function(er) {
           if (chownErOk(er))
             er = null;
           if (cb)
@@ -30401,7 +30402,7 @@ var require_polyfills = __commonJS((exports, module2) => {
         return orig;
       return function(target, mode) {
         try {
-          return orig.call(fs7, target, mode);
+          return orig.call(fs8, target, mode);
         } catch (er) {
           if (!chownErOk(er))
             throw er;
@@ -30412,7 +30413,7 @@ var require_polyfills = __commonJS((exports, module2) => {
       if (!orig)
         return orig;
       return function(target, uid, gid, cb) {
-        return orig.call(fs7, target, uid, gid, function(er) {
+        return orig.call(fs8, target, uid, gid, function(er) {
           if (chownErOk(er))
             er = null;
           if (cb)
@@ -30425,7 +30426,7 @@ var require_polyfills = __commonJS((exports, module2) => {
         return orig;
       return function(target, uid, gid) {
         try {
-          return orig.call(fs7, target, uid, gid);
+          return orig.call(fs8, target, uid, gid);
         } catch (er) {
           if (!chownErOk(er))
             throw er;
@@ -30450,14 +30451,14 @@ var require_polyfills = __commonJS((exports, module2) => {
           if (cb)
             cb.apply(this, arguments);
         }
-        return options ? orig.call(fs7, target, options, callback) : orig.call(fs7, target, callback);
+        return options ? orig.call(fs8, target, options, callback) : orig.call(fs8, target, callback);
       };
     }
     function statFixSync(orig) {
       if (!orig)
         return orig;
       return function(target, options) {
-        var stats = options ? orig.call(fs7, target, options) : orig.call(fs7, target);
+        var stats = options ? orig.call(fs8, target, options) : orig.call(fs8, target);
         if (stats) {
           if (stats.uid < 0)
             stats.uid += 4294967296;
@@ -30486,7 +30487,7 @@ var require_polyfills = __commonJS((exports, module2) => {
 var require_legacy_streams = __commonJS((exports, module2) => {
   var Stream = __require("stream").Stream;
   module2.exports = legacy;
-  function legacy(fs7) {
+  function legacy(fs8) {
     return {
       ReadStream,
       WriteStream
@@ -30531,7 +30532,7 @@ var require_legacy_streams = __commonJS((exports, module2) => {
         });
         return;
       }
-      fs7.open(this.path, this.flags, this.mode, function(err2, fd) {
+      fs8.open(this.path, this.flags, this.mode, function(err2, fd) {
         if (err2) {
           self2.emit("error", err2);
           self2.readable = false;
@@ -30571,7 +30572,7 @@ var require_legacy_streams = __commonJS((exports, module2) => {
       this.busy = false;
       this._queue = [];
       if (this.fd === null) {
-        this._open = fs7.open;
+        this._open = fs8.open;
         this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
         this.flush();
       }
@@ -30601,7 +30602,7 @@ var require_clone = __commonJS((exports, module2) => {
 
 // node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS((exports, module2) => {
-  var fs7 = __require("fs");
+  var fs8 = __require("fs");
   var polyfills = require_polyfills();
   var legacy = require_legacy_streams();
   var clone3 = require_clone();
@@ -30633,12 +30634,12 @@ var require_graceful_fs = __commonJS((exports, module2) => {
 GFS4: `);
       console.error(m);
     };
-  if (!fs7[gracefulQueue]) {
+  if (!fs8[gracefulQueue]) {
     queue = global[gracefulQueue] || [];
-    publishQueue(fs7, queue);
-    fs7.close = function(fs$close) {
+    publishQueue(fs8, queue);
+    fs8.close = function(fs$close) {
       function close(fd, cb) {
-        return fs$close.call(fs7, fd, function(err2) {
+        return fs$close.call(fs8, fd, function(err2) {
           if (!err2) {
             resetQueue();
           }
@@ -30650,40 +30651,40 @@ GFS4: `);
         value: fs$close
       });
       return close;
-    }(fs7.close);
-    fs7.closeSync = function(fs$closeSync) {
+    }(fs8.close);
+    fs8.closeSync = function(fs$closeSync) {
       function closeSync(fd) {
-        fs$closeSync.apply(fs7, arguments);
+        fs$closeSync.apply(fs8, arguments);
         resetQueue();
       }
       Object.defineProperty(closeSync, previousSymbol, {
         value: fs$closeSync
       });
       return closeSync;
-    }(fs7.closeSync);
+    }(fs8.closeSync);
     if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
       process.on("exit", function() {
-        debug(fs7[gracefulQueue]);
-        __require("assert").equal(fs7[gracefulQueue].length, 0);
+        debug(fs8[gracefulQueue]);
+        __require("assert").equal(fs8[gracefulQueue].length, 0);
       });
     }
   }
   var queue;
   if (!global[gracefulQueue]) {
-    publishQueue(global, fs7[gracefulQueue]);
-  }
-  module2.exports = patch(clone3(fs7));
-  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs7.__patched) {
-    module2.exports = patch(fs7);
-    fs7.__patched = true;
-  }
-  function patch(fs8) {
-    polyfills(fs8);
-    fs8.gracefulify = patch;
-    fs8.createReadStream = createReadStream;
-    fs8.createWriteStream = createWriteStream;
-    var fs$readFile = fs8.readFile;
-    fs8.readFile = readFile2;
+    publishQueue(global, fs8[gracefulQueue]);
+  }
+  module2.exports = patch(clone3(fs8));
+  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs8.__patched) {
+    module2.exports = patch(fs8);
+    fs8.__patched = true;
+  }
+  function patch(fs9) {
+    polyfills(fs9);
+    fs9.gracefulify = patch;
+    fs9.createReadStream = createReadStream;
+    fs9.createWriteStream = createWriteStream;
+    var fs$readFile = fs9.readFile;
+    fs9.readFile = readFile2;
     function readFile2(path11, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
@@ -30699,8 +30700,8 @@ GFS4: `);
         });
       }
     }
-    var fs$writeFile = fs8.writeFile;
-    fs8.writeFile = writeFile;
+    var fs$writeFile = fs9.writeFile;
+    fs9.writeFile = writeFile;
     function writeFile(path11, data, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
@@ -30716,9 +30717,9 @@ GFS4: `);
         });
       }
     }
-    var fs$appendFile = fs8.appendFile;
+    var fs$appendFile = fs9.appendFile;
     if (fs$appendFile)
-      fs8.appendFile = appendFile;
+      fs9.appendFile = appendFile;
     function appendFile(path11, data, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
@@ -30734,9 +30735,9 @@ GFS4: `);
         });
       }
     }
-    var fs$copyFile = fs8.copyFile;
+    var fs$copyFile = fs9.copyFile;
     if (fs$copyFile)
-      fs8.copyFile = copyFile;
+      fs9.copyFile = copyFile;
     function copyFile(src, dest, flags2, cb) {
       if (typeof flags2 === "function") {
         cb = flags2;
@@ -30754,8 +30755,8 @@ GFS4: `);
         });
       }
     }
-    var fs$readdir = fs8.readdir;
-    fs8.readdir = readdir2;
+    var fs$readdir = fs9.readdir;
+    fs9.readdir = readdir2;
     var noReaddirOptionVersions = /^v[0-5]\./;
     function readdir2(path11, options, cb) {
       if (typeof options === "function")
@@ -30786,21 +30787,21 @@ GFS4: `);
       }
     }
     if (process.version.substr(0, 4) === "v0.8") {
-      var legStreams = legacy(fs8);
+      var legStreams = legacy(fs9);
       ReadStream = legStreams.ReadStream;
       WriteStream = legStreams.WriteStream;
     }
-    var fs$ReadStream = fs8.ReadStream;
+    var fs$ReadStream = fs9.ReadStream;
     if (fs$ReadStream) {
       ReadStream.prototype = Object.create(fs$ReadStream.prototype);
       ReadStream.prototype.open = ReadStream$open;
     }
-    var fs$WriteStream = fs8.WriteStream;
+    var fs$WriteStream = fs9.WriteStream;
     if (fs$WriteStream) {
       WriteStream.prototype = Object.create(fs$WriteStream.prototype);
       WriteStream.prototype.open = WriteStream$open;
     }
-    Object.defineProperty(fs8, "ReadStream", {
+    Object.defineProperty(fs9, "ReadStream", {
       get: function() {
         return ReadStream;
       },
@@ -30810,7 +30811,7 @@ GFS4: `);
       enumerable: true,
       configurable: true
     });
-    Object.defineProperty(fs8, "WriteStream", {
+    Object.defineProperty(fs9, "WriteStream", {
       get: function() {
         return WriteStream;
       },
@@ -30821,7 +30822,7 @@ GFS4: `);
       configurable: true
     });
     var FileReadStream = ReadStream;
-    Object.defineProperty(fs8, "FileReadStream", {
+    Object.defineProperty(fs9, "FileReadStream", {
       get: function() {
         return FileReadStream;
       },
@@ -30832,7 +30833,7 @@ GFS4: `);
       configurable: true
     });
     var FileWriteStream = WriteStream;
-    Object.defineProperty(fs8, "FileWriteStream", {
+    Object.defineProperty(fs9, "FileWriteStream", {
       get: function() {
         return FileWriteStream;
       },
@@ -30881,13 +30882,13 @@ GFS4: `);
       });
     }
     function createReadStream(path11, options) {
-      return new fs8.ReadStream(path11, options);
+      return new fs9.ReadStream(path11, options);
     }
     function createWriteStream(path11, options) {
-      return new fs8.WriteStream(path11, options);
+      return new fs9.WriteStream(path11, options);
     }
-    var fs$open = fs8.open;
-    fs8.open = open;
+    var fs$open = fs9.open;
+    fs9.open = open;
     function open(path11, flags2, mode, cb) {
       if (typeof mode === "function")
         cb = mode, mode = null;
@@ -30903,20 +30904,20 @@ GFS4: `);
         });
       }
     }
-    return fs8;
+    return fs9;
   }
   function enqueue(elem) {
     debug("ENQUEUE", elem[0].name, elem[1]);
-    fs7[gracefulQueue].push(elem);
+    fs8[gracefulQueue].push(elem);
     retry();
   }
   var retryTimer;
   function resetQueue() {
     var now = Date.now();
-    for (var i2 = 0;i2 < fs7[gracefulQueue].length; ++i2) {
-      if (fs7[gracefulQueue][i2].length > 2) {
-        fs7[gracefulQueue][i2][3] = now;
-        fs7[gracefulQueue][i2][4] = now;
+    for (var i2 = 0;i2 < fs8[gracefulQueue].length; ++i2) {
+      if (fs8[gracefulQueue][i2].length > 2) {
+        fs8[gracefulQueue][i2][3] = now;
+        fs8[gracefulQueue][i2][4] = now;
       }
     }
     retry();
@@ -30924,9 +30925,9 @@ GFS4: `);
   function retry() {
     clearTimeout(retryTimer);
     retryTimer = undefined;
-    if (fs7[gracefulQueue].length === 0)
+    if (fs8[gracefulQueue].length === 0)
       return;
-    var elem = fs7[gracefulQueue].shift();
+    var elem = fs8[gracefulQueue].shift();
     var fn = elem[0];
     var args2 = elem[1];
     var err2 = elem[2];
@@ -30948,7 +30949,7 @@ GFS4: `);
         debug("RETRY", fn.name, args2);
         fn.apply(null, args2.concat([startTime]));
       } else {
-        fs7[gracefulQueue].push(elem);
+        fs8[gracefulQueue].push(elem);
       }
     }
     if (retryTimer === undefined) {
@@ -31343,10 +31344,10 @@ var require_signal_exit = __commonJS((exports, module2) => {
 // node_modules/proper-lockfile/lib/mtime-precision.js
 var require_mtime_precision = __commonJS((exports, module2) => {
   var cacheSymbol = Symbol();
-  function probe(file3, fs7, callback) {
-    const cachedPrecision = fs7[cacheSymbol];
+  function probe(file3, fs8, callback) {
+    const cachedPrecision = fs8[cacheSymbol];
     if (cachedPrecision) {
-      return fs7.stat(file3, (err2, stat) => {
+      return fs8.stat(file3, (err2, stat) => {
         if (err2) {
           return callback(err2);
         }
@@ -31354,16 +31355,16 @@ var require_mtime_precision = __commonJS((exports, module2) => {
       });
     }
     const mtime = new Date(Math.ceil(Date.now() / 1000) * 1000 + 5);
-    fs7.utimes(file3, mtime, mtime, (err2) => {
+    fs8.utimes(file3, mtime, mtime, (err2) => {
       if (err2) {
         return callback(err2);
       }
-      fs7.stat(file3, (err3, stat) => {
+      fs8.stat(file3, (err3, stat) => {
         if (err3) {
           return callback(err3);
         }
         const precision = stat.mtime.getTime() % 1000 === 0 ? "s" : "ms";
-        Object.defineProperty(fs7, cacheSymbol, { value: precision });
+        Object.defineProperty(fs8, cacheSymbol, { value: precision });
         callback(null, stat.mtime, precision);
       });
     });
@@ -31382,7 +31383,7 @@ var require_mtime_precision = __commonJS((exports, module2) => {
 // node_modules/proper-lockfile/lib/lockfile.js
 var require_lockfile = __commonJS((exports, module2) => {
   var path11 = __require("path");
-  var fs7 = require_graceful_fs();
+  var fs8 = require_graceful_fs();
   var retry = require_retry();
   var onExit = require_signal_exit();
   var mtimePrecision = require_mtime_precision();
@@ -31505,7 +31506,7 @@ var require_lockfile = __commonJS((exports, module2) => {
       update: null,
       realpath: true,
       retries: 0,
-      fs: fs7,
+      fs: fs8,
       onCompromised: (err2) => {
         throw err2;
       },
@@ -31549,7 +31550,7 @@ var require_lockfile = __commonJS((exports, module2) => {
   }
   function unlock(file3, options, callback) {
     options = {
-      fs: fs7,
+      fs: fs8,
       realpath: true,
       ...options
     };
@@ -31571,7 +31572,7 @@ var require_lockfile = __commonJS((exports, module2) => {
     options = {
       stale: 1e4,
       realpath: true,
-      fs: fs7,
+      fs: fs8,
       ...options
     };
     options.stale = Math.max(options.stale || 0, 2000);
@@ -31606,16 +31607,16 @@ var require_lockfile = __commonJS((exports, module2) => {
 
 // node_modules/proper-lockfile/lib/adapter.js
 var require_adapter = __commonJS((exports, module2) => {
-  var fs7 = require_graceful_fs();
-  function createSyncFs(fs8) {
+  var fs8 = require_graceful_fs();
+  function createSyncFs(fs9) {
     const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-    const newFs = { ...fs8 };
+    const newFs = { ...fs9 };
     methods.forEach((method) => {
       newFs[method] = (...args2) => {
         const callback = args2.pop();
         let ret;
         try {
-          ret = fs8[`${method}Sync`](...args2);
+          ret = fs9[`${method}Sync`](...args2);
         } catch (err2) {
           return callback(err2);
         }
@@ -31653,7 +31654,7 @@ var require_adapter = __commonJS((exports, module2) => {
   }
   function toSyncOptions(options) {
     options = { ...options };
-    options.fs = createSyncFs(options.fs || fs7);
+    options.fs = createSyncFs(options.fs || fs8);
     if (typeof options.retries === "number" && options.retries > 0 || options.retries && typeof options.retries.retries === "number" && options.retries.retries > 0) {
       throw Object.assign(new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
     }
@@ -31713,7 +31714,7 @@ __export(exports_config_doctor, {
   applySafeAutoFixes: () => applySafeAutoFixes
 });
 import * as crypto2 from "crypto";
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as os4 from "os";
 import * as path18 from "path";
 function getUserConfigDir3() {
@@ -31758,15 +31759,15 @@ function createConfigBackup(directory) {
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configPath = projectConfigPath;
   let content = null;
-  if (fs8.existsSync(projectConfigPath)) {
+  if (fs9.existsSync(projectConfigPath)) {
     try {
-      content = fs8.readFileSync(projectConfigPath, "utf-8");
+      content = fs9.readFileSync(projectConfigPath, "utf-8");
     } catch {}
   }
-  if (content === null && fs8.existsSync(userConfigPath)) {
+  if (content === null && fs9.existsSync(userConfigPath)) {
     configPath = userConfigPath;
     try {
-      content = fs8.readFileSync(userConfigPath, "utf-8");
+      content = fs9.readFileSync(userConfigPath, "utf-8");
     } catch {}
   }
   if (content === null) {
@@ -31781,8 +31782,8 @@ function createConfigBackup(directory) {
 }
 function writeBackupArtifact(directory, backup) {
   const swarmDir = path18.join(directory, ".swarm");
-  if (!fs8.existsSync(swarmDir)) {
-    fs8.mkdirSync(swarmDir, { recursive: true });
+  if (!fs9.existsSync(swarmDir)) {
+    fs9.mkdirSync(swarmDir, { recursive: true });
   }
   const backupFilename = `config-backup-${backup.createdAt}.json`;
   const backupPath = path18.join(swarmDir, backupFilename);
@@ -31793,15 +31794,15 @@ function writeBackupArtifact(directory, backup) {
     content: backup.content,
     preview: backup.content.substring(0, 500) + (backup.content.length > 500 ? "..." : "")
   };
-  fs8.writeFileSync(backupPath, JSON.stringify(artifact, null, 2), "utf-8");
+  fs9.writeFileSync(backupPath, JSON.stringify(artifact, null, 2), "utf-8");
   return backupPath;
 }
 function restoreFromBackup(backupPath, directory) {
-  if (!fs8.existsSync(backupPath)) {
+  if (!fs9.existsSync(backupPath)) {
     return null;
   }
   try {
-    const artifact = JSON.parse(fs8.readFileSync(backupPath, "utf-8"));
+    const artifact = JSON.parse(fs9.readFileSync(backupPath, "utf-8"));
     if (!artifact.content || !artifact.configPath || !artifact.contentHash) {
       return null;
     }
@@ -31816,10 +31817,10 @@ function restoreFromBackup(backupPath, directory) {
     }
     const targetPath = artifact.configPath;
     const targetDir = path18.dirname(targetPath);
-    if (!fs8.existsSync(targetDir)) {
-      fs8.mkdirSync(targetDir, { recursive: true });
+    if (!fs9.existsSync(targetDir)) {
+      fs9.mkdirSync(targetDir, { recursive: true });
     }
-    fs8.writeFileSync(targetPath, artifact.content, "utf-8");
+    fs9.writeFileSync(targetPath, artifact.content, "utf-8");
     return targetPath;
   } catch {
     return null;
@@ -31829,12 +31830,12 @@ function readConfigFromFile(directory) {
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configPath = projectConfigPath;
   let configContent = null;
-  if (fs8.existsSync(projectConfigPath)) {
+  if (fs9.existsSync(projectConfigPath)) {
     configPath = projectConfigPath;
-    configContent = fs8.readFileSync(projectConfigPath, "utf-8");
-  } else if (fs8.existsSync(userConfigPath)) {
+    configContent = fs9.readFileSync(projectConfigPath, "utf-8");
+  } else if (fs9.existsSync(userConfigPath)) {
     configPath = userConfigPath;
-    configContent = fs8.readFileSync(userConfigPath, "utf-8");
+    configContent = fs9.readFileSync(userConfigPath, "utf-8");
   }
   if (configContent === null) {
     return null;
@@ -32130,9 +32131,9 @@ function runConfigDoctor(config3, directory) {
   const hasAutoFixableIssues = findings.some((f) => f.autoFixable && f.proposedFix?.risk === "low");
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configSource = "defaults";
-  if (fs8.existsSync(projectConfigPath)) {
+  if (fs9.existsSync(projectConfigPath)) {
     configSource = projectConfigPath;
-  } else if (fs8.existsSync(userConfigPath)) {
+  } else if (fs9.existsSync(userConfigPath)) {
     configSource = userConfigPath;
   }
   return {
@@ -32161,12 +32162,12 @@ function applySafeAutoFixes(directory, result) {
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configPath = projectConfigPath;
   let configContent;
-  if (fs8.existsSync(projectConfigPath)) {
+  if (fs9.existsSync(projectConfigPath)) {
     configPath = projectConfigPath;
-    configContent = fs8.readFileSync(projectConfigPath, "utf-8");
-  } else if (fs8.existsSync(userConfigPath)) {
+    configContent = fs9.readFileSync(projectConfigPath, "utf-8");
+  } else if (fs9.existsSync(userConfigPath)) {
     configPath = userConfigPath;
-    configContent = fs8.readFileSync(userConfigPath, "utf-8");
+    configContent = fs9.readFileSync(userConfigPath, "utf-8");
   } else {
     return { appliedFixes, updatedConfigPath: null };
   }
@@ -32236,18 +32237,18 @@ function applySafeAutoFixes(directory, result) {
   }
   if (appliedFixes.length > 0) {
     const configDir = path18.dirname(configPath);
-    if (!fs8.existsSync(configDir)) {
-      fs8.mkdirSync(configDir, { recursive: true });
+    if (!fs9.existsSync(configDir)) {
+      fs9.mkdirSync(configDir, { recursive: true });
     }
-    fs8.writeFileSync(configPath, JSON.stringify(config3, null, 2), "utf-8");
+    fs9.writeFileSync(configPath, JSON.stringify(config3, null, 2), "utf-8");
     updatedConfigPath = configPath;
   }
   return { appliedFixes, updatedConfigPath };
 }
 function writeDoctorArtifact(directory, result) {
   const swarmDir = path18.join(directory, ".swarm");
-  if (!fs8.existsSync(swarmDir)) {
-    fs8.mkdirSync(swarmDir, { recursive: true });
+  if (!fs9.existsSync(swarmDir)) {
+    fs9.mkdirSync(swarmDir, { recursive: true });
   }
   const artifactFilename = "config-doctor.json";
   const artifactPath = path18.join(swarmDir, artifactFilename);
@@ -32271,7 +32272,7 @@ function writeDoctorArtifact(directory, result) {
       } : null
     }))
   };
-  fs8.writeFileSync(artifactPath, JSON.stringify(guiOutput, null, 2), "utf-8");
+  fs9.writeFileSync(artifactPath, JSON.stringify(guiOutput, null, 2), "utf-8");
   return artifactPath;
 }
 function shouldRunOnStartup(automationConfig) {
@@ -33249,7 +33250,7 @@ var init_detector = __esm(() => {
 });
 
 // src/build/discovery.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as path21 from "path";
 function isCommandAvailable(command) {
   if (toolchainCache.has(command)) {
@@ -33279,7 +33280,7 @@ function findBuildFiles(workingDir, patterns) {
     if (pattern.includes("*")) {
       const dir = workingDir;
       try {
-        const files = fs9.readdirSync(dir);
+        const files = fs10.readdirSync(dir);
         const regex = simpleGlobToRegex(pattern);
         const matches = files.filter((f) => regex.test(f));
         if (matches.length > 0) {
@@ -33288,7 +33289,7 @@ function findBuildFiles(workingDir, patterns) {
       } catch {}
     } else {
       const filePath = path21.join(workingDir, pattern);
-      if (fs9.existsSync(filePath)) {
+      if (fs10.existsSync(filePath)) {
         return filePath;
       }
     }
@@ -33297,11 +33298,11 @@ function findBuildFiles(workingDir, patterns) {
 }
 function getRepoDefinedScripts(workingDir, scripts) {
   const packageJsonPath = path21.join(workingDir, "package.json");
-  if (!fs9.existsSync(packageJsonPath)) {
+  if (!fs10.existsSync(packageJsonPath)) {
     return [];
   }
   try {
-    const content = fs9.readFileSync(packageJsonPath, "utf-8");
+    const content = fs10.readFileSync(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.scripts || typeof pkg.scripts !== "object") {
       return [];
@@ -33338,7 +33339,7 @@ function findAllBuildFiles(workingDir) {
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
         const filePath = path21.join(workingDir, pattern);
-        if (fs9.existsSync(filePath)) {
+        if (fs10.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
       }
@@ -33348,7 +33349,7 @@ function findAllBuildFiles(workingDir) {
 }
 function findFilesRecursive(dir, regex, results) {
   try {
-    const entries = fs9.readdirSync(dir, { withFileTypes: true });
+    const entries = fs10.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path21.join(dir, entry.name);
       if (entry.isDirectory() && !["node_modules", ".git", "dist", "build", "target"].includes(entry.name)) {
@@ -33374,7 +33375,7 @@ async function discoverBuildCommandsFromProfiles(workingDir) {
     for (const cmd of sortedCommands) {
       if (cmd.detectFile) {
         const detectFilePath = path21.join(workingDir, cmd.detectFile);
-        if (!fs9.existsSync(detectFilePath)) {
+        if (!fs10.existsSync(detectFilePath)) {
           continue;
         }
       }
@@ -33582,7 +33583,7 @@ var init_discovery = __esm(() => {
 });
 
 // src/tools/lint.ts
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as path22 from "path";
 function validateArgs(args2) {
   if (typeof args2 !== "object" || args2 === null)
@@ -33612,7 +33613,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs10.existsSync(path22.join(cwd, gradlewName)) ? path22.join(cwd, gradlewName) : null;
+  const gradlew = fs11.existsSync(path22.join(cwd, gradlewName)) ? path22.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -33646,12 +33647,12 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs10.existsSync(path22.join(cwd, "ruff.toml")))
+  if (fs11.existsSync(path22.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
     const pyproject = path22.join(cwd, "pyproject.toml");
-    if (fs10.existsSync(pyproject)) {
-      const content = fs10.readFileSync(pyproject, "utf-8");
+    if (fs11.existsSync(pyproject)) {
+      const content = fs11.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
         return isCommandAvailable("ruff");
     }
@@ -33659,21 +33660,21 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs10.existsSync(path22.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs11.existsSync(path22.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs10.existsSync(path22.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs11.existsSync(path22.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs10.existsSync(path22.join(cwd, "pom.xml"));
-  const hasGradle = fs10.existsSync(path22.join(cwd, "build.gradle")) || fs10.existsSync(path22.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs10.existsSync(path22.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs11.existsSync(path22.join(cwd, "pom.xml"));
+  const hasGradle = fs11.existsSync(path22.join(cwd, "build.gradle")) || fs11.existsSync(path22.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs11.existsSync(path22.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs10.existsSync(path22.join(cwd, "build.gradle.kts")) || fs10.existsSync(path22.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs11.existsSync(path22.join(cwd, "build.gradle.kts")) || fs11.existsSync(path22.join(cwd, "build.gradle")) || (() => {
     try {
-      return fs10.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
+      return fs11.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
       return false;
     }
@@ -33682,7 +33683,7 @@ function detectKtlint(cwd) {
 }
 function detectDotnetFormat(cwd) {
   try {
-    const files = fs10.readdirSync(cwd);
+    const files = fs11.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -33690,14 +33691,14 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs10.existsSync(path22.join(cwd, "CMakeLists.txt"))) {
+  if (fs11.existsSync(path22.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
     const dirsToCheck = [cwd, path22.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
-        return fs10.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
+        return fs11.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
       } catch {
         return false;
       }
@@ -33708,13 +33709,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs10.existsSync(path22.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs11.existsSync(path22.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs10.existsSync(path22.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs11.existsSync(path22.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs10.existsSync(path22.join(cwd, "Gemfile")) || fs10.existsSync(path22.join(cwd, "gems.rb")) || fs10.existsSync(path22.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs11.existsSync(path22.join(cwd, "Gemfile")) || fs11.existsSync(path22.join(cwd, "gems.rb")) || fs11.existsSync(path22.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -33759,7 +33760,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([biomeExit, timeout]);
     if (result === "timeout") {
       biomeProc.kill();
-    } else if (biomeProc.exitCode === 0 && fs10.existsSync(biomeBin)) {
+    } else if (biomeProc.exitCode === 0 && fs11.existsSync(biomeBin)) {
       return "biome";
     }
   } catch {}
@@ -33773,7 +33774,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([eslintExit, timeout]);
     if (result === "timeout") {
       eslintProc.kill();
-    } else if (eslintProc.exitCode === 0 && fs10.existsSync(eslintBin)) {
+    } else if (eslintProc.exitCode === 0 && fs11.existsSync(eslintBin)) {
       return "eslint";
     }
   } catch {}
@@ -33950,7 +33951,7 @@ For Rust: rustup component add clippy`
 });
 
 // src/tools/secretscan.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as path23 from "path";
 function calculateShannonEntropy(str) {
   if (str.length === 0)
@@ -34014,9 +34015,9 @@ function isGlobOrPathPattern(pattern) {
 function loadSecretScanIgnore(scanDir) {
   const ignorePath = path23.join(scanDir, ".secretscanignore");
   try {
-    if (!fs11.existsSync(ignorePath))
+    if (!fs12.existsSync(ignorePath))
       return [];
-    const content = fs11.readFileSync(ignorePath, "utf8");
+    const content = fs12.readFileSync(ignorePath, "utf8");
     const patterns = [];
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
@@ -34137,7 +34138,7 @@ function createRedactedContext(line, findings) {
 function scanFileForSecrets(filePath) {
   const findings = [];
   try {
-    const lstat = fs11.lstatSync(filePath);
+    const lstat = fs12.lstatSync(filePath);
     if (lstat.isSymbolicLink()) {
       return findings;
     }
@@ -34146,14 +34147,14 @@ function scanFileForSecrets(filePath) {
     }
     let buffer;
     if (O_NOFOLLOW !== undefined) {
-      const fd = fs11.openSync(filePath, "r", O_NOFOLLOW);
+      const fd = fs12.openSync(filePath, "r", O_NOFOLLOW);
       try {
-        buffer = fs11.readFileSync(fd);
+        buffer = fs12.readFileSync(fd);
       } finally {
-        fs11.closeSync(fd);
+        fs12.closeSync(fd);
       }
     } else {
-      buffer = fs11.readFileSync(filePath);
+      buffer = fs12.readFileSync(filePath);
     }
     if (isBinaryFile(filePath, buffer)) {
       return findings;
@@ -34208,7 +34209,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
   const files = [];
   let entries;
   try {
-    entries = fs11.readdirSync(dir);
+    entries = fs12.readdirSync(dir);
   } catch {
     stats.fileErrors++;
     return files;
@@ -34231,7 +34232,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     }
     let lstat;
     try {
-      lstat = fs11.lstatSync(fullPath);
+      lstat = fs12.lstatSync(fullPath);
     } catch {
       stats.fileErrors++;
       continue;
@@ -34243,7 +34244,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     if (lstat.isDirectory()) {
       let realPath;
       try {
-        realPath = fs11.realpathSync(fullPath);
+        realPath = fs12.realpathSync(fullPath);
       } catch {
         stats.fileErrors++;
         continue;
@@ -34460,7 +34461,7 @@ var init_secretscan = __esm(() => {
       redactTemplate: () => "SK[REDACTED]"
     }
   ];
-  O_NOFOLLOW = process.platform !== "win32" ? fs11.constants.O_NOFOLLOW : undefined;
+  O_NOFOLLOW = process.platform !== "win32" ? fs12.constants.O_NOFOLLOW : undefined;
   secretscan = createSwarmTool({
     description: "Scan directory for potential secrets (API keys, tokens, passwords) using regex patterns and entropy heuristics. Returns metadata-only findings with redacted previews - NEVER returns raw secrets. Excludes common directories (node_modules, .git, dist, etc.) by default. Supports glob patterns (e.g. **/.svelte-kit/**, **/*.test.ts) and reads .secretscanignore at the scan root.",
     args: {
@@ -34518,7 +34519,7 @@ var init_secretscan = __esm(() => {
       }
       try {
         const scanDir = path23.resolve(directory);
-        if (!fs11.existsSync(scanDir)) {
+        if (!fs12.existsSync(scanDir)) {
           const errorResult = {
             error: "directory not found",
             scan_dir: directory,
@@ -34529,7 +34530,7 @@ var init_secretscan = __esm(() => {
           };
           return JSON.stringify(errorResult, null, 2);
         }
-        const dirStat = fs11.statSync(scanDir);
+        const dirStat = fs12.statSync(scanDir);
         if (!dirStat.isDirectory()) {
           const errorResult = {
             error: "target must be a directory, not a file",
@@ -34580,7 +34581,7 @@ var init_secretscan = __esm(() => {
             break;
           const fileFindings = scanFileForSecrets(filePath);
           try {
-            const stat2 = fs11.statSync(filePath);
+            const stat2 = fs12.statSync(filePath);
             if (stat2.size > MAX_FILE_SIZE_BYTES) {
               skippedFiles++;
               continue;
@@ -34652,7 +34653,7 @@ var init_secretscan = __esm(() => {
 });
 
 // src/tools/test-runner.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as path24 from "path";
 function containsPathTraversal2(str) {
   if (/\.\.[/\\]/.test(str))
@@ -34746,19 +34747,19 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs12.existsSync(path24.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs13.existsSync(path24.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs12.existsSync(path24.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs13.existsSync(path24.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs12.existsSync(path24.join(cwd, "build.gradle")) || fs12.existsSync(path24.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs12.existsSync(path24.join(cwd, "gradlew")) || fs12.existsSync(path24.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs13.existsSync(path24.join(cwd, "build.gradle")) || fs13.existsSync(path24.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs13.existsSync(path24.join(cwd, "gradlew")) || fs13.existsSync(path24.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = fs12.readdirSync(cwd);
+    const files = fs13.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -34766,32 +34767,32 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs12.existsSync(path24.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs12.existsSync(path24.join(cwd, "CMakeCache.txt")) || fs12.existsSync(path24.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs13.existsSync(path24.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs13.existsSync(path24.join(cwd, "CMakeCache.txt")) || fs13.existsSync(path24.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs12.existsSync(path24.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs13.existsSync(path24.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs12.existsSync(path24.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs13.existsSync(path24.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs12.existsSync(path24.join(cwd, ".rspec"));
-  const hasGemfile = fs12.existsSync(path24.join(cwd, "Gemfile"));
-  const hasSpecDir = fs12.existsSync(path24.join(cwd, "spec"));
+  const hasRSpecFile = fs13.existsSync(path24.join(cwd, ".rspec"));
+  const hasGemfile = fs13.existsSync(path24.join(cwd, "Gemfile"));
+  const hasSpecDir = fs13.existsSync(path24.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs12.existsSync(path24.join(cwd, "test")) && (fs12.existsSync(path24.join(cwd, "Gemfile")) || fs12.existsSync(path24.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs13.existsSync(path24.join(cwd, "test")) && (fs13.existsSync(path24.join(cwd, "Gemfile")) || fs13.existsSync(path24.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
     const packageJsonPath = path24.join(baseDir, "package.json");
-    if (fs12.existsSync(packageJsonPath)) {
-      const content = fs12.readFileSync(packageJsonPath, "utf-8");
+    if (fs13.existsSync(packageJsonPath)) {
+      const content = fs13.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -34810,7 +34811,7 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs12.existsSync(path24.join(baseDir, "bun.lockb")) || fs12.existsSync(path24.join(baseDir, "bun.lock"))) {
+      if (fs13.existsSync(path24.join(baseDir, "bun.lockb")) || fs13.existsSync(path24.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
@@ -34820,28 +34821,28 @@ async function detectTestFramework(cwd) {
     const pyprojectTomlPath = path24.join(baseDir, "pyproject.toml");
     const setupCfgPath = path24.join(baseDir, "setup.cfg");
     const requirementsTxtPath = path24.join(baseDir, "requirements.txt");
-    if (fs12.existsSync(pyprojectTomlPath)) {
-      const content = fs12.readFileSync(pyprojectTomlPath, "utf-8");
+    if (fs13.existsSync(pyprojectTomlPath)) {
+      const content = fs13.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (fs12.existsSync(setupCfgPath)) {
-      const content = fs12.readFileSync(setupCfgPath, "utf-8");
+    if (fs13.existsSync(setupCfgPath)) {
+      const content = fs13.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (fs12.existsSync(requirementsTxtPath)) {
-      const content = fs12.readFileSync(requirementsTxtPath, "utf-8");
+    if (fs13.existsSync(requirementsTxtPath)) {
+      const content = fs13.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
     const cargoTomlPath = path24.join(baseDir, "Cargo.toml");
-    if (fs12.existsSync(cargoTomlPath)) {
-      const content = fs12.readFileSync(cargoTomlPath, "utf-8");
+    if (fs13.existsSync(cargoTomlPath)) {
+      const content = fs13.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -34853,7 +34854,7 @@ async function detectTestFramework(cwd) {
     const pesterConfigPath = path24.join(baseDir, "pester.config.ps1");
     const pesterConfigJsonPath = path24.join(baseDir, "pester.config.ps1.json");
     const pesterPs1Path = path24.join(baseDir, "tests.ps1");
-    if (fs12.existsSync(pesterConfigPath) || fs12.existsSync(pesterConfigJsonPath) || fs12.existsSync(pesterPs1Path)) {
+    if (fs13.existsSync(pesterConfigPath) || fs13.existsSync(pesterConfigJsonPath) || fs13.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -34904,7 +34905,7 @@ function getTestFilesFromConvention(sourceFiles) {
         path24.join(dirname10, "test", `${nameWithoutExt}${ext}`)
       ];
       for (const testFile of possibleTestFiles) {
-        if (fs12.existsSync(testFile) && !testFiles.includes(testFile)) {
+        if (fs13.existsSync(testFile) && !testFiles.includes(testFile)) {
           testFiles.push(testFile);
         }
       }
@@ -34920,7 +34921,7 @@ async function getTestFilesFromGraph(sourceFiles) {
   }
   for (const testFile of candidateTestFiles) {
     try {
-      const content = fs12.readFileSync(testFile, "utf-8");
+      const content = fs13.readFileSync(testFile, "utf-8");
       const testDir = path24.dirname(testFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
@@ -34941,7 +34942,7 @@ async function getTestFilesFromGraph(sourceFiles) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (sourceFiles.includes(withExt) || fs12.existsSync(withExt)) {
+              if (sourceFiles.includes(withExt) || fs13.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -34982,7 +34983,7 @@ async function getTestFilesFromGraph(sourceFiles) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (sourceFiles.includes(withExt) || fs12.existsSync(withExt)) {
+              if (sourceFiles.includes(withExt) || fs13.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -35078,8 +35079,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs12.existsSync(path24.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs12.existsSync(path24.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs13.existsSync(path24.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs13.existsSync(path24.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -35096,7 +35097,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs12.existsSync(path24.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs13.existsSync(path24.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -35689,7 +35690,7 @@ var init_test_runner = __esm(() => {
 });
 
 // src/services/preflight-service.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path25 from "path";
 function validateDirectoryPath(dir) {
   if (!dir || typeof dir !== "string") {
@@ -35723,8 +35724,8 @@ function validateTimeout(timeoutMs, defaultValue) {
 function getPackageVersion(dir) {
   try {
     const packagePath = path25.join(dir, "package.json");
-    if (fs13.existsSync(packagePath)) {
-      const content = fs13.readFileSync(packagePath, "utf-8");
+    if (fs14.existsSync(packagePath)) {
+      const content = fs14.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       return pkg.version ?? null;
     }
@@ -35734,8 +35735,8 @@ function getPackageVersion(dir) {
 function getChangelogVersion(dir) {
   try {
     const changelogPath = path25.join(dir, "CHANGELOG.md");
-    if (fs13.existsSync(changelogPath)) {
-      const content = fs13.readFileSync(changelogPath, "utf-8");
+    if (fs14.existsSync(changelogPath)) {
+      const content = fs14.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
       if (match) {
         return match[1];
@@ -35748,9 +35749,9 @@ function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
     const filePath = path25.join(dir, file3);
-    if (fs13.existsSync(filePath)) {
+    if (fs14.existsSync(filePath)) {
       try {
-        const content = fs13.readFileSync(filePath, "utf-8").trim();
+        const content = fs14.readFileSync(filePath, "utf-8").trim();
         const match = content.match(/(\d+\.\d+\.\d+)/);
         if (match) {
           return match[1];
@@ -36272,7 +36273,7 @@ __export(exports_gate_evidence, {
   deriveRequiredGates: () => deriveRequiredGates,
   DEFAULT_REQUIRED_GATES: () => DEFAULT_REQUIRED_GATES
 });
-import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync9, unlinkSync as unlinkSync5 } from "fs";
+import { mkdirSync as mkdirSync9, readFileSync as readFileSync14, renameSync as renameSync8, unlinkSync as unlinkSync5 } from "fs";
 import * as path30 from "path";
 function isValidTaskId2(taskId) {
   if (!taskId)
@@ -36337,7 +36338,7 @@ async function atomicWrite(targetPath, content) {
   const tempPath = `${targetPath}.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`;
   try {
     await Bun.write(tempPath, content);
-    renameSync9(tempPath, targetPath);
+    renameSync8(tempPath, targetPath);
   } finally {
     try {
       unlinkSync5(tempPath);
@@ -43107,7 +43108,7 @@ function resetAutomationManager() {
 // src/background/plan-sync-worker.ts
 init_manager2();
 init_utils();
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as path7 from "path";
 
 class PlanSyncWorker {
@@ -43191,7 +43192,7 @@ class PlanSyncWorker {
   }
   initializeStat() {
     try {
-      const stats = fs4.statSync(this.getPlanJsonPath());
+      const stats = fs5.statSync(this.getPlanJsonPath());
       this.lastStat = { mtimeMs: stats.mtimeMs, size: stats.size };
     } catch {
       this.lastStat = null;
@@ -43200,11 +43201,11 @@ class PlanSyncWorker {
   setupNativeWatcher() {
     const swarmDir = this.getSwarmDir();
     try {
-      if (!fs4.existsSync(swarmDir)) {
+      if (!fs5.existsSync(swarmDir)) {
         log("[PlanSyncWorker] Swarm directory does not exist yet");
         return false;
       }
-      this.watcher = fs4.watch(swarmDir, { persistent: false }, (_eventType, filename) => {
+      this.watcher = fs5.watch(swarmDir, { persistent: false }, (_eventType, filename) => {
         if (this.disposed || this.status !== "running") {
           return;
         }
@@ -43251,14 +43252,14 @@ class PlanSyncWorker {
   pollCheck() {
     try {
       const planPath = this.getPlanJsonPath();
-      if (!fs4.existsSync(planPath)) {
+      if (!fs5.existsSync(planPath)) {
         if (this.lastStat !== null) {
           this.lastStat = null;
           log("[PlanSyncWorker] plan.json deleted");
         }
         return;
       }
-      const stats = fs4.statSync(planPath);
+      const stats = fs5.statSync(planPath);
       const currentStat = { mtimeMs: stats.mtimeMs, size: stats.size };
       if (this.lastStat === null || currentStat.mtimeMs !== this.lastStat.mtimeMs || currentStat.size !== this.lastStat.size) {
         this.lastStat = currentStat;
@@ -43350,9 +43351,9 @@ class PlanSyncWorker {
       const swarmDir = this.getSwarmDir();
       const planJsonPath = path7.join(swarmDir, "plan.json");
       const markerPath = path7.join(swarmDir, ".plan-write-marker");
-      const planStats = fs4.statSync(planJsonPath);
+      const planStats = fs5.statSync(planJsonPath);
       const planMtimeMs = planStats.mtimeMs;
-      const markerContent = fs4.readFileSync(markerPath, "utf8");
+      const markerContent = fs5.readFileSync(markerPath, "utf8");
       const marker = JSON.parse(markerContent);
       const markerTimestampMs = new Date(marker.timestamp).getTime();
       if (planMtimeMs > markerTimestampMs + 5000) {
@@ -43978,7 +43979,7 @@ import path14 from "path";
 
 // src/hooks/curator.ts
 init_event_bus();
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path12 from "path";
 
 // src/hooks/knowledge-store.ts
@@ -44158,10 +44159,10 @@ async function readCuratorSummary(directory) {
 }
 async function writeCuratorSummary(directory, summary) {
   const resolvedPath = validateSwarmPath(directory, "curator-summary.json");
-  fs7.mkdirSync(path12.dirname(resolvedPath), { recursive: true });
+  fs8.mkdirSync(path12.dirname(resolvedPath), { recursive: true });
   const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
   await Bun.write(tempPath, JSON.stringify(summary, null, 2));
-  fs7.renameSync(tempPath, resolvedPath);
+  fs8.renameSync(tempPath, resolvedPath);
 }
 function normalizeAgentName(name2) {
   return name2.toLowerCase().replace(/^(mega|paid|local|lowtier|modelrelay)_/, "");
@@ -46517,7 +46518,7 @@ async function handleExportCommand(directory, _args) {
 // src/commands/handoff.ts
 init_utils2();
 import crypto3 from "crypto";
-import { renameSync as renameSync6 } from "fs";
+import { renameSync as renameSync5 } from "fs";
 
 // src/services/handoff-service.ts
 init_utils2();
@@ -46818,7 +46819,7 @@ function formatHandoffMarkdown(data) {
 
 // src/session/snapshot-writer.ts
 init_utils2();
-import { mkdirSync as mkdirSync7, renameSync as renameSync5 } from "fs";
+import { mkdirSync as mkdirSync7, renameSync as renameSync4 } from "fs";
 import * as path19 from "path";
 var pendingWrite = null;
 var lastWritePromise = Promise.resolve();
@@ -46909,7 +46910,7 @@ async function writeSnapshot(directory, state) {
     mkdirSync7(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await Bun.write(tempPath, content);
-    renameSync5(tempPath, resolvedPath);
+    renameSync4(tempPath, resolvedPath);
   } catch (error93) {
     if (process.env.DEBUG_SWARM) {
       console.warn("[snapshot-writer] write failed:", error93 instanceof Error ? error93.message : String(error93));
@@ -46943,7 +46944,7 @@ async function handleHandoffCommand(directory, _args) {
   const resolvedPath = validateSwarmPath(directory, "handoff.md");
   const tempPath = `${resolvedPath}.tmp.${crypto3.randomUUID()}`;
   await Bun.write(tempPath, markdown);
-  renameSync6(tempPath, resolvedPath);
+  renameSync5(tempPath, resolvedPath);
   await writeSnapshot(directory, swarmState);
   await flushPendingSnapshot(directory);
   return `## Handoff Brief Written
@@ -47597,7 +47598,7 @@ async function handlePromoteCommand(directory, args2) {
 }
 
 // src/commands/reset.ts
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 init_utils2();
 async function handleResetCommand(directory, args2) {
   const hasConfirm = args2.includes("--confirm");
@@ -47618,8 +47619,8 @@ async function handleResetCommand(directory, args2) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs14.existsSync(resolvedPath)) {
-        fs14.unlinkSync(resolvedPath);
+      if (fs15.existsSync(resolvedPath)) {
+        fs15.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -47636,8 +47637,8 @@ async function handleResetCommand(directory, args2) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs14.existsSync(summariesPath)) {
-      fs14.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs15.existsSync(summariesPath)) {
+      fs15.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -47657,13 +47658,13 @@ async function handleResetCommand(directory, args2) {
 
 // src/commands/reset-session.ts
 init_utils2();
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
     const statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs15.existsSync(statePath)) {
-      fs15.unlinkSync(statePath);
+    if (fs16.existsSync(statePath)) {
+      fs16.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -47689,7 +47690,7 @@ async function handleResetSessionCommand(directory, _args) {
 // src/summaries/manager.ts
 init_utils2();
 init_utils();
-import { mkdirSync as mkdirSync8, readdirSync as readdirSync7, renameSync as renameSync7, rmSync as rmSync3, statSync as statSync7 } from "fs";
+import { mkdirSync as mkdirSync8, readdirSync as readdirSync7, renameSync as renameSync6, rmSync as rmSync3, statSync as statSync7 } from "fs";
 import * as path26 from "path";
 var SUMMARY_ID_REGEX = /^S\d+$/;
 function sanitizeSummaryId(id) {
@@ -47733,7 +47734,7 @@ async function storeSummary(directory, id, fullOutput, summaryText, maxStoredByt
   const tempPath = path26.join(summaryDir, `${sanitizedId}.json.tmp.${Date.now()}.${process.pid}`);
   try {
     await Bun.write(tempPath, entryJson);
-    renameSync7(tempPath, summaryPath);
+    renameSync6(tempPath, summaryPath);
   } catch (error93) {
     try {
       rmSync3(tempPath, { force: true });
@@ -47796,18 +47797,18 @@ ${error93 instanceof Error ? error93.message : String(error93)}`;
 
 // src/commands/rollback.ts
 init_utils2();
-import * as fs16 from "fs";
+import * as fs17 from "fs";
 import * as path27 from "path";
 async function handleRollbackCommand(directory, args2) {
   const phaseArg = args2[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs16.existsSync(manifestPath2)) {
+    if (!fs17.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs16.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs17.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -47829,12 +47830,12 @@ async function handleRollbackCommand(directory, args2) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs16.existsSync(manifestPath)) {
+  if (!fs17.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs16.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs17.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -47844,10 +47845,10 @@ async function handleRollbackCommand(directory, args2) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs16.existsSync(checkpointDir)) {
+  if (!fs17.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs16.readdirSync(checkpointDir);
+  const checkpointFiles = fs17.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -47858,7 +47859,7 @@ async function handleRollbackCommand(directory, args2) {
     const src = path27.join(checkpointDir, file3);
     const dest = path27.join(swarmDir, file3);
     try {
-      fs16.cpSync(src, dest, { recursive: true, force: true });
+      fs17.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
     } catch (error93) {
       failures.push({ file: file3, error: error93.message });
@@ -47875,7 +47876,7 @@ async function handleRollbackCommand(directory, args2) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs16.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs17.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error93) {
     console.error("Failed to write rollback event:", error93);
@@ -47918,11 +47919,11 @@ async function handleSimulateCommand(directory, args2) {
   ];
   const report = reportLines.filter(Boolean).join(`
 `);
-  const fs17 = await import("fs/promises");
+  const fs18 = await import("fs/promises");
   const path28 = await import("path");
   const reportPath = path28.join(directory, ".swarm", "simulate-report.md");
-  await fs17.mkdir(path28.dirname(reportPath), { recursive: true });
-  await fs17.writeFile(reportPath, report, "utf-8");
+  await fs18.mkdir(path28.dirname(reportPath), { recursive: true });
+  await fs18.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
 
@@ -48279,7 +48280,7 @@ init_utils2();
 init_manager2();
 
 // src/services/compaction-service.ts
-import * as fs17 from "fs";
+import * as fs18 from "fs";
 import * as path28 from "path";
 function makeInitialState() {
   return {
@@ -48301,7 +48302,7 @@ function appendSnapshot(directory, tier, budgetPct, message) {
 ## [${tier.toUpperCase()}] ${timestamp} \u2014 ${budgetPct.toFixed(1)}% used
 ${message}
 `;
-    fs17.appendFileSync(snapshotPath, entry, "utf-8");
+    fs18.appendFileSync(snapshotPath, entry, "utf-8");
   } catch {}
 }
 function buildObservationMessage(budgetPct) {
@@ -49275,7 +49276,7 @@ init_constants();
 init_schema();
 
 // src/hooks/agent-activity.ts
-import { renameSync as renameSync8, unlinkSync as unlinkSync4 } from "fs";
+import { renameSync as renameSync7, unlinkSync as unlinkSync4 } from "fs";
 init_utils();
 init_utils2();
 function createAgentActivityHooks(config3, directory) {
@@ -49349,7 +49350,7 @@ async function doFlush(directory) {
     const tempPath = `${path29}.tmp`;
     try {
       await Bun.write(tempPath, updated);
-      renameSync8(tempPath, path29);
+      renameSync7(tempPath, path29);
     } catch (writeError) {
       try {
         unlinkSync4(tempPath);
@@ -49398,7 +49399,7 @@ ${content.substring(endIndex + 1)}`;
 }
 // src/hooks/compaction-customizer.ts
 init_manager2();
-import * as fs18 from "fs";
+import * as fs19 from "fs";
 import { join as join25 } from "path";
 init_utils2();
 function createCompactionCustomizerHook(config3, directory) {
@@ -49446,7 +49447,7 @@ function createCompactionCustomizerHook(config3, directory) {
       }
       try {
         const summariesDir = join25(directory, ".swarm", "summaries");
-        const files = await fs18.promises.readdir(summariesDir);
+        const files = await fs19.promises.readdir(summariesDir);
         if (files.length > 0) {
           const count = files.length;
           output.context.push(`[CONTEXT OPTIMIZATION] Tool outputs from earlier in this session have been stored to disk. When compacting, replace any large tool output blocks (bash, test_runner, lint, diff results) with a one-line reference: "[Output stored \u2014 use /swarm retrieve to access full content]". Preserve the tool name, exit status, and any error messages. Discard raw output lines.`);
@@ -49931,7 +49932,7 @@ function maskToolOutput(msg, _threshold) {
 }
 // src/hooks/delegation-gate.ts
 init_schema();
-import * as fs19 from "fs";
+import * as fs20 from "fs";
 import * as path31 from "path";
 
 // src/hooks/guardrails.ts
@@ -50876,7 +50877,7 @@ async function getEvidenceTaskId(session, directory) {
     if (!resolvedPlanPath.startsWith(resolvedDirectory + path31.sep) && resolvedPlanPath !== resolvedDirectory) {
       return null;
     }
-    const planContent = await fs19.promises.readFile(resolvedPlanPath, "utf-8");
+    const planContent = await fs20.promises.readFile(resolvedPlanPath, "utf-8");
     const plan = JSON.parse(planContent);
     if (!plan || !Array.isArray(plan.phases)) {
       return null;
@@ -51349,7 +51350,7 @@ ${warningLines.join(`
 }
 // src/hooks/delegation-sanitizer.ts
 init_utils2();
-import * as fs20 from "fs";
+import * as fs21 from "fs";
 var SANITIZATION_PATTERNS = [
   /\b\d+(st|nd|rd|th)\s+(attempt|try|time)\b/gi,
   /\b(5th|fifth|final|last)\s+attempt\b/gi,
@@ -51420,7 +51421,7 @@ function createDelegationSanitizerHook(directory) {
               stripped_patterns: result.stripped,
               timestamp: new Date().toISOString()
             };
-            fs20.appendFileSync(eventsPath, `${JSON.stringify(event)}
+            fs21.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
           } catch {}
         }
@@ -51677,12 +51678,12 @@ init_schema();
 init_manager();
 init_detector();
 init_manager2();
-import * as fs22 from "fs";
+import * as fs23 from "fs";
 
 // src/services/decision-drift-analyzer.ts
 init_utils2();
 init_manager2();
-import * as fs21 from "fs";
+import * as fs22 from "fs";
 import * as path33 from "path";
 var DEFAULT_DRIFT_CONFIG = {
   staleThresholdPhases: 1,
@@ -51840,8 +51841,8 @@ async function analyzeDecisionDrift(directory, config3 = {}) {
     const contextPath = path33.join(directory, ".swarm", "context.md");
     let contextContent = "";
     try {
-      if (fs21.existsSync(contextPath)) {
-        contextContent = fs21.readFileSync(contextPath, "utf-8");
+      if (fs22.existsSync(contextPath)) {
+        contextContent = fs22.readFileSync(contextPath, "utf-8");
       }
     } catch {
       return {
@@ -52335,11 +52336,11 @@ function createSystemEnhancerHook(config3, directory) {
               if (handoffContent) {
                 const handoffPath = validateSwarmPath(directory, "handoff.md");
                 const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-                if (fs22.existsSync(consumedPath)) {
+                if (fs23.existsSync(consumedPath)) {
                   warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                  fs22.unlinkSync(consumedPath);
+                  fs23.unlinkSync(consumedPath);
                 }
-                fs22.renameSync(handoffPath, consumedPath);
+                fs23.renameSync(handoffPath, consumedPath);
                 const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -52619,11 +52620,11 @@ ${budgetWarning}`);
             if (handoffContent) {
               const handoffPath = validateSwarmPath(directory, "handoff.md");
               const consumedPath = validateSwarmPath(directory, "handoff-consumed.md");
-              if (fs22.existsSync(consumedPath)) {
+              if (fs23.existsSync(consumedPath)) {
                 warn("Duplicate handoff detected: handoff-consumed.md already exists");
-                fs22.unlinkSync(consumedPath);
+                fs23.unlinkSync(consumedPath);
               }
-              fs22.renameSync(handoffPath, consumedPath);
+              fs23.renameSync(handoffPath, consumedPath);
               const handoffBlock = `## HANDOFF \u2014 Resuming from model switch
 The previous model's session ended. Here is your starting context:
 
@@ -53392,7 +53393,7 @@ function isReadTool(toolName) {
 }
 
 // src/hooks/incremental-verify.ts
-import * as fs23 from "fs";
+import * as fs24 from "fs";
 import * as path34 from "path";
 
 // src/hooks/spawn-helper.ts
@@ -53468,21 +53469,21 @@ function spawnAsync(command, cwd, timeoutMs) {
 // src/hooks/incremental-verify.ts
 var emittedSkipAdvisories = new Set;
 function detectPackageManager(projectDir) {
-  if (fs23.existsSync(path34.join(projectDir, "bun.lockb")))
+  if (fs24.existsSync(path34.join(projectDir, "bun.lockb")))
     return "bun";
-  if (fs23.existsSync(path34.join(projectDir, "pnpm-lock.yaml")))
+  if (fs24.existsSync(path34.join(projectDir, "pnpm-lock.yaml")))
     return "pnpm";
-  if (fs23.existsSync(path34.join(projectDir, "yarn.lock")))
+  if (fs24.existsSync(path34.join(projectDir, "yarn.lock")))
     return "yarn";
-  if (fs23.existsSync(path34.join(projectDir, "package-lock.json")))
+  if (fs24.existsSync(path34.join(projectDir, "package-lock.json")))
     return "npm";
   return "bun";
 }
 function detectTypecheckCommand(projectDir) {
   const pkgPath = path34.join(projectDir, "package.json");
-  if (fs23.existsSync(pkgPath)) {
+  if (fs24.existsSync(pkgPath)) {
     try {
-      const pkg = JSON.parse(fs23.readFileSync(pkgPath, "utf8"));
+      const pkg = JSON.parse(fs24.readFileSync(pkgPath, "utf8"));
       const scripts = pkg.scripts;
       if (scripts?.typecheck) {
         const pm = detectPackageManager(projectDir);
@@ -53496,8 +53497,8 @@ function detectTypecheckCommand(projectDir) {
         ...pkg.dependencies,
         ...pkg.devDependencies
       };
-      if (!deps?.typescript && !fs23.existsSync(path34.join(projectDir, "tsconfig.json"))) {}
-      const hasTSMarkers = deps?.typescript || fs23.existsSync(path34.join(projectDir, "tsconfig.json"));
+      if (!deps?.typescript && !fs24.existsSync(path34.join(projectDir, "tsconfig.json"))) {}
+      const hasTSMarkers = deps?.typescript || fs24.existsSync(path34.join(projectDir, "tsconfig.json"));
       if (hasTSMarkers) {
         return { command: ["npx", "tsc", "--noEmit"], language: "typescript" };
       }
@@ -53505,17 +53506,17 @@ function detectTypecheckCommand(projectDir) {
       return null;
     }
   }
-  if (fs23.existsSync(path34.join(projectDir, "go.mod"))) {
+  if (fs24.existsSync(path34.join(projectDir, "go.mod"))) {
     return { command: ["go", "vet", "./..."], language: "go" };
   }
-  if (fs23.existsSync(path34.join(projectDir, "Cargo.toml"))) {
+  if (fs24.existsSync(path34.join(projectDir, "Cargo.toml"))) {
     return { command: ["cargo", "check"], language: "rust" };
   }
-  if (fs23.existsSync(path34.join(projectDir, "pyproject.toml")) || fs23.existsSync(path34.join(projectDir, "requirements.txt")) || fs23.existsSync(path34.join(projectDir, "setup.py"))) {
+  if (fs24.existsSync(path34.join(projectDir, "pyproject.toml")) || fs24.existsSync(path34.join(projectDir, "requirements.txt")) || fs24.existsSync(path34.join(projectDir, "setup.py"))) {
     return { command: null, language: "python" };
   }
   try {
-    const entries = fs23.readdirSync(projectDir);
+    const entries = fs24.readdirSync(projectDir);
     if (entries.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       return {
         command: ["dotnet", "build", "--no-restore"],
@@ -54209,12 +54210,12 @@ Use this data to avoid repeating known failure patterns.`;
 // src/hooks/curator-drift.ts
 init_event_bus();
 init_utils2();
-import * as fs24 from "fs";
+import * as fs25 from "fs";
 import * as path36 from "path";
 var DRIFT_REPORT_PREFIX = "drift-report-phase-";
 async function readPriorDriftReports(directory) {
   const swarmDir = path36.join(directory, ".swarm");
-  const entries = await fs24.promises.readdir(swarmDir).catch(() => null);
+  const entries = await fs25.promises.readdir(swarmDir).catch(() => null);
   if (entries === null)
     return [];
   const reportFiles = entries.filter((name2) => name2.startsWith(DRIFT_REPORT_PREFIX) && name2.endsWith(".json")).sort();
@@ -54241,9 +54242,9 @@ async function writeDriftReport(directory, report) {
   const filename = `${DRIFT_REPORT_PREFIX}${report.phase}.json`;
   const filePath = validateSwarmPath(directory, filename);
   const swarmDir = path36.dirname(filePath);
-  await fs24.promises.mkdir(swarmDir, { recursive: true });
+  await fs25.promises.mkdir(swarmDir, { recursive: true });
   try {
-    await fs24.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
+    await fs25.promises.writeFile(filePath, JSON.stringify(report, null, 2), "utf-8");
   } catch (err2) {
     throw new Error(`[curator-drift] Failed to write drift report to ${filePath}: ${String(err2)}`);
   }
@@ -54634,7 +54635,7 @@ function createSelfReviewHook(config3, injectAdvisory) {
 }
 
 // src/hooks/slop-detector.ts
-import * as fs25 from "fs";
+import * as fs26 from "fs";
 import * as path38 from "path";
 var WRITE_EDIT_TOOLS = new Set([
   "write",
@@ -54680,7 +54681,7 @@ function checkBoilerplateExplosion(content, taskDescription, threshold) {
 function walkFiles(dir, exts, deadline) {
   const results = [];
   try {
-    for (const entry of fs25.readdirSync(dir, { withFileTypes: true })) {
+    for (const entry of fs26.readdirSync(dir, { withFileTypes: true })) {
       if (deadline !== undefined && Date.now() > deadline)
         break;
       if (entry.isSymbolicLink())
@@ -54700,7 +54701,7 @@ function walkFiles(dir, exts, deadline) {
   return results;
 }
 function checkDeadExports(content, projectDir, startTime) {
-  const hasPackageJson = fs25.existsSync(path38.join(projectDir, "package.json"));
+  const hasPackageJson = fs26.existsSync(path38.join(projectDir, "package.json"));
   if (!hasPackageJson)
     return null;
   const exportMatches = content.matchAll(/^\+(?:export)\s+(?:function|class|const|type|interface)\s+(\w{3,})/gm);
@@ -54723,7 +54724,7 @@ function checkDeadExports(content, projectDir, startTime) {
         if (found || Date.now() - startTime > 480)
           break;
         try {
-          const text = fs25.readFileSync(file3, "utf-8");
+          const text = fs26.readFileSync(file3, "utf-8");
           if (importPattern.test(text))
             found = true;
           importPattern.lastIndex = 0;
@@ -54856,7 +54857,7 @@ Review before proceeding.`;
 
 // src/hooks/steering-consumed.ts
 init_utils2();
-import * as fs26 from "fs";
+import * as fs27 from "fs";
 function recordSteeringConsumed(directory, directiveId) {
   try {
     const eventsPath = validateSwarmPath(directory, "events.jsonl");
@@ -54865,7 +54866,7 @@ function recordSteeringConsumed(directory, directiveId) {
       directiveId,
       timestamp: new Date().toISOString()
     };
-    fs26.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs27.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch {}
 }
@@ -55259,7 +55260,7 @@ var build_check = createSwarmTool({
 init_dist();
 init_manager();
 init_create_tool();
-import * as fs27 from "fs";
+import * as fs28 from "fs";
 import * as path39 from "path";
 var EVIDENCE_DIR = ".swarm/evidence";
 var TASK_ID_PATTERN2 = /^\d+\.\d+(\.\d+)*$/;
@@ -55283,12 +55284,12 @@ function isPathWithinSwarm(filePath, workspaceRoot) {
   return normalizedPath.startsWith(swarmPath);
 }
 function readEvidenceFile(evidencePath) {
-  if (!fs27.existsSync(evidencePath)) {
+  if (!fs28.existsSync(evidencePath)) {
     return null;
   }
   let content;
   try {
-    content = fs27.readFileSync(evidencePath, "utf-8");
+    content = fs28.readFileSync(evidencePath, "utf-8");
   } catch {
     return null;
   }
@@ -55434,7 +55435,7 @@ init_checkpoint();
 // src/tools/complexity-hotspots.ts
 init_dist();
 init_create_tool();
-import * as fs28 from "fs";
+import * as fs29 from "fs";
 import * as path40 from "path";
 var MAX_FILE_SIZE_BYTES2 = 256 * 1024;
 var DEFAULT_DAYS = 90;
@@ -55564,11 +55565,11 @@ function estimateComplexity(content) {
 }
 function getComplexityForFile(filePath) {
   try {
-    const stat2 = fs28.statSync(filePath);
+    const stat2 = fs29.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES2) {
       return null;
     }
-    const content = fs28.readFileSync(filePath, "utf-8");
+    const content = fs29.readFileSync(filePath, "utf-8");
     return estimateComplexity(content);
   } catch {
     return null;
@@ -55589,7 +55590,7 @@ async function analyzeHotspots(days, topN, extensions, directory) {
   let analyzedFiles = 0;
   for (const [file3, churnCount] of filteredChurn) {
     let fullPath = file3;
-    if (!fs28.existsSync(fullPath)) {
+    if (!fs29.existsSync(fullPath)) {
       fullPath = path40.join(cwd, file3);
     }
     const complexity = getComplexityForFile(fullPath);
@@ -55798,7 +55799,7 @@ var curator_analyze = createSwarmTool({
 });
 // src/tools/declare-scope.ts
 init_tool();
-import * as fs29 from "fs";
+import * as fs30 from "fs";
 import * as path41 from "path";
 init_create_tool();
 function validateTaskIdFormat(taskId) {
@@ -55891,9 +55892,9 @@ async function executeDeclareScope(args2, fallbackDir) {
     }
     const resolvedDir = path41.resolve(normalizedDir);
     try {
-      const realPath = fs29.realpathSync(resolvedDir);
+      const realPath = fs30.realpathSync(resolvedDir);
       const planPath2 = path41.join(realPath, ".swarm", "plan.json");
-      if (!fs29.existsSync(planPath2)) {
+      if (!fs30.existsSync(planPath2)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -55917,7 +55918,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   const directory = normalizedDir || fallbackDir;
   const planPath = path41.resolve(directory, ".swarm", "plan.json");
-  if (!fs29.existsSync(planPath)) {
+  if (!fs30.existsSync(planPath)) {
     return {
       success: false,
       message: "No plan found",
@@ -55926,7 +55927,7 @@ async function executeDeclareScope(args2, fallbackDir) {
   }
   let planContent;
   try {
-    planContent = JSON.parse(fs29.readFileSync(planPath, "utf-8"));
+    planContent = JSON.parse(fs30.readFileSync(planPath, "utf-8"));
   } catch {
     return {
       success: false,
@@ -56152,7 +56153,7 @@ var diff = createSwarmTool({
 init_dist();
 init_schema();
 import * as crypto4 from "crypto";
-import * as fs30 from "fs";
+import * as fs31 from "fs";
 import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
 import * as path42 from "path";
 init_create_tool();
@@ -56253,7 +56254,7 @@ async function scanDocIndex(directory) {
       for (const file3 of existingManifest.files) {
         try {
           const fullPath = path42.join(directory, file3.path);
-          const stat2 = fs30.statSync(fullPath);
+          const stat2 = fs31.statSync(fullPath);
           if (stat2.mtimeMs > new Date(existingManifest.scanned_at).getTime()) {
             cacheValid = false;
             break;
@@ -56271,7 +56272,7 @@ async function scanDocIndex(directory) {
   const discoveredFiles = [];
   let rawEntries;
   try {
-    rawEntries = fs30.readdirSync(directory, { recursive: true });
+    rawEntries = fs31.readdirSync(directory, { recursive: true });
   } catch {
     const manifest2 = {
       schema_version: 1,
@@ -56285,7 +56286,7 @@ async function scanDocIndex(directory) {
     const fullPath = path42.join(directory, entry);
     let stat2;
     try {
-      stat2 = fs30.statSync(fullPath);
+      stat2 = fs31.statSync(fullPath);
     } catch {
       continue;
     }
@@ -56314,7 +56315,7 @@ async function scanDocIndex(directory) {
     }
     let content;
     try {
-      content = fs30.readFileSync(fullPath, "utf-8");
+      content = fs31.readFileSync(fullPath, "utf-8");
     } catch {
       continue;
     }
@@ -56491,7 +56492,7 @@ var doc_scan = createSwarmTool({
     if (force) {
       const manifestPath = path42.join(directory, ".swarm", "doc-manifest.json");
       try {
-        fs30.unlinkSync(manifestPath);
+        fs31.unlinkSync(manifestPath);
       } catch {}
     }
     const { manifest, cached: cached3 } = await scanDocIndex(directory);
@@ -56716,7 +56717,7 @@ Use these as DOMAIN values when delegating to @sme.`;
 // src/tools/evidence-check.ts
 init_dist();
 init_create_tool();
-import * as fs31 from "fs";
+import * as fs32 from "fs";
 import * as path43 from "path";
 var MAX_FILE_SIZE_BYTES3 = 1024 * 1024;
 var MAX_EVIDENCE_FILES = 1000;
@@ -56765,12 +56766,12 @@ function parseCompletedTasks(planContent) {
 }
 function readEvidenceFiles(evidenceDir, _cwd) {
   const evidence = [];
-  if (!fs31.existsSync(evidenceDir) || !fs31.statSync(evidenceDir).isDirectory()) {
+  if (!fs32.existsSync(evidenceDir) || !fs32.statSync(evidenceDir).isDirectory()) {
     return evidence;
   }
   let files;
   try {
-    files = fs31.readdirSync(evidenceDir);
+    files = fs32.readdirSync(evidenceDir);
   } catch {
     return evidence;
   }
@@ -56786,7 +56787,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
       if (!resolvedPath.startsWith(evidenceDirResolved)) {
         continue;
       }
-      const stat2 = fs31.lstatSync(filePath);
+      const stat2 = fs32.lstatSync(filePath);
       if (!stat2.isFile()) {
         continue;
       }
@@ -56795,7 +56796,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let fileStat;
     try {
-      fileStat = fs31.statSync(filePath);
+      fileStat = fs32.statSync(filePath);
       if (fileStat.size > MAX_FILE_SIZE_BYTES3) {
         continue;
       }
@@ -56804,7 +56805,7 @@ function readEvidenceFiles(evidenceDir, _cwd) {
     }
     let content;
     try {
-      content = fs31.readFileSync(filePath, "utf-8");
+      content = fs32.readFileSync(filePath, "utf-8");
     } catch {
       continue;
     }
@@ -56914,7 +56915,7 @@ var evidence_check = createSwarmTool({
     }
     let planContent;
     try {
-      planContent = fs31.readFileSync(planPath, "utf-8");
+      planContent = fs32.readFileSync(planPath, "utf-8");
     } catch {
       const result2 = {
         message: "No completed tasks found in plan.",
@@ -56949,7 +56950,7 @@ var evidence_check = createSwarmTool({
 // src/tools/file-extractor.ts
 init_tool();
 init_create_tool();
-import * as fs32 from "fs";
+import * as fs33 from "fs";
 import * as path44 from "path";
 var EXT_MAP = {
   python: ".py",
@@ -57012,8 +57013,8 @@ var extract_code_blocks = createSwarmTool({
   execute: async (args2, directory) => {
     const { content, output_dir, prefix } = args2;
     const targetDir = output_dir || directory;
-    if (!fs32.existsSync(targetDir)) {
-      fs32.mkdirSync(targetDir, { recursive: true });
+    if (!fs33.existsSync(targetDir)) {
+      fs33.mkdirSync(targetDir, { recursive: true });
     }
     if (!content) {
       return "Error: content is required";
@@ -57035,12 +57036,12 @@ var extract_code_blocks = createSwarmTool({
       const base = path44.basename(filepath, path44.extname(filepath));
       const ext = path44.extname(filepath);
       let counter = 1;
-      while (fs32.existsSync(filepath)) {
+      while (fs33.existsSync(filepath)) {
         filepath = path44.join(targetDir, `${base}_${counter}${ext}`);
         counter++;
       }
       try {
-        fs32.writeFileSync(filepath, code.trim(), "utf-8");
+        fs33.writeFileSync(filepath, code.trim(), "utf-8");
         savedFiles.push(filepath);
       } catch (error93) {
         errors5.push(`Failed to save ${filename}: ${error93 instanceof Error ? error93.message : String(error93)}`);
@@ -57156,7 +57157,7 @@ var gitingest = createSwarmTool({
 // src/tools/imports.ts
 init_dist();
 init_create_tool();
-import * as fs33 from "fs";
+import * as fs34 from "fs";
 import * as path45 from "path";
 var MAX_FILE_PATH_LENGTH2 = 500;
 var MAX_SYMBOL_LENGTH = 256;
@@ -57325,7 +57326,7 @@ var SKIP_DIRECTORIES3 = new Set([
 function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFiles: 0, fileErrors: [] }) {
   let entries;
   try {
-    entries = fs33.readdirSync(dir);
+    entries = fs34.readdirSync(dir);
   } catch (e) {
     stats.fileErrors.push({
       path: dir,
@@ -57342,7 +57343,7 @@ function findSourceFiles(dir, files = [], stats = { skippedDirs: [], skippedFile
     const fullPath = path45.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs33.statSync(fullPath);
+      stat2 = fs34.statSync(fullPath);
     } catch (e) {
       stats.fileErrors.push({
         path: fullPath,
@@ -57411,7 +57412,7 @@ var imports = createSwarmTool({
     }
     try {
       const targetFile = path45.resolve(file3);
-      if (!fs33.existsSync(targetFile)) {
+      if (!fs34.existsSync(targetFile)) {
         const errorResult = {
           error: `target file not found: ${file3}`,
           target: file3,
@@ -57421,7 +57422,7 @@ var imports = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const targetStat = fs33.statSync(targetFile);
+      const targetStat = fs34.statSync(targetFile);
       if (!targetStat.isFile()) {
         const errorResult = {
           error: "target must be a file, not a directory",
@@ -57447,12 +57448,12 @@ var imports = createSwarmTool({
         if (consumers.length >= MAX_CONSUMERS)
           break;
         try {
-          const stat2 = fs33.statSync(filePath);
+          const stat2 = fs34.statSync(filePath);
           if (stat2.size > MAX_FILE_SIZE_BYTES4) {
             skippedFileCount++;
             continue;
           }
-          const buffer = fs33.readFileSync(filePath);
+          const buffer = fs34.readFileSync(filePath);
           if (isBinaryFile2(filePath, buffer)) {
             skippedFileCount++;
             continue;
@@ -58001,7 +58002,7 @@ init_dist();
 init_config();
 init_schema();
 init_manager();
-import * as fs34 from "fs";
+import * as fs35 from "fs";
 import * as path46 from "path";
 init_utils2();
 init_create_tool();
@@ -58261,7 +58262,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (agentsMissing.length > 0) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs34.readFileSync(planPath, "utf-8");
+      const planRaw = fs35.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase && targetPhase.tasks.length > 0 && targetPhase.tasks.every((t) => t.status === "completed")) {
@@ -58292,7 +58293,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   if (phaseCompleteConfig.regression_sweep?.enforce) {
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planRaw = fs34.readFileSync(planPath, "utf-8");
+      const planRaw = fs35.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       const targetPhase = plan.phases.find((p) => p.id === phase);
       if (targetPhase) {
@@ -58330,7 +58331,7 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
   };
   try {
     const eventsPath = validateSwarmPath(dir, "events.jsonl");
-    fs34.appendFileSync(eventsPath, `${JSON.stringify(event)}
+    fs35.appendFileSync(eventsPath, `${JSON.stringify(event)}
 `, "utf-8");
   } catch (writeError) {
     warnings.push(`Warning: failed to write phase complete event: ${writeError instanceof Error ? writeError.message : String(writeError)}`);
@@ -58349,12 +58350,12 @@ async function executePhaseComplete(args2, workingDirectory, directory) {
     }
     try {
       const planPath = validateSwarmPath(dir, "plan.json");
-      const planJson = fs34.readFileSync(planPath, "utf-8");
+      const planJson = fs35.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planJson);
       const phaseObj = plan.phases.find((p) => p.id === phase);
       if (phaseObj) {
         phaseObj.status = "completed";
-        fs34.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
+        fs35.writeFileSync(planPath, `${JSON.stringify(plan, null, 2)}
 `, "utf-8");
       }
     } catch (error93) {
@@ -58408,7 +58409,7 @@ init_dist();
 init_discovery();
 init_utils();
 init_create_tool();
-import * as fs35 from "fs";
+import * as fs36 from "fs";
 import * as path47 from "path";
 var MAX_OUTPUT_BYTES5 = 52428800;
 var AUDIT_TIMEOUT_MS = 120000;
@@ -58427,28 +58428,28 @@ function validateArgs3(args2) {
 function detectEcosystems(directory) {
   const ecosystems = [];
   const cwd = directory;
-  if (fs35.existsSync(path47.join(cwd, "package.json"))) {
+  if (fs36.existsSync(path47.join(cwd, "package.json"))) {
     ecosystems.push("npm");
   }
-  if (fs35.existsSync(path47.join(cwd, "pyproject.toml")) || fs35.existsSync(path47.join(cwd, "requirements.txt"))) {
+  if (fs36.existsSync(path47.join(cwd, "pyproject.toml")) || fs36.existsSync(path47.join(cwd, "requirements.txt"))) {
     ecosystems.push("pip");
   }
-  if (fs35.existsSync(path47.join(cwd, "Cargo.toml"))) {
+  if (fs36.existsSync(path47.join(cwd, "Cargo.toml"))) {
     ecosystems.push("cargo");
   }
-  if (fs35.existsSync(path47.join(cwd, "go.mod"))) {
+  if (fs36.existsSync(path47.join(cwd, "go.mod"))) {
     ecosystems.push("go");
   }
   try {
-    const files = fs35.readdirSync(cwd);
+    const files = fs36.readdirSync(cwd);
     if (files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"))) {
       ecosystems.push("dotnet");
     }
   } catch {}
-  if (fs35.existsSync(path47.join(cwd, "Gemfile")) || fs35.existsSync(path47.join(cwd, "Gemfile.lock"))) {
+  if (fs36.existsSync(path47.join(cwd, "Gemfile")) || fs36.existsSync(path47.join(cwd, "Gemfile.lock"))) {
     ecosystems.push("ruby");
   }
-  if (fs35.existsSync(path47.join(cwd, "pubspec.yaml"))) {
+  if (fs36.existsSync(path47.join(cwd, "pubspec.yaml"))) {
     ecosystems.push("dart");
   }
   return ecosystems;
@@ -59510,7 +59511,7 @@ var SUPPORTED_PARSER_EXTENSIONS = new Set([
 ]);
 // src/tools/pre-check-batch.ts
 init_dist();
-import * as fs38 from "fs";
+import * as fs39 from "fs";
 import * as path50 from "path";
 
 // node_modules/yocto-queue/index.js
@@ -59679,7 +59680,7 @@ init_lint();
 init_manager();
 
 // src/quality/metrics.ts
-import * as fs36 from "fs";
+import * as fs37 from "fs";
 import * as path48 from "path";
 var MAX_FILE_SIZE_BYTES5 = 256 * 1024;
 var MIN_DUPLICATION_LINES = 10;
@@ -59718,11 +59719,11 @@ function estimateCyclomaticComplexity(content) {
 }
 function getComplexityForFile2(filePath) {
   try {
-    const stat2 = fs36.statSync(filePath);
+    const stat2 = fs37.statSync(filePath);
     if (stat2.size > MAX_FILE_SIZE_BYTES5) {
       return null;
     }
-    const content = fs36.readFileSync(filePath, "utf-8");
+    const content = fs37.readFileSync(filePath, "utf-8");
     return estimateCyclomaticComplexity(content);
   } catch {
     return null;
@@ -59733,7 +59734,7 @@ async function computeComplexityDelta(files, workingDir) {
   const analyzedFiles = [];
   for (const file3 of files) {
     const fullPath = path48.isAbsolute(file3) ? file3 : path48.join(workingDir, file3);
-    if (!fs36.existsSync(fullPath)) {
+    if (!fs37.existsSync(fullPath)) {
       continue;
     }
     const complexity = getComplexityForFile2(fullPath);
@@ -59854,7 +59855,7 @@ function countGoExports(content) {
 }
 function getExportCountForFile(filePath) {
   try {
-    const content = fs36.readFileSync(filePath, "utf-8");
+    const content = fs37.readFileSync(filePath, "utf-8");
     const ext = path48.extname(filePath).toLowerCase();
     switch (ext) {
       case ".ts":
@@ -59882,7 +59883,7 @@ async function computePublicApiDelta(files, workingDir) {
   const analyzedFiles = [];
   for (const file3 of files) {
     const fullPath = path48.isAbsolute(file3) ? file3 : path48.join(workingDir, file3);
-    if (!fs36.existsSync(fullPath)) {
+    if (!fs37.existsSync(fullPath)) {
       continue;
     }
     const exports = getExportCountForFile(fullPath);
@@ -59916,15 +59917,15 @@ async function computeDuplicationRatio(files, workingDir) {
   const analyzedFiles = [];
   for (const file3 of files) {
     const fullPath = path48.isAbsolute(file3) ? file3 : path48.join(workingDir, file3);
-    if (!fs36.existsSync(fullPath)) {
+    if (!fs37.existsSync(fullPath)) {
       continue;
     }
     try {
-      const stat2 = fs36.statSync(fullPath);
+      const stat2 = fs37.statSync(fullPath);
       if (stat2.size > MAX_FILE_SIZE_BYTES5) {
         continue;
       }
-      const content = fs36.readFileSync(fullPath, "utf-8");
+      const content = fs37.readFileSync(fullPath, "utf-8");
       const lines = content.split(`
 `).filter((line) => line.trim().length > 0);
       if (lines.length < MIN_DUPLICATION_LINES) {
@@ -60100,7 +60101,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   let testLines = 0;
   let codeLines = 0;
   const srcDir = path48.join(workingDir, "src");
-  if (fs36.existsSync(srcDir)) {
+  if (fs37.existsSync(srcDir)) {
     await scanDirectoryForLines(srcDir, enforceGlobs, excludeGlobs, false, (lines) => {
       codeLines += lines;
     });
@@ -60108,14 +60109,14 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   const possibleSrcDirs = ["lib", "app", "source", "core"];
   for (const dir of possibleSrcDirs) {
     const dirPath = path48.join(workingDir, dir);
-    if (fs36.existsSync(dirPath)) {
+    if (fs37.existsSync(dirPath)) {
       await scanDirectoryForLines(dirPath, enforceGlobs, excludeGlobs, false, (lines) => {
         codeLines += lines;
       });
     }
   }
   const testsDir = path48.join(workingDir, "tests");
-  if (fs36.existsSync(testsDir)) {
+  if (fs37.existsSync(testsDir)) {
     await scanDirectoryForLines(testsDir, ["**"], ["node_modules", "dist"], true, (lines) => {
       testLines += lines;
     });
@@ -60123,7 +60124,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
   const possibleTestDirs = ["test", "__tests__", "specs"];
   for (const dir of possibleTestDirs) {
     const dirPath = path48.join(workingDir, dir);
-    if (fs36.existsSync(dirPath) && dirPath !== testsDir) {
+    if (fs37.existsSync(dirPath) && dirPath !== testsDir) {
       await scanDirectoryForLines(dirPath, ["**"], ["node_modules", "dist"], true, (lines) => {
         testLines += lines;
       });
@@ -60135,7 +60136,7 @@ async function computeTestToCodeRatio(workingDir, enforceGlobs, excludeGlobs) {
 }
 async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTestScan, callback) {
   try {
-    const entries = fs36.readdirSync(dirPath, { withFileTypes: true });
+    const entries = fs37.readdirSync(dirPath, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path48.join(dirPath, entry.name);
       if (entry.isDirectory()) {
@@ -60181,7 +60182,7 @@ async function scanDirectoryForLines(dirPath, includeGlobs, excludeGlobs, isTest
             continue;
         }
         try {
-          const content = fs36.readFileSync(fullPath, "utf-8");
+          const content = fs37.readFileSync(fullPath, "utf-8");
           const lines = countCodeLines(content);
           callback(lines);
         } catch {}
@@ -60395,7 +60396,7 @@ async function qualityBudget(input, directory) {
 init_dist();
 init_manager();
 init_detector();
-import * as fs37 from "fs";
+import * as fs38 from "fs";
 import * as path49 from "path";
 import { extname as extname9 } from "path";
 
@@ -61263,17 +61264,17 @@ var SEVERITY_ORDER = {
 };
 function shouldSkipFile(filePath) {
   try {
-    const stats = fs37.statSync(filePath);
+    const stats = fs38.statSync(filePath);
     if (stats.size > MAX_FILE_SIZE_BYTES6) {
       return { skip: true, reason: "file too large" };
     }
     if (stats.size === 0) {
       return { skip: true, reason: "empty file" };
     }
-    const fd = fs37.openSync(filePath, "r");
+    const fd = fs38.openSync(filePath, "r");
     const buffer = Buffer.alloc(8192);
-    const bytesRead = fs37.readSync(fd, buffer, 0, 8192, 0);
-    fs37.closeSync(fd);
+    const bytesRead = fs38.readSync(fd, buffer, 0, 8192, 0);
+    fs38.closeSync(fd);
     if (bytesRead > 0) {
       let nullCount = 0;
       for (let i2 = 0;i2 < bytesRead; i2++) {
@@ -61312,7 +61313,7 @@ function countBySeverity(findings) {
 }
 function scanFileWithTierA(filePath, language) {
   try {
-    const content = fs37.readFileSync(filePath, "utf-8");
+    const content = fs38.readFileSync(filePath, "utf-8");
     const findings = executeRulesSync(filePath, content, language);
     return findings.map((f) => ({
       rule_id: f.rule_id,
@@ -61360,7 +61361,7 @@ async function sastScan(input, directory, config3) {
       continue;
     }
     const resolvedPath = path49.isAbsolute(filePath) ? filePath : path49.resolve(directory, filePath);
-    if (!fs37.existsSync(resolvedPath)) {
+    if (!fs38.existsSync(resolvedPath)) {
       _filesSkipped++;
       continue;
     }
@@ -61819,7 +61820,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let stat2;
       try {
-        stat2 = fs38.statSync(file3);
+        stat2 = fs39.statSync(file3);
       } catch {
         skippedFiles++;
         continue;
@@ -61830,7 +61831,7 @@ async function runSecretscanWithFiles(files, directory) {
       }
       let content;
       try {
-        const buffer = fs38.readFileSync(file3);
+        const buffer = fs39.readFileSync(file3);
         if (buffer.includes(0)) {
           skippedFiles++;
           continue;
@@ -62250,7 +62251,7 @@ ${paginatedContent}`;
 init_tool();
 init_manager2();
 init_create_tool();
-import * as fs39 from "fs";
+import * as fs40 from "fs";
 import * as path51 from "path";
 function detectPlaceholderContent(args2) {
   const issues = [];
@@ -62362,7 +62363,7 @@ async function executeSavePlan(args2, fallbackDir) {
         phases_count: plan.phases.length,
         tasks_count: tasksCount
       });
-      await fs39.promises.writeFile(markerPath, marker, "utf8");
+      await fs40.promises.writeFile(markerPath, marker, "utf8");
     } catch {}
     return {
       success: true,
@@ -62405,7 +62406,7 @@ var save_plan = createSwarmTool({
 // src/tools/sbom-generate.ts
 init_dist();
 init_manager();
-import * as fs40 from "fs";
+import * as fs41 from "fs";
 import * as path52 from "path";
 
 // src/sbom/detectors/index.ts
@@ -63252,7 +63253,7 @@ function findManifestFiles(rootDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   function searchDir(dir) {
     try {
-      const entries = fs40.readdirSync(dir, { withFileTypes: true });
+      const entries = fs41.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path52.join(dir, entry.name);
         if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist" || entry.name === "build" || entry.name === "target") {
@@ -63279,7 +63280,7 @@ function findManifestFilesInDirs(directories, workingDir) {
   const patterns = [...new Set(allDetectors.flatMap((d) => d.patterns))];
   for (const dir of directories) {
     try {
-      const entries = fs40.readdirSync(dir, { withFileTypes: true });
+      const entries = fs41.readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
         const fullPath = path52.join(dir, entry.name);
         if (entry.isFile()) {
@@ -63316,7 +63317,7 @@ function getDirectoriesFromChangedFiles(changedFiles, workingDir) {
 }
 function ensureOutputDir(outputDir) {
   try {
-    fs40.mkdirSync(outputDir, { recursive: true });
+    fs41.mkdirSync(outputDir, { recursive: true });
   } catch (error93) {
     if (!error93 || error93.code !== "EEXIST") {
       throw error93;
@@ -63410,10 +63411,10 @@ var sbom_generate = createSwarmTool({
     for (const manifestFile of manifestFiles) {
       try {
         const fullPath = path52.isAbsolute(manifestFile) ? manifestFile : path52.join(workingDir, manifestFile);
-        if (!fs40.existsSync(fullPath)) {
+        if (!fs41.existsSync(fullPath)) {
           continue;
         }
-        const content = fs40.readFileSync(fullPath, "utf-8");
+        const content = fs41.readFileSync(fullPath, "utf-8");
         const components = detectComponents(manifestFile, content);
         processedFiles.push(manifestFile);
         if (components.length > 0) {
@@ -63427,7 +63428,7 @@ var sbom_generate = createSwarmTool({
     const bomJson = serializeCycloneDX(bom);
     const filename = generateSbomFilename();
     const outputPath = path52.join(outputDir, filename);
-    fs40.writeFileSync(outputPath, bomJson, "utf-8");
+    fs41.writeFileSync(outputPath, bomJson, "utf-8");
     const verdict = processedFiles.length > 0 ? "pass" : "pass";
     try {
       const timestamp = new Date().toISOString();
@@ -63469,7 +63470,7 @@ var sbom_generate = createSwarmTool({
 // src/tools/schema-drift.ts
 init_dist();
 init_create_tool();
-import * as fs41 from "fs";
+import * as fs42 from "fs";
 import * as path53 from "path";
 var SPEC_CANDIDATES = [
   "openapi.json",
@@ -63511,19 +63512,19 @@ function discoverSpecFile(cwd, specFileArg) {
     if (!ALLOWED_EXTENSIONS.includes(ext)) {
       throw new Error(`Invalid spec_file: must end in .json, .yaml, or .yml, got ${ext}`);
     }
-    const stats = fs41.statSync(resolvedPath);
+    const stats = fs42.statSync(resolvedPath);
     if (stats.size > MAX_SPEC_SIZE) {
       throw new Error(`Invalid spec_file: file exceeds ${MAX_SPEC_SIZE / 1024 / 1024}MB limit`);
     }
-    if (!fs41.existsSync(resolvedPath)) {
+    if (!fs42.existsSync(resolvedPath)) {
       throw new Error(`Spec file not found: ${resolvedPath}`);
     }
     return resolvedPath;
   }
   for (const candidate of SPEC_CANDIDATES) {
     const candidatePath = path53.resolve(cwd, candidate);
-    if (fs41.existsSync(candidatePath)) {
-      const stats = fs41.statSync(candidatePath);
+    if (fs42.existsSync(candidatePath)) {
+      const stats = fs42.statSync(candidatePath);
       if (stats.size <= MAX_SPEC_SIZE) {
         return candidatePath;
       }
@@ -63532,7 +63533,7 @@ function discoverSpecFile(cwd, specFileArg) {
   return null;
 }
 function parseSpec(specFile) {
-  const content = fs41.readFileSync(specFile, "utf-8");
+  const content = fs42.readFileSync(specFile, "utf-8");
   const ext = path53.extname(specFile).toLowerCase();
   if (ext === ".json") {
     return parseJsonSpec(content);
@@ -63604,7 +63605,7 @@ function extractRoutes(cwd) {
   function walkDir(dir) {
     let entries;
     try {
-      entries = fs41.readdirSync(dir, { withFileTypes: true });
+      entries = fs42.readdirSync(dir, { withFileTypes: true });
     } catch {
       return;
     }
@@ -63637,7 +63638,7 @@ function extractRoutes(cwd) {
 }
 function extractRoutesFromFile(filePath) {
   const routes = [];
-  const content = fs41.readFileSync(filePath, "utf-8");
+  const content = fs42.readFileSync(filePath, "utf-8");
   const lines = content.split(/\r?\n/);
   const expressRegex = /(?:app|router|server|express)\.(get|post|put|patch|delete|options|head)\s*\(\s*['"`]([^'"`]+)['"`]/g;
   const flaskRegex = /@(?:app|blueprint|bp)\.route\s*\(\s*['"]([^'"]+)['"]/g;
@@ -63788,7 +63789,7 @@ init_secretscan();
 // src/tools/symbols.ts
 init_tool();
 init_create_tool();
-import * as fs42 from "fs";
+import * as fs43 from "fs";
 import * as path54 from "path";
 var MAX_FILE_SIZE_BYTES7 = 1024 * 1024;
 var WINDOWS_RESERVED_NAMES = /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(\.|:|$)/i;
@@ -63819,8 +63820,8 @@ function containsWindowsAttacks(str) {
 function isPathInWorkspace(filePath, workspace) {
   try {
     const resolvedPath = path54.resolve(workspace, filePath);
-    const realWorkspace = fs42.realpathSync(workspace);
-    const realResolvedPath = fs42.realpathSync(resolvedPath);
+    const realWorkspace = fs43.realpathSync(workspace);
+    const realResolvedPath = fs43.realpathSync(resolvedPath);
     const relativePath = path54.relative(realWorkspace, realResolvedPath);
     if (relativePath.startsWith("..") || path54.isAbsolute(relativePath)) {
       return false;
@@ -63840,11 +63841,11 @@ function extractTSSymbols(filePath, cwd) {
   }
   let content;
   try {
-    const stats = fs42.statSync(fullPath);
+    const stats = fs43.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs42.readFileSync(fullPath, "utf-8");
+    content = fs43.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -63992,11 +63993,11 @@ function extractPythonSymbols(filePath, cwd) {
   }
   let content;
   try {
-    const stats = fs42.statSync(fullPath);
+    const stats = fs43.statSync(fullPath);
     if (stats.size > MAX_FILE_SIZE_BYTES7) {
       throw new Error(`File too large: ${stats.size} bytes (max: ${MAX_FILE_SIZE_BYTES7})`);
     }
-    content = fs42.readFileSync(fullPath, "utf-8");
+    content = fs43.readFileSync(fullPath, "utf-8");
   } catch {
     return [];
   }
@@ -64140,7 +64141,7 @@ init_test_runner();
 init_dist();
 init_utils();
 init_create_tool();
-import * as fs43 from "fs";
+import * as fs44 from "fs";
 import * as path55 from "path";
 var MAX_TEXT_LENGTH = 200;
 var MAX_FILE_SIZE_BYTES8 = 1024 * 1024;
@@ -64236,7 +64237,7 @@ function isSupportedExtension(filePath) {
 function findSourceFiles2(dir, files = []) {
   let entries;
   try {
-    entries = fs43.readdirSync(dir);
+    entries = fs44.readdirSync(dir);
   } catch {
     return files;
   }
@@ -64248,7 +64249,7 @@ function findSourceFiles2(dir, files = []) {
     const fullPath = path55.join(dir, entry);
     let stat2;
     try {
-      stat2 = fs43.statSync(fullPath);
+      stat2 = fs44.statSync(fullPath);
     } catch {
       continue;
     }
@@ -64341,7 +64342,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const scanPath = resolvedPath;
-    if (!fs43.existsSync(scanPath)) {
+    if (!fs44.existsSync(scanPath)) {
       const errorResult = {
         error: `path not found: ${pathsInput}`,
         total: 0,
@@ -64351,7 +64352,7 @@ var todo_extract = createSwarmTool({
       return JSON.stringify(errorResult, null, 2);
     }
     const filesToScan = [];
-    const stat2 = fs43.statSync(scanPath);
+    const stat2 = fs44.statSync(scanPath);
     if (stat2.isFile()) {
       if (isSupportedExtension(scanPath)) {
         filesToScan.push(scanPath);
@@ -64370,11 +64371,11 @@ var todo_extract = createSwarmTool({
     const allEntries = [];
     for (const filePath of filesToScan) {
       try {
-        const fileStat = fs43.statSync(filePath);
+        const fileStat = fs44.statSync(filePath);
         if (fileStat.size > MAX_FILE_SIZE_BYTES8) {
           continue;
         }
-        const content = fs43.readFileSync(filePath, "utf-8");
+        const content = fs44.readFileSync(filePath, "utf-8");
         const entries = parseTodoComments(content, filePath, tagsSet);
         allEntries.push(...entries);
       } catch {}
@@ -64402,18 +64403,18 @@ var todo_extract = createSwarmTool({
 // src/tools/update-task-status.ts
 init_tool();
 init_schema();
-import * as fs45 from "fs";
+import * as fs46 from "fs";
 import * as path57 from "path";
 
 // src/hooks/diff-scope.ts
-import * as fs44 from "fs";
+import * as fs45 from "fs";
 import * as path56 from "path";
 function getDeclaredScope(taskId, directory) {
   try {
     const planPath = path56.join(directory, ".swarm", "plan.json");
-    if (!fs44.existsSync(planPath))
+    if (!fs45.existsSync(planPath))
       return null;
-    const raw = fs44.readFileSync(planPath, "utf-8");
+    const raw = fs45.readFileSync(planPath, "utf-8");
     const plan = JSON.parse(raw);
     for (const phase of plan.phases ?? []) {
       for (const task of phase.tasks ?? []) {
@@ -64548,7 +64549,7 @@ function checkReviewerGate(taskId, workingDirectory) {
       const resolvedDir2 = workingDirectory;
       try {
         const planPath = path57.join(resolvedDir2, ".swarm", "plan.json");
-        const planRaw = fs45.readFileSync(planPath, "utf-8");
+        const planRaw = fs46.readFileSync(planPath, "utf-8");
         const plan = JSON.parse(planRaw);
         for (const planPhase of plan.phases ?? []) {
           for (const task of planPhase.tasks ?? []) {
@@ -64568,7 +64569,7 @@ function checkReviewerGate(taskId, workingDirectory) {
     const resolvedDir = workingDirectory;
     try {
       const evidencePath = path57.join(resolvedDir, ".swarm", "evidence", `${taskId}.json`);
-      const raw = fs45.readFileSync(evidencePath, "utf-8");
+      const raw = fs46.readFileSync(evidencePath, "utf-8");
       const evidence = JSON.parse(raw);
       if (evidence?.required_gates && Array.isArray(evidence.required_gates) && evidence?.gates) {
         const allGatesMet = evidence.required_gates.every((gate) => evidence.gates[gate] != null);
@@ -64609,7 +64610,7 @@ function checkReviewerGate(taskId, workingDirectory) {
     try {
       const resolvedDir2 = workingDirectory;
       const planPath = path57.join(resolvedDir2, ".swarm", "plan.json");
-      const planRaw = fs45.readFileSync(planPath, "utf-8");
+      const planRaw = fs46.readFileSync(planPath, "utf-8");
       const plan = JSON.parse(planRaw);
       for (const planPhase of plan.phases ?? []) {
         for (const task of planPhase.tasks ?? []) {
@@ -64803,9 +64804,9 @@ async function executeUpdateTaskStatus(args2, fallbackDir) {
     }
     const resolvedDir = path57.resolve(normalizedDir);
     try {
-      const realPath = fs45.realpathSync(resolvedDir);
+      const realPath = fs46.realpathSync(resolvedDir);
       const planPath = path57.join(realPath, ".swarm", "plan.json");
-      if (!fs45.existsSync(planPath)) {
+      if (!fs46.existsSync(planPath)) {
         return {
           success: false,
           message: `Invalid working_directory: plan not found in "${realPath}"`,
@@ -65258,7 +65259,8 @@ var OpenCodeSwarm = async (ctx) => {
     },
     "experimental.chat.messages.transform": composeHandlers(...[
       (input, _output) => {
-        console.error(`[DIAG] messagesTransform START`);
+        if (process.env.DEBUG_SWARM)
+          console.error(`[DIAG] messagesTransform START`);
         const p = input;
         if (p.sessionID) {
           const archAgent = swarmState.activeAgent.get(p.sessionID);
@@ -65282,24 +65284,28 @@ var OpenCodeSwarm = async (ctx) => {
         if (output.messages) {
           output.messages = consolidateSystemMessages(output.messages);
         }
-        console.error(`[DIAG] messagesTransform DONE`);
+        if (process.env.DEBUG_SWARM)
+          console.error(`[DIAG] messagesTransform DONE`);
         return Promise.resolve();
       }
     ].filter((fn) => Boolean(fn))),
     "experimental.chat.system.transform": composeHandlers(...[
       async (input, output) => {
-        console.error(`[DIAG] systemTransform START`);
+        if (process.env.DEBUG_SWARM)
+          console.error(`[DIAG] systemTransform START`);
       },
       systemEnhancerHook["experimental.chat.system.transform"],
       async (_input, _output) => {
-        console.error(`[DIAG] systemTransform enhancer DONE`);
+        if (process.env.DEBUG_SWARM)
+          console.error(`[DIAG] systemTransform enhancer DONE`);
       },
       automationConfig.capabilities?.phase_preflight === true && preflightTriggerManager ? createPhaseMonitorHook(ctx.directory, preflightTriggerManager) : knowledgeConfig.enabled ? createPhaseMonitorHook(ctx.directory) : undefined
     ].filter(Boolean)),
     "experimental.session.compacting": compactionHook["experimental.session.compacting"],
     "command.execute.before": safeHook(commandHandler),
     "tool.execute.before": async (input, output) => {
-      console.error(`[DIAG] toolBefore tool=${input.tool?.replace?.(/^[^:]+[:.]/, "") ?? input.tool} session=${input.sessionID}`);
+      if (process.env.DEBUG_SWARM)
+        console.error(`[DIAG] toolBefore tool=${input.tool?.replace?.(/^[^:]+[:.]/, "") ?? input.tool} session=${input.sessionID}`);
       if (!swarmState.activeAgent.has(input.sessionID)) {
         swarmState.activeAgent.set(input.sessionID, ORCHESTRATOR_NAME);
       }
@@ -65328,47 +65334,43 @@ var OpenCodeSwarm = async (ctx) => {
       await safeHook(activityHooks.toolBefore)(input, output);
     },
     "tool.execute.after": async (input, output) => {
+      const _dbg = !!process.env.DEBUG_SWARM;
       const _toolName = input.tool?.replace?.(/^[^:]+[:.]/, "") ?? input.tool;
-      console.error(`[DIAG] toolAfter START tool=${_toolName} session=${input.sessionID}`);
+      if (_dbg)
+        console.error(`[DIAG] toolAfter START tool=${_toolName} session=${input.sessionID}`);
       const normalizedTool = input.tool.replace(/^[^:]+[:.]/, "");
       const isTaskTool = normalizedTool === "Task" || normalizedTool === "task";
-      if (isTaskTool) {
-        const sessionId = input.sessionID;
-        swarmState.activeAgent.set(sessionId, ORCHESTRATOR_NAME);
-        ensureAgentSession(sessionId, ORCHESTRATOR_NAME);
-        const taskSession = swarmState.agentSessions.get(sessionId);
-        if (taskSession) {
-          taskSession.delegationActive = false;
-          taskSession.lastAgentEventTime = Date.now();
-        }
-        console.error(`[DIAG] Task handoff DONE (early) session=${sessionId} activeAgent=${swarmState.activeAgent.get(sessionId)}`);
-      }
-      const HOOK_CHAIN_TIMEOUT_MS = 30000;
-      const hookChainStart = Date.now();
-      let hookChainTimedOut = false;
       const hookChain = async () => {
         await activityHooks.toolAfter(input, output);
-        console.error(`[DIAG] toolAfter activity done tool=${_toolName}`);
+        if (_dbg)
+          console.error(`[DIAG] toolAfter activity done tool=${_toolName}`);
         await guardrailsHooks.toolAfter(input, output);
-        console.error(`[DIAG] toolAfter guardrails done tool=${_toolName}`);
+        if (_dbg)
+          console.error(`[DIAG] toolAfter guardrails done tool=${_toolName}`);
         await safeHook(delegationLedgerHook.toolAfter)(input, output);
-        console.error(`[DIAG] toolAfter ledger done tool=${_toolName}`);
+        if (_dbg)
+          console.error(`[DIAG] toolAfter ledger done tool=${_toolName}`);
         await safeHook(selfReviewHook.toolAfter)(input, output);
-        console.error(`[DIAG] toolAfter selfReview done tool=${_toolName}`);
+        if (_dbg)
+          console.error(`[DIAG] toolAfter selfReview done tool=${_toolName}`);
         await safeHook(delegationGateHooks.toolAfter)(input, output);
-        console.error(`[DIAG] toolAfter delegationGate done tool=${_toolName}`);
+        if (_dbg)
+          console.error(`[DIAG] toolAfter delegationGate done tool=${_toolName}`);
         if (knowledgeCuratorHook)
           await safeHook(knowledgeCuratorHook)(input, output);
         if (hivePromoterHook)
           await safeHook(hivePromoterHook)(input, output);
-        console.error(`[DIAG] toolAfter knowledge done tool=${_toolName}`);
+        if (_dbg)
+          console.error(`[DIAG] toolAfter knowledge done tool=${_toolName}`);
         await safeHook(steeringConsumedHook)(input, output);
         await safeHook(coChangeSuggesterHook)(input, output);
         await safeHook(darkMatterDetectorHook)(input, output);
-        console.error(`[DIAG] toolAfter intelligence done tool=${_toolName}`);
+        if (_dbg)
+          console.error(`[DIAG] toolAfter intelligence done tool=${_toolName}`);
         await snapshotWriterHook(input, output);
         await toolSummarizerHook?.(input, output);
-        console.error(`[DIAG] toolAfter snapshot+summarizer done tool=${_toolName}`);
+        if (_dbg)
+          console.error(`[DIAG] toolAfter snapshot+summarizer done tool=${_toolName}`);
         const execMode = config3.execution_mode ?? "balanced";
         if (execMode === "strict") {
           if (slopDetectorHook)
@@ -65401,29 +65403,33 @@ var OpenCodeSwarm = async (ctx) => {
           }
         }
       };
-      const timeout = new Promise((resolve23) => {
-        setTimeout(() => {
-          hookChainTimedOut = true;
-          resolve23();
-        }, HOOK_CHAIN_TIMEOUT_MS);
-      });
-      await Promise.race([
-        hookChain().catch((err2) => {
-          console.error(`[DIAG] toolAfter hook chain error tool=${_toolName}: ${err2 instanceof Error ? err2.message : String(err2)}`);
-        }),
-        timeout
-      ]);
-      if (hookChainTimedOut) {
-        const elapsed = Date.now() - hookChainStart;
-        console.error(`[DIAG] toolAfter TIMEOUT after ${elapsed}ms tool=${_toolName} session=${input.sessionID} \u2014 hooks abandoned to prevent session freeze`);
+      try {
+        await hookChain();
+      } catch (err2) {
+        console.warn(`[swarm] toolAfter hook chain error tool=${_toolName}: ${err2 instanceof Error ? err2.message : String(err2)}`);
+      }
+      if (isTaskTool) {
+        const sessionId = input.sessionID;
+        swarmState.activeAgent.set(sessionId, ORCHESTRATOR_NAME);
+        ensureAgentSession(sessionId, ORCHESTRATOR_NAME);
+        const taskSession = swarmState.agentSessions.get(sessionId);
+        if (taskSession) {
+          taskSession.delegationActive = false;
+          taskSession.lastAgentEventTime = Date.now();
+        }
+        if (_dbg)
+          console.error(`[DIAG] Task handoff DONE session=${sessionId} activeAgent=${swarmState.activeAgent.get(sessionId)}`);
       }
       deleteStoredInputArgs(input.callID);
-      console.error(`[DIAG] toolAfter COMPLETE tool=${_toolName}`);
+      if (_dbg)
+        console.error(`[DIAG] toolAfter COMPLETE tool=${_toolName}`);
     },
     "chat.message": safeHook(async (input, output) => {
-      console.error(`[DIAG] chat.message agent=${input.agent ?? "none"} session=${input.sessionID}`);
+      if (process.env.DEBUG_SWARM)
+        console.error(`[DIAG] chat.message agent=${input.agent ?? "none"} session=${input.sessionID}`);
       await delegationHandler(input, output);
-      console.error(`[DIAG] chat.message DONE agent=${input.agent ?? "none"}`);
+      if (process.env.DEBUG_SWARM)
+        console.error(`[DIAG] chat.message DONE agent=${input.agent ?? "none"}`);
     }),
     automation: automationManager
   };