@adhdev/daemon-standalone 0.9.82-rc.66 → 0.9.82-rc.67

package/dist/index.js

@@ -34,6 +34,780 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// ../../node_modules/better-sqlite3/lib/util.js
+var require_util = __commonJS({
+  "../../node_modules/better-sqlite3/lib/util.js"(exports2) {
+    "use strict";
+    exports2.getBooleanOption = (options, key) => {
+      let value = false;
+      if (key in options && typeof (value = options[key]) !== "boolean") {
+        throw new TypeError(`Expected the "${key}" option to be a boolean`);
+      }
+      return value;
+    };
+    exports2.cppdb = /* @__PURE__ */ Symbol();
+    exports2.inspect = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/sqlite-error.js
+var require_sqlite_error = __commonJS({
+  "../../node_modules/better-sqlite3/lib/sqlite-error.js"(exports2, module2) {
+    "use strict";
+    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
+    function SqliteError(message, code) {
+      if (new.target !== SqliteError) {
+        return new SqliteError(message, code);
+      }
+      if (typeof code !== "string") {
+        throw new TypeError("Expected second argument to be a string");
+      }
+      Error.call(this, message);
+      descriptor.value = "" + message;
+      Object.defineProperty(this, "message", descriptor);
+      Error.captureStackTrace(this, SqliteError);
+      this.code = code;
+    }
+    Object.setPrototypeOf(SqliteError, Error);
+    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
+    Object.defineProperty(SqliteError.prototype, "name", descriptor);
+    module2.exports = SqliteError;
+  }
+});
+
+// ../../node_modules/file-uri-to-path/index.js
+var require_file_uri_to_path = __commonJS({
+  "../../node_modules/file-uri-to-path/index.js"(exports2, module2) {
+    "use strict";
+    var sep = require("path").sep || "/";
+    module2.exports = fileUriToPath;
+    function fileUriToPath(uri) {
+      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
+        throw new TypeError("must pass in a file:// URI to convert to a file path");
+      }
+      var rest = decodeURI(uri.substring(7));
+      var firstSlash = rest.indexOf("/");
+      var host = rest.substring(0, firstSlash);
+      var path5 = rest.substring(firstSlash + 1);
+      if ("localhost" == host) host = "";
+      if (host) {
+        host = sep + sep + host;
+      }
+      path5 = path5.replace(/^(.+)\|/, "$1:");
+      if (sep == "\\") {
+        path5 = path5.replace(/\//g, "\\");
+      }
+      if (/^.+\:/.test(path5)) {
+      } else {
+        path5 = sep + path5;
+      }
+      return host + path5;
+    }
+  }
+});
+
+// ../../node_modules/bindings/bindings.js
+var require_bindings = __commonJS({
+  "../../node_modules/bindings/bindings.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require("fs");
+    var path5 = require("path");
+    var fileURLToPath = require_file_uri_to_path();
+    var join4 = path5.join;
+    var dirname3 = path5.dirname;
+    var exists = fs4.accessSync && function(path6) {
+      try {
+        fs4.accessSync(path6);
+      } catch (e) {
+        return false;
+      }
+      return true;
+    } || fs4.existsSync || path5.existsSync;
+    var defaults = {
+      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
+      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
+      platform: process.platform,
+      arch: process.arch,
+      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
+      version: process.versions.node,
+      bindings: "bindings.node",
+      try: [
+        // node-gyp's linked version in the "build" dir
+        ["module_root", "build", "bindings"],
+        // node-waf and gyp_addon (a.k.a node-gyp)
+        ["module_root", "build", "Debug", "bindings"],
+        ["module_root", "build", "Release", "bindings"],
+        // Debug files, for development (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Debug", "bindings"],
+        ["module_root", "Debug", "bindings"],
+        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
+        ["module_root", "out", "Release", "bindings"],
+        ["module_root", "Release", "bindings"],
+        // Legacy from node-waf, node <= 0.4.x
+        ["module_root", "build", "default", "bindings"],
+        // Production "Release" buildtype binary (meh...)
+        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
+        // node-qbs builds
+        ["module_root", "addon-build", "release", "install-root", "bindings"],
+        ["module_root", "addon-build", "debug", "install-root", "bindings"],
+        ["module_root", "addon-build", "default", "install-root", "bindings"],
+        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
+        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
+      ]
+    };
+    function bindings(opts) {
+      if (typeof opts == "string") {
+        opts = { bindings: opts };
+      } else if (!opts) {
+        opts = {};
+      }
+      Object.keys(defaults).map(function(i2) {
+        if (!(i2 in opts)) opts[i2] = defaults[i2];
+      });
+      if (!opts.module_root) {
+        opts.module_root = exports2.getRoot(exports2.getFileName());
+      }
+      if (path5.extname(opts.bindings) != ".node") {
+        opts.bindings += ".node";
+      }
+      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
+      var tries = [], i = 0, l = opts.try.length, n, b, err;
+      for (; i < l; i++) {
+        n = join4.apply(
+          null,
+          opts.try[i].map(function(p) {
+            return opts[p] || p;
+          })
+        );
+        tries.push(n);
+        try {
+          b = opts.path ? requireFunc.resolve(n) : requireFunc(n);
+          if (!opts.path) {
+            b.path = n;
+          }
+          return b;
+        } catch (e) {
+          if (e.code !== "MODULE_NOT_FOUND" && e.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e.message)) {
+            throw e;
+          }
+        }
+      }
+      err = new Error(
+        "Could not locate the bindings file. Tried:\n" + tries.map(function(a) {
+          return opts.arrow + a;
+        }).join("\n")
+      );
+      err.tries = tries;
+      throw err;
+    }
+    module2.exports = exports2 = bindings;
+    exports2.getFileName = function getFileName(calling_file) {
+      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
+      Error.stackTraceLimit = 10;
+      Error.prepareStackTrace = function(e, st) {
+        for (var i = 0, l = st.length; i < l; i++) {
+          fileName = st[i].getFileName();
+          if (fileName !== __filename) {
+            if (calling_file) {
+              if (fileName !== calling_file) {
+                return;
+              }
+            } else {
+              return;
+            }
+          }
+        }
+      };
+      Error.captureStackTrace(dummy);
+      dummy.stack;
+      Error.prepareStackTrace = origPST;
+      Error.stackTraceLimit = origSTL;
+      var fileSchema = "file://";
+      if (fileName.indexOf(fileSchema) === 0) {
+        fileName = fileURLToPath(fileName);
+      }
+      return fileName;
+    };
+    exports2.getRoot = function getRoot(file2) {
+      var dir = dirname3(file2), prev;
+      while (true) {
+        if (dir === ".") {
+          dir = process.cwd();
+        }
+        if (exists(join4(dir, "package.json")) || exists(join4(dir, "node_modules"))) {
+          return dir;
+        }
+        if (prev === dir) {
+          throw new Error(
+            'Could not find module root given file: "' + file2 + '". Do you have a `package.json` file? '
+          );
+        }
+        prev = dir;
+        dir = join4(dir, "..");
+      }
+    };
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/wrappers.js
+var require_wrappers = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/wrappers.js"(exports2) {
+    "use strict";
+    var { cppdb } = require_util();
+    exports2.prepare = function prepare(sql) {
+      return this[cppdb].prepare(sql, this, false);
+    };
+    exports2.exec = function exec(sql) {
+      this[cppdb].exec(sql);
+      return this;
+    };
+    exports2.close = function close() {
+      this[cppdb].close();
+      return this;
+    };
+    exports2.loadExtension = function loadExtension(...args) {
+      this[cppdb].loadExtension(...args);
+      return this;
+    };
+    exports2.defaultSafeIntegers = function defaultSafeIntegers(...args) {
+      this[cppdb].defaultSafeIntegers(...args);
+      return this;
+    };
+    exports2.unsafeMode = function unsafeMode(...args) {
+      this[cppdb].unsafeMode(...args);
+      return this;
+    };
+    exports2.getters = {
+      name: {
+        get: function name() {
+          return this[cppdb].name;
+        },
+        enumerable: true
+      },
+      open: {
+        get: function open() {
+          return this[cppdb].open;
+        },
+        enumerable: true
+      },
+      inTransaction: {
+        get: function inTransaction() {
+          return this[cppdb].inTransaction;
+        },
+        enumerable: true
+      },
+      readonly: {
+        get: function readonly2() {
+          return this[cppdb].readonly;
+        },
+        enumerable: true
+      },
+      memory: {
+        get: function memory() {
+          return this[cppdb].memory;
+        },
+        enumerable: true
+      }
+    };
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/transaction.js
+var require_transaction = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/transaction.js"(exports2, module2) {
+    "use strict";
+    var { cppdb } = require_util();
+    var controllers = /* @__PURE__ */ new WeakMap();
+    module2.exports = function transaction(fn) {
+      if (typeof fn !== "function") throw new TypeError("Expected first argument to be a function");
+      const db = this[cppdb];
+      const controller = getController(db, this);
+      const { apply } = Function.prototype;
+      const properties = {
+        default: { value: wrapTransaction(apply, fn, db, controller.default) },
+        deferred: { value: wrapTransaction(apply, fn, db, controller.deferred) },
+        immediate: { value: wrapTransaction(apply, fn, db, controller.immediate) },
+        exclusive: { value: wrapTransaction(apply, fn, db, controller.exclusive) },
+        database: { value: this, enumerable: true }
+      };
+      Object.defineProperties(properties.default.value, properties);
+      Object.defineProperties(properties.deferred.value, properties);
+      Object.defineProperties(properties.immediate.value, properties);
+      Object.defineProperties(properties.exclusive.value, properties);
+      return properties.default.value;
+    };
+    var getController = (db, self) => {
+      let controller = controllers.get(db);
+      if (!controller) {
+        const shared = {
+          commit: db.prepare("COMMIT", self, false),
+          rollback: db.prepare("ROLLBACK", self, false),
+          savepoint: db.prepare("SAVEPOINT `	_bs3.	`", self, false),
+          release: db.prepare("RELEASE `	_bs3.	`", self, false),
+          rollbackTo: db.prepare("ROLLBACK TO `	_bs3.	`", self, false)
+        };
+        controllers.set(db, controller = {
+          default: Object.assign({ begin: db.prepare("BEGIN", self, false) }, shared),
+          deferred: Object.assign({ begin: db.prepare("BEGIN DEFERRED", self, false) }, shared),
+          immediate: Object.assign({ begin: db.prepare("BEGIN IMMEDIATE", self, false) }, shared),
+          exclusive: Object.assign({ begin: db.prepare("BEGIN EXCLUSIVE", self, false) }, shared)
+        });
+      }
+      return controller;
+    };
+    var wrapTransaction = (apply, fn, db, { begin, commit, rollback, savepoint, release, rollbackTo }) => function sqliteTransaction() {
+      let before, after, undo;
+      if (db.inTransaction) {
+        before = savepoint;
+        after = release;
+        undo = rollbackTo;
+      } else {
+        before = begin;
+        after = commit;
+        undo = rollback;
+      }
+      before.run();
+      try {
+        const result = apply.call(fn, this, arguments);
+        if (result && typeof result.then === "function") {
+          throw new TypeError("Transaction function cannot return a promise");
+        }
+        after.run();
+        return result;
+      } catch (ex) {
+        if (db.inTransaction) {
+          undo.run();
+          if (undo !== rollback) after.run();
+        }
+        throw ex;
+      }
+    };
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/pragma.js
+var require_pragma = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/pragma.js"(exports2, module2) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module2.exports = function pragma(source, options) {
+      if (options == null) options = {};
+      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      const simple = getBooleanOption(options, "simple");
+      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
+      return simple ? stmt.pluck().get() : stmt.all();
+    };
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/backup.js
+var require_backup = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/backup.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require("fs");
+    var path5 = require("path");
+    var { promisify } = require("util");
+    var { cppdb } = require_util();
+    var fsAccess = promisify(fs4.access);
+    module2.exports = async function backup(filename, options) {
+      if (options == null) options = {};
+      if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      filename = filename.trim();
+      const attachedName = "attached" in options ? options.attached : "main";
+      const handler = "progress" in options ? options.progress : null;
+      if (!filename) throw new TypeError("Backup filename cannot be an empty string");
+      if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
+      await fsAccess(path5.dirname(filename)).catch(() => {
+        throw new TypeError("Cannot save backup because the directory does not exist");
+      });
+      const isNewFile = await fsAccess(filename).then(() => false, () => true);
+      return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
+    };
+    var runBackup = (backup, handler) => {
+      let rate = 0;
+      let useDefault = true;
+      return new Promise((resolve2, reject) => {
+        setImmediate(function step() {
+          try {
+            const progress = backup.transfer(rate);
+            if (!progress.remainingPages) {
+              backup.close();
+              resolve2(progress);
+              return;
+            }
+            if (useDefault) {
+              useDefault = false;
+              rate = 100;
+            }
+            if (handler) {
+              const ret = handler(progress);
+              if (ret !== void 0) {
+                if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
+                else throw new TypeError("Expected progress callback to return a number or undefined");
+              }
+            }
+            setImmediate(step);
+          } catch (err) {
+            backup.close();
+            reject(err);
+          }
+        });
+      });
+    };
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/serialize.js
+var require_serialize = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/serialize.js"(exports2, module2) {
+    "use strict";
+    var { cppdb } = require_util();
+    module2.exports = function serialize(options) {
+      if (options == null) options = {};
+      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
+      const attachedName = "attached" in options ? options.attached : "main";
+      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
+      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
+      return this[cppdb].serialize(attachedName);
+    };
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/function.js
+var require_function = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/function.js"(exports2, module2) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module2.exports = function defineFunction(name, options, fn) {
+      if (options == null) options = {};
+      if (typeof options === "function") {
+        fn = options;
+        options = {};
+      }
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof fn !== "function") throw new TypeError("Expected last argument to be a function");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = fn.length;
+        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].function(fn, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/aggregate.js
+var require_aggregate = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/aggregate.js"(exports2, module2) {
+    "use strict";
+    var { getBooleanOption, cppdb } = require_util();
+    module2.exports = function defineAggregate(name, options) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
+      if (!name) throw new TypeError("User-defined function name cannot be an empty string");
+      const start = "start" in options ? options.start : null;
+      const step = getFunctionOption(options, "step", true);
+      const inverse = getFunctionOption(options, "inverse", false);
+      const result = getFunctionOption(options, "result", false);
+      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
+      const deterministic = getBooleanOption(options, "deterministic");
+      const directOnly = getBooleanOption(options, "directOnly");
+      const varargs = getBooleanOption(options, "varargs");
+      let argCount = -1;
+      if (!varargs) {
+        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
+        if (argCount > 0) argCount -= 1;
+        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
+      }
+      this[cppdb].aggregate(start, step, inverse, result, name, argCount, safeIntegers, deterministic, directOnly);
+      return this;
+    };
+    var getFunctionOption = (options, key, required2) => {
+      const value = key in options ? options[key] : null;
+      if (typeof value === "function") return value;
+      if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
+      if (required2) throw new TypeError(`Missing required option "${key}"`);
+      return null;
+    };
+    var getLength = ({ length }) => {
+      if (Number.isInteger(length) && length >= 0) return length;
+      throw new TypeError("Expected function.length to be a positive integer");
+    };
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/table.js
+var require_table = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/table.js"(exports2, module2) {
+    "use strict";
+    var { cppdb } = require_util();
+    module2.exports = function defineTable(name, factory) {
+      if (typeof name !== "string") throw new TypeError("Expected first argument to be a string");
+      if (!name) throw new TypeError("Virtual table module name cannot be an empty string");
+      let eponymous = false;
+      if (typeof factory === "object" && factory !== null) {
+        eponymous = true;
+        factory = defer(parseTableDefinition(factory, "used", name));
+      } else {
+        if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
+        factory = wrapFactory(factory);
+      }
+      this[cppdb].table(factory, name, eponymous);
+      return this;
+    };
+    function wrapFactory(factory) {
+      return function virtualTableFactory(moduleName, databaseName, tableName, ...args) {
+        const thisObject = {
+          module: moduleName,
+          database: databaseName,
+          table: tableName
+        };
+        const def = apply.call(factory, thisObject, args);
+        if (typeof def !== "object" || def === null) {
+          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
+        }
+        return parseTableDefinition(def, "returned", moduleName);
+      };
+    }
+    function parseTableDefinition(def, verb, moduleName) {
+      if (!hasOwnProperty.call(def, "rows")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
+      }
+      if (!hasOwnProperty.call(def, "columns")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
+      }
+      const rows = def.rows;
+      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
+      }
+      let columns = def.columns;
+      if (!Array.isArray(columns) || !(columns = [...columns]).every((x) => typeof x === "string")) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
+      }
+      if (columns.length !== new Set(columns).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
+      }
+      if (!columns.length) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
+      }
+      let parameters;
+      if (hasOwnProperty.call(def, "parameters")) {
+        parameters = def.parameters;
+        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x) => typeof x === "string")) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
+        }
+      } else {
+        parameters = inferParameters(rows);
+      }
+      if (parameters.length !== new Set(parameters).size) {
+        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
+      }
+      if (parameters.length > 32) {
+        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
+      }
+      for (const parameter of parameters) {
+        if (columns.includes(parameter)) {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
+        }
+      }
+      let safeIntegers = 2;
+      if (hasOwnProperty.call(def, "safeIntegers")) {
+        const bool = def.safeIntegers;
+        if (typeof bool !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
+        }
+        safeIntegers = +bool;
+      }
+      let directOnly = false;
+      if (hasOwnProperty.call(def, "directOnly")) {
+        directOnly = def.directOnly;
+        if (typeof directOnly !== "boolean") {
+          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
+        }
+      }
+      const columnDefinitions = [
+        ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
+        ...columns.map(identifier)
+      ];
+      return [
+        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
+        wrapGenerator(rows, new Map(columns.map((x, i) => [x, parameters.length + i])), moduleName),
+        parameters,
+        safeIntegers,
+        directOnly
+      ];
+    }
+    function wrapGenerator(generator, columnMap, moduleName) {
+      return function* virtualTable(...args) {
+        const output = args.map((x) => Buffer.isBuffer(x) ? Buffer.from(x) : x);
+        for (let i = 0; i < columnMap.size; ++i) {
+          output.push(null);
+        }
+        for (const row of generator(...args)) {
+          if (Array.isArray(row)) {
+            extractRowArray(row, output, columnMap.size, moduleName);
+            yield output;
+          } else if (typeof row === "object" && row !== null) {
+            extractRowObject(row, output, columnMap, moduleName);
+            yield output;
+          } else {
+            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
+          }
+        }
+      };
+    }
+    function extractRowArray(row, output, columnCount, moduleName) {
+      if (row.length !== columnCount) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
+      }
+      const offset = output.length - columnCount;
+      for (let i = 0; i < columnCount; ++i) {
+        output[i + offset] = row[i];
+      }
+    }
+    function extractRowObject(row, output, columnMap, moduleName) {
+      let count = 0;
+      for (const key of Object.keys(row)) {
+        const index = columnMap.get(key);
+        if (index === void 0) {
+          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
+        }
+        output[index] = row[key];
+        count += 1;
+      }
+      if (count !== columnMap.size) {
+        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
+      }
+    }
+    function inferParameters({ length }) {
+      if (!Number.isInteger(length) || length < 0) {
+        throw new TypeError("Expected function.length to be a positive integer");
+      }
+      const params = [];
+      for (let i = 0; i < length; ++i) {
+        params.push(`$${i + 1}`);
+      }
+      return params;
+    }
+    var { hasOwnProperty } = Object.prototype;
+    var { apply } = Function.prototype;
+    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
+    });
+    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
+    var defer = (x) => () => x;
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/methods/inspect.js
+var require_inspect = __commonJS({
+  "../../node_modules/better-sqlite3/lib/methods/inspect.js"(exports2, module2) {
+    "use strict";
+    var DatabaseInspection = function Database() {
+    };
+    module2.exports = function inspect(depth, opts) {
+      return Object.assign(new DatabaseInspection(), this);
+    };
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/database.js
+var require_database = __commonJS({
+  "../../node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
+    "use strict";
+    var fs4 = require("fs");
+    var path5 = require("path");
+    var util = require_util();
+    var SqliteError = require_sqlite_error();
+    var DEFAULT_ADDON;
+    function Database(filenameGiven, options) {
+      if (new.target == null) {
+        return new Database(filenameGiven, options);
+      }
+      let buffer;
+      if (Buffer.isBuffer(filenameGiven)) {
+        buffer = filenameGiven;
+        filenameGiven = ":memory:";
+      }
+      if (filenameGiven == null) filenameGiven = "";
+      if (options == null) options = {};
+      if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
+      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
+      if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
+      if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
+      const filename = filenameGiven.trim();
+      const anonymous = filename === "" || filename === ":memory:";
+      const readonly2 = util.getBooleanOption(options, "readonly");
+      const fileMustExist = util.getBooleanOption(options, "fileMustExist");
+      const timeout = "timeout" in options ? options.timeout : 5e3;
+      const verbose = "verbose" in options ? options.verbose : null;
+      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
+      if (readonly2 && anonymous && !buffer) throw new TypeError("In-memory/temporary databases cannot be readonly");
+      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
+      if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
+      if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
+      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
+      let addon;
+      if (nativeBinding == null) {
+        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
+      } else if (typeof nativeBinding === "string") {
+        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : require;
+        addon = requireFunc(path5.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
+      } else {
+        addon = nativeBinding;
+      }
+      if (!addon.isInitialized) {
+        addon.setErrorConstructor(SqliteError);
+        addon.isInitialized = true;
+      }
+      if (!anonymous && !filename.startsWith("file:") && !fs4.existsSync(path5.dirname(filename))) {
+        throw new TypeError("Cannot open database because the directory does not exist");
+      }
+      Object.defineProperties(this, {
+        [util.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly2, fileMustExist, timeout, verbose || null, buffer || null) },
+        ...wrappers.getters
+      });
+    }
+    var wrappers = require_wrappers();
+    Database.prototype.prepare = wrappers.prepare;
+    Database.prototype.transaction = require_transaction();
+    Database.prototype.pragma = require_pragma();
+    Database.prototype.backup = require_backup();
+    Database.prototype.serialize = require_serialize();
+    Database.prototype.function = require_function();
+    Database.prototype.aggregate = require_aggregate();
+    Database.prototype.table = require_table();
+    Database.prototype.loadExtension = wrappers.loadExtension;
+    Database.prototype.exec = wrappers.exec;
+    Database.prototype.close = wrappers.close;
+    Database.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
+    Database.prototype.unsafeMode = wrappers.unsafeMode;
+    Database.prototype[util.inspect] = require_inspect();
+    module2.exports = Database;
+  }
+});
+
+// ../../node_modules/better-sqlite3/lib/index.js
+var require_lib = __commonJS({
+  "../../node_modules/better-sqlite3/lib/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = require_database();
+    module2.exports.SqliteError = require_sqlite_error();
+  }
+});
+
 // ../session-host-core/dist/index.js
 var require_dist = __commonJS({
   "../session-host-core/dist/index.js"(exports2, module2) {
@@ -23812,14 +24586,162 @@ Follow these recovery rules:
         meshLedgerEvents = new import_events.EventEmitter();
       }
     });
+    function safeMeshId(meshId) {
+      return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+    }
+    function legacyQueuePath(meshId) {
+      return (0, import_path5.join)(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+    }
+    var import_better_sqlite3;
+    var import_fs5;
+    var import_path5;
+    var BeadsDB;
+    var init_beads_db = __esm2({
+      "src/mesh/beads-db.ts"() {
+        "use strict";
+        import_better_sqlite3 = __toESM2(require_lib());
+        import_fs5 = require("fs");
+        import_path5 = require("path");
+        init_mesh_ledger();
+        BeadsDB = class _BeadsDB {
+          static instance;
+          db;
+          migratedMeshIds = /* @__PURE__ */ new Set();
+          constructor(dbPath) {
+            const dir = (0, import_path5.dirname)(dbPath);
+            if (!(0, import_fs5.existsSync)(dir)) (0, import_fs5.mkdirSync)(dir, { recursive: true });
+            this.db = new import_better_sqlite3.default(dbPath);
+            this.db.pragma("journal_mode = WAL");
+            this.db.pragma("synchronous = NORMAL");
+            this.db.pragma("foreign_keys = ON");
+            this.db.pragma("busy_timeout = 5000");
+            this.migrate();
+          }
+          static getInstance() {
+            if (!this.instance) {
+              this.instance = new _BeadsDB((0, import_path5.join)(getLedgerDir(), "beads.db"));
+            }
+            return this.instance;
+          }
+          static resetForTests() {
+            this.instance?.close();
+            this.instance = void 0;
+          }
+          close() {
+            this.db.close();
+          }
+          transaction(fn) {
+            return this.db.transaction(fn).immediate();
+          }
+          migrate() {
+            this.db.exec(`
+            CREATE TABLE IF NOT EXISTS mesh_queue (
+                id TEXT PRIMARY KEY,
+                mesh_id TEXT NOT NULL,
+                status TEXT NOT NULL,
+                target_node_id TEXT,
+                target_session_id TEXT,
+                assigned_node_id TEXT,
+                assigned_session_id TEXT,
+                created_at TEXT NOT NULL,
+                updated_at TEXT NOT NULL,
+                payload TEXT NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_queue_mesh_status_created
+                ON mesh_queue(mesh_id, status, created_at);
+            CREATE INDEX IF NOT EXISTS idx_mesh_queue_assignment
+                ON mesh_queue(mesh_id, assigned_node_id, assigned_session_id, status);
+        `);
+          }
+          ensureLegacyQueueMigrated(meshId) {
+            if (this.migratedMeshIds.has(meshId)) return;
+            this.migratedMeshIds.add(meshId);
+            const count = this.db.prepare("SELECT COUNT(*) AS count FROM mesh_queue WHERE mesh_id = ?").get(meshId);
+            if (count.count > 0) return;
+            const path28 = legacyQueuePath(meshId);
+            if (!(0, import_fs5.existsSync)(path28)) return;
+            try {
+              const entries = JSON.parse((0, import_fs5.readFileSync)(path28, "utf-8"));
+              if (!Array.isArray(entries)) return;
+              const insert = this.db.prepare(`
+                INSERT OR REPLACE INTO mesh_queue (
+                    id, mesh_id, status, target_node_id, target_session_id,
+                    assigned_node_id, assigned_session_id, created_at, updated_at, payload
+                ) VALUES (
+                    @id, @meshId, @status, @targetNodeId, @targetSessionId,
+                    @assignedNodeId, @assignedSessionId, @createdAt, @updatedAt, @payload
+                )
+            `);
+              for (const entry of entries) {
+                insert.run(this.toRow(entry));
+              }
+            } catch {
+              return;
+            }
+          }
+          getQueueEntries(meshId, statuses) {
+            this.ensureLegacyQueueMigrated(meshId);
+            if (statuses?.length) {
+              const placeholders = statuses.map(() => "?").join(", ");
+              const rows2 = this.db.prepare(`SELECT payload FROM mesh_queue WHERE mesh_id = ? AND status IN (${placeholders}) ORDER BY created_at ASC`).all(meshId, ...statuses);
+              return rows2.map((row) => JSON.parse(row.payload));
+            }
+            const rows = this.db.prepare("SELECT payload FROM mesh_queue WHERE mesh_id = ? ORDER BY created_at ASC").all(meshId);
+            return rows.map((row) => JSON.parse(row.payload));
+          }
+          getQueueRevision(meshId) {
+            this.ensureLegacyQueueMigrated(meshId);
+            const rows = this.db.prepare("SELECT id, status, updated_at FROM mesh_queue WHERE mesh_id = ? ORDER BY id ASC").all(meshId);
+            return rows.map((row) => `${row.id}:${row.status}:${row.updated_at}`).join("|");
+          }
+          replaceQueue(meshId, queue) {
+            const deleteStmt = this.db.prepare("DELETE FROM mesh_queue WHERE mesh_id = ?");
+            const insert = this.db.prepare(`
+            INSERT INTO mesh_queue (
+                id, mesh_id, status, target_node_id, target_session_id,
+                assigned_node_id, assigned_session_id, created_at, updated_at, payload
+            ) VALUES (
+                @id, @meshId, @status, @targetNodeId, @targetSessionId,
+                @assignedNodeId, @assignedSessionId, @createdAt, @updatedAt, @payload
+            )
+        `);
+            deleteStmt.run(meshId);
+            for (const entry of queue) insert.run(this.toRow(entry));
+          }
+          deleteQueue(meshId) {
+            this.db.prepare("DELETE FROM mesh_queue WHERE mesh_id = ?").run(meshId);
+            this.migratedMeshIds.delete(meshId);
+          }
+          toRow(entry) {
+            return {
+              id: entry.id,
+              meshId: entry.meshId,
+              status: entry.status,
+              targetNodeId: entry.targetNodeId ?? null,
+              targetSessionId: entry.targetSessionId ?? null,
+              assignedNodeId: entry.assignedNodeId ?? null,
+              assignedSessionId: entry.assignedSessionId ?? null,
+              createdAt: entry.createdAt,
+              updatedAt: entry.updatedAt,
+              payload: JSON.stringify(entry)
+            };
+          }
+        };
+      }
+    });
     var mesh_work_queue_exports = {};
     __export2(mesh_work_queue_exports, {
       ACTIVE_MESH_QUEUE_STATUSES: () => ACTIVE_MESH_QUEUE_STATUSES,
       HISTORICAL_MESH_QUEUE_STATUSES: () => HISTORICAL_MESH_QUEUE_STATUSES,
       MESH_TASK_MODES: () => MESH_TASK_MODES,
+      __clearMeshQueueForTests: () => __clearMeshQueueForTests,
+      __replaceMeshQueueForTests: () => __replaceMeshQueueForTests,
+      __resetBeadsDBForTests: () => __resetBeadsDBForTests,
       cancelTask: () => cancelTask,
       claimNextTask: () => claimNextTask,
       enqueueTask: () => enqueueTask,
+      getMeshQueueRevision: () => getMeshQueueRevision,
       getMeshQueueStats: () => getMeshQueueStats,
       getQueue: () => getQueue,
       normalizeMeshTaskMode: () => normalizeMeshTaskMode,
@@ -23855,53 +24777,14 @@ Follow these recovery rules:
         ]
       };
     }
-    function getQueuePath(meshId) {
-      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path5.join)(getLedgerDir(), `${safe}.queue.json`);
-    }
-    function getLockPath(meshId) {
-      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-      return (0, import_path5.join)(getLedgerDir(), `${safe}.queue.lock`);
-    }
-    function withQueueLock(meshId, fn) {
-      const lockPath = getLockPath(meshId);
-      let fd = -1;
-      for (let i = 0; i < 10; i++) {
-        try {
-          fd = (0, import_fs5.openSync)(lockPath, "wx");
-          break;
-        } catch {
-          const deadline = Date.now() + 30;
-          while (Date.now() < deadline) {
-          }
-        }
-      }
-      try {
-        return fn();
-      } finally {
-        if (fd !== -1) try {
-          (0, import_fs5.closeSync)(fd);
-        } catch {
-        }
-        try {
-          (0, import_fs5.unlinkSync)(lockPath);
-        } catch {
-        }
-      }
+    function withQueueLock(_meshId, fn) {
+      return BeadsDB.getInstance().transaction(fn);
     }
     function readQueue(meshId) {
-      const path28 = getQueuePath(meshId);
-      if (!(0, import_fs5.existsSync)(path28)) return [];
-      try {
-        const content = (0, import_fs5.readFileSync)(path28, "utf-8");
-        return JSON.parse(content);
-      } catch {
-        return [];
-      }
+      return BeadsDB.getInstance().getQueueEntries(meshId);
     }
     function writeQueue(meshId, queue) {
-      const path28 = getQueuePath(meshId);
-      (0, import_fs5.writeFileSync)(path28, JSON.stringify(queue, null, 2), "utf-8");
+      BeadsDB.getInstance().replaceQueue(meshId, queue);
     }
     function enqueueTask(meshId, message, opts) {
       requireMeshHostQueueOwner(opts);
@@ -23935,6 +24818,9 @@ Follow these recovery rules:
       }
       return queue;
     }
