@adhdev/daemon-core 0.9.82-rc.65 → 0.9.82-rc.67

package/dist/index.js

@@ -1683,15 +1683,162 @@ var init_mesh_ledger = __esm({
   }
 });
 
+// src/mesh/beads-db.ts
+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, import_fs5, import_path5, BeadsDB;
+var init_beads_db = __esm({
+  "src/mesh/beads-db.ts"() {
+    "use strict";
+    import_better_sqlite3 = __toESM(require("better-sqlite3"));
+    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)
+        };
+      }
+    };
+  }
+});
+
 // src/mesh/mesh-work-queue.ts
 var mesh_work_queue_exports = {};
 __export(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,
@@ -1727,53 +1874,14 @@ function validateMeshTaskModeRequest(mode, message) {
     ]
   };
 }
-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);
@@ -1807,6 +1915,9 @@ function getQueue(meshId, opts) {
   }
   return queue;
 }
+function getMeshQueueRevision(meshId) {
+  return BeadsDB.getInstance().getQueueRevision(meshId);
+}
 function claimNextTask(meshId, nodeId, sessionId) {
   return withQueueLock(meshId, () => {
     const queue = readQueue(meshId);
@@ -1950,15 +2061,24 @@ function getMeshQueueStats(meshId) {
     }))
   };
 }
-var import_fs5, import_path5, import_crypto5, ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, LIVE_DEBUG_READONLY_FORBIDDEN;
+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, ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, LIVE_DEBUG_READONLY_FORBIDDEN;
 var init_mesh_work_queue = __esm({
   "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"];
@@ -2107,6 +2227,60 @@ var init_cli_detector = __esm({
   }
 });
 
