opencode-swarm 6.33.8 → 6.33.9

package/dist/cli/index.js

@@ -14276,7 +14276,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 fs2 from "fs/promises";
 import * as path3 from "path";
 function isValidEvidenceType(type) {
   return VALID_EVIDENCE_TYPES.includes(type);
@@ -14352,7 +14353,7 @@ async function saveEvidence(directory, taskId, evidence) {
   const tempPath = path3.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
   try {
     await Bun.write(tempPath, bundleJson);
-    renameSync(tempPath, evidencePath);
+    await fs2.rename(tempPath, evidencePath);
   } catch (error49) {
     try {
       rmSync(tempPath, { force: true });
@@ -14408,7 +14409,7 @@ async function loadEvidence(directory, taskId) {
       const tempPath = path3.join(evidenceDir, `evidence.json.tmp.${Date.now()}.${process.pid}`);
       try {
         await Bun.write(tempPath, bundleJson);
-        renameSync(tempPath, evidencePath);
+        await fs2.rename(tempPath, evidencePath);
       } catch (writeError) {
         try {
           rmSync(tempPath, { force: true });
@@ -14622,54 +14623,54 @@ var require_polyfills = __commonJS((exports, module) => {
   }
   var chdir;
   module.exports = patch;
-  function patch(fs3) {
+  function patch(fs4) {
     if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-      patchLchmod(fs3);
-    }
-    if (!fs3.lutimes) {
-      patchLutimes(fs3);
-    }
-    fs3.chown = chownFix(fs3.chown);
-    fs3.fchown = chownFix(fs3.fchown);
-    fs3.lchown = chownFix(fs3.lchown);
-    fs3.chmod = chmodFix(fs3.chmod);
-    fs3.fchmod = chmodFix(fs3.fchmod);
-    fs3.lchmod = chmodFix(fs3.lchmod);
-    fs3.chownSync = chownFixSync(fs3.chownSync);
-    fs3.fchownSync = chownFixSync(fs3.fchownSync);
-    fs3.lchownSync = chownFixSync(fs3.lchownSync);
-    fs3.chmodSync = chmodFixSync(fs3.chmodSync);
-    fs3.fchmodSync = chmodFixSync(fs3.fchmodSync);
-    fs3.lchmodSync = chmodFixSync(fs3.lchmodSync);
-    fs3.stat = statFix(fs3.stat);
-    fs3.fstat = statFix(fs3.fstat);
-    fs3.lstat = statFix(fs3.lstat);
-    fs3.statSync = statFixSync(fs3.statSync);
-    fs3.fstatSync = statFixSync(fs3.fstatSync);
-    fs3.lstatSync = statFixSync(fs3.lstatSync);
-    if (fs3.chmod && !fs3.lchmod) {
-      fs3.lchmod = function(path6, mode, cb) {
+      patchLchmod(fs4);
+    }
+    if (!fs4.lutimes) {
+      patchLutimes(fs4);
+    }
+    fs4.chown = chownFix(fs4.chown);
+    fs4.fchown = chownFix(fs4.fchown);
+    fs4.lchown = chownFix(fs4.lchown);
+    fs4.chmod = chmodFix(fs4.chmod);
+    fs4.fchmod = chmodFix(fs4.fchmod);
+    fs4.lchmod = chmodFix(fs4.lchmod);
+    fs4.chownSync = chownFixSync(fs4.chownSync);
+    fs4.fchownSync = chownFixSync(fs4.fchownSync);
+    fs4.lchownSync = chownFixSync(fs4.lchownSync);
+    fs4.chmodSync = chmodFixSync(fs4.chmodSync);
+    fs4.fchmodSync = chmodFixSync(fs4.fchmodSync);
+    fs4.lchmodSync = chmodFixSync(fs4.lchmodSync);
+    fs4.stat = statFix(fs4.stat);
+    fs4.fstat = statFix(fs4.fstat);
+    fs4.lstat = statFix(fs4.lstat);
+    fs4.statSync = statFixSync(fs4.statSync);
+    fs4.fstatSync = statFixSync(fs4.fstatSync);
+    fs4.lstatSync = statFixSync(fs4.lstatSync);
+    if (fs4.chmod && !fs4.lchmod) {
+      fs4.lchmod = function(path6, mode, cb) {
         if (cb)
           process.nextTick(cb);
       };
-      fs3.lchmodSync = function() {};
+      fs4.lchmodSync = function() {};
     }
-    if (fs3.chown && !fs3.lchown) {
-      fs3.lchown = function(path6, uid, gid, cb) {
+    if (fs4.chown && !fs4.lchown) {
+      fs4.lchown = function(path6, uid, gid, cb) {
         if (cb)
           process.nextTick(cb);
       };
-      fs3.lchownSync = function() {};
+      fs4.lchownSync = function() {};
     }
     if (platform === "win32") {
-      fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : function(fs$rename) {
-        function rename(from, to, cb) {
+      fs4.rename = typeof fs4.rename !== "function" ? fs4.rename : function(fs$rename) {
+        function rename2(from, to, cb) {
           var start = 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() - start < 60000) {
               setTimeout(function() {
-                fs3.stat(to, function(stater, st) {
+                fs4.stat(to, function(stater, st) {
                   if (stater && stater.code === "ENOENT")
                     fs$rename(from, to, CB);
                   else
@@ -14685,11 +14686,11 @@ var require_polyfills = __commonJS((exports, module) => {
           });
         }
         if (Object.setPrototypeOf)
-          Object.setPrototypeOf(rename, fs$rename);
-        return rename;
-      }(fs3.rename);
+          Object.setPrototypeOf(rename2, fs$rename);
+        return rename2;
+      }(fs4.rename);
     }
-    fs3.read = typeof fs3.read !== "function" ? fs3.read : function(fs$read) {
+    fs4.read = typeof fs4.read !== "function" ? fs4.read : function(fs$read) {
       function read(fd, buffer, offset, length, position, callback_) {
         var callback;
         if (callback_ && typeof callback_ === "function") {
@@ -14697,23 +14698,23 @@ var require_polyfills = __commonJS((exports, module) => {
           callback = function(er, _, __) {
             if (er && er.code === "EAGAIN" && eagCounter < 10) {
               eagCounter++;
-              return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
+              return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
             }
             callback_.apply(this, arguments);
           };
         }
-        return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
+        return fs$read.call(fs4, fd, buffer, offset, length, position, callback);
       }
       if (Object.setPrototypeOf)
         Object.setPrototypeOf(read, fs$read);
       return read;
-    }(fs3.read);
-    fs3.readSync = typeof fs3.readSync !== "function" ? fs3.readSync : function(fs$readSync) {
+    }(fs4.read);
+    fs4.readSync = typeof fs4.readSync !== "function" ? fs4.readSync : function(fs$readSync) {
       return function(fd, buffer, offset, length, position) {
         var eagCounter = 0;
         while (true) {
           try {
-            return fs$readSync.call(fs3, fd, buffer, offset, length, position);
+            return fs$readSync.call(fs4, fd, buffer, offset, length, position);
           } catch (er) {
             if (er.code === "EAGAIN" && eagCounter < 10) {
               eagCounter++;
@@ -14723,90 +14724,90 @@ var require_polyfills = __commonJS((exports, module) => {
           }
         }
       };
-    }(fs3.readSync);
-    function patchLchmod(fs4) {
-      fs4.lchmod = function(path6, mode, callback) {
-        fs4.open(path6, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
+    }(fs4.readSync);
+    function patchLchmod(fs5) {
+      fs5.lchmod = function(path6, mode, callback) {
+        fs5.open(path6, constants.O_WRONLY | constants.O_SYMLINK, mode, function(err, fd) {
           if (err) {
             if (callback)
               callback(err);
             return;
           }
-          fs4.fchmod(fd, mode, function(err2) {
-            fs4.close(fd, function(err22) {
+          fs5.fchmod(fd, mode, function(err2) {
+            fs5.close(fd, function(err22) {
               if (callback)
                 callback(err2 || err22);
             });
           });
         });
       };
-      fs4.lchmodSync = function(path6, mode) {
-        var fd = fs4.openSync(path6, constants.O_WRONLY | constants.O_SYMLINK, mode);
+      fs5.lchmodSync = function(path6, mode) {
+        var fd = fs5.openSync(path6, constants.O_WRONLY | constants.O_SYMLINK, mode);
         var threw = true;
         var ret;
         try {
-          ret = fs4.fchmodSync(fd, mode);
+          ret = fs5.fchmodSync(fd, mode);
           threw = false;
         } finally {
           if (threw) {
             try {
-              fs4.closeSync(fd);
+              fs5.closeSync(fd);
             } catch (er) {}
           } else {
-            fs4.closeSync(fd);
+            fs5.closeSync(fd);
           }
         }
         return ret;
       };
     }
-    function patchLutimes(fs4) {
-      if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
-        fs4.lutimes = function(path6, at, mt, cb) {
-          fs4.open(path6, constants.O_SYMLINK, function(er, fd) {
+    function patchLutimes(fs5) {
+      if (constants.hasOwnProperty("O_SYMLINK") && fs5.futimes) {
+        fs5.lutimes = function(path6, at, mt, cb) {
+          fs5.open(path6, constants.O_SYMLINK, function(er, fd) {
             if (er) {
               if (cb)
                 cb(er);
               return;
             }
-            fs4.futimes(fd, at, mt, function(er2) {
-              fs4.close(fd, function(er22) {
+            fs5.futimes(fd, at, mt, function(er2) {
+              fs5.close(fd, function(er22) {
                 if (cb)
                   cb(er2 || er22);
               });
             });
           });
         };
-        fs4.lutimesSync = function(path6, at, mt) {
-          var fd = fs4.openSync(path6, constants.O_SYMLINK);
+        fs5.lutimesSync = function(path6, at, mt) {
+          var fd = fs5.openSync(path6, constants.O_SYMLINK);
           var ret;
           var threw = true;
           try {
-            ret = fs4.futimesSync(fd, at, mt);
+            ret = fs5.futimesSync(fd, at, mt);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs4.closeSync(fd);
+                fs5.closeSync(fd);
               } catch (er) {}
             } else {
-              fs4.closeSync(fd);
+              fs5.closeSync(fd);
             }
           }
           return ret;
         };
-      } else if (fs4.futimes) {
-        fs4.lutimes = function(_a2, _b, _c, cb) {
+      } else if (fs5.futimes) {
+        fs5.lutimes = function(_a2, _b, _c, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs4.lutimesSync = function() {};
+        fs5.lutimesSync = function() {};
       }
     }
     function chmodFix(orig) {
       if (!orig)
         return orig;
       return function(target, mode, cb) {
-        return orig.call(fs3, target, mode, function(er) {
+        return orig.call(fs4, target, mode, function(er) {
           if (chownErOk(er))
             er = null;
           if (cb)
@@ -14819,7 +14820,7 @@ var require_polyfills = __commonJS((exports, module) => {
         return orig;
       return function(target, mode) {
         try {
-          return orig.call(fs3, target, mode);
+          return orig.call(fs4, target, mode);
         } catch (er) {
           if (!chownErOk(er))
             throw er;
@@ -14830,7 +14831,7 @@ var require_polyfills = __commonJS((exports, module) => {
       if (!orig)
         return orig;
       return function(target, uid, gid, cb) {
-        return orig.call(fs3, target, uid, gid, function(er) {
+        return orig.call(fs4, target, uid, gid, function(er) {
           if (chownErOk(er))
             er = null;
           if (cb)
@@ -14843,7 +14844,7 @@ var require_polyfills = __commonJS((exports, module) => {
         return orig;
       return function(target, uid, gid) {
         try {
-          return orig.call(fs3, target, uid, gid);
+          return orig.call(fs4, target, uid, gid);
         } catch (er) {
           if (!chownErOk(er))
             throw er;
@@ -14868,14 +14869,14 @@ var require_polyfills = __commonJS((exports, module) => {
           if (cb)
             cb.apply(this, arguments);
         }
-        return options ? orig.call(fs3, target, options, callback) : orig.call(fs3, target, callback);
+        return options ? orig.call(fs4, target, options, callback) : orig.call(fs4, target, callback);
       };
     }
     function statFixSync(orig) {
       if (!orig)
         return orig;
       return function(target, options) {
-        var stats = options ? orig.call(fs3, target, options) : orig.call(fs3, target);
+        var stats = options ? orig.call(fs4, target, options) : orig.call(fs4, target);
         if (stats) {
           if (stats.uid < 0)
             stats.uid += 4294967296;
@@ -14904,7 +14905,7 @@ var require_polyfills = __commonJS((exports, module) => {
 var require_legacy_streams = __commonJS((exports, module) => {
   var Stream = __require("stream").Stream;
   module.exports = legacy;
-  function legacy(fs3) {
+  function legacy(fs4) {
     return {
       ReadStream,
       WriteStream
@@ -14949,7 +14950,7 @@ var require_legacy_streams = __commonJS((exports, module) => {
         });
         return;
       }
-      fs3.open(this.path, this.flags, this.mode, function(err, fd) {
+      fs4.open(this.path, this.flags, this.mode, function(err, fd) {
         if (err) {
           self.emit("error", err);
           self.readable = false;
@@ -14989,7 +14990,7 @@ var require_legacy_streams = __commonJS((exports, module) => {
       this.busy = false;
       this._queue = [];
       if (this.fd === null) {
-        this._open = fs3.open;
+        this._open = fs4.open;
         this._queue.push([this._open, this.path, this.flags, this.mode, undefined]);
         this.flush();
       }
@@ -15019,7 +15020,7 @@ var require_clone = __commonJS((exports, module) => {
 
 // node_modules/graceful-fs/graceful-fs.js
 var require_graceful_fs = __commonJS((exports, module) => {
-  var fs3 = __require("fs");
+  var fs4 = __require("fs");
   var polyfills = require_polyfills();
   var legacy = require_legacy_streams();
   var clone3 = require_clone();
@@ -15051,12 +15052,12 @@ var require_graceful_fs = __commonJS((exports, module) => {
 GFS4: `);
       console.error(m);
     };
-  if (!fs3[gracefulQueue]) {
+  if (!fs4[gracefulQueue]) {
     queue = global[gracefulQueue] || [];
-    publishQueue(fs3, queue);
-    fs3.close = function(fs$close) {
+    publishQueue(fs4, queue);
+    fs4.close = function(fs$close) {
       function close(fd, cb) {
-        return fs$close.call(fs3, fd, function(err) {
+        return fs$close.call(fs4, fd, function(err) {
           if (!err) {
             resetQueue();
           }
@@ -15068,40 +15069,40 @@ GFS4: `);
         value: fs$close
       });
       return close;
-    }(fs3.close);
-    fs3.closeSync = function(fs$closeSync) {
+    }(fs4.close);
+    fs4.closeSync = function(fs$closeSync) {
       function closeSync(fd) {
-        fs$closeSync.apply(fs3, arguments);
+        fs$closeSync.apply(fs4, arguments);
         resetQueue();
       }
       Object.defineProperty(closeSync, previousSymbol, {
         value: fs$closeSync
       });
       return closeSync;
-    }(fs3.closeSync);
+    }(fs4.closeSync);
     if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
       process.on("exit", function() {
-        debug(fs3[gracefulQueue]);
-        __require("assert").equal(fs3[gracefulQueue].length, 0);
+        debug(fs4[gracefulQueue]);
+        __require("assert").equal(fs4[gracefulQueue].length, 0);
       });
     }
   }
   var queue;
   if (!global[gracefulQueue]) {
-    publishQueue(global, fs3[gracefulQueue]);
-  }
-  module.exports = patch(clone3(fs3));
-  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs3.__patched) {
-    module.exports = patch(fs3);
-    fs3.__patched = true;
-  }
-  function patch(fs4) {
-    polyfills(fs4);
-    fs4.gracefulify = patch;
-    fs4.createReadStream = createReadStream;
-    fs4.createWriteStream = createWriteStream;
-    var fs$readFile = fs4.readFile;
-    fs4.readFile = readFile;
+    publishQueue(global, fs4[gracefulQueue]);
+  }
+  module.exports = patch(clone3(fs4));
+  if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs4.__patched) {
+    module.exports = patch(fs4);
+    fs4.__patched = true;
+  }
+  function patch(fs5) {
+    polyfills(fs5);
+    fs5.gracefulify = patch;
+    fs5.createReadStream = createReadStream;
+    fs5.createWriteStream = createWriteStream;
+    var fs$readFile = fs5.readFile;
+    fs5.readFile = readFile;
     function readFile(path6, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
@@ -15117,8 +15118,8 @@ GFS4: `);
         });
       }
     }
-    var fs$writeFile = fs4.writeFile;
-    fs4.writeFile = writeFile;
+    var fs$writeFile = fs5.writeFile;
+    fs5.writeFile = writeFile;
     function writeFile(path6, data, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
@@ -15134,9 +15135,9 @@ GFS4: `);
         });
       }
     }
-    var fs$appendFile = fs4.appendFile;
+    var fs$appendFile = fs5.appendFile;
     if (fs$appendFile)
-      fs4.appendFile = appendFile;
+      fs5.appendFile = appendFile;
     function appendFile(path6, data, options, cb) {
       if (typeof options === "function")
         cb = options, options = null;
@@ -15152,9 +15153,9 @@ GFS4: `);
         });
       }
     }
-    var fs$copyFile = fs4.copyFile;
+    var fs$copyFile = fs5.copyFile;
     if (fs$copyFile)
-      fs4.copyFile = copyFile;
+      fs5.copyFile = copyFile;
     function copyFile(src, dest, flags, cb) {
       if (typeof flags === "function") {
         cb = flags;
@@ -15172,8 +15173,8 @@ GFS4: `);
         });
       }
     }
-    var fs$readdir = fs4.readdir;
-    fs4.readdir = readdir;
+    var fs$readdir = fs5.readdir;
+    fs5.readdir = readdir;
     var noReaddirOptionVersions = /^v[0-5]\./;
     function readdir(path6, options, cb) {
       if (typeof options === "function")
@@ -15204,21 +15205,21 @@ GFS4: `);
       }
     }
     if (process.version.substr(0, 4) === "v0.8") {
-      var legStreams = legacy(fs4);
+      var legStreams = legacy(fs5);
       ReadStream = legStreams.ReadStream;
       WriteStream = legStreams.WriteStream;
     }
-    var fs$ReadStream = fs4.ReadStream;
+    var fs$ReadStream = fs5.ReadStream;
     if (fs$ReadStream) {
       ReadStream.prototype = Object.create(fs$ReadStream.prototype);
       ReadStream.prototype.open = ReadStream$open;
     }
-    var fs$WriteStream = fs4.WriteStream;
+    var fs$WriteStream = fs5.WriteStream;
     if (fs$WriteStream) {
       WriteStream.prototype = Object.create(fs$WriteStream.prototype);
       WriteStream.prototype.open = WriteStream$open;
     }
-    Object.defineProperty(fs4, "ReadStream", {
+    Object.defineProperty(fs5, "ReadStream", {
       get: function() {
         return ReadStream;
       },
@@ -15228,7 +15229,7 @@ GFS4: `);
       enumerable: true,
       configurable: true
     });
-    Object.defineProperty(fs4, "WriteStream", {
+    Object.defineProperty(fs5, "WriteStream", {
       get: function() {
         return WriteStream;
       },
@@ -15239,7 +15240,7 @@ GFS4: `);
       configurable: true
     });
     var FileReadStream = ReadStream;
-    Object.defineProperty(fs4, "FileReadStream", {
+    Object.defineProperty(fs5, "FileReadStream", {
       get: function() {
         return FileReadStream;
       },
@@ -15250,7 +15251,7 @@ GFS4: `);
       configurable: true
     });
     var FileWriteStream = WriteStream;
-    Object.defineProperty(fs4, "FileWriteStream", {
+    Object.defineProperty(fs5, "FileWriteStream", {
       get: function() {
         return FileWriteStream;
       },
@@ -15299,13 +15300,13 @@ GFS4: `);
       });
     }
     function createReadStream(path6, options) {
-      return new fs4.ReadStream(path6, options);
+      return new fs5.ReadStream(path6, options);
     }
     function createWriteStream(path6, options) {
-      return new fs4.WriteStream(path6, options);
+      return new fs5.WriteStream(path6, options);
     }
-    var fs$open = fs4.open;
-    fs4.open = open;
+    var fs$open = fs5.open;
+    fs5.open = open;
     function open(path6, flags, mode, cb) {
       if (typeof mode === "function")
         cb = mode, mode = null;
@@ -15321,20 +15322,20 @@ GFS4: `);
         });
       }
     }
-    return fs4;
+    return fs5;
   }
   function enqueue(elem) {
     debug("ENQUEUE", elem[0].name, elem[1]);
-    fs3[gracefulQueue].push(elem);
+    fs4[gracefulQueue].push(elem);
     retry();
   }
   var retryTimer;
   function resetQueue() {
     var now = Date.now();
-    for (var i = 0;i < fs3[gracefulQueue].length; ++i) {
-      if (fs3[gracefulQueue][i].length > 2) {
-        fs3[gracefulQueue][i][3] = now;
-        fs3[gracefulQueue][i][4] = now;
+    for (var i = 0;i < fs4[gracefulQueue].length; ++i) {
+      if (fs4[gracefulQueue][i].length > 2) {
+        fs4[gracefulQueue][i][3] = now;
+        fs4[gracefulQueue][i][4] = now;
       }
     }
     retry();
@@ -15342,9 +15343,9 @@ GFS4: `);
   function retry() {
     clearTimeout(retryTimer);
     retryTimer = undefined;
-    if (fs3[gracefulQueue].length === 0)
+    if (fs4[gracefulQueue].length === 0)
       return;
-    var elem = fs3[gracefulQueue].shift();
+    var elem = fs4[gracefulQueue].shift();
     var fn = elem[0];
     var args = elem[1];
     var err = elem[2];
@@ -15366,7 +15367,7 @@ GFS4: `);
         debug("RETRY", fn.name, args);
         fn.apply(null, args.concat([startTime]));
       } else {
-        fs3[gracefulQueue].push(elem);
+        fs4[gracefulQueue].push(elem);
       }
     }
     if (retryTimer === undefined) {
@@ -15761,10 +15762,10 @@ var require_signal_exit = __commonJS((exports, module) => {
 // node_modules/proper-lockfile/lib/mtime-precision.js
 var require_mtime_precision = __commonJS((exports, module) => {
   var cacheSymbol = Symbol();
-  function probe(file3, fs3, callback) {
-    const cachedPrecision = fs3[cacheSymbol];
+  function probe(file3, fs4, callback) {
+    const cachedPrecision = fs4[cacheSymbol];
     if (cachedPrecision) {
-      return fs3.stat(file3, (err, stat) => {
+      return fs4.stat(file3, (err, stat) => {
         if (err) {
           return callback(err);
         }
@@ -15772,16 +15773,16 @@ var require_mtime_precision = __commonJS((exports, module) => {
       });
     }
     const mtime = new Date(Math.ceil(Date.now() / 1000) * 1000 + 5);
-    fs3.utimes(file3, mtime, mtime, (err) => {
+    fs4.utimes(file3, mtime, mtime, (err) => {
       if (err) {
         return callback(err);
       }
-      fs3.stat(file3, (err2, stat) => {
+      fs4.stat(file3, (err2, stat) => {
         if (err2) {
           return callback(err2);
         }
         const precision = stat.mtime.getTime() % 1000 === 0 ? "s" : "ms";
-        Object.defineProperty(fs3, cacheSymbol, { value: precision });
+        Object.defineProperty(fs4, cacheSymbol, { value: precision });
         callback(null, stat.mtime, precision);
       });
     });
@@ -15800,7 +15801,7 @@ var require_mtime_precision = __commonJS((exports, module) => {
 // node_modules/proper-lockfile/lib/lockfile.js
 var require_lockfile = __commonJS((exports, module) => {
   var path6 = __require("path");
-  var fs3 = require_graceful_fs();
+  var fs4 = require_graceful_fs();
   var retry = require_retry();
   var onExit = require_signal_exit();
   var mtimePrecision = require_mtime_precision();
@@ -15923,7 +15924,7 @@ var require_lockfile = __commonJS((exports, module) => {
       update: null,
       realpath: true,
       retries: 0,
-      fs: fs3,
+      fs: fs4,
       onCompromised: (err) => {
         throw err;
       },
@@ -15967,7 +15968,7 @@ var require_lockfile = __commonJS((exports, module) => {
   }
   function unlock(file3, options, callback) {
     options = {
-      fs: fs3,
+      fs: fs4,
       realpath: true,
       ...options
     };
@@ -15989,7 +15990,7 @@ var require_lockfile = __commonJS((exports, module) => {
     options = {
       stale: 1e4,
       realpath: true,
-      fs: fs3,
+      fs: fs4,
       ...options
     };
     options.stale = Math.max(options.stale || 0, 2000);
@@ -16024,16 +16025,16 @@ var require_lockfile = __commonJS((exports, module) => {
 
 // node_modules/proper-lockfile/lib/adapter.js
 var require_adapter = __commonJS((exports, module) => {
-  var fs3 = require_graceful_fs();
-  function createSyncFs(fs4) {
+  var fs4 = require_graceful_fs();
+  function createSyncFs(fs5) {
     const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-    const newFs = { ...fs4 };
+    const newFs = { ...fs5 };
     methods.forEach((method) => {
       newFs[method] = (...args) => {
         const callback = args.pop();
         let ret;
         try {
-          ret = fs4[`${method}Sync`](...args);
+          ret = fs5[`${method}Sync`](...args);
         } catch (err) {
           return callback(err);
         }
@@ -16071,7 +16072,7 @@ var require_adapter = __commonJS((exports, module) => {
   }
   function toSyncOptions(options) {
     options = { ...options };
-    options.fs = createSyncFs(options.fs || fs3);
+    options.fs = createSyncFs(options.fs || fs4);
     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" });
     }
@@ -16118,7 +16119,7 @@ var require_proper_lockfile = __commonJS((exports, module) => {
 });
 
 // src/plan/manager.ts
-import { renameSync as renameSync3, unlinkSync } from "fs";
+import { renameSync as renameSync2, unlinkSync } from "fs";
 import * as path11 from "path";
 async function loadPlanJsonOnly(directory) {
   const planJsonContent = await readSwarmFileAsync(directory, "plan.json");
@@ -16210,7 +16211,7 @@ ${markdown}`;
   const mdTempPath = path11.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await Bun.write(mdTempPath, markdownWithHash);
-    renameSync3(mdTempPath, mdPath);
+    renameSync2(mdTempPath, mdPath);
   } finally {
     try {
       unlinkSync(mdTempPath);
@@ -16299,7 +16300,7 @@ async function savePlan(directory, plan, options) {
   const tempPath = path11.join(swarmDir, `plan.json.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await Bun.write(tempPath, JSON.stringify(validated, null, 2));
-    renameSync3(tempPath, planPath);
+    renameSync2(tempPath, planPath);
   } finally {
     try {
       unlinkSync(tempPath);
@@ -16313,7 +16314,7 @@ ${markdown}`;
   const mdTempPath = path11.join(swarmDir, `plan.md.tmp.${Date.now()}.${Math.floor(Math.random() * 1e9)}`);
   try {
     await Bun.write(mdTempPath, markdownWithHash);
-    renameSync3(mdTempPath, mdPath);
+    renameSync2(mdTempPath, mdPath);
   } finally {
     try {
       unlinkSync(mdTempPath);
@@ -16617,7 +16618,7 @@ __export(exports_config_doctor, {
   applySafeAutoFixes: () => applySafeAutoFixes
 });
 import * as crypto2 from "crypto";
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as os4 from "os";
 import * as path13 from "path";
 function getUserConfigDir3() {
@@ -16662,15 +16663,15 @@ function createConfigBackup(directory) {
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configPath = projectConfigPath;
   let content = null;
-  if (fs3.existsSync(projectConfigPath)) {
+  if (fs4.existsSync(projectConfigPath)) {
     try {
-      content = fs3.readFileSync(projectConfigPath, "utf-8");
+      content = fs4.readFileSync(projectConfigPath, "utf-8");
     } catch {}
   }
-  if (content === null && fs3.existsSync(userConfigPath)) {
+  if (content === null && fs4.existsSync(userConfigPath)) {
     configPath = userConfigPath;
     try {
-      content = fs3.readFileSync(userConfigPath, "utf-8");
+      content = fs4.readFileSync(userConfigPath, "utf-8");
     } catch {}
   }
   if (content === null) {
@@ -16685,8 +16686,8 @@ function createConfigBackup(directory) {
 }
 function writeBackupArtifact(directory, backup) {
   const swarmDir = path13.join(directory, ".swarm");
-  if (!fs3.existsSync(swarmDir)) {
-    fs3.mkdirSync(swarmDir, { recursive: true });
+  if (!fs4.existsSync(swarmDir)) {
+    fs4.mkdirSync(swarmDir, { recursive: true });
   }
   const backupFilename = `config-backup-${backup.createdAt}.json`;
   const backupPath = path13.join(swarmDir, backupFilename);
@@ -16697,15 +16698,15 @@ function writeBackupArtifact(directory, backup) {
     content: backup.content,
     preview: backup.content.substring(0, 500) + (backup.content.length > 500 ? "..." : "")
   };
-  fs3.writeFileSync(backupPath, JSON.stringify(artifact, null, 2), "utf-8");
+  fs4.writeFileSync(backupPath, JSON.stringify(artifact, null, 2), "utf-8");
   return backupPath;
 }
 function restoreFromBackup(backupPath, directory) {
-  if (!fs3.existsSync(backupPath)) {
+  if (!fs4.existsSync(backupPath)) {
     return null;
   }
   try {
-    const artifact = JSON.parse(fs3.readFileSync(backupPath, "utf-8"));
+    const artifact = JSON.parse(fs4.readFileSync(backupPath, "utf-8"));
     if (!artifact.content || !artifact.configPath || !artifact.contentHash) {
       return null;
     }
@@ -16720,10 +16721,10 @@ function restoreFromBackup(backupPath, directory) {
     }
     const targetPath = artifact.configPath;
     const targetDir = path13.dirname(targetPath);
-    if (!fs3.existsSync(targetDir)) {
-      fs3.mkdirSync(targetDir, { recursive: true });
+    if (!fs4.existsSync(targetDir)) {
+      fs4.mkdirSync(targetDir, { recursive: true });
     }
-    fs3.writeFileSync(targetPath, artifact.content, "utf-8");
+    fs4.writeFileSync(targetPath, artifact.content, "utf-8");
     return targetPath;
   } catch {
     return null;
@@ -16733,12 +16734,12 @@ function readConfigFromFile(directory) {
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configPath = projectConfigPath;
   let configContent = null;
-  if (fs3.existsSync(projectConfigPath)) {
+  if (fs4.existsSync(projectConfigPath)) {
     configPath = projectConfigPath;
-    configContent = fs3.readFileSync(projectConfigPath, "utf-8");
-  } else if (fs3.existsSync(userConfigPath)) {
+    configContent = fs4.readFileSync(projectConfigPath, "utf-8");
+  } else if (fs4.existsSync(userConfigPath)) {
     configPath = userConfigPath;
-    configContent = fs3.readFileSync(userConfigPath, "utf-8");
+    configContent = fs4.readFileSync(userConfigPath, "utf-8");
   }
   if (configContent === null) {
     return null;
@@ -17034,9 +17035,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 (fs3.existsSync(projectConfigPath)) {
+  if (fs4.existsSync(projectConfigPath)) {
     configSource = projectConfigPath;
-  } else if (fs3.existsSync(userConfigPath)) {
+  } else if (fs4.existsSync(userConfigPath)) {
     configSource = userConfigPath;
   }
   return {
@@ -17065,12 +17066,12 @@ function applySafeAutoFixes(directory, result) {
   const { userConfigPath, projectConfigPath } = getConfigPaths(directory);
   let configPath = projectConfigPath;
   let configContent;
-  if (fs3.existsSync(projectConfigPath)) {
+  if (fs4.existsSync(projectConfigPath)) {
     configPath = projectConfigPath;
-    configContent = fs3.readFileSync(projectConfigPath, "utf-8");
-  } else if (fs3.existsSync(userConfigPath)) {
+    configContent = fs4.readFileSync(projectConfigPath, "utf-8");
+  } else if (fs4.existsSync(userConfigPath)) {
     configPath = userConfigPath;
-    configContent = fs3.readFileSync(userConfigPath, "utf-8");
+    configContent = fs4.readFileSync(userConfigPath, "utf-8");
   } else {
     return { appliedFixes, updatedConfigPath: null };
   }
@@ -17140,18 +17141,18 @@ function applySafeAutoFixes(directory, result) {
   }
   if (appliedFixes.length > 0) {
     const configDir = path13.dirname(configPath);
-    if (!fs3.existsSync(configDir)) {
-      fs3.mkdirSync(configDir, { recursive: true });
+    if (!fs4.existsSync(configDir)) {
+      fs4.mkdirSync(configDir, { recursive: true });
     }
-    fs3.writeFileSync(configPath, JSON.stringify(config3, null, 2), "utf-8");
+    fs4.writeFileSync(configPath, JSON.stringify(config3, null, 2), "utf-8");
     updatedConfigPath = configPath;
   }
   return { appliedFixes, updatedConfigPath };
 }
 function writeDoctorArtifact(directory, result) {
   const swarmDir = path13.join(directory, ".swarm");
-  if (!fs3.existsSync(swarmDir)) {
-    fs3.mkdirSync(swarmDir, { recursive: true });
+  if (!fs4.existsSync(swarmDir)) {
+    fs4.mkdirSync(swarmDir, { recursive: true });
   }
   const artifactFilename = "config-doctor.json";
   const artifactPath = path13.join(swarmDir, artifactFilename);
@@ -17175,7 +17176,7 @@ function writeDoctorArtifact(directory, result) {
       } : null
     }))
   };
-  fs3.writeFileSync(artifactPath, JSON.stringify(guiOutput, null, 2), "utf-8");
+  fs4.writeFileSync(artifactPath, JSON.stringify(guiOutput, null, 2), "utf-8");
   return artifactPath;
 }
 function shouldRunOnStartup(automationConfig) {
@@ -17514,7 +17515,7 @@ var init_evidence_summary_service = __esm(() => {
 });
 
 // src/cli/index.ts
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as os5 from "os";
 import * as path23 from "path";
 
@@ -18759,7 +18760,7 @@ async function handleBenchmarkCommand(directory, args) {
 
 // src/tools/checkpoint.ts
 import { spawnSync } from "child_process";
-import * as fs2 from "fs";
+import * as fs3 from "fs";
 import * as path4 from "path";
 
 // node_modules/@opencode-ai/plugin/node_modules/zod/v4/classic/external.js
@@ -31150,8 +31151,8 @@ function getCheckpointLogPath(directory) {
 function readCheckpointLog(directory) {
   const logPath = getCheckpointLogPath(directory);
   try {
-    if (fs2.existsSync(logPath)) {
-      const content = fs2.readFileSync(logPath, "utf-8");
+    if (fs3.existsSync(logPath)) {
+      const content = fs3.readFileSync(logPath, "utf-8");
       const parsed = JSON.parse(content);
       if (!parsed.checkpoints || !Array.isArray(parsed.checkpoints)) {
         return { version: 1, checkpoints: [] };
@@ -31164,12 +31165,12 @@ function readCheckpointLog(directory) {
 function writeCheckpointLog(log2, directory) {
   const logPath = getCheckpointLogPath(directory);
   const dir = path4.dirname(logPath);
-  if (!fs2.existsSync(dir)) {
-    fs2.mkdirSync(dir, { recursive: true });
+  if (!fs3.existsSync(dir)) {
+    fs3.mkdirSync(dir, { recursive: true });
   }
   const tempPath = `${logPath}.tmp`;
-  fs2.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
-  fs2.renameSync(tempPath, logPath);
+  fs3.writeFileSync(tempPath, JSON.stringify(log2, null, 2), "utf-8");
+  fs3.renameSync(tempPath, logPath);
 }
 function gitExec(args) {
   const result = spawnSync("git", args, {
@@ -33649,7 +33650,7 @@ async function handleExportCommand(directory, _args) {
 // src/commands/handoff.ts
 init_utils2();
 import crypto3 from "crypto";
-import { renameSync as renameSync5 } from "fs";
+import { renameSync as renameSync4 } from "fs";
 
 // src/services/handoff-service.ts
 init_utils2();
@@ -33950,7 +33951,7 @@ function formatHandoffMarkdown(data) {
 
 // src/session/snapshot-writer.ts
 init_utils2();
-import { mkdirSync as mkdirSync4, renameSync as renameSync4 } from "fs";
+import { mkdirSync as mkdirSync4, renameSync as renameSync3 } from "fs";
 import * as path14 from "path";
 var pendingWrite = null;
 var lastWritePromise = Promise.resolve();
@@ -34041,7 +34042,7 @@ async function writeSnapshot(directory, state) {
     mkdirSync4(dir, { recursive: true });
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await Bun.write(tempPath, content);
-    renameSync4(tempPath, resolvedPath);
+    renameSync3(tempPath, resolvedPath);
   } catch (error93) {
     if (process.env.DEBUG_SWARM) {
       console.warn("[snapshot-writer] write failed:", error93 instanceof Error ? error93.message : String(error93));
@@ -34065,7 +34066,7 @@ async function handleHandoffCommand(directory, _args) {
   const resolvedPath = validateSwarmPath(directory, "handoff.md");
   const tempPath = `${resolvedPath}.tmp.${crypto3.randomUUID()}`;
   await Bun.write(tempPath, markdown);
-  renameSync5(tempPath, resolvedPath);
+  renameSync4(tempPath, resolvedPath);
   await writeSnapshot(directory, swarmState);
   await flushPendingSnapshot(directory);
   return `## Handoff Brief Written
@@ -34664,15 +34665,15 @@ async function handlePlanCommand(directory, args) {
 // src/services/preflight-service.ts
 init_manager();
 init_manager2();
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as path20 from "path";
 
 // src/tools/lint.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path17 from "path";
 
 // src/build/discovery.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as path16 from "path";
 
 // src/lang/detector.ts
@@ -35713,7 +35714,7 @@ function findBuildFiles(workingDir, patterns) {
     if (pattern.includes("*")) {
       const dir = workingDir;
       try {
-        const files = fs4.readdirSync(dir);
+        const files = fs5.readdirSync(dir);
         const regex = simpleGlobToRegex(pattern);
         const matches = files.filter((f) => regex.test(f));
         if (matches.length > 0) {
@@ -35722,7 +35723,7 @@ function findBuildFiles(workingDir, patterns) {
       } catch {}
     } else {
       const filePath = path16.join(workingDir, pattern);
-      if (fs4.existsSync(filePath)) {
+      if (fs5.existsSync(filePath)) {
         return filePath;
       }
     }
@@ -35731,11 +35732,11 @@ function findBuildFiles(workingDir, patterns) {
 }
 function getRepoDefinedScripts(workingDir, scripts) {
   const packageJsonPath = path16.join(workingDir, "package.json");
-  if (!fs4.existsSync(packageJsonPath)) {
+  if (!fs5.existsSync(packageJsonPath)) {
     return [];
   }
   try {
-    const content = fs4.readFileSync(packageJsonPath, "utf-8");
+    const content = fs5.readFileSync(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
     if (!pkg.scripts || typeof pkg.scripts !== "object") {
       return [];
@@ -35772,7 +35773,7 @@ function findAllBuildFiles(workingDir) {
         findFilesRecursive(workingDir, regex, allBuildFiles);
       } else {
         const filePath = path16.join(workingDir, pattern);
-        if (fs4.existsSync(filePath)) {
+        if (fs5.existsSync(filePath)) {
           allBuildFiles.add(filePath);
         }
       }
@@ -35782,7 +35783,7 @@ function findAllBuildFiles(workingDir) {
 }
 function findFilesRecursive(dir, regex, results) {
   try {
-    const entries = fs4.readdirSync(dir, { withFileTypes: true });
+    const entries = fs5.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = path16.join(dir, entry.name);
       if (entry.isDirectory() && !["node_modules", ".git", "dist", "build", "target"].includes(entry.name)) {
@@ -35808,7 +35809,7 @@ async function discoverBuildCommandsFromProfiles(workingDir) {
     for (const cmd of sortedCommands) {
       if (cmd.detectFile) {
         const detectFilePath = path16.join(workingDir, cmd.detectFile);
-        if (!fs4.existsSync(detectFilePath)) {
+        if (!fs5.existsSync(detectFilePath)) {
           continue;
         }
       }
@@ -35941,7 +35942,7 @@ function getLinterCommand(linter, mode, projectDir) {
 }
 function getAdditionalLinterCommand(linter, mode, cwd) {
   const gradlewName = process.platform === "win32" ? "gradlew.bat" : "gradlew";
-  const gradlew = fs5.existsSync(path17.join(cwd, gradlewName)) ? path17.join(cwd, gradlewName) : null;
+  const gradlew = fs6.existsSync(path17.join(cwd, gradlewName)) ? path17.join(cwd, gradlewName) : null;
   switch (linter) {
     case "ruff":
       return mode === "fix" ? ["ruff", "check", "--fix", "."] : ["ruff", "check", "."];
@@ -35975,12 +35976,12 @@ function getAdditionalLinterCommand(linter, mode, cwd) {
   }
 }
 function detectRuff(cwd) {
-  if (fs5.existsSync(path17.join(cwd, "ruff.toml")))
+  if (fs6.existsSync(path17.join(cwd, "ruff.toml")))
     return isCommandAvailable("ruff");
   try {
     const pyproject = path17.join(cwd, "pyproject.toml");
-    if (fs5.existsSync(pyproject)) {
-      const content = fs5.readFileSync(pyproject, "utf-8");
+    if (fs6.existsSync(pyproject)) {
+      const content = fs6.readFileSync(pyproject, "utf-8");
       if (content.includes("[tool.ruff]"))
         return isCommandAvailable("ruff");
     }
@@ -35988,21 +35989,21 @@ function detectRuff(cwd) {
   return false;
 }
 function detectClippy(cwd) {
-  return fs5.existsSync(path17.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
+  return fs6.existsSync(path17.join(cwd, "Cargo.toml")) && isCommandAvailable("cargo");
 }
 function detectGolangciLint(cwd) {
-  return fs5.existsSync(path17.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
+  return fs6.existsSync(path17.join(cwd, "go.mod")) && isCommandAvailable("golangci-lint");
 }
 function detectCheckstyle(cwd) {
-  const hasMaven = fs5.existsSync(path17.join(cwd, "pom.xml"));
-  const hasGradle = fs5.existsSync(path17.join(cwd, "build.gradle")) || fs5.existsSync(path17.join(cwd, "build.gradle.kts"));
-  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs5.existsSync(path17.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
+  const hasMaven = fs6.existsSync(path17.join(cwd, "pom.xml"));
+  const hasGradle = fs6.existsSync(path17.join(cwd, "build.gradle")) || fs6.existsSync(path17.join(cwd, "build.gradle.kts"));
+  const hasBinary = hasMaven && isCommandAvailable("mvn") || hasGradle && (fs6.existsSync(path17.join(cwd, "gradlew")) || isCommandAvailable("gradle"));
   return (hasMaven || hasGradle) && hasBinary;
 }
 function detectKtlint(cwd) {
-  const hasKotlin = fs5.existsSync(path17.join(cwd, "build.gradle.kts")) || fs5.existsSync(path17.join(cwd, "build.gradle")) || (() => {
+  const hasKotlin = fs6.existsSync(path17.join(cwd, "build.gradle.kts")) || fs6.existsSync(path17.join(cwd, "build.gradle")) || (() => {
     try {
-      return fs5.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
+      return fs6.readdirSync(cwd).some((f) => f.endsWith(".kt") || f.endsWith(".kts"));
     } catch {
       return false;
     }
@@ -36011,7 +36012,7 @@ function detectKtlint(cwd) {
 }
 function detectDotnetFormat(cwd) {
   try {
-    const files = fs5.readdirSync(cwd);
+    const files = fs6.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -36019,14 +36020,14 @@ function detectDotnetFormat(cwd) {
   }
 }
 function detectCppcheck(cwd) {
-  if (fs5.existsSync(path17.join(cwd, "CMakeLists.txt"))) {
+  if (fs6.existsSync(path17.join(cwd, "CMakeLists.txt"))) {
     return isCommandAvailable("cppcheck");
   }
   try {
     const dirsToCheck = [cwd, path17.join(cwd, "src")];
     const hasCpp = dirsToCheck.some((dir) => {
       try {
-        return fs5.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
+        return fs6.readdirSync(dir).some((f) => /\.(c|cpp|cc|cxx|h|hpp)$/.test(f));
       } catch {
         return false;
       }
@@ -36037,13 +36038,13 @@ function detectCppcheck(cwd) {
   }
 }
 function detectSwiftlint(cwd) {
-  return fs5.existsSync(path17.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
+  return fs6.existsSync(path17.join(cwd, "Package.swift")) && isCommandAvailable("swiftlint");
 }
 function detectDartAnalyze(cwd) {
-  return fs5.existsSync(path17.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs6.existsSync(path17.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRubocop(cwd) {
-  return (fs5.existsSync(path17.join(cwd, "Gemfile")) || fs5.existsSync(path17.join(cwd, "gems.rb")) || fs5.existsSync(path17.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
+  return (fs6.existsSync(path17.join(cwd, "Gemfile")) || fs6.existsSync(path17.join(cwd, "gems.rb")) || fs6.existsSync(path17.join(cwd, ".rubocop.yml"))) && (isCommandAvailable("rubocop") || isCommandAvailable("bundle"));
 }
 function detectAdditionalLinter(cwd) {
   if (detectRuff(cwd))
@@ -36088,7 +36089,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([biomeExit, timeout]);
     if (result === "timeout") {
       biomeProc.kill();
-    } else if (biomeProc.exitCode === 0 && fs5.existsSync(biomeBin)) {
+    } else if (biomeProc.exitCode === 0 && fs6.existsSync(biomeBin)) {
       return "biome";
     }
   } catch {}
@@ -36102,7 +36103,7 @@ async function _detectAvailableLinter(_projectDir, biomeBin, eslintBin) {
     const result = await Promise.race([eslintExit, timeout]);
     if (result === "timeout") {
       eslintProc.kill();
-    } else if (eslintProc.exitCode === 0 && fs5.existsSync(eslintBin)) {
+    } else if (eslintProc.exitCode === 0 && fs6.existsSync(eslintBin)) {
       return "eslint";
     }
   } catch {}
@@ -36272,7 +36273,7 @@ For Rust: rustup component add clippy`
 });
 
 // src/tools/secretscan.ts
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import * as path18 from "path";
 var MAX_FILE_PATH_LENGTH = 500;
 var MAX_FILE_SIZE_BYTES = 512 * 1024;
@@ -36515,9 +36516,9 @@ function isGlobOrPathPattern(pattern) {
 function loadSecretScanIgnore(scanDir) {
   const ignorePath = path18.join(scanDir, ".secretscanignore");
   try {
-    if (!fs6.existsSync(ignorePath))
+    if (!fs7.existsSync(ignorePath))
       return [];
-    const content = fs6.readFileSync(ignorePath, "utf8");
+    const content = fs7.readFileSync(ignorePath, "utf8");
     const patterns = [];
     for (const rawLine of content.split(/\r?\n/)) {
       const line = rawLine.trim();
@@ -36635,11 +36636,11 @@ function createRedactedContext(line, findings) {
   result += line.slice(lastEnd);
   return result;
 }
-var O_NOFOLLOW = process.platform !== "win32" ? fs6.constants.O_NOFOLLOW : undefined;
+var O_NOFOLLOW = process.platform !== "win32" ? fs7.constants.O_NOFOLLOW : undefined;
 function scanFileForSecrets(filePath) {
   const findings = [];
   try {
-    const lstat = fs6.lstatSync(filePath);
+    const lstat = fs7.lstatSync(filePath);
     if (lstat.isSymbolicLink()) {
       return findings;
     }
@@ -36648,14 +36649,14 @@ function scanFileForSecrets(filePath) {
     }
     let buffer;
     if (O_NOFOLLOW !== undefined) {
-      const fd = fs6.openSync(filePath, "r", O_NOFOLLOW);
+      const fd = fs7.openSync(filePath, "r", O_NOFOLLOW);
       try {
-        buffer = fs6.readFileSync(fd);
+        buffer = fs7.readFileSync(fd);
       } finally {
-        fs6.closeSync(fd);
+        fs7.closeSync(fd);
       }
     } else {
-      buffer = fs6.readFileSync(filePath);
+      buffer = fs7.readFileSync(filePath);
     }
     if (isBinaryFile(filePath, buffer)) {
       return findings;
@@ -36710,7 +36711,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
   const files = [];
   let entries;
   try {
-    entries = fs6.readdirSync(dir);
+    entries = fs7.readdirSync(dir);
   } catch {
     stats.fileErrors++;
     return files;
@@ -36733,7 +36734,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     }
     let lstat;
     try {
-      lstat = fs6.lstatSync(fullPath);
+      lstat = fs7.lstatSync(fullPath);
     } catch {
       stats.fileErrors++;
       continue;
@@ -36745,7 +36746,7 @@ function findScannableFiles(dir, excludeExact, excludeGlobs, scanDir, visited, s
     if (lstat.isDirectory()) {
       let realPath;
       try {
-        realPath = fs6.realpathSync(fullPath);
+        realPath = fs7.realpathSync(fullPath);
       } catch {
         stats.fileErrors++;
         continue;
@@ -36828,7 +36829,7 @@ var secretscan = createSwarmTool({
     }
     try {
       const scanDir = path18.resolve(directory);
-      if (!fs6.existsSync(scanDir)) {
+      if (!fs7.existsSync(scanDir)) {
         const errorResult = {
           error: "directory not found",
           scan_dir: directory,
@@ -36839,7 +36840,7 @@ var secretscan = createSwarmTool({
         };
         return JSON.stringify(errorResult, null, 2);
       }
-      const dirStat = fs6.statSync(scanDir);
+      const dirStat = fs7.statSync(scanDir);
       if (!dirStat.isDirectory()) {
         const errorResult = {
           error: "target must be a directory, not a file",
@@ -36890,7 +36891,7 @@ var secretscan = createSwarmTool({
           break;
         const fileFindings = scanFileForSecrets(filePath);
         try {
-          const stat2 = fs6.statSync(filePath);
+          const stat2 = fs7.statSync(filePath);
           if (stat2.size > MAX_FILE_SIZE_BYTES) {
             skippedFiles++;
             continue;
@@ -36977,7 +36978,7 @@ async function runSecretscan(directory) {
 }
 
 // src/tools/test-runner.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path19 from "path";
 var MAX_OUTPUT_BYTES3 = 512000;
 var MAX_COMMAND_LENGTH2 = 500;
@@ -37077,19 +37078,19 @@ function hasDevDependency(devDeps, ...patterns) {
   return hasPackageJsonDependency(devDeps, ...patterns);
 }
 function detectGoTest(cwd) {
-  return fs7.existsSync(path19.join(cwd, "go.mod")) && isCommandAvailable("go");
+  return fs8.existsSync(path19.join(cwd, "go.mod")) && isCommandAvailable("go");
 }
 function detectJavaMaven(cwd) {
-  return fs7.existsSync(path19.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
+  return fs8.existsSync(path19.join(cwd, "pom.xml")) && isCommandAvailable("mvn");
 }
 function detectGradle(cwd) {
-  const hasBuildFile = fs7.existsSync(path19.join(cwd, "build.gradle")) || fs7.existsSync(path19.join(cwd, "build.gradle.kts"));
-  const hasGradlew = fs7.existsSync(path19.join(cwd, "gradlew")) || fs7.existsSync(path19.join(cwd, "gradlew.bat"));
+  const hasBuildFile = fs8.existsSync(path19.join(cwd, "build.gradle")) || fs8.existsSync(path19.join(cwd, "build.gradle.kts"));
+  const hasGradlew = fs8.existsSync(path19.join(cwd, "gradlew")) || fs8.existsSync(path19.join(cwd, "gradlew.bat"));
   return hasBuildFile && (hasGradlew || isCommandAvailable("gradle"));
 }
 function detectDotnetTest(cwd) {
   try {
-    const files = fs7.readdirSync(cwd);
+    const files = fs8.readdirSync(cwd);
     const hasCsproj = files.some((f) => f.endsWith(".csproj"));
     return hasCsproj && isCommandAvailable("dotnet");
   } catch {
@@ -37097,32 +37098,32 @@ function detectDotnetTest(cwd) {
   }
 }
 function detectCTest(cwd) {
-  const hasSource = fs7.existsSync(path19.join(cwd, "CMakeLists.txt"));
-  const hasBuildCache = fs7.existsSync(path19.join(cwd, "CMakeCache.txt")) || fs7.existsSync(path19.join(cwd, "build", "CMakeCache.txt"));
+  const hasSource = fs8.existsSync(path19.join(cwd, "CMakeLists.txt"));
+  const hasBuildCache = fs8.existsSync(path19.join(cwd, "CMakeCache.txt")) || fs8.existsSync(path19.join(cwd, "build", "CMakeCache.txt"));
   return (hasSource || hasBuildCache) && isCommandAvailable("ctest");
 }
 function detectSwiftTest(cwd) {
-  return fs7.existsSync(path19.join(cwd, "Package.swift")) && isCommandAvailable("swift");
+  return fs8.existsSync(path19.join(cwd, "Package.swift")) && isCommandAvailable("swift");
 }
 function detectDartTest(cwd) {
-  return fs7.existsSync(path19.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
+  return fs8.existsSync(path19.join(cwd, "pubspec.yaml")) && (isCommandAvailable("dart") || isCommandAvailable("flutter"));
 }
 function detectRSpec(cwd) {
-  const hasRSpecFile = fs7.existsSync(path19.join(cwd, ".rspec"));
-  const hasGemfile = fs7.existsSync(path19.join(cwd, "Gemfile"));
-  const hasSpecDir = fs7.existsSync(path19.join(cwd, "spec"));
+  const hasRSpecFile = fs8.existsSync(path19.join(cwd, ".rspec"));
+  const hasGemfile = fs8.existsSync(path19.join(cwd, "Gemfile"));
+  const hasSpecDir = fs8.existsSync(path19.join(cwd, "spec"));
   const hasRSpec = hasRSpecFile || hasGemfile && hasSpecDir;
   return hasRSpec && (isCommandAvailable("bundle") || isCommandAvailable("rspec"));
 }
 function detectMinitest(cwd) {
-  return fs7.existsSync(path19.join(cwd, "test")) && (fs7.existsSync(path19.join(cwd, "Gemfile")) || fs7.existsSync(path19.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
+  return fs8.existsSync(path19.join(cwd, "test")) && (fs8.existsSync(path19.join(cwd, "Gemfile")) || fs8.existsSync(path19.join(cwd, "Rakefile"))) && isCommandAvailable("ruby");
 }
 async function detectTestFramework(cwd) {
   const baseDir = cwd;
   try {
     const packageJsonPath = path19.join(baseDir, "package.json");
-    if (fs7.existsSync(packageJsonPath)) {
-      const content = fs7.readFileSync(packageJsonPath, "utf-8");
+    if (fs8.existsSync(packageJsonPath)) {
+      const content = fs8.readFileSync(packageJsonPath, "utf-8");
       const pkg = JSON.parse(content);
       const _deps = pkg.dependencies || {};
       const devDeps = pkg.devDependencies || {};
@@ -37141,7 +37142,7 @@ async function detectTestFramework(cwd) {
         return "jest";
       if (hasDevDependency(devDeps, "mocha", "@types/mocha"))
         return "mocha";
-      if (fs7.existsSync(path19.join(baseDir, "bun.lockb")) || fs7.existsSync(path19.join(baseDir, "bun.lock"))) {
+      if (fs8.existsSync(path19.join(baseDir, "bun.lockb")) || fs8.existsSync(path19.join(baseDir, "bun.lock"))) {
         if (scripts.test?.includes("bun"))
           return "bun";
       }
@@ -37151,28 +37152,28 @@ async function detectTestFramework(cwd) {
     const pyprojectTomlPath = path19.join(baseDir, "pyproject.toml");
     const setupCfgPath = path19.join(baseDir, "setup.cfg");
     const requirementsTxtPath = path19.join(baseDir, "requirements.txt");
-    if (fs7.existsSync(pyprojectTomlPath)) {
-      const content = fs7.readFileSync(pyprojectTomlPath, "utf-8");
+    if (fs8.existsSync(pyprojectTomlPath)) {
+      const content = fs8.readFileSync(pyprojectTomlPath, "utf-8");
       if (content.includes("[tool.pytest"))
         return "pytest";
       if (content.includes("pytest"))
         return "pytest";
     }
-    if (fs7.existsSync(setupCfgPath)) {
-      const content = fs7.readFileSync(setupCfgPath, "utf-8");
+    if (fs8.existsSync(setupCfgPath)) {
+      const content = fs8.readFileSync(setupCfgPath, "utf-8");
       if (content.includes("[pytest]"))
         return "pytest";
     }
-    if (fs7.existsSync(requirementsTxtPath)) {
-      const content = fs7.readFileSync(requirementsTxtPath, "utf-8");
+    if (fs8.existsSync(requirementsTxtPath)) {
+      const content = fs8.readFileSync(requirementsTxtPath, "utf-8");
       if (content.includes("pytest"))
         return "pytest";
     }
   } catch {}
   try {
     const cargoTomlPath = path19.join(baseDir, "Cargo.toml");
-    if (fs7.existsSync(cargoTomlPath)) {
-      const content = fs7.readFileSync(cargoTomlPath, "utf-8");
+    if (fs8.existsSync(cargoTomlPath)) {
+      const content = fs8.readFileSync(cargoTomlPath, "utf-8");
       if (content.includes("[dev-dependencies]")) {
         if (content.includes("tokio") || content.includes("mockall") || content.includes("pretty_assertions")) {
           return "cargo";
@@ -37184,7 +37185,7 @@ async function detectTestFramework(cwd) {
     const pesterConfigPath = path19.join(baseDir, "pester.config.ps1");
     const pesterConfigJsonPath = path19.join(baseDir, "pester.config.ps1.json");
     const pesterPs1Path = path19.join(baseDir, "tests.ps1");
-    if (fs7.existsSync(pesterConfigPath) || fs7.existsSync(pesterConfigJsonPath) || fs7.existsSync(pesterPs1Path)) {
+    if (fs8.existsSync(pesterConfigPath) || fs8.existsSync(pesterConfigJsonPath) || fs8.existsSync(pesterPs1Path)) {
       return "pester";
     }
   } catch {}
@@ -37254,7 +37255,7 @@ function getTestFilesFromConvention(sourceFiles) {
         path19.join(dirname9, "test", `${nameWithoutExt}${ext}`)
       ];
       for (const testFile of possibleTestFiles) {
-        if (fs7.existsSync(testFile) && !testFiles.includes(testFile)) {
+        if (fs8.existsSync(testFile) && !testFiles.includes(testFile)) {
           testFiles.push(testFile);
         }
       }
@@ -37270,7 +37271,7 @@ async function getTestFilesFromGraph(sourceFiles) {
   }
   for (const testFile of candidateTestFiles) {
     try {
-      const content = fs7.readFileSync(testFile, "utf-8");
+      const content = fs8.readFileSync(testFile, "utf-8");
       const testDir = path19.dirname(testFile);
       const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
       let match;
@@ -37291,7 +37292,7 @@ async function getTestFilesFromGraph(sourceFiles) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (sourceFiles.includes(withExt) || fs7.existsSync(withExt)) {
+              if (sourceFiles.includes(withExt) || fs8.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -37332,7 +37333,7 @@ async function getTestFilesFromGraph(sourceFiles) {
               ".cjs"
             ]) {
               const withExt = resolvedImport + extToTry;
-              if (sourceFiles.includes(withExt) || fs7.existsSync(withExt)) {
+              if (sourceFiles.includes(withExt) || fs8.existsSync(withExt)) {
                 resolvedImport = withExt;
                 break;
               }
@@ -37428,8 +37429,8 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
       return ["mvn", "test"];
     case "gradle": {
       const isWindows = process.platform === "win32";
-      const hasGradlewBat = fs7.existsSync(path19.join(baseDir, "gradlew.bat"));
-      const hasGradlew = fs7.existsSync(path19.join(baseDir, "gradlew"));
+      const hasGradlewBat = fs8.existsSync(path19.join(baseDir, "gradlew.bat"));
+      const hasGradlew = fs8.existsSync(path19.join(baseDir, "gradlew"));
       if (hasGradlewBat && isWindows)
         return ["gradlew.bat", "test"];
       if (hasGradlew)
@@ -37446,7 +37447,7 @@ function buildTestCommand(framework, scope, files, coverage, baseDir) {
         "cmake-build-release",
         "out"
       ];
-      const actualBuildDir = buildDirCandidates.find((d) => fs7.existsSync(path19.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
+      const actualBuildDir = buildDirCandidates.find((d) => fs8.existsSync(path19.join(baseDir, d, "CMakeCache.txt"))) ?? "build";
       return ["ctest", "--test-dir", actualBuildDir];
     }
     case "swift-test":
@@ -38057,8 +38058,8 @@ function validateTimeout(timeoutMs, defaultValue) {
 function getPackageVersion(dir) {
   try {
     const packagePath = path20.join(dir, "package.json");
-    if (fs8.existsSync(packagePath)) {
-      const content = fs8.readFileSync(packagePath, "utf-8");
+    if (fs9.existsSync(packagePath)) {
+      const content = fs9.readFileSync(packagePath, "utf-8");
       const pkg = JSON.parse(content);
       return pkg.version ?? null;
     }
@@ -38068,8 +38069,8 @@ function getPackageVersion(dir) {
 function getChangelogVersion(dir) {
   try {
     const changelogPath = path20.join(dir, "CHANGELOG.md");
-    if (fs8.existsSync(changelogPath)) {
-      const content = fs8.readFileSync(changelogPath, "utf-8");
+    if (fs9.existsSync(changelogPath)) {
+      const content = fs9.readFileSync(changelogPath, "utf-8");
       const match = content.match(/^##\s*\[?(\d+\.\d+\.\d+)\]?/m);
       if (match) {
         return match[1];
@@ -38082,9 +38083,9 @@ function getVersionFileVersion(dir) {
   const possibleFiles = ["VERSION.txt", "version.txt", "VERSION", "version"];
   for (const file3 of possibleFiles) {
     const filePath = path20.join(dir, file3);
-    if (fs8.existsSync(filePath)) {
+    if (fs9.existsSync(filePath)) {
       try {
-        const content = fs8.readFileSync(filePath, "utf-8").trim();
+        const content = fs9.readFileSync(filePath, "utf-8").trim();
         const match = content.match(/(\d+\.\d+\.\d+)/);
         if (match) {
           return match[1];
@@ -38627,7 +38628,7 @@ async function handlePromoteCommand(directory, args) {
 }
 
 // src/commands/reset.ts
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 
 // src/background/manager.ts
 init_utils();
@@ -39326,8 +39327,8 @@ async function handleResetCommand(directory, args) {
   for (const filename of filesToReset) {
     try {
       const resolvedPath = validateSwarmPath(directory, filename);
-      if (fs9.existsSync(resolvedPath)) {
-        fs9.unlinkSync(resolvedPath);
+      if (fs10.existsSync(resolvedPath)) {
+        fs10.unlinkSync(resolvedPath);
         results.push(`- \u2705 Deleted ${filename}`);
       } else {
         results.push(`- \u23ED\uFE0F ${filename} not found (skipped)`);
@@ -39344,8 +39345,8 @@ async function handleResetCommand(directory, args) {
   }
   try {
     const summariesPath = validateSwarmPath(directory, "summaries");
-    if (fs9.existsSync(summariesPath)) {
-      fs9.rmSync(summariesPath, { recursive: true, force: true });
+    if (fs10.existsSync(summariesPath)) {
+      fs10.rmSync(summariesPath, { recursive: true, force: true });
       results.push("- \u2705 Deleted summaries/ directory");
     } else {
       results.push("- \u23ED\uFE0F summaries/ not found (skipped)");
@@ -39365,13 +39366,13 @@ async function handleResetCommand(directory, args) {
 
 // src/commands/reset-session.ts
 init_utils2();
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 async function handleResetSessionCommand(directory, _args) {
   const results = [];
   try {
     const statePath = validateSwarmPath(directory, "session/state.json");
-    if (fs10.existsSync(statePath)) {
-      fs10.unlinkSync(statePath);
+    if (fs11.existsSync(statePath)) {
+      fs11.unlinkSync(statePath);
       results.push("\u2705 Deleted .swarm/session/state.json");
     } else {
       results.push("\u23ED\uFE0F state.json not found (already clean)");
@@ -39474,18 +39475,18 @@ ${error93 instanceof Error ? error93.message : String(error93)}`;
 
 // src/commands/rollback.ts
 init_utils2();
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as path22 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs11.existsSync(manifestPath2)) {
+    if (!fs12.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs11.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs12.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -39507,12 +39508,12 @@ async function handleRollbackCommand(directory, args) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs11.existsSync(manifestPath)) {
+  if (!fs12.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs11.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs12.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -39522,10 +39523,10 @@ async function handleRollbackCommand(directory, args) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs11.existsSync(checkpointDir)) {
+  if (!fs12.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs11.readdirSync(checkpointDir);
+  const checkpointFiles = fs12.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -39536,7 +39537,7 @@ async function handleRollbackCommand(directory, args) {
     const src = path22.join(checkpointDir, file3);
     const dest = path22.join(swarmDir, file3);
     try {
-      fs11.cpSync(src, dest, { recursive: true, force: true });
+      fs12.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
     } catch (error93) {
       failures.push({ file: file3, error: error93.message });
@@ -39553,7 +39554,7 @@ async function handleRollbackCommand(directory, args) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs11.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs12.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error93) {
     console.error("Failed to write rollback event:", error93);
@@ -39596,11 +39597,11 @@ async function handleSimulateCommand(directory, args) {
   ];
   const report = reportLines.filter(Boolean).join(`
 `);
-  const fs12 = await import("fs/promises");
+  const fs13 = await import("fs/promises");
   const path23 = await import("path");
   const reportPath = path23.join(directory, ".swarm", "simulate-report.md");
-  await fs12.mkdir(path23.dirname(reportPath), { recursive: true });
-  await fs12.writeFile(reportPath, report, "utf-8");
+  await fs13.mkdir(path23.dirname(reportPath), { recursive: true });
+  await fs13.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
 
@@ -40396,13 +40397,13 @@ var OPENCODE_CONFIG_PATH = path23.join(CONFIG_DIR, "opencode.json");
 var PLUGIN_CONFIG_PATH = path23.join(CONFIG_DIR, "opencode-swarm.json");
 var PROMPTS_DIR = path23.join(CONFIG_DIR, "opencode-swarm");
 function ensureDir(dir) {
-  if (!fs12.existsSync(dir)) {
-    fs12.mkdirSync(dir, { recursive: true });
+  if (!fs13.existsSync(dir)) {
+    fs13.mkdirSync(dir, { recursive: true });
   }
 }
 function loadJson(filepath) {
   try {
-    const content = fs12.readFileSync(filepath, "utf-8");
+    const content = fs13.readFileSync(filepath, "utf-8");
     const stripped = content.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (match, comment) => comment ? "" : match).replace(/,(\s*[}\]])/g, "$1");
     return JSON.parse(stripped);
   } catch {
@@ -40410,7 +40411,7 @@ function loadJson(filepath) {
   }
 }
 function saveJson(filepath, data) {
-  fs12.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
+  fs13.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
 async function install() {
@@ -40443,7 +40444,7 @@ async function install() {
   saveJson(OPENCODE_CONFIG_PATH, opencodeConfig);
   console.log("\u2713 Added opencode-swarm to OpenCode plugins");
   console.log("\u2713 Disabled default OpenCode agents (explore, general)");
-  if (!fs12.existsSync(PLUGIN_CONFIG_PATH)) {
+  if (!fs13.existsSync(PLUGIN_CONFIG_PATH)) {
     const defaultConfig = {
       agents: {
         coder: { model: "opencode/minimax-m2.5-free" },
@@ -40486,7 +40487,7 @@ async function uninstall() {
 `);
     const opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
     if (!opencodeConfig) {
-      if (fs12.existsSync(OPENCODE_CONFIG_PATH)) {
+      if (fs13.existsSync(OPENCODE_CONFIG_PATH)) {
         console.log(`\u2717 Could not parse opencode config at: ${OPENCODE_CONFIG_PATH}`);
         return 1;
       } else {
@@ -40518,13 +40519,13 @@ async function uninstall() {
     console.log("\u2713 Re-enabled default OpenCode agents (explore, general)");
     if (process.argv.includes("--clean")) {
       let cleaned = false;
-      if (fs12.existsSync(PLUGIN_CONFIG_PATH)) {
-        fs12.unlinkSync(PLUGIN_CONFIG_PATH);
+      if (fs13.existsSync(PLUGIN_CONFIG_PATH)) {
+        fs13.unlinkSync(PLUGIN_CONFIG_PATH);
         console.log(`\u2713 Removed plugin config: ${PLUGIN_CONFIG_PATH}`);
         cleaned = true;
       }
-      if (fs12.existsSync(PROMPTS_DIR)) {
-        fs12.rmSync(PROMPTS_DIR, { recursive: true });
+      if (fs13.existsSync(PROMPTS_DIR)) {
+        fs13.rmSync(PROMPTS_DIR, { recursive: true });
         console.log(`\u2713 Removed custom prompts: ${PROMPTS_DIR}`);
         cleaned = true;
       }