+    function getMeshQueueRevision(meshId) {
+      return BeadsDB.getInstance().getQueueRevision(meshId);
+    }
     function claimNextTask(meshId, nodeId, sessionId) {
       return withQueueLock(meshId, () => {
         const queue = readQueue(meshId);
@@ -24078,8 +24964,17 @@ Follow these recovery rules:
         }))
       };
     }
-    var import_fs5;
-    var import_path5;
+    function __replaceMeshQueueForTests(meshId, queue) {
+      BeadsDB.getInstance().transaction(() => {
+        BeadsDB.getInstance().replaceQueue(meshId, queue);
+      });
+    }
+    function __clearMeshQueueForTests(meshId) {
+      BeadsDB.getInstance().deleteQueue(meshId);
+    }
+    function __resetBeadsDBForTests() {
+      BeadsDB.resetForTests();
+    }
     var import_crypto5;
     var ACTIVE_MESH_QUEUE_STATUSES;
     var HISTORICAL_MESH_QUEUE_STATUSES;
@@ -24088,11 +24983,9 @@ Follow these recovery rules:
     var init_mesh_work_queue = __esm2({
       "src/mesh/mesh-work-queue.ts"() {
         "use strict";
-        import_fs5 = require("fs");
-        import_path5 = require("path");
         import_crypto5 = require("crypto");
-        init_mesh_ledger();
         init_mesh_host_ownership();
+        init_beads_db();
         ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
         HISTORICAL_MESH_QUEUE_STATUSES = ["completed", "failed", "cancelled"];
         MESH_TASK_MODES = ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"];
@@ -24241,6 +25134,59 @@ Follow these recovery rules:
         import_fs6 = require("fs");
       }
     });
+    var fs22;
+    var AsyncBatchWriter;
+    var init_async_batch_writer = __esm2({
+      "src/logging/async-batch-writer.ts"() {
+        "use strict";
+        fs22 = __toESM2(require("fs"));
+        AsyncBatchWriter = class {
+          // Maps filePath -> string buffer
+          static buffers = /* @__PURE__ */ new Map();
+          static writePromises = /* @__PURE__ */ new Map();
+          static flushTimer = null;
+          /**
+           * Queues data to be written to a file asynchronously in a batch.
+           */
+          static write(filePath, data) {
+            let buf = this.buffers.get(filePath);
+            if (!buf) {
+              buf = [];
+              this.buffers.set(filePath, buf);
+            }
+            buf.push(data);
+            if (!this.flushTimer) {
+              this.flushTimer = setTimeout(() => {
+                this.flushTimer = null;
+                this.flushAll();
+              }, 50);
+            }
+          }
+          static async flushAll() {
+            const entries = Array.from(this.buffers.entries());
+            this.buffers.clear();
+            for (const [filePath, buffer] of entries) {
+              const dataToWrite = buffer.join("");
+              const doWrite = async () => {
+                try {
+                  const prevPromise = this.writePromises.get(filePath);
+                  if (prevPromise) await prevPromise;
+                  await fs22.promises.appendFile(filePath, dataToWrite, { encoding: "utf-8", mode: 384 });
+                } catch {
+                }
+              };
+              const writePromise = doWrite();
+              this.writePromises.set(filePath, writePromise);
+              writePromise.finally(() => {
+                if (this.writePromises.get(filePath) === writePromise) {
+                  this.writePromises.delete(filePath);
+                }
+              });
+            }
+          }
+        };
+      }
+    });
     function setLogLevel(level) {
       currentLevel = level;
       daemonLog("Logger", `Log level set to: ${level}`, "info");
@@ -24267,7 +25213,7 @@ Follow these recovery rules:
     }
     function cleanOldLogs() {
       try {
-        const files = fs22.readdirSync(LOG_DIR).filter((f) => f.startsWith("daemon-") && f.endsWith(".log"));
+        const files = fs32.readdirSync(LOG_DIR).filter((f) => f.startsWith("daemon-") && f.endsWith(".log"));
         const cutoff = /* @__PURE__ */ new Date();
         cutoff.setDate(cutoff.getDate() - MAX_LOG_DAYS);
         const cutoffStr = cutoff.toISOString().slice(0, 10);
@@ -24275,7 +25221,7 @@ Follow these recovery rules:
           const dateMatch = file2.match(/daemon-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs22.unlinkSync(path9.join(LOG_DIR, file2));
+              fs32.unlinkSync(path9.join(LOG_DIR, file2));
             } catch {
             }
           }
@@ -24285,14 +25231,14 @@ Follow these recovery rules:
     }
     function rotateSizeIfNeeded() {
       try {
-        const stat2 = fs22.statSync(currentLogFile);
+        const stat2 = fs32.statSync(currentLogFile);
         if (stat2.size > MAX_LOG_SIZE) {
           const backup = currentLogFile.replace(".log", ".1.log");
           try {
-            fs22.unlinkSync(backup);
+            fs32.unlinkSync(backup);
           } catch {
           }
-          fs22.renameSync(currentLogFile, backup);
+          fs32.renameSync(currentLogFile, backup);
         }
       } catch {
       }
@@ -24303,7 +25249,7 @@ Follow these recovery rules:
           checkDateRotation();
           rotateSizeIfNeeded();
         }
-        fs22.appendFileSync(currentLogFile, line + "\n");
+        AsyncBatchWriter.write(currentLogFile, line + "\n");
       } catch {
       }
     }
@@ -24391,7 +25337,7 @@ Follow these recovery rules:
       writeToFile(`Log file: ${currentLogFile}`);
       writeToFile(`Log level: ${currentLevel}`);
     }
-    var fs22;
+    var fs32;
     var path9;
     var os32;
     var LEVEL_NUM;