+// src/logging/async-batch-writer.ts
+var fs2, AsyncBatchWriter;
+var init_async_batch_writer = __esm({
+  "src/logging/async-batch-writer.ts"() {
+    "use strict";
+    fs2 = __toESM(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 fs2.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);
+            }
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/logging/logger.ts
 function setLogLevel(level) {
   currentLevel = level;
@@ -2134,7 +2308,7 @@ function checkDateRotation() {
 }
 function cleanOldLogs() {
   try {
-    const files = fs2.readdirSync(LOG_DIR).filter((f) => f.startsWith("daemon-") && f.endsWith(".log"));
+    const files = fs3.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);
@@ -2142,7 +2316,7 @@ function cleanOldLogs() {
       const dateMatch = file.match(/daemon-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs2.unlinkSync(path9.join(LOG_DIR, file));
+          fs3.unlinkSync(path9.join(LOG_DIR, file));
         } catch {
         }
       }
@@ -2152,14 +2326,14 @@ function cleanOldLogs() {
 }
 function rotateSizeIfNeeded() {
   try {
-    const stat2 = fs2.statSync(currentLogFile);
+    const stat2 = fs3.statSync(currentLogFile);
     if (stat2.size > MAX_LOG_SIZE) {
       const backup = currentLogFile.replace(".log", ".1.log");
       try {
-        fs2.unlinkSync(backup);
+        fs3.unlinkSync(backup);
       } catch {
       }
-      fs2.renameSync(currentLogFile, backup);
+      fs3.renameSync(currentLogFile, backup);
     }
   } catch {
   }
@@ -2170,7 +2344,7 @@ function writeToFile(line) {
       checkDateRotation();
       rotateSizeIfNeeded();
     }
-    fs2.appendFileSync(currentLogFile, line + "\n");
+    AsyncBatchWriter.write(currentLogFile, line + "\n");
   } catch {
   }
 }
@@ -2258,13 +2432,14 @@ function installGlobalInterceptor() {
   writeToFile(`Log file: ${currentLogFile}`);
   writeToFile(`Log level: ${currentLevel}`);
 }
-var fs2, path9, os3, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH;
+var fs3, path9, os3, LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH;
 var init_logger = __esm({
   "src/logging/logger.ts"() {
     "use strict";
-    fs2 = __toESM(require("fs"));
+    fs3 = __toESM(require("fs"));
     path9 = __toESM(require("path"));
     os3 = __toESM(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";
@@ -2272,7 +2447,7 @@ var init_logger = __esm({
     MAX_LOG_SIZE = 5 * 1024 * 1024;
     MAX_LOG_DAYS = 7;
     try {
-      fs2.mkdirSync(LOG_DIR, { recursive: true });
+      fs3.mkdirSync(LOG_DIR, { recursive: true });
     } catch {
     }
     currentDate = getDateStr();
@@ -2280,14 +2455,14 @@ var init_logger = __esm({
     cleanOldLogs();
     try {
       const oldLog = path9.join(LOG_DIR, "daemon.log");
-      if (fs2.existsSync(oldLog)) {
-        const stat2 = fs2.statSync(oldLog);
+      if (fs3.existsSync(oldLog)) {
+        const stat2 = fs3.statSync(oldLog);
         const oldDate = stat2.mtime.toISOString().slice(0, 10);
-        fs2.renameSync(oldLog, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
+        fs3.renameSync(oldLog, path9.join(LOG_DIR, `daemon-${oldDate}.log`));
       }
       const oldLogBackup = path9.join(LOG_DIR, "daemon.log.old");
-      if (fs2.existsSync(oldLogBackup)) {
-        fs2.unlinkSync(oldLogBackup);
+      if (fs3.existsSync(oldLogBackup)) {
+        fs3.unlinkSync(oldLogBackup);
       }
     } catch {
     }
@@ -3630,8 +3805,8 @@ var init_pty_transport = __esm({
         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();
@@ -3731,27 +3906,35 @@ function findBinary(name) {
     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;
@@ -3762,12 +3945,12 @@ function isScriptBinary(binaryPath) {
 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);
@@ -3849,13 +4032,12 @@ function normalizeCliProviderForRuntime(raw) {
     }
   };
 }
-var os9, path14, import_child_process4, TerminalTranscriptAccumulator, buildCliSpawnEnv;
+var os9, path14, TerminalTranscriptAccumulator, buildCliSpawnEnv;
 var init_provider_cli_shared = __esm({
   "src/cli-adapters/provider-cli-shared.ts"() {
     "use strict";
     os9 = __toESM(require("os"));
     path14 = __toESM(require("path"));
-    import_child_process4 = require("child_process");
     init_spawn_env();
     TerminalTranscriptAccumulator = class {
       lines = [[]];
@@ -6459,6 +6641,7 @@ __export(index_exports, {
   getLogLevel: () => getLogLevel,
   getMesh: () => getMesh,
   getMeshByRepo: () => getMeshByRepo,
+  getMeshQueueRevision: () => getMeshQueueRevision,
   getMeshQueueStats: () => getMeshQueueStats,
   getNpmExecOptions: () => getNpmExecOptions,
   getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
@@ -9339,9 +9522,11 @@ function resetState() {
 
 // src/detection/ide-detector.ts
 var import_child_process2 = require("child_process");
+var import_util = require("util");
 var import_fs9 = require("fs");
 var import_os2 = require("os");
 var path10 = __toESM(require("path"));
+var execAsync2 = (0, import_util.promisify)(import_child_process2.exec);
 var BUILTIN_IDE_DEFINITIONS = [];
 var registeredIDEs = /* @__PURE__ */ new Map();
 function registerIDEDefinition(def) {
@@ -9365,24 +9550,33 @@ function findCliCommand(command) {
     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_os2.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_os2.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;
   }
@@ -9430,7 +9624,7 @@ async function detectIDEs(providerLoader) {
       }
     }
     const installed = os22 === "darwin" ? !!(resolvedCli || appPath) : !!resolvedCli;
-    const version = resolvedCli ? getIdeVersion(resolvedCli) : null;
+    const version = resolvedCli ? await getIdeVersion(resolvedCli) : null;
     results.push({
       id: def.id,
       name: def.name,
@@ -9451,18 +9645,22 @@ init_cli_detector();
 // src/system/host-memory.ts
 var os4 = __toESM(require("os"));
 var import_child_process3 = require("child_process");
-function parseDarwinAvailableBytes(totalMem) {
-  if (os4.platform() !== "darwin") return null;
+var import_util2 = require("util");
+var execAsync3 = (0, import_util2.promisify)(import_child_process3.exec);
+var cachedDarwinAvail = null;
+var darwinMemoryInterval = null;
+async function updateDarwinMemoryCache() {
+  if (os4.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, "_");
@@ -9476,18 +9674,24 @@ function parseDarwinAvailableBytes(totalMem) {
     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, os4.totalmem()) : null;
   } catch {
-    return null;
   }
 }
 function getHostMemorySnapshot() {
+  if (os4.platform() === "darwin" && !darwinMemoryInterval) {
+    updateDarwinMemoryCache();
+    darwinMemoryInterval = setInterval(updateDarwinMemoryCache, 3e3);
+    darwinMemoryInterval.unref();
+  }
   const totalMem = os4.totalmem();
   const freeMem = os4.freemem();
-  const darwinAvail = parseDarwinAvailableBytes(totalMem);
-  const availableMem = darwinAvail != null ? darwinAvail : freeMem;
-  return { totalMem, freeMem, availableMem };
+  const availableMem = os4.platform() === "darwin" ? cachedDarwinAvail ?? freeMem : freeMem;
+  return {
+    totalMem,
+    freeMem,
+    availableMem
+  };
 }
 
 // src/session-host/runtime-surface.ts
@@ -11852,7 +12056,7 @@ ${cleanBody}`;
 }
 
 // src/config/chat-history.ts
-var fs3 = __toESM(require("fs"));
+var fs4 = __toESM(require("fs"));
 var path11 = __toESM(require("path"));
 var os5 = __toESM(require("os"));
 var HISTORY_DIR = path11.join(os5.homedir(), ".adhdev", "history");
@@ -11972,8 +12176,8 @@ function buildSavedHistorySessionSummaryMapFromEntries(entries) {
 function readPersistedSavedHistorySessionSummaries(dir) {
   try {
     const filePath = getSavedHistoryIndexFilePath(dir);
-    if (!fs3.existsSync(filePath)) return null;
-    const raw = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+    if (!fs4.existsSync(filePath)) return null;
+    const raw = JSON.parse(fs4.readFileSync(filePath, "utf-8"));
     if (!raw || raw.version !== SAVED_HISTORY_INDEX_VERSION || !raw.sessions || typeof raw.sessions !== "object") {
       return null;
     }
@@ -12000,7 +12204,7 @@ function sanitizeHistoryFileSegment(value) {
 }
 function listHistoryFiles(dir, historySessionId) {
   const sanitizedSessionId = historySessionId ? sanitizeHistoryFileSegment(historySessionId) : "";
-  return fs3.readdirSync(dir).filter((file) => {
+  return fs4.readdirSync(dir).filter((file) => {
     if (!file.endsWith(".jsonl")) return false;
     if (sanitizedSessionId) {
       return file.startsWith(`${sanitizedSessionId}_`);
@@ -12018,7 +12222,7 @@ function extractSavedHistorySessionIdFromFile(file) {
 function buildSavedHistoryFileSignatureMap(dir, files) {
   return new Map(files.map((file) => {
     try {
-      const stat2 = fs3.statSync(path11.join(dir, file));
+      const stat2 = fs4.statSync(path11.join(dir, file));
       return [file, `${file}:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`];
     } catch {
       return [file, `${file}:missing`];
@@ -12041,8 +12245,8 @@ function sleepBlocking(ms) {
 function loadPersistedSavedHistoryIndexFromFile(dir) {
   try {
     const filePath = getSavedHistoryIndexFilePath(dir);
-    if (!fs3.existsSync(filePath)) return /* @__PURE__ */ new Map();
-    const raw = JSON.parse(fs3.readFileSync(filePath, "utf-8"));
+    if (!fs4.existsSync(filePath)) return /* @__PURE__ */ new Map();
+    const raw = JSON.parse(fs4.readFileSync(filePath, "utf-8"));
     if (!raw || raw.version !== SAVED_HISTORY_INDEX_VERSION || !raw.files || typeof raw.files !== "object") {
       return /* @__PURE__ */ new Map();
     }
@@ -12064,27 +12268,27 @@ function writePersistedSavedHistoryIndexFile(dir, entries) {
     files: Object.fromEntries(entries.entries()),
     sessions: buildSavedHistorySessionSummaryMapFromEntries(entries)
   };
-  fs3.writeFileSync(tempPath, JSON.stringify(payload), "utf-8");
-  fs3.renameSync(tempPath, filePath);
+  fs4.writeFileSync(tempPath, JSON.stringify(payload), "utf-8");
+  fs4.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 {
-      fs3.mkdirSync(lockPath);
+      fs4.mkdirSync(lockPath);
       return () => {
         try {
-          fs3.rmSync(lockPath, { recursive: true, force: true });
+          fs4.rmSync(lockPath, { recursive: true, force: true });
         } catch {
         }
       };
     } catch (error) {
       if (error?.code !== "EEXIST") return null;
       try {
-        const stat2 = fs3.statSync(lockPath);
+        const stat2 = fs4.statSync(lockPath);
         if (Date.now() - stat2.mtimeMs > SAVED_HISTORY_INDEX_LOCK_STALE_MS) {
-          fs3.rmSync(lockPath, { recursive: true, force: true });
+          fs4.rmSync(lockPath, { recursive: true, force: true });
           continue;
         }
       } catch {
@@ -12131,7 +12335,7 @@ function savePersistedSavedHistoryIndex(dir, entries) {
     }
     for (const file of Array.from(currentEntries.keys())) {
       if (incomingFiles.has(file)) continue;
-      if (!fs3.existsSync(path11.join(dir, file))) {
+      if (!fs4.existsSync(path11.join(dir, file))) {
         currentEntries.delete(file);
       }
     }
@@ -12139,14 +12343,14 @@ function savePersistedSavedHistoryIndex(dir, entries) {
 }
 function invalidatePersistedSavedHistoryIndex(agentType, dir) {
   try {
-    fs3.rmSync(getSavedHistoryIndexFilePath(dir), { force: true });
+    fs4.rmSync(getSavedHistoryIndexFilePath(dir), { force: true });
   } catch {
   }
   savedHistorySessionCache.delete(agentType.replace(/[^a-zA-Z0-9_-]/g, "_"));
 }
 function buildSavedHistoryIndexFileSignature(dir) {
   try {
-    const stat2 = fs3.statSync(getSavedHistoryIndexFilePath(dir));
+    const stat2 = fs4.statSync(getSavedHistoryIndexFilePath(dir));
     return `index:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`;
   } catch {
     return "index:missing";
@@ -12154,10 +12358,10 @@ function buildSavedHistoryIndexFileSignature(dir) {
 }
 function historyDirectoryHasFilesNewerThanIndex(dir) {
   try {
-    const indexStat = fs3.statSync(getSavedHistoryIndexFilePath(dir));
+    const indexStat = fs4.statSync(getSavedHistoryIndexFilePath(dir));
     const files = listHistoryFiles(dir);
     for (const file of files) {
-      const stat2 = fs3.statSync(path11.join(dir, file));
+      const stat2 = fs4.statSync(path11.join(dir, file));
       if (stat2.mtimeMs > indexStat.mtimeMs) return true;
     }
     return false;
@@ -12167,7 +12371,7 @@ function historyDirectoryHasFilesNewerThanIndex(dir) {
 }
 function buildSavedHistoryFileSignature(dir, file) {
   try {
-    const stat2 = fs3.statSync(path11.join(dir, file));
+    const stat2 = fs4.statSync(path11.join(dir, file));
     return `${file}:${stat2.size}:${Math.trunc(stat2.mtimeMs)}`;
   } catch {
     return `${file}:missing`;
@@ -12248,7 +12452,7 @@ function computeSavedHistoryFileSummary(dir, file) {
   const historySessionId = extractSavedHistorySessionIdFromFile(file);
   if (!historySessionId) return null;
   const filePath = path11.join(dir, file);
-  const content = fs3.readFileSync(filePath, "utf-8");
+  const content = fs4.readFileSync(filePath, "utf-8");
   const lines = content.split("\n").filter(Boolean);
   let messageCount = 0;
   let firstMessageAt = 0;
@@ -12309,7 +12513,7 @@ function scheduleSavedHistoryBackgroundRefresh(agentType, dir) {
   savedHistoryBackgroundRefresh.add(key);
   setTimeout(() => {
     try {
-      if (!fs3.existsSync(dir)) return;
+      if (!fs4.existsSync(dir)) return;
       const files = listHistoryFiles(dir);
       const fileSignatures = buildSavedHistoryFileSignatureMap(dir, files);
       const persistedEntries = loadPersistedSavedHistoryIndex(dir);
@@ -12455,13 +12659,13 @@ var ChatHistoryWriter = class {
       }
       if (newMessages.length === 0) return;
       const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
-      fs3.mkdirSync(dir, { recursive: true });
+      fs4.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const filePrefix = effectiveHistoryKey ? `${this.sanitize(effectiveHistoryKey)}_` : "";
       const fileName = `${filePrefix}${date}.jsonl`;
       const filePath = path11.join(dir, fileName);
       const lines = newMessages.map((m) => JSON.stringify(m)).join("\n") + "\n";
-      fs3.appendFileSync(filePath, lines, "utf-8");
+      fs4.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) {
@@ -12551,7 +12755,7 @@ var ChatHistoryWriter = class {
     if (!id || !ws) return;
     try {
       const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
-      fs3.mkdirSync(dir, { recursive: true });
+      fs4.mkdirSync(dir, { recursive: true });
       const date = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
       const fileName = `${this.sanitize(id)}_${date}.jsonl`;
       const filePath = path11.join(dir, fileName);
@@ -12566,7 +12770,7 @@ var ChatHistoryWriter = class {
         historySessionId: id,
         workspace: ws
       };
-      fs3.appendFileSync(filePath, JSON.stringify(record) + "\n", "utf-8");
+      fs4.appendFileSync(filePath, JSON.stringify(record) + "\n", "utf-8");
       updateSavedHistoryIndexForSessionStart(agentType, dir, fileName, id, ws);
     } catch {
     }
@@ -12601,14 +12805,14 @@ var ChatHistoryWriter = class {
         this.lastSeenCounts.delete(fromDedupKey);
       }
       const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
-      if (!fs3.existsSync(dir)) return;
+      if (!fs4.existsSync(dir)) return;
       const fromPrefix = `${this.sanitize(fromId)}_`;
       const toPrefix = `${this.sanitize(toId)}_`;
-      const files = fs3.readdirSync(dir).filter((file) => file.startsWith(fromPrefix) && file.endsWith(".jsonl"));
+      const files = fs4.readdirSync(dir).filter((file) => file.startsWith(fromPrefix) && file.endsWith(".jsonl"));
       for (const file of files) {
         const sourcePath = path11.join(dir, file);
         const targetPath = path11.join(dir, `${toPrefix}${file.slice(fromPrefix.length)}`);
-        const sourceLines = fs3.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
+        const sourceLines = fs4.readFileSync(sourcePath, "utf-8").split("\n").filter(Boolean);
         const rewritten = sourceLines.map((line) => {
           try {
             const parsed = JSON.parse(line);
@@ -12622,16 +12826,16 @@ var ChatHistoryWriter = class {
           }
         }).filter((line) => !!line);
         if (rewritten.length === 0) {
-          fs3.unlinkSync(sourcePath);
+          fs4.unlinkSync(sourcePath);
           continue;
         }
-        const existing = fs3.existsSync(targetPath) ? new Set(fs3.readFileSync(targetPath, "utf-8").split("\n").filter(Boolean)) : /* @__PURE__ */ new Set();
+        const existing = fs4.existsSync(targetPath) ? new Set(fs4.readFileSync(targetPath, "utf-8").split("\n").filter(Boolean)) : /* @__PURE__ */ new Set();
         const nextLines = rewritten.filter((line) => !existing.has(line));
         if (nextLines.length > 0) {
-          fs3.appendFileSync(targetPath, `${nextLines.join("\n")}
+          fs4.appendFileSync(targetPath, `${nextLines.join("\n")}
 `, "utf-8");
         }
-        fs3.unlinkSync(sourcePath);
+        fs4.unlinkSync(sourcePath);
       }
       invalidatePersistedSavedHistoryIndex(agentType, dir);
     } catch {
@@ -12642,13 +12846,13 @@ var ChatHistoryWriter = class {
     if (!sessionId) return;
     try {
       const dir = path11.join(HISTORY_DIR, this.sanitize(agentType));
-      if (!fs3.existsSync(dir)) return;
+      if (!fs4.existsSync(dir)) return;
       const prefix = `${this.sanitize(sessionId)}_`;
-      const files = fs3.readdirSync(dir).filter((file) => file.startsWith(prefix) && file.endsWith(".jsonl")).sort();
+      const files = fs4.readdirSync(dir).filter((file) => file.startsWith(prefix) && file.endsWith(".jsonl")).sort();
       const seen = /* @__PURE__ */ new Set();
       for (const file of files) {
         const filePath = path11.join(dir, file);
-        const lines = fs3.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
+        const lines = fs4.readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
         const next = [];
         for (const line of lines) {
           let parsed = null;
@@ -12677,10 +12881,10 @@ var ChatHistoryWriter = class {
         }
         const collapsed = collapseReplayAssistantTurns(dedupedAdjacent, historyBehavior);
         if (collapsed.length === 0) {
-          fs3.unlinkSync(filePath);
+          fs4.unlinkSync(filePath);
           continue;
         }
-        fs3.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join("\n")}
+        fs4.writeFileSync(filePath, `${collapsed.map((entry) => JSON.stringify(entry)).join("\n")}
 `, "utf-8");
       }
       invalidatePersistedSavedHistoryIndex(agentType, dir);
@@ -12697,18 +12901,18 @@ var ChatHistoryWriter = class {
   /** Delete history files older than 30 days */
   async rotateOldFiles() {
     try {
-      if (!fs3.existsSync(HISTORY_DIR)) return;
+      if (!fs4.existsSync(HISTORY_DIR)) return;
       const cutoff = Date.now() - RETAIN_DAYS * 24 * 60 * 60 * 1e3;
-      const agentDirs = fs3.readdirSync(HISTORY_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
+      const agentDirs = fs4.readdirSync(HISTORY_DIR, { withFileTypes: true }).filter((d) => d.isDirectory());
       for (const dir of agentDirs) {
         const dirPath = path11.join(HISTORY_DIR, dir.name);
-        const files = fs3.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl") || f.endsWith(".terminal.log"));
+        const files = fs4.readdirSync(dirPath).filter((f) => f.endsWith(".jsonl") || f.endsWith(".terminal.log"));
         let removedAny = false;
         for (const file of files) {
           const filePath = path11.join(dirPath, file);
-          const stat2 = fs3.statSync(filePath);
+          const stat2 = fs4.statSync(filePath);
           if (stat2.mtimeMs < cutoff) {
-            fs3.unlinkSync(filePath);
+            fs4.unlinkSync(filePath);
             removedAny = true;
           }
         }
@@ -12756,13 +12960,13 @@ function readChatHistory(agentType, offset = 0, limit = 30, historySessionId, ex
   try {
     const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
     const dir = path11.join(HISTORY_DIR, sanitized);
-    if (!fs3.existsSync(dir)) return { messages: [], hasMore: false };
+    if (!fs4.existsSync(dir)) return { messages: [], hasMore: false };
     const files = listHistoryFiles(dir, historySessionId);
     const allMessages = [];
     const seen = /* @__PURE__ */ new Set();
     for (const file of files) {
       const filePath = path11.join(dir, file);
-      const content = fs3.readFileSync(filePath, "utf-8");
+      const content = fs4.readFileSync(filePath, "utf-8");
       const lines = content.trim().split("\n").filter(Boolean);
       for (let i = 0; i < lines.length; i++) {
         try {
@@ -12786,7 +12990,7 @@ function listSavedHistorySessions(agentType, options = {}, historyBehavior) {
   try {
     const sanitized = agentType.replace(/[^a-zA-Z0-9_-]/g, "_");
     const dir = path11.join(HISTORY_DIR, sanitized);
-    if (!fs3.existsSync(dir)) {
+    if (!fs4.existsSync(dir)) {
       savedHistorySessionCache.delete(sanitized);
       return { sessions: [], hasMore: false };
     }
@@ -12847,10 +13051,10 @@ function listSavedHistorySessions(agentType, options = {}, historyBehavior) {
 function readExistingSessionStartRecord(agentType, historySessionId) {
   try {
     const dir = path11.join(HISTORY_DIR, agentType);
-    if (!fs3.existsSync(dir)) return null;
+    if (!fs4.existsSync(dir)) return null;
     const files = listHistoryFiles(dir, historySessionId).sort();
     for (const file of files) {
-      const lines = fs3.readFileSync(path11.join(dir, file), "utf-8").split("\n").filter(Boolean);
+      const lines = fs4.readFileSync(path11.join(dir, file), "utf-8").split("\n").filter(Boolean);
       for (const line of lines) {
         try {
           const parsed = JSON.parse(line);
@@ -12871,16 +13075,16 @@ function rewriteCanonicalSavedHistory(agentType, historySessionId, records) {
   if (records.length === 0) return false;
   try {
     const dir = path11.join(HISTORY_DIR, agentType);
-    fs3.mkdirSync(dir, { recursive: true });
+    fs4.mkdirSync(dir, { recursive: true });
     const prefix = `${historySessionId.replace(/[^a-zA-Z0-9_-]/g, "_")}_`;
-    for (const file of fs3.readdirSync(dir)) {
+    for (const file of fs4.readdirSync(dir)) {
       if (file.startsWith(prefix) && file.endsWith(".jsonl")) {
-        fs3.unlinkSync(path11.join(dir, file));
+        fs4.unlinkSync(path11.join(dir, file));
       }
     }
     const targetDate = new Date(records[records.length - 1].receivedAt || Date.now()).toISOString().slice(0, 10);
     const filePath = path11.join(dir, `${prefix}${targetDate}.jsonl`);
-    fs3.writeFileSync(filePath, `${records.map((record) => JSON.stringify(record)).join("\n")}
+    fs4.writeFileSync(filePath, `${records.map((record) => JSON.stringify(record)).join("\n")}
 `, "utf-8");
     invalidatePersistedSavedHistoryIndex(agentType, dir);
     savedHistorySessionCache.delete(agentType.replace(/[^a-zA-Z0-9_-]/g, "_"));
@@ -12988,7 +13192,7 @@ function buildNativeSessionSummary(agentType, historySessionId, records, sourceP
   if (visible.length === 0) return null;
   let sourceMtimeMs = 0;
   try {
-    sourceMtimeMs = fs3.statSync(sourcePath).mtimeMs;
+    sourceMtimeMs = fs4.statSync(sourcePath).mtimeMs;
   } catch {
   }
   const firstMessageAt = visible[0]?.receivedAt || sourceMtimeMs || Date.now();
@@ -13761,6 +13965,19 @@ function formatAutoApprovalMessage(modalMessage, buttonLabel) {
 }
 
 // src/providers/ide-provider-instance.ts
+async function withTimeout(promise, timeoutMs, label) {
+  let timer = null;
+  try {
+    return await Promise.race([
+      promise,
+      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";
@@ -13985,7 +14202,7 @@ var IdeProviderInstance = class {
         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 {
@@ -14000,7 +14217,7 @@ var IdeProviderInstance = class {
       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);
@@ -14311,7 +14528,7 @@ ${effect.notification.body || ""}`.trim();
         now
       );
       LOG.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);
@@ -15380,7 +15597,7 @@ function resolveLegacyProviderScript(fn, scriptName, params) {
 }
 
 // src/commands/chat-commands.ts
-var fs4 = __toESM(require("fs"));
+var fs5 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
 var path12 = __toESM(require("path"));
 var import_node_crypto = require("crypto");
@@ -15953,11 +16170,11 @@ function buildChatDebugBundleSummary(bundle) {
 function storeChatDebugBundleOnDaemon(bundle, targetSessionId) {
   const bundleId = createChatDebugBundleId(targetSessionId);
   const dir = getChatDebugBundleDir();
-  fs4.mkdirSync(dir, { recursive: true });
+  fs5.mkdirSync(dir, { recursive: true });
   const savedPath = path12.join(dir, `${bundleId}.json`);
   const json = `${JSON.stringify(bundle, null, 2)}
 `;
-  fs4.writeFileSync(savedPath, json, { encoding: "utf8", mode: 384 });
+  fs5.writeFileSync(savedPath, json, { encoding: "utf8", mode: 384 });
   return { bundleId, savedPath, sizeBytes: Buffer.byteLength(json, "utf8") };
 }
 function isDaemonFileDebugDelivery(args) {
@@ -17120,7 +17337,7 @@ async function handleResolveAction(h, args) {
 }
 
 // src/commands/cdp-commands.ts
-var fs5 = __toESM(require("fs"));
+var fs6 = __toESM(require("fs"));
 var path13 = __toESM(require("path"));
 var os7 = __toESM(require("os"));
 var KEY_TO_VK = {
@@ -17393,7 +17610,7 @@ function resolveSafePath(requestedPath) {
   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);
@@ -17405,14 +17622,14 @@ function listDirectoryEntriesSafe(dirPath) {
       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",
@@ -17430,7 +17647,7 @@ function listWindowsDriveEntries(excludePath) {
     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 {
@@ -17441,7 +17658,7 @@ function listWindowsDriveEntries(excludePath) {
 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 };
@@ -17450,8 +17667,8 @@ async function handleFileRead(h, args) {
 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 };
@@ -18577,7 +18794,7 @@ var os13 = __toESM(require("os"));
 var path18 = __toESM(require("path"));
 var crypto4 = __toESM(require("crypto"));
 var import_fs10 = require("fs");
-var import_child_process6 = require("child_process");
+var import_child_process5 = require("child_process");
 var import_chalk = __toESM(require("chalk"));
 init_provider_cli_adapter();
 init_cli_detector();
@@ -18587,7 +18804,7 @@ init_config();
 var os12 = __toESM(require("os"));
 var path16 = __toESM(require("path"));
 var crypto3 = __toESM(require("crypto"));
-var fs6 = __toESM(require("fs"));
+var fs7 = __toESM(require("fs"));
 var import_node_module = require("module");
 init_provider_cli_adapter();
 init_logger();
@@ -18646,9 +18863,9 @@ function materializeImageDataPart(part, index, dir) {
   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;
 }
@@ -18660,14 +18877,14 @@ function cleanupStaleMaterializedImages(dir) {
   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 {
       }
@@ -18906,7 +19123,7 @@ var CliProviderInstance = class {
     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;
     }
@@ -19822,7 +20039,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);
@@ -19861,7 +20078,7 @@ ${effect.notification.body || ""}`.trim();
 // src/providers/acp-provider-instance.ts
 var path17 = __toESM(require("path"));
 var import_stream = require("stream");
-var import_child_process5 = require("child_process");
+var import_child_process4 = require("child_process");
 var import_sdk = require("@agentclientprotocol/sdk");
 init_logger();
 function getPromptCapabilityFlags(agentCapabilities) {
@@ -20378,7 +20595,7 @@ var AcpProviderInstance = class {
     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,
       stdio: ["pipe", "pipe", "pipe"],
@@ -21105,7 +21322,7 @@ function commandExists(command) {
     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 } : {}
     });
@@ -21914,13 +22131,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
 };
 
 // src/launch.ts
-var import_child_process7 = require("child_process");
+var import_child_process6 = require("child_process");
 var net = __toESM(require("net"));
 var os15 = __toESM(require("os"));
 var path20 = __toESM(require("path"));
 
 // src/providers/provider-loader.ts
-var fs7 = __toESM(require("fs"));
+var fs8 = __toESM(require("fs"));
 var path19 = __toESM(require("path"));
 var os14 = __toESM(require("os"));
 var chokidar = __toESM(require("chokidar"));
@@ -22273,9 +22490,9 @@ var ProviderLoader = class _ProviderLoader {
   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;
@@ -22283,7 +22500,7 @@ var ProviderLoader = class _ProviderLoader {
   }
   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;
     }
@@ -22445,7 +22662,7 @@ var ProviderLoader = class _ProviderLoader {
     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)`);
@@ -22453,7 +22670,7 @@ var ProviderLoader = class _ProviderLoader {
     } 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)`);
@@ -22468,10 +22685,10 @@ var ProviderLoader = class _ProviderLoader {
    * 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;
@@ -22969,7 +23186,7 @@ var ProviderLoader = class _ProviderLoader {
               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;
             }
@@ -22985,7 +23202,7 @@ var ProviderLoader = class _ProviderLoader {
             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.`;
@@ -23003,7 +23220,7 @@ var ProviderLoader = class _ProviderLoader {
               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) {
@@ -23020,7 +23237,7 @@ var ProviderLoader = class _ProviderLoader {
         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;
         }
       }
     }
@@ -23053,14 +23270,14 @@ var ProviderLoader = class _ProviderLoader {
       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 cached = this.scriptsCache.get(dir);
     if (cached) return cached;
     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);
@@ -23081,9 +23298,9 @@ var ProviderLoader = class _ProviderLoader {
   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;
         }
@@ -23096,13 +23313,17 @@ var ProviderLoader = class _ProviderLoader {
           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);
@@ -23155,13 +23376,15 @@ var ProviderLoader = class _ProviderLoader {
       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 meta = JSON.parse(fs7.readFileSync(metaPath, "utf-8"));
+      if (fs8.existsSync(metaPath)) {
+        const meta = JSON.parse(fs8.readFileSync(metaPath, "utf-8"));
         prevEtag = meta.etag || "";
         prevTimestamp = meta.timestamp || 0;
       }
@@ -23219,36 +23442,36 @@ var ProviderLoader = class _ProviderLoader {
       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);
@@ -23280,7 +23503,7 @@ var ProviderLoader = class _ProviderLoader {
             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();
@@ -23299,22 +23522,22 @@ var ProviderLoader = class _ProviderLoader {
   }
   /** 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(),
@@ -23325,11 +23548,11 @@ var ProviderLoader = class _ProviderLoader {
   }
   /** 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++;
         }
@@ -23556,18 +23779,18 @@ var ProviderLoader = class _ProviderLoader {
     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 {
               }
@@ -23586,7 +23809,7 @@ var ProviderLoader = class _ProviderLoader {
    */
   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);
@@ -23596,13 +23819,13 @@ var ProviderLoader = class _ProviderLoader {
     const toCamel = (name) => name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
     const result = {};
     try {
-      for (const file of fs7.readdirSync(dir)) {
+      for (const file of fs8.readdirSync(dir)) {
         if (!file.endsWith(".js")) continue;
         const scriptName = toCamel(file.replace(".js", ""));
         const filePath = path19.join(dir, file);
         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;
@@ -23648,12 +23871,12 @@ var ProviderLoader = class _ProviderLoader {
    * 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;
       }
@@ -23661,7 +23884,7 @@ var ProviderLoader = class _ProviderLoader {
       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 || "";
@@ -23681,7 +23904,7 @@ var ProviderLoader = class _ProviderLoader {
           } 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);
@@ -23786,6 +24009,14 @@ function findMacAppProcessPids(psOutput, appPaths) {
 }
 
 // src/launch.ts
+async function execQuiet(command, options = {}) {
+  return new Promise((resolve16) => {
+    (0, import_child_process6.exec)(command, options, (error, stdout) => {
+      if (error) return resolve16("");
+      resolve16(stdout.toString());
+    });
+  });
+}
 var _providerLoader = null;
 function getProviderLoader() {
   if (!_providerLoader) {
@@ -23824,11 +24055,11 @@ function escapeForAppleScript(value) {
 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"]
@@ -23838,8 +24069,8 @@ function getMacAppProcessPids(ideId) {
     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 {
@@ -23902,68 +24133,68 @@ async function killIdeProcess(ideId) {
   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
         });
@@ -23971,7 +24202,7 @@ function isIdeRunning(ideId) {
       } 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",
@@ -23982,20 +24213,20 @@ function isIdeRunning(ideId) {
         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 }
         );
@@ -24004,20 +24235,20 @@ function isIdeRunning(ideId) {
       }
       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 }
       );
@@ -24027,7 +24258,7 @@ function detectCurrentWorkspace(ideId) {
     }
   } else if (plat === "win32") {
     try {
-      const fs16 = require("fs");
+      const fs17 = require("fs");
       const appNameMap = getMacAppIdentifiers();
       const appName = appNameMap[ideId];
       if (appName) {
@@ -24036,8 +24267,8 @@ function detectCurrentWorkspace(ideId) {
           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];
@@ -24104,8 +24335,8 @@ async function launchWithCdp(options = {}) {
       };
     }
   }
-  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) {
@@ -24180,10 +24411,10 @@ async function launchMacOS(ide, port, workspace, newWindow) {
   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}`);
   }
@@ -24209,7 +24440,7 @@ async function launchLinux(ide, port, workspace, newWindow) {
   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();
@@ -24221,14 +24452,14 @@ init_cli_detector();
 init_logger();
 
 // src/logging/command-log.ts
-var fs8 = __toESM(require("fs"));
+var fs9 = __toESM(require("fs"));
 var path21 = __toESM(require("path"));
 var os16 = __toESM(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([
@@ -24274,7 +24505,7 @@ function checkRotation() {
 }
 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);
@@ -24282,7 +24513,7 @@ function cleanOldFiles() {
       const dateMatch = file.match(/commands-(\d{4}-\d{2}-\d{2})/);
       if (dateMatch && dateMatch[1] < cutoffStr) {
         try {
-          fs8.unlinkSync(path21.join(LOG_DIR2, file));
+          fs9.unlinkSync(path21.join(LOG_DIR2, file));
         } catch {
         }
       }
@@ -24292,14 +24523,14 @@ function cleanOldFiles() {
 }
 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 {
   }
@@ -24332,14 +24563,14 @@ function logCommand(entry) {
       ...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 {
@@ -24369,14 +24600,11 @@ var yaml2 = __toESM(require("js-yaml"));
 init_logger();
 
 // src/commands/mesh-coordinator.ts
-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 = __toESM(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) {
@@ -24386,8 +24614,7 @@ function isHermesProvider(provider, cliType) {
 function resolveHermesMeshCoordinatorSetup(options) {
   const mcpServer = resolveAdhdevMcpServerLaunch({
     meshId: options.meshId,
-    nodeExecutable: options.nodeExecutable,
-    adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+    adhdevMcpCommand: options.adhdevMcpCommand,
     adhdevMcpTransport: options.adhdevMcpTransport,
     adhdevMcpPort: options.adhdevMcpPort
   });
@@ -24418,7 +24645,7 @@ function createHermesManualMeshCoordinatorSetup(meshId, workspace) {
     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,
@@ -24455,8 +24682,7 @@ function resolveMeshCoordinatorSetup(options) {
     }
     const mcpServer = resolveAdhdevMcpServerLaunch({
       meshId,
-      nodeExecutable: options.nodeExecutable,
-      adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+      adhdevMcpCommand: options.adhdevMcpCommand,
       adhdevMcpTransport: options.adhdevMcpTransport,
       adhdevMcpPort: options.adhdevMcpPort
     });
@@ -24528,19 +24754,19 @@ function resolveMcpConfigPath(configPath, workspace) {
   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();
@@ -24553,109 +24779,6 @@ function resolveMcpPort(explicitPort) {
   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 parse = (value) => value.replace(/^v/, "").split(".").map((part) => Number.parseInt(part, 10) || 0);
-  const left = parse(a);
-  const right = parse(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;
-  }
-}
 
 // src/commands/router.ts
 init_mesh_events();
@@ -24975,23 +25098,23 @@ function buildStatusSnapshot(options) {
 }
 
 // src/commands/upgrade-helper.ts
+var import_child_process7 = require("child_process");
 var import_child_process8 = require("child_process");
-var import_child_process9 = require("child_process");
-var fs9 = __toESM(require("fs"));
+var fs10 = __toESM(require("fs"));
 var os19 = __toESM(require("os"));
 var path22 = __toESM(require("path"));
 var UPGRADE_HELPER_ENV = "ADHDEV_DAEMON_UPGRADE_HELPER";
 function getUpgradeLogPath() {
   const home = os19.homedir();
   const dir = path22.join(home, ".adhdev");
-  fs9.mkdirSync(dir, { recursive: true });
+  fs10.mkdirSync(dir, { recursive: true });
   return path22.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 {
   }
 }
@@ -24999,12 +25122,12 @@ function resolveSiblingNpmInvocation(nodeExecutable, platform10 = process.platfo
   const binDir = path22.dirname(nodeExecutable);
   if (platform10 === "win32") {
     const npmCliPath = path22.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 = path22.join(binDir, candidate);
-      if (fs9.existsSync(candidatePath)) {
+      if (fs10.existsSync(candidatePath)) {
         return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
       }
     }
@@ -25012,7 +25135,7 @@ function resolveSiblingNpmInvocation(nodeExecutable, platform10 = process.platfo
   }
   for (const candidate of ["npm"]) {
     const candidatePath = path22.join(binDir, candidate);
-    if (fs9.existsSync(candidatePath)) {
+    if (fs10.existsSync(candidatePath)) {
       return { executable: candidatePath, argsPrefix: [], execOptions: getNpmExecOptions(platform10) };
     }
   }
@@ -25022,12 +25145,12 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   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 = path22.dirname(resolvedPath);
     }
   } catch {
@@ -25036,8 +25159,8 @@ function findCurrentPackageRoot(currentCliPath, packageName) {
   while (true) {
     const packageJsonPath = path22.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;
@@ -25095,7 +25218,7 @@ function getNpmExecOptions(platform10 = process.platform) {
 }
 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],
     {
@@ -25108,7 +25231,7 @@ function execNpmCommandSync(args, options = {}, surface) {
 function killPid(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");
     }
@@ -25120,7 +25243,7 @@ function killPid(pid) {
 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",
@@ -25132,7 +25255,7 @@ function getWindowsProcessCommandLine(pid) {
   } catch {
   }
   try {
-    const wmicOut = (0, import_child_process8.execFileSync)("wmic", [
+    const wmicOut = (0, import_child_process7.execFileSync)("wmic", [
       "process",
       "where",
       pidFilter,
@@ -25148,7 +25271,7 @@ function getProcessCommandLine(pid) {
   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"]
@@ -25176,8 +25299,8 @@ async function waitForPidExit(pid, timeoutMs) {
 function stopSessionHostProcesses(appName) {
   const pidFile = path22.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)) {
         killPid(pid);
       }
@@ -25185,7 +25308,7 @@ function stopSessionHostProcesses(appName) {
   } catch {
   } finally {
     try {
-      fs9.unlinkSync(pidFile);
+      fs10.unlinkSync(pidFile);
     } catch {
     }
   }
@@ -25193,7 +25316,7 @@ function stopSessionHostProcesses(appName) {
 function removeDaemonPidFile() {
   const pidFile = path22.join(os19.homedir(), ".adhdev", "daemon.pid");
   try {
-    fs9.unlinkSync(pidFile);
+    fs10.unlinkSync(pidFile);
   } catch {
   }
 }
@@ -25211,30 +25334,30 @@ function cleanupStaleGlobalInstallDirs(pkgName, surface) {
   if (pkgName.startsWith("@")) {
     const [scope, name] = pkgName.split("/");
     const scopeDir = path22.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(path22.join(scopeDir, entry), { recursive: true, force: true });
+      fs10.rmSync(path22.join(scopeDir, entry), { recursive: true, force: true });
       appendUpgradeLog(`Removed stale scoped staging dir: ${path22.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(path22.join(npmRoot, entry), { recursive: true, force: true });
+      fs10.rmSync(path22.join(npmRoot, entry), { recursive: true, force: true });
       appendUpgradeLog(`Removed stale staging dir: ${path22.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(path22.join(binDir, entry), { recursive: true, force: true });
+      fs10.rmSync(path22.join(binDir, entry), { recursive: true, force: true });
       appendUpgradeLog(`Removed stale bin staging entry: ${path22.join(binDir, entry)}`);
     }
   }
 }
 function spawnDetachedDaemonUpgradeHelper(payload) {
   const env = { ...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,
@@ -25264,7 +25387,7 @@ async function runDaemonUpgradeHelper(payload) {
   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,
     {
@@ -25286,7 +25409,7 @@ async function runDaemonUpgradeHelper(payload) {
     const env = { ...process.env };
     delete env[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,
@@ -25313,9 +25436,10 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
 }
 
 // src/commands/router.ts
+init_mesh_work_queue();
 var import_os3 = require("os");
 var import_path8 = require("path");
-var fs10 = __toESM(require("fs"));
+var fs11 = __toESM(require("fs"));
 var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
 var CHANNEL_SERVER_URL = {
   stable: "https://api.adhf.dev",
@@ -25959,7 +26083,7 @@ async function hydrateInlineMeshDirectTruth(args) {
       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) {
@@ -26126,14 +26250,14 @@ function recordMeshRefineStage(stages, stage, status, startedAt, details) {
   });
 }
 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",
@@ -26144,8 +26268,8 @@ async function computeGitPatchId(cwd, fromRef, toRef) {
 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
@@ -26193,6 +26317,81 @@ async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead)
     };
   }
 }
+async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree) {
+  const startedAt = Date.now();
+  const entries = [];
+  try {
+    const { execFile: execFile3 } = await import("child_process");
+    const { promisify: promisify6 } = await import("util");
+    const execFileAsync3 = promisify6(execFile3);
+    const runGit2 = async (cwd, args) => {
+      const { stdout } = await execFileAsync3("git", args, {
+        cwd,
+        encoding: "utf8",
+        timeout: 3e4,
+        maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES,
+        windowsHide: true
+      });
+      return String(stdout || "");
+    };
+    const treeOutput = await runGit2(repoRoot, ["ls-tree", "-r", "-z", mergedTree]);
+    const gitlinks = treeOutput.split("\0").filter(Boolean).map((record) => {
+      const match = /^160000\s+commit\s+([0-9a-f]{40})\t(.+)$/.exec(record);
+      return match ? { commit: match[1], path: match[2] } : null;
+    }).filter((entry) => !!entry);
+    for (const gitlink of gitlinks) {
+      const submodulePath = (0, import_path8.resolve)(repoRoot, gitlink.path);
+      const entry = {
+        path: gitlink.path,
+        commit: gitlink.commit,
+        reachable: false
+      };
+      try {
+        if (!fs11.existsSync(submodulePath)) {
+          entry.error = `Submodule checkout missing at ${gitlink.path}`;
+          entries.push(entry);
+          continue;
+        }
+        entry.checkedLocal = true;
+        try {
+          await runGit2(submodulePath, ["cat-file", "-e", `${gitlink.commit}^{commit}`]);
+          entry.reachable = true;
+          entries.push(entry);
+          continue;
+        } catch {
+        }
+        try {
+          await runGit2(submodulePath, ["fetch", "origin", gitlink.commit]);
+          entry.fetchedFromOrigin = true;
+          await runGit2(submodulePath, ["cat-file", "-e", `${gitlink.commit}^{commit}`]);
+          entry.reachable = true;
+        } catch (e) {
+          entry.error = truncateValidationOutput(e?.stderr || e?.message || String(e));
+        }
+      } catch (e) {
+        entry.error = truncateValidationOutput(e?.message || String(e));
+      }
+      entries.push(entry);
+    }
+    const unreachable = entries.filter((entry) => !entry.reachable);
+    return {
+      status: unreachable.length ? "failed" : "passed",
+      checked: entries.length,
+      unreachable,
+      entries,
+      durationMs: Date.now() - startedAt
+    };
+  } catch (e) {
+    return {
+      status: "failed",
+      checked: entries.length,
+      unreachable: entries.filter((entry) => !entry.reachable),
+      entries,
+      durationMs: Date.now() - startedAt,
+      error: truncateValidationOutput(e?.message || String(e))
+    };
+  }
+}
 function buildMeshRefineValidationPlan(mesh, workspace) {
   const plan = resolveMeshRefineValidationPlan(mesh, workspace);
   return {
@@ -26214,8 +26413,8 @@ function buildMeshRefineValidationPlan(mesh, workspace) {
 }
 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",
@@ -26305,9 +26504,9 @@ function resolveHermesUserHome() {
 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 };
 }
@@ -26344,9 +26543,9 @@ function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
   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 (error) {
       LOG.warn("MeshCoordinator", `Could not copy Hermes ${fileName} into isolated coordinator home: ${error?.message || error}`);
     }
@@ -26559,6 +26758,7 @@ var DaemonCommandRouter = class {
   getCachedAggregateMeshStatus(meshId, mesh, options) {
     const cached = this.aggregateMeshStatusCache.get(meshId);
     if (!cached?.snapshot || cached.snapshot.success !== true || !Array.isArray(cached.snapshot.nodes)) return null;
+    if (cached.queueRevision !== getMeshQueueRevision(meshId)) return null;
     let snapshot = this.cloneJsonValue(cached.snapshot);
     snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
     if (shouldRefreshStalePendingAggregate(snapshot, options)) return null;
@@ -26596,7 +26796,7 @@ var DaemonCommandRouter = class {
         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) {
@@ -26699,13 +26899,13 @@ var DaemonCommandRouter = class {
         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",
@@ -26725,7 +26925,7 @@ var DaemonCommandRouter = class {
     const normalizePath = (value) => {
       const resolved = (0, import_path8.resolve)(value);
       try {
-        return fs10.realpathSync(resolved);
+        return fs11.realpathSync(resolved);
       } catch {
         return resolved;
       }
@@ -26798,8 +26998,8 @@ var DaemonCommandRouter = class {
       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,
@@ -27209,8 +27409,8 @@ var DaemonCommandRouter = class {
       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();
@@ -27301,6 +27501,37 @@ var DaemonCommandRouter = class {
           }
         };
       }
+      const submoduleReachabilityStarted = Date.now();
+      const submoduleReachability = await runMeshRefineSubmoduleReachabilityGate(repoRoot, patchEquivalence.mergedTree || branchHead);
+      recordMeshRefineStage(refineStages, "submodule_reachability", submoduleReachability.status, submoduleReachabilityStarted, {
+        checked: submoduleReachability.checked,
+        unreachable: submoduleReachability.unreachable.map((entry) => ({ path: entry.path, commit: entry.commit, error: entry.error })),
+        error: submoduleReachability.error
+      });
+      if (submoduleReachability.status === "failed") {
+        return {
+          success: false,
+          code: "submodule_reachability_failed",
+          convergenceStatus: "blocked_review",
+          error: "Refinery submodule reachability preflight failed; merge/refine cleanup was not attempted.",
+          branch,
+          into: baseBranch,
+          validationSummary,
+          patchEquivalence,
+          submoduleReachability,
+          refineStages,
+          finalBranchConvergenceState: {
+            branch,
+            baseBranch,
+            merged: false,
+            removed: false,
+            validation: "passed",
+            patchEquivalence: "passed",
+            submoduleReachability: "failed",
+            status: "blocked_review"
+          }
+        };
+      }
       let mergeResult;
       const mergeStarted = Date.now();
       try {
@@ -27488,8 +27719,8 @@ var DaemonCommandRouter = class {
           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 };
@@ -28912,7 +29143,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;
@@ -28948,14 +29179,14 @@ ${block2}`);
             };
           }
           try {
-            mkdirSync17(dirname9(mcpConfigPath), { recursive: true });
+            mkdirSync18(dirname9(mcpConfigPath), { recursive: true });
           } catch (error) {
             const message = `Could not prepare MCP config path for automatic setup: ${error?.message || error}`;
             LOG.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));
@@ -28985,7 +29216,7 @@ ${block2}`);
             }
           };
           try {
-            writeFileSync15(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
+            writeFileSync14(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
           } catch (error) {
             const message = `Could not write MCP config for automatic setup: ${error?.message || error}`;
             LOG.error("MeshCoordinator", message);
@@ -29213,7 +29444,7 @@ ${block2}`);
               }
             }
             if (workspace) {
-              if (!fs10.existsSync(workspace)) {
+              if (!fs11.existsSync(workspace)) {
                 const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
                 let remoteProbeApplied = false;
                 if (inlineTransitGit) {
@@ -29422,7 +29653,7 @@ ${block2}`);
       }
     }
     if (killProcess) {
-      const running = isIdeRunning(ideType);
+      const running = await isIdeRunning(ideType);
       if (running) {
         LOG.info("StopIDE", `Killing IDE process: ${ideType}`);
         const killed = await killIdeProcess(ideType);
@@ -29448,6 +29679,8 @@ var DaemonStatusReporter = class {
   lastStatusSentAt = 0;
   statusPendingThrottle = false;
   lastP2PStatusHash = "";
+  lastP2PStatusSentAt = 0;
+  p2pDebounceTimer = null;
   lastServerStatusHash = "";
   lastStatusSummary = "";
   statusTimer = null;
@@ -29699,7 +29932,18 @@ var DaemonStatusReporter = class {
     })() : { ...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;
     }
@@ -31034,11 +31278,11 @@ var ProviderInstanceManager = class {
 };
 
 // src/providers/version-archive.ts
-var fs11 = __toESM(require("fs"));
+var fs12 = __toESM(require("fs"));
 var path23 = __toESM(require("path"));
 var os20 = __toESM(require("os"));
-var import_child_process10 = require("child_process");
 var import_os4 = require("os");
+var import_child_process9 = require("child_process");
 var ARCHIVE_PATH = path23.join(os20.homedir(), ".adhdev", "version-history.json");
 var MAX_ENTRIES_PER_PROVIDER = 20;
 var VersionArchive = class {
@@ -31048,8 +31292,8 @@ var VersionArchive = class {
   }
   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 = {};
@@ -31086,27 +31330,43 @@ var VersionArchive = class {
   }
   save() {
     try {
-      fs11.mkdirSync(path23.dirname(ARCHIVE_PATH), { recursive: true });
-      fs11.writeFileSync(ARCHIVE_PATH, JSON.stringify(this.history, null, 2));
+      fs12.mkdirSync(path23.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
+    }, (error, stdout) => {
+      if (error) 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 = path23.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.]+)?)/);
@@ -31128,13 +31388,13 @@ function getPlatformVersionCommand(versionCommand, currentOs) {
   }
   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;
@@ -31144,18 +31404,18 @@ function checkPathExists2(paths) {
     if (p.includes("*")) {
       const home = os20.homedir();
       const resolved = p.replace(/\*/g, home.split(path23.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 = path23.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) {
@@ -31180,16 +31440,16 @@ async function detectAllVersions(loader, archive) {
       let resolvedBin = cliBin;
       if (!resolvedBin && appPath && currentOs === "darwin") {
         const bundled = path23.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;
@@ -31197,7 +31457,7 @@ async function detectAllVersions(loader, archive) {
       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;
@@ -31219,7 +31479,7 @@ async function detectAllVersions(loader, archive) {
 
 // src/daemon/dev-server.ts
 var http2 = __toESM(require("http"));
-var fs15 = __toESM(require("fs"));
+var fs16 = __toESM(require("fs"));
 var path27 = __toESM(require("path"));
 init_config();
 
@@ -31570,7 +31830,7 @@ async (params) => {
 init_logger();
 
 // src/daemon/dev-cdp-handlers.ts
-var fs12 = __toESM(require("fs"));
+var fs13 = __toESM(require("fs"));
 var path24 = __toESM(require("path"));
 init_logger();
 async function handleCdpEvaluate(ctx, req, res) {
@@ -31751,17 +32011,17 @@ async function handleScriptHints(ctx, type, _req, res) {
   }
   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;
         }
@@ -31773,7 +32033,7 @@ async function handleScriptHints(ctx, type, _req, res) {
     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;
@@ -32588,7 +32848,7 @@ async function handleDomContext(ctx, type, req, res) {
 }
 
 // src/daemon/dev-cli-debug.ts
-var fs13 = __toESM(require("fs"));
+var fs14 = __toESM(require("fs"));
 var path25 = __toESM(require("path"));
 function slugifyFixtureName(value) {
   const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -32604,10 +32864,10 @@ function getCliFixtureDir(ctx, type) {
 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 = [];
@@ -33343,7 +33603,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       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 = {
@@ -33371,7 +33631,7 @@ async function handleCliFixtureCapture(ctx, req, res) {
       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,
@@ -33389,14 +33649,14 @@ async function handleCliFixtureCapture(ctx, req, res) {
 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((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
+    const fixtures = fs14.readdirSync(fixtureDir).filter((file) => file.endsWith(".json")).sort((a, b) => b.localeCompare(a, void 0, { numeric: true, sensitivity: "base" })).map((file) => {
       const fullPath = path25.join(fixtureDir, file);
       try {
-        const raw = JSON.parse(fs13.readFileSync(fullPath, "utf-8"));
+        const raw = JSON.parse(fs14.readFileSync(fullPath, "utf-8"));
         return {
           name: raw.name || file.replace(/\.json$/i, ""),
           path: fullPath,
@@ -33529,7 +33789,7 @@ async function handleCliRaw(ctx, req, res) {
 }
 
 // src/daemon/dev-auto-implement.ts
-var fs14 = __toESM(require("fs"));
+var fs15 = __toESM(require("fs"));
 var path26 = __toESM(require("path"));
 var os21 = __toESM(require("os"));
 function getAutoImplPid(ctx) {
@@ -33577,10 +33837,10 @@ function resolveAutoImplReference(ctx, category, requestedReference, targetType)
   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;
     }
@@ -33602,13 +33862,13 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
   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 };
@@ -33616,15 +33876,15 @@ function resolveAutoImplWritableProviderDir(ctx, category, type, requestedDir) {
 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 file of fs14.readdirSync(latestDir)) {
+  for (const file of fs15.readdirSync(latestDir)) {
     if (!file.endsWith(".js")) continue;
     try {
-      referenceScripts[file] = fs14.readFileSync(path26.join(latestDir, file), "utf-8");
+      referenceScripts[file] = fs15.readFileSync(path26.join(latestDir, file), "utf-8");
     } catch {
     }
   }
@@ -33733,15 +33993,15 @@ async function handleAutoImplement(ctx, type, req, res) {
     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.` });
@@ -33843,7 +34103,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         } catch {
         }
         try {
-          fs14.unlinkSync(promptFile);
+          fs15.unlinkSync(promptFile);
         } catch {
         }
         ctx.log(`Auto-implement (ACP) ${success ? "completed" : "failed"}: ${type} (exit: ${code})`);
@@ -34069,7 +34329,7 @@ async function handleAutoImplement(ctx, type, req, res) {
         }
       });
       try {
-        fs14.unlinkSync(promptFile);
+        fs15.unlinkSync(promptFile);
       } catch {
       }
       ctx.log(`Auto-implement ${success ? "completed" : "failed"}: ${type} (exit: ${code})${verificationSummary ? ` verify=${verificationSummary.pass ? "pass" : "fail"}` : ""}`);
@@ -34174,10 +34434,10 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
     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 file of fs14.readdirSync(latestScriptsDir)) {
+    for (const file of fs15.readdirSync(latestScriptsDir)) {
       if (file.endsWith(".js") && targetFileNames.has(file)) {
         try {
-          const content = fs14.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
+          const content = fs15.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -34187,14 +34447,14 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
         }
       }
     }
-    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 file of refFiles) {
         try {
-          const content = fs14.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
+          const content = fs15.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -34239,7 +34499,7 @@ function buildAutoImplPrompt(ctx, type, provider, providerDir, functions, domCon
   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;
@@ -34483,11 +34743,11 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
     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 file of fs14.readdirSync(latestScriptsDir)) {
+    for (const file of fs15.readdirSync(latestScriptsDir)) {
       if (!file.endsWith(".js")) continue;
       if (!targetFileNames.has(file)) continue;
       try {
-        const content = fs14.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
+        const content = fs15.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
         lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
         lines.push("```javascript");
         lines.push(content);
@@ -34496,14 +34756,14 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
       } 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 file of refFiles) {
         try {
-          const content = fs14.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
+          const content = fs15.readFileSync(path26.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u{1F512}`);
           lines.push("```javascript");
           lines.push(content);
@@ -34540,7 +34800,7 @@ function buildCliAutoImplPrompt(ctx, type, provider, providerDir, functions, ref
   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;
@@ -35280,7 +35540,7 @@ var DevServer = class _DevServer {
       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;
   }
@@ -35292,7 +35552,7 @@ var DevServer = class _DevServer {
     }
     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) {
@@ -35322,7 +35582,7 @@ var DevServer = class _DevServer {
       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" });
@@ -35431,14 +35691,14 @@ var DevServer = class _DevServer {
     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" });
           }
         }
@@ -35466,11 +35726,11 @@ var DevServer = class _DevServer {
       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 } */
@@ -35492,9 +35752,9 @@ var DevServer = class _DevServer {
       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 });
@@ -35511,8 +35771,8 @@ var DevServer = class _DevServer {
     }
     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;
       }
@@ -35531,11 +35791,11 @@ var DevServer = class _DevServer {
       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 });
@@ -35680,20 +35940,20 @@ var DevServer = class _DevServer {
     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, 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);
         }
       }
@@ -35742,10 +36002,10 @@ var DevServer = class _DevServer {
   }
   // ─── 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;
       }
@@ -35767,13 +36027,13 @@ var DevServer = class _DevServer {
     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 };
@@ -35816,10 +36076,10 @@ var DevServer = class _DevServer {
       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 file of fs15.readdirSync(latestScriptsDir)) {
+      for (const file of fs16.readdirSync(latestScriptsDir)) {
         if (file.endsWith(".js") && targetFileNames.has(file)) {
           try {
-            const content = fs15.readFileSync(path27.join(latestScriptsDir, file), "utf-8");
+            const content = fs16.readFileSync(path27.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
             lines.push("```javascript");
             lines.push(content);
@@ -35829,14 +36089,14 @@ var DevServer = class _DevServer {
           }
         }
       }
-      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 file of refFiles) {
           try {
-            const content = fs15.readFileSync(path27.join(latestScriptsDir, file), "utf-8");
+            const content = fs16.readFileSync(path27.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -35881,7 +36141,7 @@ var DevServer = class _DevServer {
     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;
@@ -36062,11 +36322,11 @@ var DevServer = class _DevServer {
       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 file of fs15.readdirSync(latestScriptsDir)) {
+      for (const file of fs16.readdirSync(latestScriptsDir)) {
         if (!file.endsWith(".js")) continue;
         if (!targetFileNames.has(file)) continue;
         try {
-          const content = fs15.readFileSync(path27.join(latestScriptsDir, file), "utf-8");
+          const content = fs16.readFileSync(path27.join(latestScriptsDir, file), "utf-8");
           lines.push(`### \`${file}\` \u270F\uFE0F EDIT`);
           lines.push("```javascript");
           lines.push(content);
@@ -36075,14 +36335,14 @@ var DevServer = class _DevServer {
         } 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 file of refFiles) {
           try {
-            const content = fs15.readFileSync(path27.join(latestScriptsDir, file), "utf-8");
+            const content = fs16.readFileSync(path27.join(latestScriptsDir, file), "utf-8");
             lines.push(`### \`${file}\` \u{1F512}`);
             lines.push("```javascript");
             lines.push(content);
@@ -36119,7 +36379,7 @@ var DevServer = class _DevServer {
     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;
@@ -36896,7 +37156,8 @@ function shouldAutoRestoreHostedSessionsOnStartup(env = process.env) {
 }
 
 // src/installer.ts
-var import_child_process11 = require("child_process");
+var import_child_process10 = require("child_process");
+var import_util3 = require("util");
 var EXTENSION_CATALOG = [
   // AI Agent extensions
   {
@@ -36983,15 +37244,15 @@ var EXTENSION_CATALOG = [
     apiKeyName: "OpenAI/Anthropic API key"
   }
 ];
-function isExtensionInstalled(ide, marketplaceId) {
+var execAsync4 = (0, import_util3.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;
@@ -37007,7 +37268,7 @@ async function installExtension(ide, extension) {
       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,
@@ -37023,11 +37284,11 @@ async function installExtension(ide, extension) {
       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 }, (error, _stdout, stderr) => {
+          (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
             resolve16({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
@@ -37043,7 +37304,7 @@ async function installExtension(ide, extension) {
   }
   return new Promise((resolve16) => {
     const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
-    (0, import_child_process11.exec)(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
+    (0, import_child_process10.exec)(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
       if (error) {
         resolve16({
           extensionId: extension.id,
@@ -37080,7 +37341,7 @@ function launchIDE(ide, workspacePath) {
   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;
@@ -37516,6 +37777,7 @@ async function shutdownDaemonComponents(components) {
   getLogLevel,
   getMesh,
   getMeshByRepo,
+  getMeshQueueRevision,
   getMeshQueueStats,
   getNpmExecOptions,
   getPendingMeshCoordinatorEvents,