@@ -24414,9 +25360,10 @@ Follow these recovery rules:
     var init_logger = __esm2({
       "src/logging/logger.ts"() {
         "use strict";
-        fs22 = __toESM2(require("fs"));
+        fs32 = __toESM2(require("fs"));
         path9 = __toESM2(require("path"));
         os32 = __toESM2(require("os"));
+        init_async_batch_writer();
         LEVEL_NUM = { debug: 0, info: 1, warn: 2, error: 3 };
         LEVEL_LABEL = { debug: "DBG", info: "INF", warn: "WRN", error: "ERR" };
         currentLevel = "info";
@@ -24424,7 +25371,7 @@ Follow these recovery rules:
         MAX_LOG_SIZE = 5 * 1024 * 1024;
         MAX_LOG_DAYS = 7;
         try {
-          fs22.mkdirSync(LOG_DIR, { recursive: true });
+          fs32.mkdirSync(LOG_DIR, { recursive: true });
         } catch {
         }
         currentDate = getDateStr();
@@ -24432,14 +25379,14 @@ Follow these recovery rules:
         cleanOldLogs();
         try {
           const oldLog = path9.join(LOG_DIR, "daemon.log");
-          if (fs22.existsSync(oldLog)) {
-            const stat2 = fs22.statSync(oldLog);
+          if (fs32.existsSync(oldLog)) {
+            const stat2 = fs32.statSync(oldLog);
             const oldDate = stat2.mtime.toISOString().slice(0, 10);
-            fs22.renameSync(oldLog, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
+            fs32.renameSync(oldLog, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
           }
           const oldLogBackup = path9.join(LOG_DIR, "daemon.log.old");
-          if (fs22.existsSync(oldLogBackup)) {
-            fs22.unlinkSync(oldLogBackup);
+          if (fs32.existsSync(oldLogBackup)) {
+            fs32.unlinkSync(oldLogBackup);
           }
         } catch {
         }
@@ -25792,8 +26739,8 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
             let cwd = options.cwd;
             if (cwd) {
               try {
-                const fs16 = require("fs");
-                const stat2 = fs16.statSync(cwd);
+                const fs17 = require("fs");
+                const stat2 = fs17.statSync(cwd);
                 if (!stat2.isDirectory()) cwd = os8.homedir();
               } catch {
                 cwd = os8.homedir();
@@ -25891,27 +26838,35 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         return path14.isAbsolute(expanded) ? expanded : path14.resolve(expanded);
       }
       const isWin = os9.platform() === "win32";
-      try {
-        const cmd = isWin ? `where ${trimmed}` : `which ${trimmed}`;
-        return (0, import_child_process4.execSync)(cmd, {
-          encoding: "utf-8",
-          timeout: 5e3,
-          stdio: ["pipe", "pipe", "pipe"],
-          ...isWin ? { windowsHide: true } : {}
-        }).trim().split("\n")[0].trim();
-      } catch {
-        return isWin ? `${trimmed}.cmd` : trimmed;
+      const paths = (process.env.PATH || "").split(path14.delimiter);
+      const exes = isWin ? [".exe", ".cmd", ".bat", ""] : [""];
+      for (const p of paths) {
+        if (!p) continue;
+        for (const ext of exes) {
+          const fullPath = path14.join(p, trimmed + ext);
+          try {
+            const fs17 = require("fs");
+            if (fs17.existsSync(fullPath)) {
+              const stat2 = fs17.statSync(fullPath);
+              if (stat2.isFile() && (isWin || stat2.mode & 73)) {
+                return fullPath;
+              }
+            }
+          } catch {
+          }
+        }
       }
+      return isWin ? `${trimmed}.cmd` : trimmed;
     }
     function isScriptBinary(binaryPath) {
       if (!path14.isAbsolute(binaryPath)) return false;
       try {
-        const fs16 = require("fs");
-        const resolved = fs16.realpathSync(binaryPath);
+        const fs17 = require("fs");
+        const resolved = fs17.realpathSync(binaryPath);
         const head = Buffer.alloc(8);
-        const fd = fs16.openSync(resolved, "r");
-        fs16.readSync(fd, head, 0, 8, 0);
-        fs16.closeSync(fd);
+        const fd = fs17.openSync(resolved, "r");
+        fs17.readSync(fd, head, 0, 8, 0);
+        fs17.closeSync(fd);
         let i = 0;
         if (head[0] === 239 && head[1] === 187 && head[2] === 191) i = 3;
         return head[i] === 35 && head[i + 1] === 33;
@@ -25922,12 +26877,12 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
     function looksLikeMachOOrElf(filePath) {
       if (!path14.isAbsolute(filePath)) return false;
       try {
-        const fs16 = require("fs");
-        const resolved = fs16.realpathSync(filePath);
+        const fs17 = require("fs");
+        const resolved = fs17.realpathSync(filePath);
         const buf = Buffer.alloc(8);
-        const fd = fs16.openSync(resolved, "r");
-        fs16.readSync(fd, buf, 0, 8, 0);
-        fs16.closeSync(fd);
+        const fd = fs17.openSync(resolved, "r");
+        fs17.readSync(fd, buf, 0, 8, 0);
+        fs17.closeSync(fd);
         let i = 0;
         if (buf[0] === 239 && buf[1] === 187 && buf[2] === 191) i = 3;
         const b = buf.subarray(i);
@@ -26011,7 +26966,6 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
     }
     var os9;
     var path14;
-    var import_child_process4;
     var TerminalTranscriptAccumulator;
     var buildCliSpawnEnv;
     var init_provider_cli_shared = __esm2({
@@ -26019,7 +26973,6 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         "use strict";
         os9 = __toESM2(require("os"));
         path14 = __toESM2(require("path"));
-        import_child_process4 = require("child_process");
         init_spawn_env();
         TerminalTranscriptAccumulator = class {
           lines = [[]];
@@ -28616,6 +29569,7 @@ ${lastSnapshot}`;
       getLogLevel: () => getLogLevel,
       getMesh: () => getMesh,
       getMeshByRepo: () => getMeshByRepo,
+      getMeshQueueRevision: () => getMeshQueueRevision,
       getMeshQueueStats: () => getMeshQueueStats,
       getNpmExecOptions: () => getNpmExecOptions,
       getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
@@ -31442,9 +32396,11 @@ ${lastSnapshot}`;
       saveState({ ...DEFAULT_STATE });
     }
     var import_child_process2 = require("child_process");
+    var import_util3 = require("util");
     var import_fs9 = require("fs");
     var import_os22 = require("os");
     var path10 = __toESM2(require("path"));
+    var execAsync2 = (0, import_util3.promisify)(import_child_process2.exec);
     var BUILTIN_IDE_DEFINITIONS = [];
     var registeredIDEs = /* @__PURE__ */ new Map();
     function registerIDEDefinition(def) {
@@ -31468,24 +32424,33 @@ ${lastSnapshot}`;
         const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
         return (0, import_fs9.existsSync)(resolved) ? resolved : null;
       }
-      try {
-        const result = (0, import_child_process2.execSync)(
-          (0, import_os22.platform)() === "win32" ? `where ${trimmed}` : `which ${trimmed}`,
-          { encoding: "utf-8", timeout: 5e3, stdio: ["pipe", "pipe", "pipe"] }
-        ).trim();
-        return result.split("\n")[0] || null;
-      } catch {
-        return null;
+      const isWin = (0, import_os22.platform)() === "win32";
+      const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
+      const exes = isWin ? [".exe", ".cmd", ".bat", ""] : [""];
+      for (const p of paths) {
+        if (!p) continue;
+        for (const ext of exes) {
+          const fullPath = path10.join(p, trimmed + ext);
+          try {
+            if ((0, import_fs9.existsSync)(fullPath)) {
+              const stat2 = (0, import_fs9.statSync)(fullPath);
+              if (stat2.isFile() && (isWin || stat2.mode & 73)) {
+                return fullPath;
+              }
+            }
+          } catch {
+          }
+        }
       }
+      return null;
     }
-    function getIdeVersion(cliCommand) {
+    async function getIdeVersion(cliCommand) {
       try {
-        const result = (0, import_child_process2.execSync)(`"${cliCommand}" --version`, {
+        const { stdout } = await execAsync2(`"${cliCommand}" --version`, {
           encoding: "utf-8",
-          timeout: 1e4,
-          stdio: ["pipe", "pipe", "pipe"]
-        }).trim();
-        return result.split("\n")[0] || null;
+          timeout: 1e4
+        });
+        return stdout.trim().split("\n")[0] || null;
       } catch {
         return null;
       }
@@ -31533,7 +32498,7 @@ ${lastSnapshot}`;
           }
         }
         const installed = os222 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
-        const version2 = resolvedCli ? getIdeVersion(resolvedCli) : null;
+        const version2 = resolvedCli ? await getIdeVersion(resolvedCli) : null;
         results.push({
           id: def.id,
           name: def.name,
@@ -31550,18 +32515,22 @@ ${lastSnapshot}`;
     init_cli_detector();
     var os42 = __toESM2(require("os"));
     var import_child_process3 = require("child_process");
-    function parseDarwinAvailableBytes(totalMem) {
-      if (os42.platform() !== "darwin") return null;
+    var import_util22 = require("util");
+    var execAsync3 = (0, import_util22.promisify)(import_child_process3.exec);
+    var cachedDarwinAvail = null;
+    var darwinMemoryInterval = null;
+    async function updateDarwinMemoryCache() {
+      if (os42.platform() !== "darwin") return;
       try {
-        const out = (0, import_child_process3.execSync)("vm_stat", {
+        const { stdout } = await execAsync3("vm_stat", {
           encoding: "utf-8",
           timeout: 4e3,
           maxBuffer: 256 * 1024
         });
-        const pageSizeMatch = out.match(/page size of (\d+)\s*bytes/i);
+        const pageSizeMatch = stdout.match(/page size of (\d+)\s*bytes/i);
         const pageSize = pageSizeMatch ? parseInt(pageSizeMatch[1], 10) : 4096;
         const counts = {};
-        for (const line of out.split("\n")) {
+        for (const line of stdout.split("\n")) {
           const m = line.match(/^\s*Pages\s+([^:]+):\s+([\d,]+)\s*\.?/);
           if (!m) continue;
           const key = m[1].trim().toLowerCase().replace(/\s+/g, "_");
@@ -31575,18 +32544,24 @@ ${lastSnapshot}`;
         const fileBacked = counts["file_backed"] ?? 0;
         const availPages = free + inactive + speculative + purgeable + fileBacked;
         const bytes = availPages * pageSize;
-        if (!Number.isFinite(bytes) || bytes < 0) return null;
-        return Math.min(bytes, totalMem);
+        cachedDarwinAvail = Number.isFinite(bytes) && bytes >= 0 ? Math.min(bytes, os42.totalmem()) : null;
       } catch {
-        return null;
       }
     }
     function getHostMemorySnapshot() {
+      if (os42.platform() === "darwin" && !darwinMemoryInterval) {
+        updateDarwinMemoryCache();
+        darwinMemoryInterval = setInterval(updateDarwinMemoryCache, 3e3);
+        darwinMemoryInterval.unref();
+      }
       const totalMem = os42.totalmem();
       const freeMem = os42.freemem();
-      const darwinAvail = parseDarwinAvailableBytes(totalMem);
-      const availableMem = darwinAvail != null ? darwinAvail : freeMem;
-      return { totalMem, freeMem, availableMem };
+      const availableMem = os42.platform() === "darwin" ? cachedDarwinAvail ?? freeMem : freeMem;
+      return {
+        totalMem,
+        freeMem,
+        availableMem
+      };
     }
     var LIVE_LIFECYCLES = /* @__PURE__ */ new Set(["starting", "running", "stopping", "interrupted"]);
     function isSessionHostLiveRuntime(record2) {
@@ -33929,7 +34904,7 @@ ${lastSnapshot}`;
 ${cleanBody}`;
       return cleanTitle || cleanBody;
     }
-    var fs32 = __toESM2(require("fs"));
+    var fs42 = __toESM2(require("fs"));
     var path11 = __toESM2(require("path"));
     var os52 = __toESM2(require("os"));
     var HISTORY_DIR = path11.join(os52.homedir(), ".adhdev", "history");
@@ -34049,8 +35024,8 @@ ${cleanBody}`;
     function readPersistedSavedHistorySessionSummaries(dir) {
       try {
         const filePath = getSavedHistoryIndexFilePath(dir);
-        if (!fs32.existsSync(filePath)) return null;
-        const raw = JSON.parse(fs32.readFileSync(filePath, "utf-8"));
+        if (!fs42.existsSync(filePath)) return null;
+        const raw = JSON.parse(fs42.readFileSync(filePath, "utf-8"));
         if (!raw || raw.version !== SAVED_HISTORY_INDEX_VERSION || !raw.sessions || typeof raw.sessions !== "object") {
           return null;
         }
@@ -34077,7 +35052,7 @@ ${cleanBody}`;
     }
     function listHistoryFiles(dir, historySessionId) {
       const sanitizedSessionId = historySessionId ? sanitizeHistoryFileSegment(historySessionId) : "";
-      return fs32.readdirSync(dir).filter((file2) => {
+      return fs42.readdirSync(dir).filter((file2) => {
         if (!file2.endsWith(".jsonl")) return false;
         if (sanitizedSessionId) {
           return file2.startsWith(`${sanitizedSessionId}_`);
@@ -34095,7 +35070,7 @@ ${cleanBody}`;
     function buildSavedHistoryFileSignatureMap(dir, files) {
       return new Map(files.map((file2) => {
         try {
-          const stat2 = fs32.statSync(path11.join(dir, file2));
+          const stat2 = fs42.statSync(path11.join(dir, file2));
           return [file2, `${file2}:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`];
         } catch {
           return [file2, `${file2}:missing`];
@@ -34118,8 +35093,8 @@ ${cleanBody}`;
     function loadPersistedSavedHistoryIndexFromFile(dir) {
       try {
         const filePath = getSavedHistoryIndexFilePath(dir);
-        if (!fs32.existsSync(filePath)) return /* @__PURE__ */ new Map();
-        const raw = JSON.parse(fs32.readFileSync(filePath, "utf-8"));
+        if (!fs42.existsSync(filePath)) return /* @__PURE__ */ new Map();
+        const raw = JSON.parse(fs42.readFileSync(filePath, "utf-8"));
         if (!raw || raw.version !== SAVED_HISTORY_INDEX_VERSION || !raw.files || typeof raw.files !== "object") {
           return /* @__PURE__ */ new Map();
         }
@@ -34141,27 +35116,27 @@ ${cleanBody}`;
         files: Object.fromEntries(entries.entries()),
         sessions: buildSavedHistorySessionSummaryMapFromEntries(entries)
       };
-      fs32.writeFileSync(tempPath, JSON.stringify(payload), "utf-8");
-      fs32.renameSync(tempPath, filePath);
+      fs42.writeFileSync(tempPath, JSON.stringify(payload), "utf-8");
+      fs42.renameSync(tempPath, filePath);
     }
     function acquireSavedHistoryIndexLock(dir) {
       const lockPath = getSavedHistoryIndexLockPath(dir);
       const deadline = Date.now() + SAVED_HISTORY_INDEX_LOCK_WAIT_MS;
       while (Date.now() <= deadline) {
         try {
-          fs32.mkdirSync(lockPath);
+          fs42.mkdirSync(lockPath);
           return () => {
             try {
-              fs32.rmSync(lockPath, { recursive: true, force: true });
+              fs42.rmSync(lockPath, { recursive: true, force: true });
             } catch {
             }
           };
         } catch (error48) {
           if (error48?.code !== "EEXIST") return null;
           try {
-            const stat2 = fs32.statSync(lockPath);
+            const stat2 = fs42.statSync(lockPath);
             if (Date.now() - stat2.mtimeMs > SAVED_HISTORY_INDEX_LOCK_STALE_MS) {
-              fs32.rmSync(lockPath, { recursive: true, force: true });
+              fs42.rmSync(lockPath, { recursive: true, force: true });
               continue;
             }
           } catch {
@@ -34208,7 +35183,7 @@ ${cleanBody}`;
         }
         for (const file2 of Array.from(currentEntries.keys())) {
           if (incomingFiles.has(file2)) continue;
-          if (!fs32.existsSync(path11.join(dir, file2))) {
+          if (!fs42.existsSync(path11.join(dir, file2))) {
             currentEntries.delete(file2);
           }
         }
@@ -34216,14 +35191,14 @@ ${cleanBody}`;
     }
     function invalidatePersistedSavedHistoryIndex(agentType, dir) {
       try {
-        fs32.rmSync(getSavedHistoryIndexFilePath(dir), { force: true });
+        fs42.rmSync(getSavedHistoryIndexFilePath(dir), { force: true });
       } catch {
       }
       savedHistorySessionCache.delete(agentType.replace(/[^a-zA-Z0-9_-]/g, "_"));
     }
     function buildSavedHistoryIndexFileSignature(dir) {
       try {
-        const stat2 = fs32.statSync(getSavedHistoryIndexFilePath(dir));
+        const stat2 = fs42.statSync(getSavedHistoryIndexFilePath(dir));
         return `index:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`;
       } catch {
         return "index:missing";
@@ -34231,10 +35206,10 @@ ${cleanBody}`;
     }
     function historyDirectoryHasFilesNewerThanIndex(dir) {
       try {
-        const indexStat = fs32.statSync(getSavedHistoryIndexFilePath(dir));
+        const indexStat = fs42.statSync(getSavedHistoryIndexFilePath(dir));
         const files = listHistoryFiles(dir);
         for (const file2 of files) {
-          const stat2 = fs32.statSync(path11.join(dir, file2));
+          const stat2 = fs42.statSync(path11.join(dir, file2));
           if (stat2.mtimeMs > indexStat.mtimeMs) return true;
         }
         return false;
@@ -34244,7 +35219,7 @@ ${cleanBody}`;
     }
     function buildSavedHistoryFileSignature(dir, file2) {
       try {
-        const stat2 = fs32.statSync(path11.join(dir, file2));
+        const stat2 = fs42.statSync(path11.join(dir, file2));
         return `${file2}:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`;
       } catch {
         return `${file2}:missing`;
@@ -34325,7 +35300,7 @@ ${cleanBody}`;
       const historySessionId = extractSavedHistorySessionIdFromFile(file2);
       if (!historySessionId) return null;
       const filePath = path11.join(dir, file2);
-      const content = fs32.readFileSync(filePath, "utf-8");
+      const content = fs42.readFileSync(filePath, "utf-8");
       const lines = content.split("\n").filter(Boolean);
       let messageCount = 0;
       let firstMessageAt = 0;
@@ -34386,7 +35361,7 @@ ${cleanBody}`;
       savedHistoryBackgroundRefresh.add(key);
       setTimeout(() => {
         try {
-          if (!fs32.existsSync(dir)) return;
+          if (!fs42.existsSync(dir)) return;
           const files = listHistoryFiles(dir);
           const fileSignatures = buildSavedHistoryFileSignatureMap(dir, files);
           const persistedEntries = loadPersistedSavedHistoryIndex(dir);
@@ -34532,13 +35507,13 @@ ${cleanBody}`;
           }
           if (newMessages.length === 0) return;
           const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
-          fs32.mkdirSync(dir, { recursive: true });
+          fs42.mkdirSync(dir, { recursive: true });
           const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
           const filePrefix = effectiveHistoryKey ? `${this.sanitize(effectiveHistoryKey)}_` : "";
           const fileName = `${filePrefix}${date5}.jsonl`;
           const filePath = path11.join(dir, fileName);
           const lines = newMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-          fs32.appendFileSync(filePath, lines, "utf-8");
+          fs42.appendFileSync(filePath, lines, "utf-8");
           updateSavedHistoryIndexForAppendedMessages(agentType, dir, fileName, effectiveHistoryKey, newMessages);
           const prevCount = this.lastSeenCounts.get(dedupKey) || 0;
           if (!historySessionId && messages.length < prevCount * 0.5 && prevCount > 3) {
@@ -34628,7 +35603,7 @@ ${cleanBody}`;
         if (!id || !ws) return;
         try {
           const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
-          fs32.mkdirSync(dir, { recursive: true });
+          fs42.mkdirSync(dir, { recursive: true });
           const date5 = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
           const fileName = `${this.sanitize(id)}_${date5}.jsonl`;
           const filePath = path11.join(dir, fileName);
@@ -34643,7 +35618,7 @@ ${cleanBody}`;
             historySessionId: id,
             workspace: ws
           };
-          fs32.appendFileSync(filePath, JSON.stringify(record2) + "\n", "utf-8");
+          fs42.appendFileSync(filePath, JSON.stringify(record2) + "\n", "utf-8");
           updateSavedHistoryIndexForSessionStart(agentType, dir, fileName, id, ws);
         } catch {
         }
@@ -34678,14 +35653,14 @@ ${cleanBody}`;
             this.lastSeenCounts.delete(fromDedupKey);
           }
           const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
-          if (!fs32.existsSync(dir)) return;
+          if (!fs42.existsSync(dir)) return;
           const fromPrefix = `${this.sanitize(fromId)}_`;
           const toPrefix = `${this.sanitize(toId)}_`;
-          const files = fs32.readdirSync(dir).filter((file2) => file2.startsWith(fromPrefix) && file2.endsWith(".jsonl"));
+          const files = fs42.readdirSync(dir).filter((file2) => file2.startsWith(fromPrefix) && file2.endsWith(".jsonl"));
           for (const file2 of files) {
             const sourcePath = path11.join(dir, file2);
             const targetPath = path11.join(dir, `${toPrefix}${file2.slice(fromPrefix.length)}`);
-            const sourceLines = fs32.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
+            const sourceLines = fs42.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
             const rewritten = sourceLines.map((line) => {
               try {
                 const parsed = JSON.parse(line);
@@ -34699,16 +35674,16 @@ ${cleanBody}`;
               }
             }).filter((line) => !!line);
             if (rewritten.length === 0) {
-              fs32.unlinkSync(sourcePath);
+              fs42.unlinkSync(sourcePath);
               continue;
             }
-            const existing = fs32.existsSync(targetPath) ? new Set(fs32.readFileSync(targetPath, "utf-8").split("\n").filter(Boolean)) : /* @__PURE__ */ new Set();
+            const existing = fs42.existsSync(targetPath) ? new Set(fs42.readFileSync(targetPath, "utf-8").split("\n").filter(Boolean)) : /* @__PURE__ */ new Set();
             const nextLines = rewritten.filter((line) => !existing.has(line));
             if (nextLines.length > 0) {
-              fs32.appendFileSync(targetPath, `${nextLines.join("\n")}
+              fs42.appendFileSync(targetPath, `${nextLines.join("\n")}
 `, "utf-8");
             }
-            fs32.unlinkSync(sourcePath);
+            fs42.unlinkSync(sourcePath);
           }
           invalidatePersistedSavedHistoryIndex(agentType, dir);
         } catch {
@@ -34719,13 +35694,13 @@ ${cleanBody}`;
         if (!sessionId) return;
         try {
           const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
-          if (!fs32.existsSync(dir)) return;
+          if (!fs42.existsSync(dir)) return;
           const prefix = `${this.sanitize(sessionId)}_`;
-          const files = fs32.readdirSync(dir).filter((file2) => file2.startsWith(prefix) && file2.endsWith(".jsonl")).sort();
+          const files = fs42.readdirSync(dir).filter((file2) => file2.startsWith(prefix) && file2.endsWith(".jsonl")).sort();
           const seen = /* @__PURE__ */ new Set();
           for (const file2 of files) {
             const filePath = path11.join(dir, file2);
-            const lines = fs32.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+            const lines = fs42.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
             const next = [];
             for (const line of lines) {
               let parsed = null;
@@ -34754,10 +35729,10 @@ ${cleanBody}`;
             }
             const collapsed = collapseReplayAssistantTurns(dedupedAdjacent, historyBehavior);
             if (collapsed.length === 0) {
-              fs32.unlinkSync(filePath);
+              fs42.unlinkSync(filePath);
               continue;
             }
-            fs32.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join("\n")}
+            fs42.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join("\n")}
 `, "utf-8");
           }
           invalidatePersistedSavedHistoryIndex(agentType, dir);
@@ -34774,18 +35749,18 @@ ${cleanBody}`;
       /** Delete history files older than 30 days */
       async rotateOldFiles() {
         try {
-          if (!fs32.existsSync(HISTORY_DIR)) return;
+          if (!fs42.existsSync(HISTORY_DIR)) return;
           const cutoff = Date.now() - RETAIN_DAYS * 24 * 60 * 60 * 1e3;
-          const agentDirs = fs32.readdirSync(HISTORY_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+          const agentDirs = fs42.readdirSync(HISTORY_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
           for (const dir of agentDirs) {
             const dirPath = path11.join(HISTORY_DIR, dir.name);
-            const files = fs32.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl") || f.endsWith(".terminal.log"));
+            const files = fs42.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl") || f.endsWith(".terminal.log"));
             let removedAny = false;
             for (const file2 of files) {
               const filePath = path11.join(dirPath, file2);
-              const stat2 = fs32.statSync(filePath);
+              const stat2 = fs42.statSync(filePath);
               if (stat2.mtimeMs < cutoff) {
-                fs32.unlinkSync(filePath);
+                fs42.unlinkSync(filePath);
                 removedAny = true;
               }
             }
@@ -34833,13 +35808,13 @@ ${cleanBody}`;
       try {
         const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
         const dir = path11.join(HISTORY_DIR, sanitized);
-        if (!fs32.existsSync(dir)) return { messages: [], hasMore: false };
+        if (!fs42.existsSync(dir)) return { messages: [], hasMore: false };
         const files = listHistoryFiles(dir, historySessionId);
         const allMessages = [];
         const seen = /* @__PURE__ */ new Set();
         for (const file2 of files) {
           const filePath = path11.join(dir, file2);
-          const content = fs32.readFileSync(filePath, "utf-8");
+          const content = fs42.readFileSync(filePath, "utf-8");
           const lines = content.trim().split("\n").filter(Boolean);
           for (let i = 0; i < lines.length; i++) {
             try {
@@ -34863,7 +35838,7 @@ ${cleanBody}`;
       try {
         const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
         const dir = path11.join(HISTORY_DIR, sanitized);
-        if (!fs32.existsSync(dir)) {
+        if (!fs42.existsSync(dir)) {
           savedHistorySessionCache.delete(sanitized);
           return { sessions: [], hasMore: false };
         }
@@ -34924,10 +35899,10 @@ ${cleanBody}`;
     function readExistingSessionStartRecord(agentType, historySessionId) {
       try {
         const dir = path11.join(HISTORY_DIR, agentType);
-        if (!fs32.existsSync(dir)) return null;
+        if (!fs42.existsSync(dir)) return null;
         const files = listHistoryFiles(dir, historySessionId).sort();
         for (const file2 of files) {
-          const lines = fs32.readFileSync(path11.join(dir, file2), "utf-8").split("\n").filter(Boolean);
+          const lines = fs42.readFileSync(path11.join(dir, file2), "utf-8").split("\n").filter(Boolean);
           for (const line of lines) {
             try {
               const parsed = JSON.parse(line);
@@ -34948,16 +35923,16 @@ ${cleanBody}`;
       if (records.length === 0) return false;
       try {
         const dir = path11.join(HISTORY_DIR, agentType);
-        fs32.mkdirSync(dir, { recursive: true });
+        fs42.mkdirSync(dir, { recursive: true });
         const prefix = `${historySessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}_`;
-        for (const file2 of fs32.readdirSync(dir)) {
+        for (const file2 of fs42.readdirSync(dir)) {
           if (file2.startsWith(prefix) && file2.endsWith(".jsonl")) {
-            fs32.unlinkSync(path11.join(dir, file2));
+            fs42.unlinkSync(path11.join(dir, file2));
           }
         }
         const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
         const filePath = path11.join(dir, `${prefix}${targetDate}.jsonl`);
-        fs32.writeFileSync(filePath, `${records.map((record2) => JSON.stringify(record2)).join("\n")}
+        fs42.writeFileSync(filePath, `${records.map((record2) => JSON.stringify(record2)).join("\n")}
 `, "utf-8");
         invalidatePersistedSavedHistoryIndex(agentType, dir);
         savedHistorySessionCache.delete(agentType.replace(/[^a-zA-Z0-9_-]/g, "_"));
@@ -35065,7 +36040,7 @@ ${cleanBody}`;
       if (visible.length === 0) return null;
       let sourceMtimeMs = 0;
       try {
-        sourceMtimeMs = fs32.statSync(sourcePath).mtimeMs;
+        sourceMtimeMs = fs42.statSync(sourcePath).mtimeMs;
       } catch {
       }
       const firstMessageAt = visible[0]?.receivedAt || sourceMtimeMs || Date.now();
@@ -35824,6 +36799,19 @@ ${effect.notification.body || ""}`.trim();
       if (cleanMessage) lines.push(cleanMessage);
       return lines.join("\n");
     }
+    async function withTimeout(promise2, timeoutMs, label) {
+      let timer = null;
+      try {
+        return await Promise.race([
+          promise2,
+          new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new Error(`${label} timed out after ${timeoutMs}ms`)), timeoutMs);
+          })
+        ]);
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    }
     var IdeProviderInstance = class {
       type;
       category = "ide";
@@ -36048,7 +37036,7 @@ ${effect.notification.body || ""}`.trim();
             if (webviewScript) {
               const matchText = this.provider.webviewMatchText;
               const matchFn = matchText ? (body) => body.includes(matchText) : void 0;
-              const webviewRaw = await cdp.evaluateInWebviewFrame(webviewScript, matchFn);
+              const webviewRaw = await withTimeout(cdp.evaluateInWebviewFrame(webviewScript, matchFn), 3e4, "evaluateInWebviewFrame");
               if (webviewRaw) {
                 raw = typeof webviewRaw === "string" ? (() => {
                   try {
@@ -36063,7 +37051,7 @@ ${effect.notification.body || ""}`.trim();
           if (!raw) {
             const readChatScript = this.getReadChatScript();
             if (!readChatScript) return;
-            raw = await cdp.evaluate(readChatScript, 3e4);
+            raw = await withTimeout(cdp.evaluate(readChatScript, 3e4), 3e4, "evaluate.readChatScript");
             if (typeof raw === "string") {
               try {
                 raw = JSON.parse(raw);
@@ -36374,7 +37362,7 @@ ${effect.notification.body || ""}`.trim();
             now
           );
           LOG2.info("IdeInstance", `[IdeInstance:${this.type}] autoApprove: executing resolveAction for "${targetButton}"`);
-          let rawResult = await cdp.evaluate(script, 1e4);
+          let rawResult = await withTimeout(cdp.evaluate(script, 1e4), 1e4, "evaluate.autoApprove");
           if (typeof rawResult === "string") {
             try {
               rawResult = JSON.parse(rawResult);
@@ -37417,7 +38405,7 @@ ${effect.notification.body || ""}`.trim();
       }
       return fn() || null;
     }
-    var fs42 = __toESM2(require("fs"));
+    var fs5 = __toESM2(require("fs"));
     var os62 = __toESM2(require("os"));
     var path12 = __toESM2(require("path"));
     var import_node_crypto = require("crypto");
@@ -37984,11 +38972,11 @@ ${effect.notification.body || ""}`.trim();
     function storeChatDebugBundleOnDaemon(bundle, targetSessionId) {
       const bundleId = createChatDebugBundleId(targetSessionId);
       const dir = getChatDebugBundleDir();
-      fs42.mkdirSync(dir, { recursive: true });
+      fs5.mkdirSync(dir, { recursive: true });
       const savedPath = path12.join(dir, `${bundleId}.json`);
       const json2 = `${JSON.stringify(bundle, null, 2)}
 `;
-      fs42.writeFileSync(savedPath, json2, { encoding: "utf8", mode: 384 });
+      fs5.writeFileSync(savedPath, json2, { encoding: "utf8", mode: 384 });
       return { bundleId, savedPath, sizeBytes: Buffer.byteLength(json2, "utf8") };
     }
     function isDaemonFileDebugDelivery(args) {
@@ -39149,7 +40137,7 @@ ${effect.notification.body || ""}`.trim();
       }
       return { success: false, error: "resolveAction script not available for this provider" };
     }
-    var fs5 = __toESM2(require("fs"));
+    var fs6 = __toESM2(require("fs"));
     var path13 = __toESM2(require("path"));
     var os7 = __toESM2(require("os"));
     var KEY_TO_VK = {
@@ -39422,7 +40410,7 @@ ${effect.notification.body || ""}`.trim();
       return path13.resolve(inputPath);
     }
     function listDirectoryEntriesSafe(dirPath) {
-      const entries = fs5.readdirSync(dirPath, { withFileTypes: true });
+      const entries = fs6.readdirSync(dirPath, { withFileTypes: true });
       const files = [];
       for (const entry of entries) {
         const entryPath = path13.join(dirPath, entry.name);
@@ -39434,14 +40422,14 @@ ${effect.notification.body || ""}`.trim();
           if (entry.isFile()) {
             let size;
             try {
-              size = fs5.statSync(entryPath).size;
+              size = fs6.statSync(entryPath).size;
             } catch {
               size = void 0;
             }
             files.push({ name: entry.name, type: "file", size });
             continue;
           }
-          const stat2 = fs5.statSync(entryPath);
+          const stat2 = fs6.statSync(entryPath);
           files.push({
             name: entry.name,
             type: stat2.isDirectory() ? "directory" : "file",
@@ -39459,7 +40447,7 @@ ${effect.notification.body || ""}`.trim();
         const letter = String.fromCharCode(code);
         const root = `${letter}:\\`;
         try {
-          if (!fs5.existsSync(root)) continue;
+          if (!fs6.existsSync(root)) continue;
           if (excluded && root.toLowerCase() === excluded) continue;
           drives.push({ name: `${letter}:`, type: "directory", path: root });
         } catch {
@@ -39470,7 +40458,7 @@ ${effect.notification.body || ""}`.trim();
     async function handleFileRead(h, args) {
       try {
         const filePath = resolveSafePath(args?.path);
-        const content = fs5.readFileSync(filePath, "utf-8");
+        const content = fs6.readFileSync(filePath, "utf-8");
         return { success: true, content, path: filePath };
       } catch (e) {
         return { success: false, error: e.message };
@@ -39479,8 +40467,8 @@ ${effect.notification.body || ""}`.trim();
     async function handleFileWrite(h, args) {
       try {
         const filePath = resolveSafePath(args?.path);
-        fs5.mkdirSync(path13.dirname(filePath), { recursive: true });
-        fs5.writeFileSync(filePath, args?.content || "", "utf-8");
+        fs6.mkdirSync(path13.dirname(filePath), { recursive: true });
+        fs6.writeFileSync(filePath, args?.content || "", "utf-8");
         return { success: true, path: filePath };
       } catch (e) {
         return { success: false, error: e.message };
@@ -40592,7 +41580,7 @@ ${effect.notification.body || ""}`.trim();
     var path18 = __toESM2(require("path"));
     var crypto4 = __toESM2(require("crypto"));
     var import_fs10 = require("fs");
-    var import_child_process6 = require("child_process");
+    var import_child_process5 = require("child_process");
     var import_chalk = __toESM2((init_source(), __toCommonJS(source_exports)));
     init_provider_cli_adapter();
     init_cli_detector();
@@ -40600,7 +41588,7 @@ ${effect.notification.body || ""}`.trim();
     var os12 = __toESM2(require("os"));
     var path16 = __toESM2(require("path"));
     var crypto3 = __toESM2(require("crypto"));
-    var fs6 = __toESM2(require("fs"));
+    var fs7 = __toESM2(require("fs"));
     var import_node_module = require("module");
     init_provider_cli_adapter();
     init_logger();
@@ -40655,9 +41643,9 @@ ${effect.notification.body || ""}`.trim();
       if (!part.data) return null;
       const rawData = part.data.includes(",") ? part.data.split(",").pop() || "" : part.data;
       if (!rawData) return null;
-      fs6.mkdirSync(dir, { recursive: true });
+      fs7.mkdirSync(dir, { recursive: true });
       const filePath = path16.join(dir, safeInputImageBasename(index, part.mimeType));
-      fs6.writeFileSync(filePath, Buffer.from(rawData, "base64"));
+      fs7.writeFileSync(filePath, Buffer.from(rawData, "base64"));
       cleanupStaleMaterializedImages(dir);
       return filePath;
     }
@@ -40669,14 +41657,14 @@ ${effect.notification.body || ""}`.trim();
       if (now - lastMaterializedImageCleanupAt < MATERIALIZED_IMAGE_CLEANUP_INTERVAL_MS) return;
       lastMaterializedImageCleanupAt = now;
       try {
-        const entries = fs6.readdirSync(dir);
+        const entries = fs7.readdirSync(dir);
         for (const entry of entries) {
           if (!entry.startsWith("adhdev-input-image-")) continue;
           const fullPath = path16.join(dir, entry);
           try {
-            const stat2 = fs6.statSync(fullPath);
+            const stat2 = fs7.statSync(fullPath);
             if (now - stat2.mtimeMs > MATERIALIZED_IMAGE_MAX_AGE_MS) {
-              fs6.unlinkSync(fullPath);
+              fs7.unlinkSync(fullPath);
             }
           } catch {
           }
@@ -40915,7 +41903,7 @@ ${effect.notification.body || ""}`.trim();
         const resolvedDbPath = probe.dbPath.replace(/^~/, os12.homedir());
         const now = Date.now();
         if (this.cachedSqliteDbMissingUntil > now) return null;
-        if (!fs6.existsSync(resolvedDbPath)) {
+        if (!fs7.existsSync(resolvedDbPath)) {
           this.cachedSqliteDbMissingUntil = now + 1e4;
           return null;
         }
@@ -41831,7 +42819,7 @@ ${effect.notification.body || ""}`.trim();
         };
         addDir(this.workingDir);
         try {
-          addDir(fs6.realpathSync.native(this.workingDir));
+          addDir(fs7.realpathSync.native(this.workingDir));
         } catch {
         }
         return Array.from(dirs);
@@ -41868,7 +42856,7 @@ ${effect.notification.body || ""}`.trim();
     };
     var path17 = __toESM2(require("path"));
     var import_stream = require("stream");
-    var import_child_process5 = require("child_process");
+    var import_child_process4 = require("child_process");
     var import_sdk = (init_acp(), __toCommonJS(acp_exports));
     init_logger();
     function getPromptCapabilityFlags(agentCapabilities) {
@@ -42385,7 +43373,7 @@ ${effect.notification.body || ""}`.trim();
         this.errorMessage = null;
         this.errorReason = null;
         this.stderrBuffer = [];
-        this.process = (0, import_child_process5.spawn)(command, args, {
+        this.process = (0, import_child_process4.spawn)(command, args, {
           cwd: this.workingDir,
           env: env2,
           stdio: ["pipe", "pipe", "pipe"],
@@ -43106,7 +44094,7 @@ ${rawInput}` : rawInput;
         return (0, import_fs10.existsSync)(expandExecutable(trimmed));
       }
       try {
-        (0, import_child_process6.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
+        (0, import_child_process5.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
           stdio: "ignore",
           ...process.platform === "win32" ? { windowsHide: true } : {}
         });
@@ -43913,11 +44901,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
         return null;
       }
     };
-    var import_child_process7 = require("child_process");
+    var import_child_process6 = require("child_process");
     var net3 = __toESM2(require("net"));
     var os15 = __toESM2(require("os"));
     var path20 = __toESM2(require("path"));
-    var fs7 = __toESM2(require("fs"));
+    var fs8 = __toESM2(require("fs"));
     var path19 = __toESM2(require("path"));
     var os14 = __toESM2(require("os"));
     var chokidar = __toESM2(require_chokidar());
@@ -44266,9 +45254,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
       static siblingStderrLogged = /* @__PURE__ */ new Set();
       static looksLikeProviderRoot(candidate) {
         try {
-          if (!fs7.existsSync(candidate) || !fs7.statSync(candidate).isDirectory()) return false;
+          if (!fs8.existsSync(candidate) || !fs8.statSync(candidate).isDirectory()) return false;
           return ["ide", "extension", "cli", "acp"].some(
-            (category) => fs7.existsSync(path19.join(candidate, category))
+            (category) => fs8.existsSync(path19.join(candidate, category))
           );
         } catch {
           return false;
@@ -44276,7 +45264,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       static hasProviderRootMarker(candidate) {
         try {
-          return fs7.existsSync(path19.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
+          return fs8.existsSync(path19.join(candidate, _ProviderLoader.SIBLING_MARKER_FILE));
         } catch {
           return false;
         }
@@ -44438,7 +45426,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         this.providers.clear();
         this.providerAvailability.clear();
         let upstreamCount = 0;
-        if (!this.disableUpstream && fs7.existsSync(this.upstreamDir)) {
+        if (!this.disableUpstream && fs8.existsSync(this.upstreamDir)) {
           upstreamCount = this.loadDir(this.upstreamDir);
           if (upstreamCount > 0) {
             this.log(`Loaded ${upstreamCount} upstream providers (auto-updated)`);
@@ -44446,7 +45434,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         } else if (this.disableUpstream) {
           this.log("Upstream loading disabled (sourceMode=no-upstream)");
         }
-        if (fs7.existsSync(this.userDir)) {
+        if (fs8.existsSync(this.userDir)) {
           const userCount = this.loadDir(this.userDir, [".upstream"]);
           if (userCount > 0) {
             this.log(`Loaded ${userCount} user custom providers (never auto-updated)`);
@@ -44461,10 +45449,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
        * Check if upstream directory exists and has providers.
        */
       hasUpstream() {
-        if (!fs7.existsSync(this.upstreamDir)) return false;
+        if (!fs8.existsSync(this.upstreamDir)) return false;
         try {
-          return fs7.readdirSync(this.upstreamDir).some(
-            (d) => fs7.statSync(path19.join(this.upstreamDir, d)).isDirectory()
+          return fs8.readdirSync(this.upstreamDir).some(
+            (d) => fs8.statSync(path19.join(this.upstreamDir, d)).isDirectory()
           );
         } catch {
           return false;
@@ -44962,7 +45950,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   resolved._resolvedScriptsSource = `compatibility:${entry.ideVersion}`;
                   if (providerDir) {
                     const fullDir = path19.join(providerDir, entry.scriptDir);
-                    resolved._resolvedScriptsPath = fs7.existsSync(path19.join(fullDir, "scripts.js")) ? path19.join(fullDir, "scripts.js") : fullDir;
+                    resolved._resolvedScriptsPath = fs8.existsSync(path19.join(fullDir, "scripts.js")) ? path19.join(fullDir, "scripts.js") : fullDir;
                   }
                   matched = true;
                 }
@@ -44978,7 +45966,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 resolved._resolvedScriptsSource = "defaultScriptDir:version_miss";
                 if (providerDir) {
                   const fullDir = path19.join(providerDir, base.defaultScriptDir);
-                  resolved._resolvedScriptsPath = fs7.existsSync(path19.join(fullDir, "scripts.js")) ? path19.join(fullDir, "scripts.js") : fullDir;
+                  resolved._resolvedScriptsPath = fs8.existsSync(path19.join(fullDir, "scripts.js")) ? path19.join(fullDir, "scripts.js") : fullDir;
                 }
               }
               resolved._versionWarning = `Version ${currentVersion} not in compatibility matrix. Using default scripts.`;
@@ -44996,7 +45984,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                   resolved._resolvedScriptsSource = `versions:${range}`;
                   if (providerDir) {
                     const fullDir = path19.join(providerDir, dirOverride);
-                    resolved._resolvedScriptsPath = fs7.existsSync(path19.join(fullDir, "scripts.js")) ? path19.join(fullDir, "scripts.js") : fullDir;
+                    resolved._resolvedScriptsPath = fs8.existsSync(path19.join(fullDir, "scripts.js")) ? path19.join(fullDir, "scripts.js") : fullDir;
                   }
                 }
               } else if (override.scripts) {
@@ -45013,7 +46001,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
             resolved._resolvedScriptsSource = "defaultScriptDir:no_version";
             if (providerDir) {
               const fullDir = path19.join(providerDir, base.defaultScriptDir);
-              resolved._resolvedScriptsPath = fs7.existsSync(path19.join(fullDir, "scripts.js")) ? path19.join(fullDir, "scripts.js") : fullDir;
+              resolved._resolvedScriptsPath = fs8.existsSync(path19.join(fullDir, "scripts.js")) ? path19.join(fullDir, "scripts.js") : fullDir;
             }
           }
         }
@@ -45046,14 +46034,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
           return null;
         }
         const dir = path19.join(providerDir, scriptDir);
-        if (!fs7.existsSync(dir)) {
+        if (!fs8.existsSync(dir)) {
           this.log(`  [loadScriptsFromDir] ${type}: dir not found: ${dir}`);
           return null;
         }
         const cached2 = this.scriptsCache.get(dir);
         if (cached2) return cached2;
         const scriptsJs = path19.join(dir, "scripts.js");
-        if (fs7.existsSync(scriptsJs)) {
+        if (fs8.existsSync(scriptsJs)) {
           try {
             delete require.cache[require.resolve(scriptsJs)];
             const loaded = require(scriptsJs);
@@ -45074,9 +46062,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
       watch() {
         this.stopWatch();
         const watchDir = (dir) => {
-          if (!fs7.existsSync(dir)) {
+          if (!fs8.existsSync(dir)) {
             try {
-              fs7.mkdirSync(dir, { recursive: true });
+              fs8.mkdirSync(dir, { recursive: true });
             } catch {
               return;
             }
@@ -45089,13 +46077,17 @@ Run 'adhdev doctor' for detailed diagnostics.`
               ignoreInitial: true,
               awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 }
             });
+            let reloadTimer = null;
             const handleChange = (filePath) => {
               if (/[\/\\]fixtures[\/\\]/.test(filePath)) {
                 return;
               }
               if (filePath.endsWith(".js") || filePath.endsWith(".json")) {
-                this.log(`File changed: ${path19.basename(filePath)}, reloading...`);
-                this.reload();
+                if (reloadTimer) clearTimeout(reloadTimer);
+                reloadTimer = setTimeout(() => {
+                  this.log(`File changed: ${path19.basename(filePath)}, reloading...`);
+                  this.reload();
+                }, 300);
               }
             };
             watcher.on("add", handleChange).on("change", handleChange).on("unlink", handleChange);
@@ -45148,13 +46140,15 @@ Run 'adhdev doctor' for detailed diagnostics.`
           return { updated: false };
         }
         const https = require("https");
-        const { execSync: execSync7 } = require("child_process");
+        const { exec: exec7 } = require("child_process");
+        const { promisify: promisify6 } = require("util");
+        const execAsync5 = promisify6(exec7);
         const metaPath = path19.join(this.upstreamDir, _ProviderLoader.META_FILE);
         let prevEtag = "";
         let prevTimestamp = 0;
         try {
-          if (fs7.existsSync(metaPath)) {
-            const meta3 = JSON.parse(fs7.readFileSync(metaPath, "utf-8"));
+          if (fs8.existsSync(metaPath)) {
+            const meta3 = JSON.parse(fs8.readFileSync(metaPath, "utf-8"));
             prevEtag = meta3.etag || "";
             prevTimestamp = meta3.timestamp || 0;
           }
@@ -45212,36 +46206,36 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const tmpTar = path19.join(os14.tmpdir(), `adhdev-providers-${Date.now()}.tar.gz`);
           const tmpExtract = path19.join(os14.tmpdir(), `adhdev-providers-extract-${Date.now()}`);
           await this.downloadFile(_ProviderLoader.GITHUB_TARBALL_URL, tmpTar);
-          fs7.mkdirSync(tmpExtract, { recursive: true });
-          execSync7(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
-          const extracted = fs7.readdirSync(tmpExtract);
+          fs8.mkdirSync(tmpExtract, { recursive: true });
+          await execAsync5(`tar -xzf "${tmpTar}" -C "${tmpExtract}"`, { timeout: 3e4 });
+          const extracted = fs8.readdirSync(tmpExtract);
           const rootDir = extracted.find(
-            (d) => fs7.statSync(path19.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
+            (d) => fs8.statSync(path19.join(tmpExtract, d)).isDirectory() && d.startsWith("adhdev-providers")
           );
           if (!rootDir) throw new Error("Unexpected tarball structure");
           const sourceDir = path19.join(tmpExtract, rootDir);
           const backupDir = this.upstreamDir + ".bak";
-          if (fs7.existsSync(this.upstreamDir)) {
-            if (fs7.existsSync(backupDir)) fs7.rmSync(backupDir, { recursive: true, force: true });
-            fs7.renameSync(this.upstreamDir, backupDir);
+          if (fs8.existsSync(this.upstreamDir)) {
+            if (fs8.existsSync(backupDir)) fs8.rmSync(backupDir, { recursive: true, force: true });
+            fs8.renameSync(this.upstreamDir, backupDir);
           }
           try {
             this.copyDirRecursive(sourceDir, this.upstreamDir);
             this.writeMeta(metaPath, etag || `ts-${Date.now()}`, Date.now());
-            if (fs7.existsSync(backupDir)) fs7.rmSync(backupDir, { recursive: true, force: true });
+            if (fs8.existsSync(backupDir)) fs8.rmSync(backupDir, { recursive: true, force: true });
           } catch (e) {
-            if (fs7.existsSync(backupDir)) {
-              if (fs7.existsSync(this.upstreamDir)) fs7.rmSync(this.upstreamDir, { recursive: true, force: true });
-              fs7.renameSync(backupDir, this.upstreamDir);
+            if (fs8.existsSync(backupDir)) {
+              if (fs8.existsSync(this.upstreamDir)) fs8.rmSync(this.upstreamDir, { recursive: true, force: true });
+              fs8.renameSync(backupDir, this.upstreamDir);
             }
             throw e;
           }
           try {
-            fs7.rmSync(tmpTar, { force: true });
+            fs8.rmSync(tmpTar, { force: true });
           } catch {
           }
           try {
-            fs7.rmSync(tmpExtract, { recursive: true, force: true });
+            fs8.rmSync(tmpExtract, { recursive: true, force: true });
           } catch {
           }
           const upstreamCount = this.countProviders(this.upstreamDir);
@@ -45273,7 +46267,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
                 reject(new Error(`HTTP ${res.statusCode}`));
                 return;
               }
-              const ws = fs7.createWriteStream(destPath);
+              const ws = fs8.createWriteStream(destPath);
               res.pipe(ws);
               ws.on("finish", () => {
                 ws.close();
@@ -45292,22 +46286,22 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       /** Recursive directory copy */
       copyDirRecursive(src, dest) {
-        fs7.mkdirSync(dest, { recursive: true });
-        for (const entry of fs7.readdirSync(src, { withFileTypes: true })) {
+        fs8.mkdirSync(dest, { recursive: true });
+        for (const entry of fs8.readdirSync(src, { withFileTypes: true })) {
           const srcPath = path19.join(src, entry.name);
           const destPath = path19.join(dest, entry.name);
           if (entry.isDirectory()) {
             this.copyDirRecursive(srcPath, destPath);
           } else {
-            fs7.copyFileSync(srcPath, destPath);
+            fs8.copyFileSync(srcPath, destPath);
           }
         }
       }
       /** .meta.json save */
       writeMeta(metaPath, etag, timestamp) {
         try {
-          fs7.mkdirSync(path19.dirname(metaPath), { recursive: true });
-          fs7.writeFileSync(metaPath, JSON.stringify({
+          fs8.mkdirSync(path19.dirname(metaPath), { recursive: true });
+          fs8.writeFileSync(metaPath, JSON.stringify({
             etag,
             timestamp,
             lastCheck: new Date(timestamp).toISOString(),
@@ -45318,11 +46312,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       /** Count provider files (provider.js or provider.json) */
       countProviders(dir) {
-        if (!fs7.existsSync(dir)) return 0;
+        if (!fs8.existsSync(dir)) return 0;
         let count = 0;
         const scan = (d) => {
           try {
-            for (const entry of fs7.readdirSync(d, { withFileTypes: true })) {
+            for (const entry of fs8.readdirSync(d, { withFileTypes: true })) {
               if (entry.isDirectory()) scan(path19.join(d, entry.name));
               else if (entry.name === "provider.json") count++;
             }
@@ -45549,18 +46543,18 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const cat = provider.category;
         const searchRoots = this.getProviderRoots();
         for (const root of searchRoots) {
-          if (!fs7.existsSync(root)) continue;
+          if (!fs8.existsSync(root)) continue;
           const candidate = this.getProviderDir(root, cat, type);
-          if (fs7.existsSync(path19.join(candidate, "provider.json"))) return candidate;
+          if (fs8.existsSync(path19.join(candidate, "provider.json"))) return candidate;
           const catDir = path19.join(root, cat);
-          if (fs7.existsSync(catDir)) {
+          if (fs8.existsSync(catDir)) {
             try {
-              for (const entry of fs7.readdirSync(catDir, { withFileTypes: true })) {
+              for (const entry of fs8.readdirSync(catDir, { withFileTypes: true })) {
                 if (!entry.isDirectory()) continue;
                 const jsonPath = path19.join(catDir, entry.name, "provider.json");
-                if (fs7.existsSync(jsonPath)) {
+                if (fs8.existsSync(jsonPath)) {
                   try {
-                    const data = JSON.parse(fs7.readFileSync(jsonPath, "utf-8"));
+                    const data = JSON.parse(fs8.readFileSync(jsonPath, "utf-8"));
                     if (data.type === type) return path19.join(catDir, entry.name);
                   } catch {
                   }
@@ -45579,7 +46573,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
        */
       buildScriptWrappersFromDir(dir) {
         const scriptsJs = path19.join(dir, "scripts.js");
-        if (fs7.existsSync(scriptsJs)) {
+        if (fs8.existsSync(scriptsJs)) {
           try {
             delete require.cache[require.resolve(scriptsJs)];
             return require(scriptsJs);
@@ -45589,13 +46583,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
         const toCamel = (name) => name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
         const result = {};
         try {
-          for (const file2 of fs7.readdirSync(dir)) {
+          for (const file2 of fs8.readdirSync(dir)) {
             if (!file2.endsWith(".js")) continue;
             const scriptName = toCamel(file2.replace(".js", ""));
             const filePath = path19.join(dir, file2);
             result[scriptName] = (...args) => {
               try {
-                let content = fs7.readFileSync(filePath, "utf-8");
+                let content = fs8.readFileSync(filePath, "utf-8");
                 if (args[0] && typeof args[0] === "object") {
                   for (const [key, val] of Object.entries(args[0])) {
                     let v = val;
@@ -45641,12 +46635,12 @@ Run 'adhdev doctor' for detailed diagnostics.`
        * Structure: dir/category/agent-name/provider.{json,js}
        */
       loadDir(dir, excludeDirs) {
-        if (!fs7.existsSync(dir)) return 0;
+        if (!fs8.existsSync(dir)) return 0;
         let count = 0;
         const scan = (d) => {
           let entries;
           try {
-            entries = fs7.readdirSync(d, { withFileTypes: true });
+            entries = fs8.readdirSync(d, { withFileTypes: true });
           } catch {
             return;
           }
@@ -45654,7 +46648,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           if (hasJson) {
             const jsonPath = path19.join(d, "provider.json");
             try {
-              const raw = fs7.readFileSync(jsonPath, "utf-8");
+              const raw = fs8.readFileSync(jsonPath, "utf-8");
               const mod = JSON.parse(raw);
               if (typeof mod.extensionIdPattern === "string") {
                 const flags = mod.extensionIdPattern_flags || "";
@@ -45674,7 +46668,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
               } else {
                 const hasCompatibility = Array.isArray(normalizedProvider.compatibility);
                 const scriptsPath = path19.join(d, "scripts.js");
-                if (!hasCompatibility && fs7.existsSync(scriptsPath)) {
+                if (!hasCompatibility && fs8.existsSync(scriptsPath)) {
                   try {
                     delete require.cache[require.resolve(scriptsPath)];
                     const scripts = require(scriptsPath);
@@ -45775,6 +46769,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
       }
       return pids;
     }
+    async function execQuiet(command, options = {}) {
+      return new Promise((resolve16) => {
+        (0, import_child_process6.exec)(command, options, (error48, stdout) => {
+          if (error48) return resolve16("");
+          resolve16(stdout.toString());
+        });
+      });
+    }
     var _providerLoader = null;
     function getProviderLoader() {
       if (!_providerLoader) {
@@ -45813,11 +46815,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
     function getIdePathCandidates(ideId) {
       return getProviderLoader().getIdePathCandidates(ideId);
     }
-    function getMacAppProcessPids(ideId) {
+    async function getMacAppProcessPids(ideId) {
       const appPaths = getIdePathCandidates(ideId);
       if (appPaths.length === 0) return [];
       try {
-        const output = (0, import_child_process7.execSync)("ps axww -o pid=,args=", {
+        const output = await execQuiet("ps axww -o pid=,args=", {
           encoding: "utf-8",
           timeout: 3e3,
           stdio: ["pipe", "pipe", "pipe"]
@@ -45827,8 +46829,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
         return [];
       }
     }
-    function killMacAppPathProcesses(ideId, signal) {
-      const pids = getMacAppProcessPids(ideId);
+    async function killMacAppPathProcesses(ideId, signal) {
+      const pids = await getMacAppProcessPids(ideId);
       let signalled = false;
       for (const pid of pids) {
         try {
@@ -45891,68 +46893,68 @@ Run 'adhdev doctor' for detailed diagnostics.`
       try {
         if (plat === "darwin" && appName) {
           try {
-            (0, import_child_process7.execSync)(`osascript -e 'tell application "${escapeForAppleScript(appName)}" to quit' 2>/dev/null`, {
+            await execQuiet(`osascript -e 'tell application "${escapeForAppleScript(appName)}" to quit' 2>/dev/null`, {
               timeout: 5e3
             });
           } catch {
             try {
-              (0, import_child_process7.execSync)(`pkill -x "${appName}" 2>/dev/null`, { timeout: 5e3 });
+              await execQuiet(`pkill -x "${appName}" 2>/dev/null`, { timeout: 5e3 });
             } catch {
             }
           }
-          killMacAppPathProcesses(ideId, "SIGTERM");
+          await killMacAppPathProcesses(ideId, "SIGTERM");
         } else if (plat === "win32" && winProcesses) {
           for (const proc of winProcesses) {
             try {
-              (0, import_child_process7.execSync)(`taskkill /IM "${proc}" /F 2>nul`, { timeout: 5e3 });
+              await execQuiet(`taskkill /IM "${proc}" /F 2>nul`, { timeout: 5e3 });
             } catch {
             }
           }
           try {
             const exeName = winProcesses[0].replace(".exe", "");
-            (0, import_child_process7.execSync)(`powershell -Command "Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue | Stop-Process -Force"`, {
+            await execQuiet(`powershell -Command "Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue | Stop-Process -Force"`, {
               timeout: 1e4
             });
           } catch {
           }
         } else {
           try {
-            (0, import_child_process7.execSync)(`pkill -f "${ideId}" 2>/dev/null`);
+            await execQuiet(`pkill -f "${ideId}" 2>/dev/null`);
           } catch {
           }
         }
         for (let i = 0; i < 30; i++) {
           await new Promise((r) => setTimeout(r, 500));
-          if (!isIdeRunning(ideId)) return true;
+          if (!await isIdeRunning(ideId)) return true;
         }
         if (plat === "darwin" && appName) {
           try {
-            (0, import_child_process7.execSync)(`pkill -9 -x "${appName}" 2>/dev/null`, { timeout: 5e3 });
+            await execQuiet(`pkill -9 -x "${appName}" 2>/dev/null`, { timeout: 5e3 });
           } catch {
           }
-          killMacAppPathProcesses(ideId, "SIGKILL");
+          await killMacAppPathProcesses(ideId, "SIGKILL");
         } else if (plat === "win32" && winProcesses) {
           for (const proc of winProcesses) {
             try {
-              (0, import_child_process7.execSync)(`taskkill /IM "${proc}" /F 2>nul`);
+              await execQuiet(`taskkill /IM "${proc}" /F 2>nul`);
             } catch {
             }
           }
         }
         await new Promise((r) => setTimeout(r, 2e3));
-        return !isIdeRunning(ideId);
+        return !await isIdeRunning(ideId);
       } catch {
         return false;
       }
     }
-    function isIdeRunning(ideId) {
+    async function isIdeRunning(ideId) {
       const plat = os15.platform();
       try {
         if (plat === "darwin") {
           const appName = getMacAppIdentifiers()[ideId];
-          if (!appName) return getMacAppProcessPids(ideId).length > 0;
+          if (!appName) return (await getMacAppProcessPids(ideId)).length > 0;
           try {
-            const result = (0, import_child_process7.execSync)(`pgrep -x "${appName}" 2>/dev/null`, {
+            const result = await execQuiet(`pgrep -x "${appName}" 2>/dev/null`, {
               encoding: "utf-8",
               timeout: 3e3
             });
@@ -45960,7 +46962,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           } catch {
           }
           try {
-            const result = (0, import_child_process7.execSync)(
+            const result = await execQuiet(
               `osascript -e 'tell application "System Events" to count (every process whose name is "${escapeForAppleScript(appName)}")'`,
               {
                 encoding: "utf-8",
@@ -45971,20 +46973,20 @@ Run 'adhdev doctor' for detailed diagnostics.`
             if (Number.parseInt(result.trim() || "0", 10) > 0) return true;
           } catch {
           }
-          return getMacAppProcessPids(ideId).length > 0;
+          return (await getMacAppProcessPids(ideId)).length > 0;
         } else if (plat === "win32") {
           const winProcesses = getWinProcessNames()[ideId];
           if (!winProcesses) return false;
           for (const proc of winProcesses) {
             try {
-              const result = (0, import_child_process7.execSync)(`tasklist /FI "IMAGENAME eq ${proc}" /NH 2>nul`, { encoding: "utf-8" });
+              const result = await execQuiet(`tasklist /FI "IMAGENAME eq ${proc}" /NH 2>nul`, { encoding: "utf-8" });
               if (result.includes(proc)) return true;
             } catch {
             }
           }
           try {
             const exeName = winProcesses[0].replace(".exe", "");
-            const result = (0, import_child_process7.execSync)(
+            const result = await execQuiet(
               `powershell -Command "(Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue).Count"`,
               { encoding: "utf-8", timeout: 5e3 }
             );
@@ -45993,20 +46995,20 @@ Run 'adhdev doctor' for detailed diagnostics.`
           }
           return false;
         } else {
-          const result = (0, import_child_process7.execSync)(`pgrep -f "${ideId}" 2>/dev/null`, { encoding: "utf-8" });
+          const result = await execQuiet(`pgrep -f "${ideId}" 2>/dev/null`, { encoding: "utf-8" });
           return result.trim().length > 0;
         }
       } catch {
         return false;
       }
     }
-    function detectCurrentWorkspace(ideId) {
+    async function detectCurrentWorkspace(ideId) {
       const plat = os15.platform();
       if (plat === "darwin") {
         try {
           const appName = getMacAppIdentifiers()[ideId];
           if (!appName) return void 0;
-          const result = (0, import_child_process7.execSync)(
+          const result = await execQuiet(
             `lsof -c "${appName}" 2>/dev/null | grep cwd | head -1 | awk '{print $NF}'`,
             { encoding: "utf-8", timeout: 3e3 }
           );
@@ -46016,7 +47018,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
       } else if (plat === "win32") {
         try {
-          const fs16 = require("fs");
+          const fs17 = require("fs");
           const appNameMap = getMacAppIdentifiers();
           const appName = appNameMap[ideId];
           if (appName) {
@@ -46025,8 +47027,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
               appName,
               "storage.json"
             );
-            if (fs16.existsSync(storagePath)) {
-              const data = JSON.parse(fs16.readFileSync(storagePath, "utf-8"));
+            if (fs17.existsSync(storagePath)) {
+              const data = JSON.parse(fs17.readFileSync(storagePath, "utf-8"));
               const workspaces = data?.openedPathsList?.workspaces3 || data?.openedPathsList?.entries || [];
               if (workspaces.length > 0) {
                 const recent = workspaces[0];
@@ -46093,8 +47095,8 @@ Run 'adhdev doctor' for detailed diagnostics.`
           };
         }
       }
-      const alreadyRunning = isIdeRunning(targetIde.id);
-      const workspace = options.workspace || (alreadyRunning ? detectCurrentWorkspace(targetIde.id) : void 0);
+      const alreadyRunning = await isIdeRunning(targetIde.id);
+      const workspace = options.workspace || (alreadyRunning ? await detectCurrentWorkspace(targetIde.id) : void 0);
       if (alreadyRunning) {
         const killed = await killIdeProcess(targetIde.id);
         if (!killed) {
@@ -46169,10 +47171,10 @@ Run 'adhdev doctor' for detailed diagnostics.`
       const canUseAppLauncher = !!appName;
       const useAppLauncher = preferredMethod === "app" ? canUseAppLauncher : preferredMethod === "cli" ? false : !canUseCli && canUseAppLauncher;
       if (!useAppLauncher && ide.cliCommand) {
-        (0, import_child_process7.spawn)(ide.cliCommand, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
+        (0, import_child_process6.spawn)(ide.cliCommand, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
       } else if (appName) {
         const openArgs = ["-a", appName, "--args", ...args];
-        (0, import_child_process7.spawn)("open", openArgs, { detached: true, stdio: "ignore" }).unref();
+        (0, import_child_process6.spawn)("open", openArgs, { detached: true, stdio: "ignore" }).unref();
       } else {
         throw new Error(`No app identifier or CLI for ${ide.displayName}`);
       }
@@ -46198,7 +47200,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       const args = ["--remote-debugging-port=" + port];
       if (newWindow) args.push("--new-window");
       if (workspace) args.push(workspace);
-      (0, import_child_process7.spawn)(cli, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
+      (0, import_child_process6.spawn)(cli, args, { detached: true, stdio: "ignore", windowsHide: true }).unref();
     }
     function getAvailableIdeIds() {
       return getProviderLoader().getAvailableIdeTypes();
@@ -46206,14 +47208,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
     init_config();
     init_cli_detector();
     init_logger();
-    var fs8 = __toESM2(require("fs"));
+    var fs9 = __toESM2(require("fs"));
     var path21 = __toESM2(require("path"));
     var os16 = __toESM2(require("os"));
     var LOG_DIR2 = process.platform === "win32" ? path21.join(process.env.LOCALAPPDATA || process.env.APPDATA || path21.join(os16.homedir(), "AppData", "Local"), "adhdev", "logs") : process.platform === "darwin" ? path21.join(os16.homedir(), "Library", "Logs", "adhdev") : path21.join(os16.homedir(), ".local", "share", "adhdev", "logs");
     var MAX_FILE_SIZE = 5 * 1024 * 1024;
     var MAX_DAYS = 7;
     try {
-      fs8.mkdirSync(LOG_DIR2, { recursive: true });
+      fs9.mkdirSync(LOG_DIR2, { recursive: true });
     } catch {
     }
     var SENSITIVE_KEYS = /* @__PURE__ */ new Set([
@@ -46259,7 +47261,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     function cleanOldFiles() {
       try {
-        const files = fs8.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
+        const files = fs9.readdirSync(LOG_DIR2).filter((f) => f.startsWith("commands-") && f.endsWith(".jsonl"));
         const cutoff = /* @__PURE__ */ new Date();
         cutoff.setDate(cutoff.getDate() - MAX_DAYS);
         const cutoffStr = cutoff.toISOString().slice(0, 10);
@@ -46267,7 +47269,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const dateMatch = file2.match(/commands-(\d{4}-\d{2}-\d{2})/);
           if (dateMatch && dateMatch[1] < cutoffStr) {
             try {
-              fs8.unlinkSync(path21.join(LOG_DIR2, file2));
+              fs9.unlinkSync(path21.join(LOG_DIR2, file2));
             } catch {
             }
           }
@@ -46277,14 +47279,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     function checkSize() {
       try {
-        const stat2 = fs8.statSync(currentFile);
+        const stat2 = fs9.statSync(currentFile);
         if (stat2.size > MAX_FILE_SIZE) {
           const backup = currentFile.replace(".jsonl", ".1.jsonl");
           try {
-            fs8.unlinkSync(backup);
+            fs9.unlinkSync(backup);
           } catch {
           }
-          fs8.renameSync(currentFile, backup);
+          fs9.renameSync(currentFile, backup);
         }
       } catch {
       }
@@ -46317,14 +47319,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
           ...entry.error ? { err: entry.error } : {},
           ...entry.durationMs !== void 0 ? { ms: entry.durationMs } : {}
         });
-        fs8.appendFileSync(currentFile, line + "\n");
+        fs9.appendFileSync(currentFile, line + "\n");
       } catch {
       }
     }
     function getRecentCommands(count = 50) {
       try {
-        if (!fs8.existsSync(currentFile)) return [];
-        const content = fs8.readFileSync(currentFile, "utf-8");
+        if (!fs9.existsSync(currentFile)) return [];
+        const content = fs9.readFileSync(currentFile, "utf-8");
         const lines = content.trim().split("\n").filter(Boolean);
         return lines.slice(-count).map((line) => {
           try {
@@ -46350,14 +47352,11 @@ Run 'adhdev doctor' for detailed diagnostics.`
     cleanOldFiles();
     var yaml2 = __toESM2(require_js_yaml());
     init_logger();
-    var import_node_child_process3 = require("child_process");
     var import_node_crypto2 = require("crypto");
-    var import_node_fs3 = require("fs");
-    var import_node_module2 = require("module");
     var os17 = __toESM2(require("os"));
     var import_node_path = require("path");
     var DEFAULT_SERVER_NAME = "adhdev-mesh";
-    var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev-mcp";
+    var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev";
     var HERMES_CLI_TYPE = "hermes-cli";
     var HERMES_MCP_CONFIG_PATH = "~/.hermes/config.yaml";
     function isHermesProvider(provider, cliType) {
@@ -46367,8 +47366,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     function resolveHermesMeshCoordinatorSetup(options) {
       const mcpServer = resolveAdhdevMcpServerLaunch({
         meshId: options.meshId,
-        nodeExecutable: options.nodeExecutable,
-        adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+        adhdevMcpCommand: options.adhdevMcpCommand,
         adhdevMcpTransport: options.adhdevMcpTransport,
         adhdevMcpPort: options.adhdevMcpPort
       });
@@ -46399,7 +47397,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         requiresRestart: true,
         instructions: "Hermes CLI does not auto-import repo-local .mcp.json. Add this MCP server to Hermes config under mcp_servers, then start a fresh Hermes session.",
         template: renderMeshCoordinatorTemplate(
-          "mcp_servers:\n  {{serverName}}:\n    command: {{adhdevMcpCommand}}\n    args:\n      - --repo-mesh\n      - {{meshId}}\n    enabled: true\n",
+          "mcp_servers:\n  {{serverName}}:\n    command: {{adhdevMcpCommand}}\n    args:\n      - mcp\n      - --mode\n      - ipc\n      - --repo-mesh\n      - {{meshId}}\n    enabled: true\n",
           {
             meshId,
             workspace,
@@ -46436,8 +47434,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         }
         const mcpServer = resolveAdhdevMcpServerLaunch({
           meshId,
-          nodeExecutable: options.nodeExecutable,
-          adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+          adhdevMcpCommand: options.adhdevMcpCommand,
           adhdevMcpTransport: options.adhdevMcpTransport,
           adhdevMcpPort: options.adhdevMcpPort
         });
@@ -46509,19 +47506,19 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       return (0, import_node_path.join)(workspace, trimmed);
     }
     function resolveAdhdevMcpServerLaunch(options) {
-      const entryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath);
-      if (!entryPath) return null;
-      const nodeExecutable = resolveMcpNodeExecutable(options.nodeExecutable);
-      if (!nodeExecutable) return null;
+      const command = resolveAdhdevCommand(options.adhdevMcpCommand);
       const transport = resolveMcpTransport(options.adhdevMcpTransport);
-      const args = [entryPath, "--mode", transport, "--repo-mesh", options.meshId];
+      const args = ["mcp", "--mode", transport, "--repo-mesh", options.meshId];
       const port = resolveMcpPort(options.adhdevMcpPort);
       if (port !== void 0) args.push("--port", String(port));
       return {
-        command: nodeExecutable,
+        command,
         args
       };
     }
+    function resolveAdhdevCommand(explicitCommand) {
+      return explicitCommand?.trim() || process.env.ADHDEV_COORDINATOR_MCP_COMMAND?.trim() || DEFAULT_ADHDEV_MCP_COMMAND;
+    }
     function resolveMcpTransport(explicitTransport) {
       if (explicitTransport === "local" || explicitTransport === "ipc") return explicitTransport;
       const envTransport = process.env.ADHDEV_COORDINATOR_MCP_TRANSPORT?.trim();
@@ -46534,109 +47531,6 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       const parsed = Number(raw);
       return Number.isInteger(parsed) && parsed > 0 ? parsed : void 0;
     }
-    function resolveMcpNodeExecutable(explicitExecutable) {
-      const explicit = explicitExecutable?.trim();
-      if (explicit) return explicit;
-      const candidates = [];
-      const addCandidate = (candidate) => {
-        const trimmed = candidate?.trim();
-        if (!trimmed) return;
-        const normalized = normalizeExistingPath(trimmed) || trimmed;
-        if (!candidates.includes(normalized)) candidates.push(normalized);
-      };
-      addCandidate(process.env.ADHDEV_MCP_NODE_EXECUTABLE);
-      addCandidate(process.env.ADHDEV_NODE_EXECUTABLE);
-      addCandidate(process.env.npm_node_execpath);
-      addNodeCandidatesFromPath(process.env.PATH, addCandidate);
-      addNodeCandidatesFromNvm(os17.homedir(), addCandidate);
-      addCandidate("/opt/homebrew/bin/node");
-      addCandidate("/usr/local/bin/node");
-      addCandidate("/usr/bin/node");
-      addCandidate(process.execPath);
-      for (const candidate of candidates) {
-        if (nodeRuntimeSupportsWebSocket(candidate)) return candidate;
-      }
-      return null;
-    }
-    function addNodeCandidatesFromPath(pathValue, addCandidate) {
-      for (const entry of (pathValue || "").split(":")) {
-        const dir = entry.trim();
-        if (!dir) continue;
-        addCandidate((0, import_node_path.join)(dir, "node"));
-      }
-    }
-    function addNodeCandidatesFromNvm(homeDir, addCandidate) {
-      const versionsDir = (0, import_node_path.join)(homeDir, ".nvm", "versions", "node");
-      try {
-        const versionDirs = (0, import_node_fs3.readdirSync)(versionsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(compareNodeVersionNamesDescending);
-        for (const versionDir of versionDirs) {
-          addCandidate((0, import_node_path.join)(versionsDir, versionDir, "bin", "node"));
-        }
-      } catch {
-      }
-    }
-    function compareNodeVersionNamesDescending(a, b) {
-      const parse3 = (value) => value.replace(/^v/, "").split(".").map((part) => Number.parseInt(part, 10) || 0);
-      const left = parse3(a);
-      const right = parse3(b);
-      for (let i = 0; i < Math.max(left.length, right.length); i++) {
-        const diff = (right[i] || 0) - (left[i] || 0);
-        if (diff !== 0) return diff;
-      }
-      return b.localeCompare(a);
-    }
-    function nodeRuntimeSupportsWebSocket(nodeExecutable) {
-      try {
-        (0, import_node_child_process3.execFileSync)(nodeExecutable, ["-e", "process.exit(typeof WebSocket === 'function' ? 0 : 42)"], {
-          stdio: "ignore",
-          timeout: 3e3
-        });
-        return true;
-      } catch {
-        return false;
-      }
-    }
-    function resolveAdhdevMcpEntryPath(explicitPath) {
-      const explicit = explicitPath?.trim();
-      if (explicit) return normalizeExistingPath(explicit) || explicit;
-      const envPath = process.env.ADHDEV_MCP_SERVER_PATH?.trim();
-      if (envPath) return normalizeExistingPath(envPath) || envPath;
-      const candidates = [];
-      const addCandidate = (candidate) => {
-        if (!candidates.includes(candidate)) candidates.push(candidate);
-      };
-      const addPackagedCandidates = (baseFile) => {
-        if (!baseFile) return;
-        const realBase = normalizeExistingPath(baseFile) || baseFile;
-        const dir = (0, import_node_path.dirname)(realBase);
-        addCandidate((0, import_node_path.resolve)(dir, "../vendor/mcp-server/index.js"));
-        addCandidate((0, import_node_path.resolve)(dir, "../../vendor/mcp-server/index.js"));
-        addCandidate((0, import_node_path.resolve)(dir, "../../../vendor/mcp-server/index.js"));
-        addCandidate((0, import_node_path.resolve)(dir, "../../mcp-server/dist/index.js"));
-        addCandidate((0, import_node_path.resolve)(dir, "../../../mcp-server/dist/index.js"));
-      };
-      addPackagedCandidates(process.argv[1]);
-      for (const candidate of candidates) {
-        const normalized = normalizeExistingPath(candidate);
-        if (normalized) return normalized;
-      }
-      try {
-        const requireBase = process.argv[1] ? normalizeExistingPath(process.argv[1]) || process.argv[1] : (0, import_node_path.join)(process.cwd(), "adhdev-daemon.js");
-        const req = (0, import_node_module2.createRequire)(requireBase);
-        const resolvedModule = req.resolve("@adhdev/mcp-server");
-        return normalizeExistingPath(resolvedModule) || resolvedModule;
-      } catch {
-        return null;
-      }
-    }
-    function normalizeExistingPath(filePath) {
-      try {
-        if (!(0, import_node_fs3.existsSync)(filePath)) return null;
-        return import_node_fs3.realpathSync.native(filePath);
-      } catch {
-        return null;
-      }
-    }
     init_mesh_events();
     init_mesh_host_ownership();
     var os18 = __toESM2(require("os"));
@@ -46950,23 +47844,23 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         }
       };
     }
+    var import_child_process7 = require("child_process");
     var import_child_process8 = require("child_process");
-    var import_child_process9 = require("child_process");
-    var fs9 = __toESM2(require("fs"));
+    var fs10 = __toESM2(require("fs"));
     var os19 = __toESM2(require("os"));
     var path222 = __toESM2(require("path"));
     var UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
     function getUpgradeLogPath() {
       const home = os19.homedir();
       const dir = path222.join(home, ".adhdev");
-      fs9.mkdirSync(dir, { recursive: true });
+      fs10.mkdirSync(dir, { recursive: true });
       return path222.join(dir, "daemon-upgrade.log");
     }
     function appendUpgradeLog(message) {
       const line = `[${(/* @__PURE__ */ new Date()).toISOString()}] ${message}
 `;
       try {
-        fs9.appendFileSync(getUpgradeLogPath(), line, "utf8");
+        fs10.appendFileSync(getUpgradeLogPath(), line, "utf8");
       } catch {
       }
     }
@@ -46974,12 +47868,12 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       const binDir = path222.dirname(nodeExecutable);
       if (platform10 === "win32") {
         const npmCliPath = path222.join(binDir, "node_modules", "npm", "bin", "npm-cli.js");
-        if (fs9.existsSync(npmCliPath)) {
+        if (fs10.existsSync(npmCliPath)) {
           return { executable: nodeExecutable, argsPrefix: [npmCliPath], execOptions: getNpmExecOptions(platform10) };
         }
         for (const candidate of ["npm.exe", "npm"]) {
           const candidatePath = path222.join(binDir, candidate);
-          if (fs9.existsSync(candidatePath)) {
+          if (fs10.existsSync(candidatePath)) {
             return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
           }
         }
@@ -46987,7 +47881,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       }
       for (const candidate of ["npm"]) {
         const candidatePath = path222.join(binDir, candidate);
-        if (fs9.existsSync(candidatePath)) {
+        if (fs10.existsSync(candidatePath)) {
           return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
         }
       }
@@ -46997,12 +47891,12 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       if (!currentCliPath) return null;
       let resolvedPath = currentCliPath;
       try {
-        resolvedPath = fs9.realpathSync.native(currentCliPath);
+        resolvedPath = fs10.realpathSync.native(currentCliPath);
       } catch {
       }
       let currentDir = resolvedPath;
       try {
-        if (fs9.statSync(resolvedPath).isFile()) {
+        if (fs10.statSync(resolvedPath).isFile()) {
           currentDir = path222.dirname(resolvedPath);
         }
       } catch {
@@ -47011,8 +47905,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       while (true) {
         const packageJsonPath = path222.join(currentDir, "package.json");
         try {
-          if (fs9.existsSync(packageJsonPath)) {
-            const parsed = JSON.parse(fs9.readFileSync(packageJsonPath, "utf8"));
+          if (fs10.existsSync(packageJsonPath)) {
+            const parsed = JSON.parse(fs10.readFileSync(packageJsonPath, "utf8"));
             if (parsed?.name === packageName) {
               const normalized = currentDir.replace(/\\/g, "/");
               return normalized.includes("/node_modules/") ? currentDir : null;
@@ -47070,7 +47964,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     }
     function execNpmCommandSync(args, options = {}, surface) {
       const execOptions = surface?.execOptions || getNpmExecOptions();
-      return (0, import_child_process8.execFileSync)(
+      return (0, import_child_process7.execFileSync)(
         surface?.npmExecutable || "npm",
         [...surface?.npmArgsPrefix || [], ...args],
         {
@@ -47083,7 +47977,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     function killPid2(pid) {
       try {
         if (process.platform === "win32") {
-          (0, import_child_process8.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+          (0, import_child_process7.execFileSync)("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
         } else {
           process.kill(pid, "SIGTERM");
         }
@@ -47095,7 +47989,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     function getWindowsProcessCommandLine(pid) {
       const pidFilter = `ProcessId=${pid}`;
       try {
-        const psOut = (0, import_child_process8.execFileSync)("powershell.exe", [
+        const psOut = (0, import_child_process7.execFileSync)("powershell.exe", [
           "-NoProfile",
           "-NonInteractive",
           "-ExecutionPolicy",
@@ -47107,7 +48001,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       } catch {
       }
       try {
-        const wmicOut = (0, import_child_process8.execFileSync)("wmic", [
+        const wmicOut = (0, import_child_process7.execFileSync)("wmic", [
           "process",
           "where",
           pidFilter,
@@ -47123,7 +48017,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       if (!Number.isFinite(pid) || pid <= 0) return null;
       if (process.platform === "win32") return getWindowsProcessCommandLine(pid);
       try {
-        const text = (0, import_child_process8.execFileSync)("ps", ["-o", "command=", "-p", String(pid)], {
+        const text = (0, import_child_process7.execFileSync)("ps", ["-o", "command=", "-p", String(pid)], {
           encoding: "utf8",
           timeout: 3e3,
           stdio: ["ignore", "pipe", "ignore"]
@@ -47151,8 +48045,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     function stopSessionHostProcesses(appName) {
       const pidFile = path222.join(os19.homedir(), ".adhdev", `${appName}-session-host.pid`);
       try {
-        if (fs9.existsSync(pidFile)) {
-          const pid = Number.parseInt(fs9.readFileSync(pidFile, "utf8").trim(), 10);
+        if (fs10.existsSync(pidFile)) {
+          const pid = Number.parseInt(fs10.readFileSync(pidFile, "utf8").trim(), 10);
           if (Number.isFinite(pid) && pid !== process.pid && isManagedSessionHostPid(pid)) {
             killPid2(pid);
           }
@@ -47160,7 +48054,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       } catch {
       } finally {
         try {
-          fs9.unlinkSync(pidFile);
+          fs10.unlinkSync(pidFile);
         } catch {
         }
       }
@@ -47168,7 +48062,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     function removeDaemonPidFile() {
       const pidFile = path222.join(os19.homedir(), ".adhdev", "daemon.pid");
       try {
-        fs9.unlinkSync(pidFile);
+        fs10.unlinkSync(pidFile);
       } catch {
       }
     }
@@ -47186,30 +48080,30 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       if (pkgName.startsWith("@")) {
         const [scope, name] = pkgName.split("/");
         const scopeDir = path222.join(npmRoot, scope);
-        if (!fs9.existsSync(scopeDir)) return;
-        for (const entry of fs9.readdirSync(scopeDir)) {
+        if (!fs10.existsSync(scopeDir)) return;
+        for (const entry of fs10.readdirSync(scopeDir)) {
           if (!entry.startsWith(`.${name}-`)) continue;
-          fs9.rmSync(path222.join(scopeDir, entry), { recursive: true, force: true });
+          fs10.rmSync(path222.join(scopeDir, entry), { recursive: true, force: true });
           appendUpgradeLog(`Removed stale scoped staging dir: ${path222.join(scopeDir, entry)}`);
         }
       } else {
-        for (const entry of fs9.readdirSync(npmRoot)) {
+        for (const entry of fs10.readdirSync(npmRoot)) {
           if (!entry.startsWith(`.${pkgName}-`)) continue;
-          fs9.rmSync(path222.join(npmRoot, entry), { recursive: true, force: true });
+          fs10.rmSync(path222.join(npmRoot, entry), { recursive: true, force: true });
           appendUpgradeLog(`Removed stale staging dir: ${path222.join(npmRoot, entry)}`);
         }
       }
-      if (fs9.existsSync(binDir)) {
-        for (const entry of fs9.readdirSync(binDir)) {
+      if (fs10.existsSync(binDir)) {
+        for (const entry of fs10.readdirSync(binDir)) {
           if (!Array.from(binNames).some((name) => entry.startsWith(`.${name}-`))) continue;
-          fs9.rmSync(path222.join(binDir, entry), { recursive: true, force: true });
+          fs10.rmSync(path222.join(binDir, entry), { recursive: true, force: true });
           appendUpgradeLog(`Removed stale bin staging entry: ${path222.join(binDir, entry)}`);
         }
       }
     }
     function spawnDetachedDaemonUpgradeHelper(payload) {
       const env2 = { ...process.env, [UPGRADE_HELPER_ENV]: JSON.stringify(payload) };
-      const child = (0, import_child_process9.spawn)(process.execPath, process.argv.slice(1), {
+      const child = (0, import_child_process8.spawn)(process.execPath, process.argv.slice(1), {
         detached: true,
         stdio: "ignore",
         windowsHide: true,
@@ -47239,7 +48133,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
       const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
       appendUpgradeLog(`Installing ${spec}`);
-      const installOutput = (0, import_child_process8.execFileSync)(
+      const installOutput = (0, import_child_process7.execFileSync)(
         installCommand.command,
         installCommand.args,
         {
@@ -47261,7 +48155,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         const env2 = { ...process.env };
         delete env2[UPGRADE_HELPER_ENV];
         appendUpgradeLog(`Restarting daemon with args: ${restartArgv.join(" ")}`);
-        const child = (0, import_child_process9.spawn)(process.execPath, restartArgv, {
+        const child = (0, import_child_process8.spawn)(process.execPath, restartArgv, {
           detached: true,
           stdio: "ignore",
           windowsHide: true,
@@ -47286,9 +48180,10 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         process.exit(1);
       }
     }
+    init_mesh_work_queue();
     var import_os3 = require("os");
     var import_path8 = require("path");
-    var fs10 = __toESM2(require("fs"));
+    var fs11 = __toESM2(require("fs"));
     var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
     var CHANNEL_SERVER_URL = {
       stable: "https://api.adhf.dev",
@@ -47932,7 +48827,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           if (!isSelfNode && daemonId) unavailableNodeIds.push(nodeId);
           continue;
         }
-        if (fs10.existsSync(workspace)) {
+        if (fs11.existsSync(workspace)) {
           try {
             const localGit = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
             if (localGit?.isGitRepo) {
@@ -48099,14 +48994,14 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       });
     }
     async function computeGitPatchId(cwd, fromRef, toRef) {
-      const { execFileSync: execFileSync4 } = await import("child_process");
-      const diff = execFileSync4("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
+      const { execFileSync: execFileSync3 } = await import("child_process");
+      const diff = execFileSync3("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
         cwd,
         encoding: "utf8",
         maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
       });
       if (!diff.trim()) return "";
-      const patchId = execFileSync4("git", ["patch-id", "--stable"], {
+      const patchId = execFileSync3("git", ["patch-id", "--stable"], {
         cwd,
         input: diff,
         encoding: "utf8",
@@ -48117,8 +49012,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead) {
       const startedAt = Date.now();
       try {
-        const { execFileSync: execFileSync4 } = await import("child_process");
-        const git = (args) => execFileSync4("git", args, {
+        const { execFileSync: execFileSync3 } = await import("child_process");
+        const git = (args) => execFileSync3("git", args, {
           cwd: repoRoot,
           encoding: "utf8",
           maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
@@ -48171,8 +49066,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       const entries = [];
       try {
         const { execFile: execFile3 } = await import("child_process");
-        const { promisify: promisify3 } = await import("util");
-        const execFileAsync3 = promisify3(execFile3);
+        const { promisify: promisify6 } = await import("util");
+        const execFileAsync3 = promisify6(execFile3);
         const runGit2 = async (cwd, args) => {
           const { stdout } = await execFileAsync3("git", args, {
             cwd,
@@ -48196,7 +49091,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             reachable: false
           };
           try {
-            if (!fs10.existsSync(submodulePath)) {
+            if (!fs11.existsSync(submodulePath)) {
               entry.error = `Submodule checkout missing at ${gitlink.path}`;
               entries.push(entry);
               continue;
@@ -48262,8 +49157,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     }
     async function runMeshRefineValidationGate(mesh, workspace) {
       const { execFile: execFile3 } = await import("child_process");
-      const { promisify: promisify3 } = await import("util");
-      const execFileAsync3 = promisify3(execFile3);
+      const { promisify: promisify6 } = await import("util");
+      const execFileAsync3 = promisify6(execFile3);
       const selection = resolveMeshRefineValidationPlan(mesh, workspace);
       const summary = {
         status: "skipped",
@@ -48353,9 +49248,9 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     function loadHermesCoordinatorBaseConfig(targetConfigPath) {
       const sourceHome = resolveHermesUserHome();
       const sourceConfigPath = (0, import_path8.join)(sourceHome, "config.yaml");
-      if (!fs10.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if (!fs11.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
       if ((0, import_path8.resolve)(sourceConfigPath) === (0, import_path8.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      const parsed = parseMeshCoordinatorMcpConfig(fs10.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
+      const parsed = parseMeshCoordinatorMcpConfig(fs11.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
     }
@@ -48392,9 +49287,9 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       for (const fileName of [".env", "auth.json"]) {
         const sourcePath = (0, import_path8.join)(sourceHome, fileName);
         const targetPath = (0, import_path8.join)(targetHome, fileName);
-        if (!fs10.existsSync(sourcePath)) continue;
+        if (!fs11.existsSync(sourcePath)) continue;
         try {
-          fs10.copyFileSync(sourcePath, targetPath);
+          fs11.copyFileSync(sourcePath, targetPath);
         } catch (error48) {
           LOG2.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error48?.message || error48}`);
         }
@@ -48607,6 +49502,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       getCachedAggregateMeshStatus(meshId, mesh, options) {
         const cached2 = this.aggregateMeshStatusCache.get(meshId);
         if (!cached2?.snapshot || cached2.snapshot.success !== true || !Array.isArray(cached2.snapshot.nodes)) return null;
+        if (cached2.queueRevision !== getMeshQueueRevision(meshId)) return null;
         let snapshot = this.cloneJsonValue(cached2.snapshot);
         snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
         if (shouldRefreshStalePendingAggregate(snapshot, options)) return null;
@@ -48644,7 +49540,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             returnedAt: new Date(builtAt).toISOString()
           }
         };
-        this.aggregateMeshStatusCache.set(meshId, { builtAt, snapshot: this.cloneJsonValue(next) });
+        this.aggregateMeshStatusCache.set(meshId, { builtAt, snapshot: this.cloneJsonValue(next), queueRevision: getMeshQueueRevision(meshId) });
         return next;
       }
       getCachedInlineMesh(meshId, inlineMesh) {
@@ -48747,13 +49643,13 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             recoveryHint: "Inspect the mesh node record before removing it, or remove stale metadata manually only after confirming no managed worktree remains."
           };
         }
-        const worktreeExists = fs10.existsSync(workspace);
+        const worktreeExists = fs11.existsSync(workspace);
         const sourceNode = args.node?.clonedFromNodeId ? args.mesh?.nodes?.find((n) => n.id === args.node.clonedFromNodeId || n.nodeId === args.node.clonedFromNodeId) : args.mesh?.nodes?.find((n) => !n.isLocalWorktree);
         const repoRoot = typeof sourceNode?.repoRoot === "string" && sourceNode.repoRoot.trim() ? sourceNode.repoRoot.trim() : typeof sourceNode?.workspace === "string" && sourceNode.workspace.trim() ? sourceNode.workspace.trim() : "";
         if (!worktreeExists) {
           return { success: true, skipped: true, removedPath: workspace, repoRoot: repoRoot || void 0, reason: "worktree_path_missing" };
         }
-        if (!repoRoot || !fs10.existsSync(repoRoot)) {
+        if (!repoRoot || !fs11.existsSync(repoRoot)) {
           return {
             success: false,
             code: "mesh_worktree_cleanup_missing_source_repo",
@@ -48773,7 +49669,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         const normalizePath = (value) => {
           const resolved = (0, import_path8.resolve)(value);
           try {
-            return fs10.realpathSync(resolved);
+            return fs11.realpathSync(resolved);
           } catch {
             return resolved;
           }
@@ -48846,8 +49742,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           return { allow: true, status: metadataStatus, source: "node_branch_convergence" };
         }
         const { execFile: execFile3 } = await import("child_process");
-        const { promisify: promisify3 } = await import("util");
-        const execFileAsync3 = promisify3(execFile3);
+        const { promisify: promisify6 } = await import("util");
+        const execFileAsync3 = promisify6(execFile3);
         const runGit2 = async (gitArgs, cwd) => {
           const { stdout } = await execFileAsync3("git", gitArgs, {
             cwd,
@@ -49257,8 +50153,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
           if (!repoRoot) return { success: false, error: "Source node repoRoot not found", refineStages };
           const { execFile: execFile3 } = await import("child_process");
-          const { promisify: promisify3 } = await import("util");
-          const execFileAsync3 = promisify3(execFile3);
+          const { promisify: promisify6 } = await import("util");
+          const execFileAsync3 = promisify6(execFile3);
           const resolveStarted = Date.now();
           const { stdout: branchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
           const branch = branchStdout.trim();
@@ -49567,8 +50463,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               if (sinceTs > 0) {
                 return { success: true, logs: [], totalBuffered: 0 };
               }
-              if (fs10.existsSync(LOG_PATH)) {
-                const content = fs10.readFileSync(LOG_PATH, "utf-8");
+              if (fs11.existsSync(LOG_PATH)) {
+                const content = fs11.readFileSync(LOG_PATH, "utf-8");
                 const allLines = content.split("\n");
                 const recent = allLines.slice(-count).join("\n");
                 return { success: true, logs: recent, totalLines: allLines.length };
@@ -50991,7 +51887,7 @@ ${block2}`);
                   workspace
                 };
               }
-              const { existsSync: existsSync27, readFileSync: readFileSync19, writeFileSync: writeFileSync15, copyFileSync: copyFileSync4, mkdirSync: mkdirSync17 } = await import("fs");
+              const { existsSync: existsSync26, readFileSync: readFileSync19, writeFileSync: writeFileSync14, copyFileSync: copyFileSync4, mkdirSync: mkdirSync18 } = await import("fs");
               const { dirname: dirname9 } = await import("path");
               const mcpConfigPath = coordinatorSetup.configPath;
               const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -51027,14 +51923,14 @@ ${block2}`);
                 };
               }
               try {
-                mkdirSync17(dirname9(mcpConfigPath), { recursive: true });
+                mkdirSync18(dirname9(mcpConfigPath), { recursive: true });
               } catch (error48) {
                 const message = `Could not prepare MCP config path for automatic setup: ${error48?.message || error48}`;
                 LOG2.error("MeshCoordinator", message);
                 if (hermesManualFallback) return returnManualFallback(message);
                 return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
               }
-              const hadExistingMcpConfig = existsSync27(mcpConfigPath);
+              const hadExistingMcpConfig = existsSync26(mcpConfigPath);
               let existingMcpConfig = hermesBaseConfig?.config || {};
               if (hermesBaseConfig) {
                 copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname9(mcpConfigPath));
@@ -51064,7 +51960,7 @@ ${block2}`);
                 }
               };
               try {
-                writeFileSync15(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
+                writeFileSync14(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
               } catch (error48) {
                 const message = `Could not write MCP config for automatic setup: ${error48?.message || error48}`;
                 LOG2.error("MeshCoordinator", message);
@@ -51292,7 +52188,7 @@ ${block2}`);
                   }
                 }
                 if (workspace) {
-                  if (!fs10.existsSync(workspace)) {
+                  if (!fs11.existsSync(workspace)) {
                     const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
                     let remoteProbeApplied = false;
                     if (inlineTransitGit) {
@@ -51501,7 +52397,7 @@ ${block2}`);
           }
         }
         if (killProcess) {
-          const running = isIdeRunning(ideType);
+          const running = await isIdeRunning(ideType);
           if (running) {
             LOG2.info("StopIDE", `Killing IDE process: ${ideType}`);
             const killed = await killIdeProcess(ideType);
@@ -51525,6 +52421,8 @@ ${block2}`);
       lastStatusSentAt = 0;
       statusPendingThrottle = false;
       lastP2PStatusHash = "";
+      lastP2PStatusSentAt = 0;
+      p2pDebounceTimer = null;
       lastServerStatusHash = "";
       lastStatusSummary = "";
       statusTimer = null;
@@ -51776,7 +52674,18 @@ ${block2}`);
         })() : { ...hashTarget, sessions };
         const h = this.simpleHash(JSON.stringify(hashPayload));
         if (h !== this.lastP2PStatusHash) {
+          const now = Date.now();
+          if (this.lastP2PStatusSentAt && now - this.lastP2PStatusSentAt < 500) {
+            if (!this.p2pDebounceTimer) {
+              this.p2pDebounceTimer = setTimeout(() => {
+                this.p2pDebounceTimer = null;
+                this.sendUnifiedStatusReport({ reason: "p2p_debounce" });
+              }, 500);
+            }
+            return false;
+          }
           this.lastP2PStatusHash = h;
+          this.lastP2PStatusSentAt = now;
           this.deps.p2p?.sendStatus(payload);
           return true;
         }
@@ -53091,11 +54000,11 @@ ${block2}`);
         this.eventListeners = [];
       }
     };
-    var fs11 = __toESM2(require("fs"));
+    var fs12 = __toESM2(require("fs"));
     var path232 = __toESM2(require("path"));
     var os20 = __toESM2(require("os"));
-    var import_child_process10 = require("child_process");
     var import_os4 = require("os");
+    var import_child_process9 = require("child_process");
     var ARCHIVE_PATH = path232.join(os20.homedir(), ".adhdev", "version-history.json");
     var MAX_ENTRIES_PER_PROVIDER = 20;
     var VersionArchive = class {
@@ -53105,8 +54014,8 @@ ${block2}`);
       }
       load() {
         try {
-          if (fs11.existsSync(ARCHIVE_PATH)) {
-            this.history = JSON.parse(fs11.readFileSync(ARCHIVE_PATH, "utf-8"));
+          if (fs12.existsSync(ARCHIVE_PATH)) {
+            this.history = JSON.parse(fs12.readFileSync(ARCHIVE_PATH, "utf-8"));
           }
         } catch {
           this.history = {};
@@ -53143,27 +54052,43 @@ ${block2}`);
       }
       save() {
         try {
-          fs11.mkdirSync(path232.dirname(ARCHIVE_PATH), { recursive: true });
-          fs11.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+          fs12.mkdirSync(path232.dirname(ARCHIVE_PATH), { recursive: true });
+          fs12.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
         } catch {
         }
       }
     };
-    function runCommand(cmd, timeout = 1e4) {
-      try {
-        return (0, import_child_process10.execSync)(cmd, {
+    async function runCommand(cmd, timeout = 1e4) {
+      return new Promise((resolve16) => {
+        (0, import_child_process9.exec)(cmd, {
           encoding: "utf-8",
-          timeout,
-          stdio: ["pipe", "pipe", "pipe"]
-        }).trim();
-      } catch {
-        return null;
-      }
+          timeout
+        }, (error48, stdout) => {
+          if (error48) return resolve16(null);
+          resolve16(stdout.trim());
+        });
+      });
     }
     function findBinary2(name) {
-      const cmd = (0, import_os4.platform)() === "win32" ? `where ${name}` : `which ${name}`;
-      const result = runCommand(cmd, 5e3);
-      return result ? result.split("\n")[0] : null;
+      const isWin = (0, import_os4.platform)() === "win32";
+      const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
+      const exes = isWin ? [".exe", ".cmd", ".bat", ""] : [""];
+      for (const p of paths) {
+        if (!p) continue;
+        for (const ext of exes) {
+          const fullPath = path232.join(p, name + ext);
+          try {
+            if (fs12.existsSync(fullPath)) {
+              const stat2 = fs12.statSync(fullPath);
+              if (stat2.isFile() && (isWin || stat2.mode & 73)) {
+                return fullPath;
+              }
+            }
+          } catch {
+          }
+        }
+      }
+      return null;
     }
     function parseVersion2(raw) {
       const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
@@ -53185,13 +54110,13 @@ ${block2}`);
       }
       return void 0;
     }
-    function getVersion(binary, versionCommand) {
+    async function getVersion(binary, versionCommand) {
       if (versionCommand) {
-        const raw = runCommand(versionCommand);
+        const raw = await runCommand(versionCommand);
         return raw ? parseVersion2(raw) : null;
       }
       for (const flag of ["--version", "-V", "-v"]) {
-        const raw = runCommand(`"${binary}" ${flag}`);
+        const raw = await runCommand(`"${binary}" ${flag}`);
         if (raw && raw.length < 500) return parseVersion2(raw);
       }
       return null;
@@ -53201,18 +54126,18 @@ ${block2}`);
         if (p.includes("*")) {
           const home = os20.homedir();
           const resolved = p.replace(/\*/g, home.split(path232.sep).pop() || "");
-          if (fs11.existsSync(resolved)) return resolved;
+          if (fs12.existsSync(resolved)) return resolved;
         } else {
-          if (fs11.existsSync(p)) return p;
+          if (fs12.existsSync(p)) return p;
         }
       }
       return null;
     }
-    function getMacAppVersion(appPath) {
+    async function getMacAppVersion(appPath) {
       if ((0, import_os4.platform)() !== "darwin" || !appPath.endsWith(".app")) return null;
       const plistPath = path232.join(appPath, "Contents", "Info.plist");
-      if (!fs11.existsSync(plistPath)) return null;
-      const raw = runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
+      if (!fs12.existsSync(plistPath)) return null;
+      const raw = await runCommand(`/usr/libexec/PlistBuddy -c "Print CFBundleShortVersionString" "${plistPath}"`);
       return raw || null;
     }
     async function detectAllVersions(loader, archive) {
@@ -53237,16 +54162,16 @@ ${block2}`);
           let resolvedBin = cliBin;
           if (!resolvedBin && appPath && currentOs === "darwin") {
             const bundled = path232.join(appPath, "Contents", "Resources", "app", "bin", provider.cli || "");
-            if (provider.cli && fs11.existsSync(bundled)) resolvedBin = bundled;
+            if (provider.cli && fs12.existsSync(bundled)) resolvedBin = bundled;
           }
           info.installed = !!(appPath || resolvedBin);
           info.path = appPath || null;
           info.binary = resolvedBin || null;
           if (resolvedBin) {
-            info.version = getVersion(resolvedBin, versionCommand);
+            info.version = await getVersion(resolvedBin, versionCommand);
           }
           if (!info.version && appPath) {
-            info.version = getMacAppVersion(appPath);
+            info.version = await getMacAppVersion(appPath);
           }
         } else if (provider.category === "cli" || provider.category === "acp") {
           const bin = provider.binary || provider.spawn?.command || provider.cli || provider.type;
@@ -53254,7 +54179,7 @@ ${block2}`);
           info.installed = !!binPath;
           info.binary = binPath || null;
           if (binPath) {
-            info.version = getVersion(binPath, versionCommand);
+            info.version = await getVersion(binPath, versionCommand);
           }
         } else if (provider.category === "extension") {
           info.installed = false;
@@ -53274,7 +54199,7 @@ ${block2}`);
       return results;
     }
     var http2 = __toESM2(require("http"));
-    var fs15 = __toESM2(require("fs"));
+    var fs16 = __toESM2(require("fs"));
     var path27 = __toESM2(require("path"));
     init_config();
     function generateFiles(type, name, category, opts = {}) {
@@ -53619,7 +54544,7 @@ async (params) => {
       };
     }
     init_logger();
-    var fs12 = __toESM2(require("fs"));
+    var fs13 = __toESM2(require("fs"));
     var path24 = __toESM2(require("path"));
     init_logger();
     async function handleCdpEvaluate(ctx, req, res) {
@@ -53800,17 +54725,17 @@ async (params) => {
       }
       let scriptsPath = "";
       const directScripts = path24.join(dir, "scripts.js");
-      if (fs12.existsSync(directScripts)) {
+      if (fs13.existsSync(directScripts)) {
         scriptsPath = directScripts;
       } else {
         const scriptsDir = path24.join(dir, "scripts");
-        if (fs12.existsSync(scriptsDir)) {
-          const versions = fs12.readdirSync(scriptsDir).filter((d) => {
-            return fs12.statSync(path24.join(scriptsDir, d)).isDirectory();
+        if (fs13.existsSync(scriptsDir)) {
+          const versions = fs13.readdirSync(scriptsDir).filter((d) => {
+            return fs13.statSync(path24.join(scriptsDir, d)).isDirectory();
           }).sort().reverse();
           for (const ver of versions) {
             const p = path24.join(scriptsDir, ver, "scripts.js");
-            if (fs12.existsSync(p)) {
+            if (fs13.existsSync(p)) {
               scriptsPath = p;
               break;
             }
@@ -53822,7 +54747,7 @@ async (params) => {
         return;
       }
       try {
-        const source = fs12.readFileSync(scriptsPath, "utf-8");
+        const source = fs13.readFileSync(scriptsPath, "utf-8");
         const hints = {};
         const funcRegex = /module\.exports\.(\w+)\s*=\s*function\s+\w+\s*\(params\)/g;
         let match;
@@ -54635,7 +55560,7 @@ async (params) => {
         ctx.json(res, 500, { error: `DOM context collection failed: ${e.message}` });
       }
     }
-    var fs13 = __toESM2(require("fs"));
+    var fs14 = __toESM2(require("fs"));
     var path25 = __toESM2(require("path"));
     function slugifyFixtureName(value) {
       const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -54651,10 +55576,10 @@ async (params) => {
     function readCliFixture(ctx, type, name) {
       const fixtureDir = getCliFixtureDir(ctx, type);
       const filePath = path25.join(fixtureDir, `${name}.json`);
-      if (!fs13.existsSync(filePath)) {
+      if (!fs14.existsSync(filePath)) {
         throw new Error(`Fixture not found: ${filePath}`);
       }
-      return JSON.parse(fs13.readFileSync(filePath, "utf-8"));
+      return JSON.parse(fs14.readFileSync(filePath, "utf-8"));
     }
     function getExerciseTranscriptText(result) {
       const parts = [];
@@ -55390,7 +56315,7 @@ async (params) => {
           return;
         }
         const fixtureDir = getCliFixtureDir(ctx, type);
-        fs13.mkdirSync(fixtureDir, { recursive: true });
+        fs14.mkdirSync(fixtureDir, { recursive: true });
         const name = slugifyFixtureName(String(body?.name || `${type}-${Date.now()}`));
         const result = await runCliExerciseInternal(ctx, { ...request, type });
         const fixture = {
@@ -55418,7 +56343,7 @@ async (params) => {
           notes: typeof body?.notes === "string" ? body.notes : void 0
         };
         const filePath = path25.join(fixtureDir, `${name}.json`);
-        fs13.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
+        fs14.writeFileSync(filePath, JSON.stringify(fixture, null, 2));
         ctx.json(res, 200, {
           saved: true,
           name,
@@ -55436,14 +56361,14 @@ async (params) => {
     async function handleCliFixtureList(ctx, type, _req, res) {
       try {
         const fixtureDir = getCliFixtureDir(ctx, type);
-        if (!fs13.existsSync(fixtureDir)) {
+        if (!fs14.existsSync(fixtureDir)) {
           ctx.json(res, 200, { fixtures: [], count: 0 });
           return;
         }
-        const fixtures = fs13.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
+        const fixtures = fs14.readdirSync(fixtureDir).filter((file2) => file2.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file2) => {
           const fullPath = path25.join(fixtureDir, file2);
           try {
-            const raw = JSON.parse(fs13.readFileSync(fullPath, "utf-8"));
+            const raw = JSON.parse(fs14.readFileSync(fullPath, "utf-8"));
             return {
               name: raw.name || file2.replace(/\.json$/i, ""),
               path: fullPath,
@@ -55574,7 +56499,7 @@ async (params) => {
         ctx.json(res, 500, { error: `Raw send failed: ${e.message}` });
       }
     }
-    var fs14 = __toESM2(require("fs"));
+    var fs15 = __toESM2(require("fs"));
     var path26 = __toESM2(require("path"));
     var os21 = __toESM2(require("os"));
     function getAutoImplPid(ctx) {
@@ -55622,10 +56547,10 @@ async (params) => {
       return fallback?.type || null;
     }
     function getLatestScriptVersionDir(scriptsDir) {
-      if (!fs14.existsSync(scriptsDir)) return null;
-      const versions = fs14.readdirSync(scriptsDir).filter((d) => {
+      if (!fs15.existsSync(scriptsDir)) return null;
+      const versions = fs15.readdirSync(scriptsDir).filter((d) => {
         try {
-          return fs14.statSync(path26.join(scriptsDir, d)).isDirectory();
+          return fs15.statSync(path26.join(scriptsDir, d)).isDirectory();
         } catch {
           return false;
         }
@@ -55647,13 +56572,13 @@ async (params) => {
       if (!sourceDir) {
         return { dir: null, reason: `Provider source directory not found for '${type}'` };
       }
-      if (!fs14.existsSync(desiredDir)) {
-        fs14.mkdirSync(path26.dirname(desiredDir), { recursive: true });
-        fs14.cpSync(sourceDir, desiredDir, { recursive: true });
+      if (!fs15.existsSync(desiredDir)) {
+        fs15.mkdirSync(path26.dirname(desiredDir), { recursive: true });
+        fs15.cpSync(sourceDir, desiredDir, { recursive: true });
         ctx.log(`Auto-implement writable copy created: ${desiredDir}`);
       }
       const providerJson = path26.join(desiredDir, "provider.json");
-      if (!fs14.existsSync(providerJson)) {
+      if (!fs15.existsSync(providerJson)) {
         return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
       }
       return { dir: desiredDir };
@@ -55661,15 +56586,15 @@ async (params) => {
     function loadAutoImplReferenceScripts(ctx, referenceType) {
       if (!referenceType) return {};
       const refDir = ctx.findProviderDir(referenceType);
-      if (!refDir || !fs14.existsSync(refDir)) return {};
+      if (!refDir || !fs15.existsSync(refDir)) return {};
       const referenceScripts = {};
       const scriptsDir = path26.join(refDir, "scripts");
       const latestDir = getLatestScriptVersionDir(scriptsDir);
       if (!latestDir) return referenceScripts;
-      for (const file2 of fs14.readdirSync(latestDir)) {
+      for (const file2 of fs15.readdirSync(latestDir)) {
         if (!file2.endsWith(".js")) continue;
         try {
-          referenceScripts[file2] = fs14.readFileSync(path26.join(latestDir, file2), "utf-8");
+          referenceScripts[file2] = fs15.readFileSync(path26.join(latestDir, file2), "utf-8");
         } catch {
         }
       }
@@ -55778,15 +56703,15 @@ async (params) => {
         const referenceScripts = loadAutoImplReferenceScripts(ctx, resolvedReference);
         const prompt = buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domContext, referenceScripts, comment, resolvedReference, verification);
         const tmpDir = path26.join(os21.tmpdir(), "adhdev-autoimpl");
-        if (!fs14.existsSync(tmpDir)) fs14.mkdirSync(tmpDir, { recursive: true });
+        if (!fs15.existsSync(tmpDir)) fs15.mkdirSync(tmpDir, { recursive: true });
         const promptFile = path26.join(tmpDir, `prompt-${type}-${Date.now()}.md`);
-        fs14.writeFileSync(promptFile, prompt, "utf-8");
+        fs15.writeFileSync(promptFile, prompt, "utf-8");
         ctx.log(`Auto-implement prompt written to ${promptFile} (${prompt.length} chars)`);
         const agentProvider = ctx.providerLoader.resolve(agent) || ctx.providerLoader.getMeta(agent);
         const spawn4 = agentProvider?.spawn;
         if (!spawn4?.command) {
           try {
-            fs14.unlinkSync(promptFile);
+            fs15.unlinkSync(promptFile);
           } catch {
           }
           ctx.json(res, 400, { error: `Agent '${agent}' has no spawn config. Select a CLI provider with a spawn configuration.` });
@@ -55888,7 +56813,7 @@ async (params) => {
             } catch {
             }
             try {
-              fs14.unlinkSync(promptFile);
+              fs15.unlinkSync(promptFile);
             } catch {
             }
             ctx.log(`Auto-implement (ACP) ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -56114,7 +57039,7 @@ async (params) => {
             }
           });
           try {
-            fs14.unlinkSync(promptFile);
+            fs15.unlinkSync(promptFile);
           } catch {
           }
           ctx.log(`Auto-implement ${success2 ? "completed" : "failed"}: ${type} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -56219,10 +57144,10 @@ async (params) => {
         lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
         lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
         lines.push("");
-        for (const file2 of fs14.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs15.readdirSync(latestScriptsDir)) {
           if (file2.endsWith(".js") && targetFileNames.has(file2)) {
             try {
-              const content = fs14.readFileSync(path26.join(latestScriptsDir, file2), "utf-8");
+              const content = fs15.readFileSync(path26.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -56232,14 +57157,14 @@ async (params) => {
             }
           }
         }
-        const refFiles = fs14.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs15.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
         if (refFiles.length > 0) {
           lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
           lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
           lines.push("");
           for (const file2 of refFiles) {
             try {
-              const content = fs14.readFileSync(path26.join(latestScriptsDir, file2), "utf-8");
+              const content = fs15.readFileSync(path26.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -56284,7 +57209,7 @@ async (params) => {
       const loadGuide = (name) => {
         try {
           const p = path26.join(docsDir, name);
-          if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
+          if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -56528,11 +57453,11 @@ async (params) => {
         lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
         lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
         lines.push("");
-        for (const file2 of fs14.readdirSync(latestScriptsDir)) {
+        for (const file2 of fs15.readdirSync(latestScriptsDir)) {
           if (!file2.endsWith(".js")) continue;
           if (!targetFileNames.has(file2)) continue;
           try {
-            const content = fs14.readFileSync(path26.join(latestScriptsDir, file2), "utf-8");
+            const content = fs15.readFileSync(path26.join(latestScriptsDir, file2), "utf-8");
             lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -56541,14 +57466,14 @@ async (params) => {
           } catch {
           }
         }
-        const refFiles = fs14.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+        const refFiles = fs15.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
         if (refFiles.length > 0) {
           lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
           lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
           lines.push("");
           for (const file2 of refFiles) {
             try {
-              const content = fs14.readFileSync(path26.join(latestScriptsDir, file2), "utf-8");
+              const content = fs15.readFileSync(path26.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u{1F512}`);
               lines.push("```javascript");
               lines.push(content);
@@ -56585,7 +57510,7 @@ async (params) => {
       const loadGuide = (name) => {
         try {
           const p = path26.join(docsDir, name);
-          if (fs14.existsSync(p)) return fs14.readFileSync(p, "utf-8");
+          if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
         } catch {
         }
         return null;
@@ -57323,7 +58248,7 @@ data: ${JSON.stringify(msg.data)}
           path27.join(process.cwd(), "packages/web-devconsole/dist")
         ];
         for (const dir of candidates) {
-          if (fs15.existsSync(path27.join(dir, "index.html"))) return dir;
+          if (fs16.existsSync(path27.join(dir, "index.html"))) return dir;
         }
         return null;
       }
@@ -57335,7 +58260,7 @@ data: ${JSON.stringify(msg.data)}
         }
         const htmlPath = path27.join(distDir, "index.html");
         try {
-          const html = fs15.readFileSync(htmlPath, "utf-8");
+          const html = fs16.readFileSync(htmlPath, "utf-8");
           res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
           res.end(html);
         } catch (e) {
@@ -57365,7 +58290,7 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          const content = fs15.readFileSync(filePath);
+          const content = fs16.readFileSync(filePath);
           const ext = path27.extname(filePath);
           const contentType = _DevServer.MIME_MAP[ext] || "application/octet-stream";
           res.writeHead(200, { "Content-Type": contentType, "Cache-Control": "public, max-age=31536000, immutable" });
@@ -57474,14 +58399,14 @@ data: ${JSON.stringify(msg.data)}
         const files = [];
         const scan = (d, prefix) => {
           try {
-            for (const entry of fs15.readdirSync(d, { withFileTypes: true })) {
+            for (const entry of fs16.readdirSync(d, { withFileTypes: true })) {
               if (entry.name.startsWith(".") || entry.name.endsWith(".bak")) continue;
               const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
               if (entry.isDirectory()) {
                 files.push({ path: rel, size: 0, type: "dir" });
                 scan(path27.join(d, entry.name), rel);
               } else {
-                const stat2 = fs15.statSync(path27.join(d, entry.name));
+                const stat2 = fs16.statSync(path27.join(d, entry.name));
                 files.push({ path: rel, size: stat2.size, type: "file" });
               }
             }
@@ -57509,11 +58434,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 403, { error: "Forbidden" });
           return;
         }
-        if (!fs15.existsSync(fullPath) || fs15.statSync(fullPath).isDirectory()) {
+        if (!fs16.existsSync(fullPath) || fs16.statSync(fullPath).isDirectory()) {
           this.json(res, 404, { error: `File not found: ${filePath}` });
           return;
         }
-        const content = fs15.readFileSync(fullPath, "utf-8");
+        const content = fs16.readFileSync(fullPath, "utf-8");
         this.json(res, 200, { type, path: filePath, content, lines: content.split("\n").length });
       }
       /** POST /api/providers/:type/file — write a file { path, content } */
@@ -57535,9 +58460,9 @@ data: ${JSON.stringify(msg.data)}
           return;
         }
         try {
-          if (fs15.existsSync(fullPath)) fs15.copyFileSync(fullPath, fullPath + ".bak");
-          fs15.mkdirSync(path27.dirname(fullPath), { recursive: true });
-          fs15.writeFileSync(fullPath, content, "utf-8");
+          if (fs16.existsSync(fullPath)) fs16.copyFileSync(fullPath, fullPath + ".bak");
+          fs16.mkdirSync(path27.dirname(fullPath), { recursive: true });
+          fs16.writeFileSync(fullPath, content, "utf-8");
           this.log(`File saved: ${fullPath} (${content.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: filePath, chars: content.length });
@@ -57554,8 +58479,8 @@ data: ${JSON.stringify(msg.data)}
         }
         for (const name of ["scripts.js", "provider.json"]) {
           const p = path27.join(dir, name);
-          if (fs15.existsSync(p)) {
-            const source = fs15.readFileSync(p, "utf-8");
+          if (fs16.existsSync(p)) {
+            const source = fs16.readFileSync(p, "utf-8");
             this.json(res, 200, { type, path: p, source, lines: source.split("\n").length });
             return;
           }
@@ -57574,11 +58499,11 @@ data: ${JSON.stringify(msg.data)}
           this.json(res, 404, { error: `Provider not found: ${type}` });
           return;
         }
-        const target = fs15.existsSync(path27.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
+        const target = fs16.existsSync(path27.join(dir, "scripts.js")) ? "scripts.js" : "provider.json";
         const targetPath = path27.join(dir, target);
         try {
-          if (fs15.existsSync(targetPath)) fs15.copyFileSync(targetPath, targetPath + ".bak");
-          fs15.writeFileSync(targetPath, source, "utf-8");
+          if (fs16.existsSync(targetPath)) fs16.copyFileSync(targetPath, targetPath + ".bak");
+          fs16.writeFileSync(targetPath, source, "utf-8");
           this.log(`Saved provider: ${targetPath} (${source.length} chars)`);
           this.providerLoader.reload();
           this.json(res, 200, { saved: true, path: targetPath, chars: source.length });
@@ -57723,20 +58648,20 @@ data: ${JSON.stringify(msg.data)}
         let targetDir;
         targetDir = this.providerLoader.getUserProviderDir(category, type);
         const jsonPath = path27.join(targetDir, "provider.json");
-        if (fs15.existsSync(jsonPath)) {
+        if (fs16.existsSync(jsonPath)) {
           this.json(res, 409, { error: `Provider already exists at ${targetDir}`, path: targetDir });
           return;
         }
         try {
           const result = generateFiles(type, name, category, { cdpPorts, cli, processName, installPath, binary, extensionId, version: version2, osPaths, processNames });
-          fs15.mkdirSync(targetDir, { recursive: true });
-          fs15.writeFileSync(jsonPath, result["provider.json"], "utf-8");
+          fs16.mkdirSync(targetDir, { recursive: true });
+          fs16.writeFileSync(jsonPath, result["provider.json"], "utf-8");
           const createdFiles = ["provider.json"];
           if (result.files) {
             for (const [relPath, content] of Object.entries(result.files)) {
               const fullPath = path27.join(targetDir, relPath);
-              fs15.mkdirSync(path27.dirname(fullPath), { recursive: true });
-              fs15.writeFileSync(fullPath, content, "utf-8");
+              fs16.mkdirSync(path27.dirname(fullPath), { recursive: true });
+              fs16.writeFileSync(fullPath, content, "utf-8");
               createdFiles.push(relPath);
             }
           }
@@ -57785,10 +58710,10 @@ data: ${JSON.stringify(msg.data)}
       }
       // ─── Phase 2: Auto-Implement Backend ───
       getLatestScriptVersionDir(scriptsDir) {
-        if (!fs15.existsSync(scriptsDir)) return null;
-        const versions = fs15.readdirSync(scriptsDir).filter((d) => {
+        if (!fs16.existsSync(scriptsDir)) return null;
+        const versions = fs16.readdirSync(scriptsDir).filter((d) => {
           try {
-            return fs15.statSync(path27.join(scriptsDir, d)).isDirectory();
+            return fs16.statSync(path27.join(scriptsDir, d)).isDirectory();
           } catch {
             return false;
           }
@@ -57810,13 +58735,13 @@ data: ${JSON.stringify(msg.data)}
         if (!sourceDir) {
           return { dir: null, reason: `Provider source directory not found for '${type}'` };
         }
-        if (!fs15.existsSync(desiredDir)) {
-          fs15.mkdirSync(path27.dirname(desiredDir), { recursive: true });
-          fs15.cpSync(sourceDir, desiredDir, { recursive: true });
+        if (!fs16.existsSync(desiredDir)) {
+          fs16.mkdirSync(path27.dirname(desiredDir), { recursive: true });
+          fs16.cpSync(sourceDir, desiredDir, { recursive: true });
           this.log(`Auto-implement writable copy created: ${desiredDir}`);
         }
         const providerJson = path27.join(desiredDir, "provider.json");
-        if (!fs15.existsSync(providerJson)) {
+        if (!fs16.existsSync(providerJson)) {
           return { dir: null, reason: `provider.json not found in writable provider directory: ${desiredDir}` };
         }
         return { dir: desiredDir };
@@ -57859,10 +58784,10 @@ data: ${JSON.stringify(msg.data)}
           lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
           lines.push("These are the ONLY files you are allowed to modify. Replace the TODO stubs with working implementations.");
           lines.push("");
-          for (const file2 of fs15.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs16.readdirSync(latestScriptsDir)) {
             if (file2.endsWith(".js") && targetFileNames.has(file2)) {
               try {
-                const content = fs15.readFileSync(path27.join(latestScriptsDir, file2), "utf-8");
+                const content = fs16.readFileSync(path27.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -57872,14 +58797,14 @@ data: ${JSON.stringify(msg.data)}
               }
             }
           }
-          const refFiles = fs15.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+          const refFiles = fs16.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
           if (refFiles.length > 0) {
             lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
             lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
             lines.push("");
             for (const file2 of refFiles) {
               try {
-                const content = fs15.readFileSync(path27.join(latestScriptsDir, file2), "utf-8");
+                const content = fs16.readFileSync(path27.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -57924,7 +58849,7 @@ data: ${JSON.stringify(msg.data)}
         const loadGuide = (name) => {
           try {
             const p = path27.join(docsDir, name);
-            if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
+            if (fs16.existsSync(p)) return fs16.readFileSync(p, "utf-8");
           } catch {
           }
           return null;
@@ -58105,11 +59030,11 @@ data: ${JSON.stringify(msg.data)}
           lines.push("## \u270F\uFE0F Target Files (EDIT THESE)");
           lines.push("These are the ONLY files you are allowed to modify. Replace TODO or heuristic-only logic with working PTY-aware implementations.");
           lines.push("");
-          for (const file2 of fs15.readdirSync(latestScriptsDir)) {
+          for (const file2 of fs16.readdirSync(latestScriptsDir)) {
             if (!file2.endsWith(".js")) continue;
             if (!targetFileNames.has(file2)) continue;
             try {
-              const content = fs15.readFileSync(path27.join(latestScriptsDir, file2), "utf-8");
+              const content = fs16.readFileSync(path27.join(latestScriptsDir, file2), "utf-8");
               lines.push(`### \`${file2}\` \u270F\uFE0F EDIT`);
               lines.push("```javascript");
               lines.push(content);
@@ -58118,14 +59043,14 @@ data: ${JSON.stringify(msg.data)}
             } catch {
             }
           }
-          const refFiles = fs15.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
+          const refFiles = fs16.readdirSync(latestScriptsDir).filter((f) => f.endsWith(".js") && !targetFileNames.has(f));
           if (refFiles.length > 0) {
             lines.push("## \u{1F512} Other Scripts (REFERENCE ONLY \u2014 DO NOT EDIT)");
             lines.push("These files are shown for context only. Do NOT modify them under any circumstances.");
             lines.push("");
             for (const file2 of refFiles) {
               try {
-                const content = fs15.readFileSync(path27.join(latestScriptsDir, file2), "utf-8");
+                const content = fs16.readFileSync(path27.join(latestScriptsDir, file2), "utf-8");
                 lines.push(`### \`${file2}\` \u{1F512}`);
                 lines.push("```javascript");
                 lines.push(content);
@@ -58162,7 +59087,7 @@ data: ${JSON.stringify(msg.data)}
         const loadGuide = (name) => {
           try {
             const p = path27.join(docsDir, name);
-            if (fs15.existsSync(p)) return fs15.readFileSync(p, "utf-8");
+            if (fs16.existsSync(p)) return fs16.readFileSync(p, "utf-8");
           } catch {
           }
           return null;
@@ -58927,7 +59852,8 @@ data: ${JSON.stringify(msg.data)}
       if (raw === "0" || raw === "false" || raw === "no") return false;
       return raw === "1" || raw === "true" || raw === "yes";
     }
-    var import_child_process11 = require("child_process");
+    var import_child_process10 = require("child_process");
+    var import_util32 = require("util");
     var EXTENSION_CATALOG = [
       // AI Agent extensions
       {
@@ -59014,15 +59940,15 @@ data: ${JSON.stringify(msg.data)}
         apiKeyName: "OpenAI/Anthropic API key"
       }
     ];
-    function isExtensionInstalled(ide, marketplaceId) {
+    var execAsync4 = (0, import_util32.promisify)(import_child_process10.exec);
+    async function isExtensionInstalled(ide, marketplaceId) {
       if (!ide.cliCommand) return false;
       try {
-        const result = (0, import_child_process11.execSync)(`"${ide.cliCommand}" --list-extensions`, {
+        const { stdout } = await execAsync4(`"${ide.cliCommand}" --list-extensions`, {
           encoding: "utf-8",
-          timeout: 15e3,
-          stdio: ["pipe", "pipe", "pipe"]
+          timeout: 15e3
         });
-        const installed = result.trim().split("\n").map((e) => e.trim().toLowerCase());
+        const installed = stdout.trim().split("\n").map((e) => e.trim().toLowerCase());
         return installed.includes(marketplaceId.toLowerCase());
       } catch {
         return false;
@@ -59038,7 +59964,7 @@ data: ${JSON.stringify(msg.data)}
           error: `No CLI command found for ${ide.displayName}. Please install it manually.`
         };
       }
-      const alreadyInstalled = isExtensionInstalled(ide, extension.marketplaceId);
+      const alreadyInstalled = await isExtensionInstalled(ide, extension.marketplaceId);
       if (alreadyInstalled) {
         return {
           extensionId: extension.id,
@@ -59054,11 +59980,11 @@ data: ${JSON.stringify(msg.data)}
           const res = await fetch(extension.vsixUrl);
           if (res.ok) {
             const buffer = Buffer.from(await res.arrayBuffer());
-            const fs16 = await import("fs");
-            fs16.writeFileSync(vsixPath, buffer);
+            const fs17 = await import("fs");
+            fs17.writeFileSync(vsixPath, buffer);
             return new Promise((resolve16) => {
               const cmd = `"${ide.cliCommand}" --install-extension "${vsixPath}" --force`;
-              (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
+              (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error48, _stdout, stderr) => {
                 resolve16({
                   extensionId: extension.id,
                   marketplaceId: extension.marketplaceId,
@@ -59074,7 +60000,7 @@ data: ${JSON.stringify(msg.data)}
       }
       return new Promise((resolve16) => {
         const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
-        (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error48, stdout, stderr) => {
+        (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error48, stdout, stderr) => {
           if (error48) {
             resolve16({
               extensionId: extension.id,
@@ -59111,7 +60037,7 @@ data: ${JSON.stringify(msg.data)}
       if (!ide.cliCommand) return false;
       try {
         const args = workspacePath ? `"${workspacePath}"` : "";
-        (0, import_child_process11.exec)(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
+        (0, import_child_process10.exec)(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
         return true;
       } catch {
         return false;