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

package/dist/index.mjs

@@ -1268,7 +1268,7 @@ __export(mesh_ledger_exports, {
   readLedgerEntries: () => readLedgerEntries,
   readLedgerSlice: () => readLedgerSlice
 });
-import { existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, appendFileSync, statSync as statSync2, renameSync } from "fs";
+import { appendFileSync, existsSync as existsSync6, mkdirSync as mkdirSync3, readFileSync as readFileSync4, statSync as statSync2, renameSync } from "fs";
 import { join as join6 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter } from "events";
@@ -1678,15 +1678,162 @@ var init_mesh_ledger = __esm({
   }
 });
 
+// src/mesh/beads-db.ts
+import Database from "better-sqlite3";
+import { existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname2, join as join7 } from "path";
+function safeMeshId(meshId) {
+  return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+}
+function legacyQueuePath(meshId) {
+  return join7(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+}
+var BeadsDB;
+var init_beads_db = __esm({
+  "src/mesh/beads-db.ts"() {
+    "use strict";
+    init_mesh_ledger();
+    BeadsDB = class _BeadsDB {
+      static instance;
+      db;
+      migratedMeshIds = /* @__PURE__ */ new Set();
+      constructor(dbPath) {
+        const dir = dirname2(dbPath);
+        if (!existsSync7(dir)) mkdirSync4(dir, { recursive: true });
+        this.db = new Database(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(join7(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 (!existsSync7(path28)) return;
+        try {
+          const entries = JSON.parse(readFileSync5(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,
@@ -1696,8 +1843,6 @@ __export(mesh_work_queue_exports, {
   updateTaskStatus: () => updateTaskStatus,
   validateMeshTaskModeRequest: () => validateMeshTaskModeRequest
 });
-import { existsSync as existsSync7, writeFileSync as writeFileSync3, readFileSync as readFileSync5, openSync, closeSync, unlinkSync } from "fs";
-import { join as join7 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 function normalizeMeshTaskMode(value) {
   if (typeof value !== "string") return void 0;
@@ -1725,53 +1870,14 @@ function validateMeshTaskModeRequest(mode, message) {
     ]
   };
 }
-function getQueuePath(meshId) {
-  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join7(getLedgerDir(), `${safe}.queue.json`);
-}
-function getLockPath(meshId) {
-  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join7(getLedgerDir(), `${safe}.queue.lock`);
-}
-function withQueueLock(meshId, fn) {
-  const lockPath = getLockPath(meshId);
-  let fd = -1;
-  for (let i = 0; i < 10; i++) {
-    try {
-      fd = openSync(lockPath, "wx");
-      break;
-    } catch {
-      const deadline = Date.now() + 30;
-      while (Date.now() < deadline) {
-      }
-    }
-  }
-  try {
-    return fn();
-  } finally {
-    if (fd !== -1) try {
-      closeSync(fd);
-    } catch {
-    }
-    try {
-      unlinkSync(lockPath);
-    } catch {
-    }
-  }
+function withQueueLock(_meshId, fn) {
+  return BeadsDB.getInstance().transaction(fn);
 }
 function readQueue(meshId) {
-  const path28 = getQueuePath(meshId);
-  if (!existsSync7(path28)) return [];
-  try {
-    const content = readFileSync5(path28, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return [];
-  }
+  return BeadsDB.getInstance().getQueueEntries(meshId);
 }
 function writeQueue(meshId, queue) {
-  const path28 = getQueuePath(meshId);
-  writeFileSync3(path28, JSON.stringify(queue, null, 2), "utf-8");
+  BeadsDB.getInstance().replaceQueue(meshId, queue);
 }
 function enqueueTask(meshId, message, opts) {
   requireMeshHostQueueOwner(opts);
@@ -1805,6 +1911,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);
@@ -1948,12 +2057,23 @@ function getMeshQueueStats(meshId) {
     }))
   };
 }
+function __replaceMeshQueueForTests(meshId, queue) {
+  BeadsDB.getInstance().transaction(() => {
+    BeadsDB.getInstance().replaceQueue(meshId, queue);
+  });
+}
+function __clearMeshQueueForTests(meshId) {
+  BeadsDB.getInstance().deleteQueue(meshId);
+}
+function __resetBeadsDBForTests() {
+  BeadsDB.resetForTests();
+}
 var 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";
-    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"];
@@ -2101,8 +2221,62 @@ var init_cli_detector = __esm({
   }
 });
 
-// src/logging/logger.ts
+// src/logging/async-batch-writer.ts
 import * as fs2 from "fs";
+var AsyncBatchWriter;
+var init_async_batch_writer = __esm({
+  "src/logging/async-batch-writer.ts"() {
+    "use strict";
+    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
+import * as fs3 from "fs";
 import * as path9 from "path";
 import * as os3 from "os";
 function setLogLevel(level) {
@@ -2131,7 +2305,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);
@@ -2139,7 +2313,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 {
         }
       }
@@ -2149,14 +2323,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 {
   }
@@ -2167,7 +2341,7 @@ function writeToFile(line) {
       checkDateRotation();
       rotateSizeIfNeeded();
     }
-    fs2.appendFileSync(currentLogFile, line + "\n");
+    AsyncBatchWriter.write(currentLogFile, line + "\n");
   } catch {
   }
 }
@@ -2259,6 +2433,7 @@ var LEVEL_NUM, LEVEL_LABEL, currentLevel, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, c
 var init_logger = __esm({
   "src/logging/logger.ts"() {
     "use strict";
+    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";
@@ -2266,7 +2441,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();
@@ -2274,14 +2449,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 {
     }
@@ -2327,7 +2502,7 @@ __export(mesh_events_exports, {
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
-import { appendFileSync as appendFileSync3, existsSync as existsSync10, readFileSync as readFileSync6, unlinkSync as unlinkSync3 } from "fs";
+import { appendFileSync as appendFileSync2, existsSync as existsSync10, readFileSync as readFileSync6, unlinkSync as unlinkSync2 } from "fs";
 import { join as join10 } from "path";
 function readWorkerResultMetadata(event) {
   return readRecord(event.workerResult) || readRecord(event.meshWorkerResult) || readRecord(event.structuredResult);
@@ -2366,7 +2541,7 @@ function queuePendingMeshCoordinatorEvent(event) {
       LOG.info("MeshEvents", `Suppressed duplicate pending ${event.event} for refine job ${readRefineJobId(event)}`);
       return true;
     }
-    appendFileSync3(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
+    appendFileSync2(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
     return true;
   } catch (e) {
     LOG.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
@@ -2380,7 +2555,7 @@ function drainPendingMeshCoordinatorEvents(meshId) {
   try {
     const raw = readFileSync6(path28, "utf-8");
     try {
-      unlinkSync3(path28);
+      unlinkSync2(path28);
     } catch {
     }
     return raw.split("\n").filter(Boolean).flatMap((line) => {
@@ -2415,7 +2590,7 @@ function clearPendingMeshCoordinatorEvents(meshId) {
   if (!meshId) return;
   const path28 = getPendingEventsPath(meshId);
   if (existsSync10(path28)) try {
-    unlinkSync3(path28);
+    unlinkSync2(path28);
   } catch {
   }
 }
@@ -3627,8 +3802,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();
@@ -3650,7 +3825,6 @@ var init_pty_transport = __esm({
 // src/cli-adapters/provider-cli-shared.ts
 import * as os9 from "os";
 import * as path14 from "path";
-import { execSync as execSync3 } from "child_process";
 function stripAnsi(str) {
   return str.replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B[P^_X][\s\S]*?(?:\x07|\x1B\\)/g, "").replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, "");
 }
@@ -3731,27 +3905,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 execSync3(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 +3944,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);
@@ -9011,7 +9193,7 @@ var P2pRelayFailureError = class extends Error {
 
 // src/config/state-store.ts
 init_config();
-import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7, writeFileSync as writeFileSync3 } from "fs";
 import { join as join11 } from "path";
 var DEFAULT_STATE = {
   recentActivity: [],
@@ -9074,17 +9256,19 @@ function loadState() {
 function saveState(state) {
   const statePath = getStatePath();
   const normalized = normalizeState(state);
-  writeFileSync4(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  writeFileSync3(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function resetState() {
   saveState({ ...DEFAULT_STATE });
 }
 
 // src/detection/ide-detector.ts
-import { execSync } from "child_process";
-import { existsSync as existsSync12 } from "fs";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify3 } from "util";
+import { existsSync as existsSync12, statSync as statSync4 } from "fs";
 import { platform as platform2, homedir as homedir5 } from "os";
 import * as path10 from "path";
+var execAsync2 = promisify3(exec2);
 var BUILTIN_IDE_DEFINITIONS = [];
 var registeredIDEs = /* @__PURE__ */ new Map();
 function registerIDEDefinition(def) {
@@ -9108,24 +9292,33 @@ function findCliCommand(command) {
     const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
     return existsSync12(resolved) ? resolved : null;
   }
-  try {
-    const result = execSync(
-      platform2() === "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 = platform2() === "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 (existsSync12(fullPath)) {
+          const stat2 = statSync4(fullPath);
+          if (stat2.isFile() && (isWin || stat2.mode & 73)) {
+            return fullPath;
+          }
+        }
+      } catch {
+      }
+    }
   }
+  return null;
 }
-function getIdeVersion(cliCommand) {
+async function getIdeVersion(cliCommand) {
   try {
-    const result = 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;
   }
@@ -9173,7 +9366,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,
@@ -9193,19 +9386,23 @@ init_cli_detector();
 
 // src/system/host-memory.ts
 import * as os4 from "os";
-import { execSync as execSync2 } from "child_process";
-function parseDarwinAvailableBytes(totalMem) {
-  if (os4.platform() !== "darwin") return null;
+import { exec as exec3 } from "child_process";
+import { promisify as promisify4 } from "util";
+var execAsync3 = promisify4(exec3);
+var cachedDarwinAvail = null;
+var darwinMemoryInterval = null;
+async function updateDarwinMemoryCache() {
+  if (os4.platform() !== "darwin") return;
   try {
-    const out = execSync2("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, "_");
@@ -9219,18 +9416,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
@@ -11595,7 +11798,7 @@ ${cleanBody}`;
 }
 
 // src/config/chat-history.ts
-import * as fs3 from "fs";
+import * as fs4 from "fs";
 import * as path11 from "path";
 import * as os5 from "os";
 var HISTORY_DIR = path11.join(os5.homedir(), ".adhdev", "history");
@@ -11715,8 +11918,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;
     }
@@ -11743,7 +11946,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}_`);
@@ -11761,7 +11964,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`];
@@ -11784,8 +11987,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();
     }
@@ -11807,27 +12010,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 {
@@ -11874,7 +12077,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);
       }
     }
@@ -11882,14 +12085,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";
@@ -11897,10 +12100,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;
@@ -11910,7 +12113,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`;
@@ -11991,7 +12194,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;
@@ -12052,7 +12255,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);
@@ -12198,13 +12401,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) {
@@ -12294,7 +12497,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);
@@ -12309,7 +12512,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 {
     }
@@ -12344,14 +12547,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);
@@ -12365,16 +12568,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 {
@@ -12385,13 +12588,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;
@@ -12420,10 +12623,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);
@@ -12440,18 +12643,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;
           }
         }
@@ -12499,13 +12702,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 {
@@ -12529,7 +12732,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 };
     }
@@ -12590,10 +12793,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);
@@ -12614,16 +12817,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, "_"));
@@ -12731,7 +12934,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();
@@ -13504,6 +13707,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";
@@ -13728,7 +13944,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 {
@@ -13743,7 +13959,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);
@@ -14054,7 +14270,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);
@@ -15123,7 +15339,7 @@ function resolveLegacyProviderScript(fn, scriptName, params) {
 }
 
 // src/commands/chat-commands.ts
-import * as fs4 from "fs";
+import * as fs5 from "fs";
 import * as os6 from "os";
 import * as path12 from "path";
 import { randomUUID as randomUUID7 } from "crypto";
@@ -15696,11 +15912,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) {
@@ -16863,7 +17079,7 @@ async function handleResolveAction(h, args) {
 }
 
 // src/commands/cdp-commands.ts
-import * as fs5 from "fs";
+import * as fs6 from "fs";
 import * as path13 from "path";
 import * as os7 from "os";
 var KEY_TO_VK = {
@@ -17136,7 +17352,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);
@@ -17148,14 +17364,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",
@@ -17173,7 +17389,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 {
@@ -17184,7 +17400,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 };
@@ -17193,8 +17409,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 };
@@ -18322,7 +18538,7 @@ init_config();
 import * as os13 from "os";
 import * as path18 from "path";
 import * as crypto4 from "crypto";
-import { existsSync as existsSync16, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, writeFileSync as writeFileSync8 } from "fs";
 import { execFileSync } from "child_process";
 import chalk from "chalk";
 
@@ -18330,7 +18546,7 @@ import chalk from "chalk";
 import * as os12 from "os";
 import * as path16 from "path";
 import * as crypto3 from "crypto";
-import * as fs6 from "fs";
+import * as fs7 from "fs";
 import { createRequire } from "module";
 init_provider_cli_adapter();
 init_logger();
@@ -18389,9 +18605,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;
 }
@@ -18403,14 +18619,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 {
       }
@@ -18649,7 +18865,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;
     }
@@ -19565,7 +19781,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);
@@ -20879,10 +21095,10 @@ function hasCliArg(args, flag) {
 }
 function ensureEmptyDelegatedMcpConfig(workspace) {
   const baseDir = path18.join(os13.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-  mkdirSync9(baseDir, { recursive: true });
+  mkdirSync10(baseDir, { recursive: true });
   const workspaceHash = crypto4.createHash("sha256").update(path18.resolve(workspace || os13.tmpdir())).digest("hex").slice(0, 16);
   const filePath = path18.join(baseDir, `${workspaceHash}.json`);
-  writeFileSync9(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+  writeFileSync8(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
   return filePath;
 }
 function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -21662,13 +21878,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
 };
 
 // src/launch.ts
-import { execSync as execSync4, spawn as spawn2 } from "child_process";
+import { exec as exec4, spawn as spawn2 } from "child_process";
 import * as net from "net";
 import * as os15 from "os";
 import * as path20 from "path";
 
 // src/providers/provider-loader.ts
-import * as fs7 from "fs";
+import * as fs8 from "fs";
 import * as path19 from "path";
 import * as os14 from "os";
 import * as chokidar from "chokidar";
@@ -22021,9 +22237,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;
@@ -22031,7 +22247,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;
     }
@@ -22193,7 +22409,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)`);
@@ -22201,7 +22417,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)`);
@@ -22216,10 +22432,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;
@@ -22717,7 +22933,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;
             }
@@ -22733,7 +22949,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.`;
@@ -22751,7 +22967,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) {
@@ -22768,7 +22984,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;
         }
       }
     }
@@ -22801,14 +23017,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);
@@ -22829,9 +23045,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;
         }
@@ -22844,13 +23060,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);
@@ -22903,13 +23123,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;
       }
@@ -22967,36 +23189,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);
@@ -23028,7 +23250,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();
@@ -23047,22 +23269,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(),
@@ -23073,11 +23295,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++;
         }
@@ -23304,18 +23526,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 {
               }
@@ -23334,7 +23556,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);
@@ -23344,13 +23566,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;
@@ -23396,12 +23618,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;
       }
@@ -23409,7 +23631,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 || "";
@@ -23429,7 +23651,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);
@@ -23534,6 +23756,14 @@ function findMacAppProcessPids(psOutput, appPaths) {
 }
 
 // src/launch.ts
+async function execQuiet(command, options = {}) {
+  return new Promise((resolve16) => {
+    exec4(command, options, (error, stdout) => {
+      if (error) return resolve16("");
+      resolve16(stdout.toString());
+    });
+  });
+}
 var _providerLoader = null;
 function getProviderLoader() {
   if (!_providerLoader) {
@@ -23572,11 +23802,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 = execSync4("ps axww -o pid=,args=", {
+    const output = await execQuiet("ps axww -o pid=,args=", {
       encoding: "utf-8",
       timeout: 3e3,
       stdio: ["pipe", "pipe", "pipe"]
@@ -23586,8 +23816,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 {
@@ -23650,68 +23880,68 @@ async function killIdeProcess(ideId) {
   try {
     if (plat === "darwin" && appName) {
       try {
-        execSync4(`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 {
-          execSync4(`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 {
-          execSync4(`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", "");
-        execSync4(`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 {
-        execSync4(`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 {
-        execSync4(`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 {
-          execSync4(`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 = execSync4(`pgrep -x "${appName}" 2>/dev/null`, {
+        const result = await execQuiet(`pgrep -x "${appName}" 2>/dev/null`, {
           encoding: "utf-8",
           timeout: 3e3
         });
@@ -23719,7 +23949,7 @@ function isIdeRunning(ideId) {
       } catch {
       }
       try {
-        const result = execSync4(
+        const result = await execQuiet(
           `osascript -e 'tell application "System Events" to count (every process whose name is "${escapeForAppleScript(appName)}")'`,
           {
             encoding: "utf-8",
@@ -23730,20 +23960,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 = execSync4(`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 = execSync4(
+        const result = await execQuiet(
           `powershell -Command "(Get-Process -Name '${exeName}' -ErrorAction SilentlyContinue).Count"`,
           { encoding: "utf-8", timeout: 5e3 }
         );
@@ -23752,20 +23982,20 @@ function isIdeRunning(ideId) {
       }
       return false;
     } else {
-      const result = execSync4(`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 = execSync4(
+      const result = await execQuiet(
         `lsof -c "${appName}" 2>/dev/null | grep cwd | head -1 | awk '{print $NF}'`,
         { encoding: "utf-8", timeout: 3e3 }
       );
@@ -23775,7 +24005,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) {
@@ -23784,8 +24014,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];
@@ -23852,8 +24082,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) {
@@ -23969,14 +24199,14 @@ init_cli_detector();
 init_logger();
 
 // src/logging/command-log.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 import * as path21 from "path";
 import * as os16 from "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([
@@ -24022,7 +24252,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);
@@ -24030,7 +24260,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 {
         }
       }
@@ -24040,14 +24270,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 {
   }
@@ -24080,14 +24310,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 {
@@ -24117,14 +24347,11 @@ init_logger();
 import * as yaml2 from "js-yaml";
 
 // src/commands/mesh-coordinator.ts
-import { execFileSync as execFileSync2 } from "child_process";
 import { createHash as createHash3 } from "crypto";
-import { existsSync as existsSync19, readdirSync as readdirSync7, realpathSync as realpathSync2 } from "fs";
-import { createRequire as createRequire2 } from "module";
 import * as os17 from "os";
-import { dirname as dirname4, isAbsolute as isAbsolute11, join as join22, resolve as resolve13 } from "path";
+import { isAbsolute as isAbsolute11, join as join22, resolve as resolve13 } from "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) {
@@ -24134,8 +24361,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
   });
@@ -24166,7 +24392,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,
@@ -24203,8 +24429,7 @@ function resolveMeshCoordinatorSetup(options) {
     }
     const mcpServer = resolveAdhdevMcpServerLaunch({
       meshId,
-      nodeExecutable: options.nodeExecutable,
-      adhdevMcpEntryPath: options.adhdevMcpEntryPath,
+      adhdevMcpCommand: options.adhdevMcpCommand,
       adhdevMcpTransport: options.adhdevMcpTransport,
       adhdevMcpPort: options.adhdevMcpPort
     });
@@ -24276,19 +24501,19 @@ function resolveMcpConfigPath(configPath, workspace) {
   return join22(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();
@@ -24301,109 +24526,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(join22(dir, "node"));
-  }
-}
-function addNodeCandidatesFromNvm(homeDir, addCandidate) {
-  const versionsDir = join22(homeDir, ".nvm", "versions", "node");
-  try {
-    const versionDirs = readdirSync7(versionsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(compareNodeVersionNamesDescending);
-    for (const versionDir of versionDirs) {
-      addCandidate(join22(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 {
-    execFileSync2(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 = dirname4(realBase);
-    addCandidate(resolve13(dir, "../vendor/mcp-server/index.js"));
-    addCandidate(resolve13(dir, "../../vendor/mcp-server/index.js"));
-    addCandidate(resolve13(dir, "../../../vendor/mcp-server/index.js"));
-    addCandidate(resolve13(dir, "../../mcp-server/dist/index.js"));
-    addCandidate(resolve13(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] : join22(process.cwd(), "adhdev-daemon.js");
-    const req = createRequire2(requireBase);
-    const resolvedModule = req.resolve("@adhdev/mcp-server");
-    return normalizeExistingPath(resolvedModule) || resolvedModule;
-  } catch {
-    return null;
-  }
-}
-function normalizeExistingPath(filePath) {
-  try {
-    if (!existsSync19(filePath)) return null;
-    return realpathSync2.native(filePath);
-  } catch {
-    return null;
-  }
-}
 
 // src/commands/router.ts
 init_mesh_events();
@@ -24723,23 +24845,23 @@ function buildStatusSnapshot(options) {
 }
 
 // src/commands/upgrade-helper.ts
-import { execFileSync as execFileSync3 } from "child_process";
+import { execFileSync as execFileSync2 } from "child_process";
 import { spawn as spawn3 } from "child_process";
-import * as fs9 from "fs";
+import * as fs10 from "fs";
 import * as os19 from "os";
 import * as path22 from "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 {
   }
 }
@@ -24747,12 +24869,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) };
       }
     }
@@ -24760,7 +24882,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) };
     }
   }
@@ -24770,12 +24892,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 {
@@ -24784,8 +24906,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;
@@ -24843,7 +24965,7 @@ function getNpmExecOptions(platform10 = process.platform) {
 }
 function execNpmCommandSync(args, options = {}, surface) {
   const execOptions = surface?.execOptions || getNpmExecOptions();
-  return execFileSync3(
+  return execFileSync2(
     surface?.npmExecutable || "npm",
     [...surface?.npmArgsPrefix || [], ...args],
     {
@@ -24856,7 +24978,7 @@ function execNpmCommandSync(args, options = {}, surface) {
 function killPid(pid) {
   try {
     if (process.platform === "win32") {
-      execFileSync3("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+      execFileSync2("taskkill", ["/PID", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
     } else {
       process.kill(pid, "SIGTERM");
     }
@@ -24868,7 +24990,7 @@ function killPid(pid) {
 function getWindowsProcessCommandLine(pid) {
   const pidFilter = `ProcessId=${pid}`;
   try {
-    const psOut = execFileSync3("powershell.exe", [
+    const psOut = execFileSync2("powershell.exe", [
       "-NoProfile",
       "-NonInteractive",
       "-ExecutionPolicy",
@@ -24880,7 +25002,7 @@ function getWindowsProcessCommandLine(pid) {
   } catch {
   }
   try {
-    const wmicOut = execFileSync3("wmic", [
+    const wmicOut = execFileSync2("wmic", [
       "process",
       "where",
       pidFilter,
@@ -24896,7 +25018,7 @@ function getProcessCommandLine(pid) {
   if (!Number.isFinite(pid) || pid <= 0) return null;
   if (process.platform === "win32") return getWindowsProcessCommandLine(pid);
   try {
-    const text = execFileSync3("ps", ["-o", "command=", "-p", String(pid)], {
+    const text = execFileSync2("ps", ["-o", "command=", "-p", String(pid)], {
       encoding: "utf8",
       timeout: 3e3,
       stdio: ["ignore", "pipe", "ignore"]
@@ -24924,8 +25046,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);
       }
@@ -24933,7 +25055,7 @@ function stopSessionHostProcesses(appName) {
   } catch {
   } finally {
     try {
-      fs9.unlinkSync(pidFile);
+      fs10.unlinkSync(pidFile);
     } catch {
     }
   }
@@ -24941,7 +25063,7 @@ function stopSessionHostProcesses(appName) {
 function removeDaemonPidFile() {
   const pidFile = path22.join(os19.homedir(), ".adhdev", "daemon.pid");
   try {
-    fs9.unlinkSync(pidFile);
+    fs10.unlinkSync(pidFile);
   } catch {
   }
 }
@@ -24959,23 +25081,23 @@ 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)}`);
     }
   }
@@ -25012,7 +25134,7 @@ async function runDaemonUpgradeHelper(payload) {
   cleanupStaleGlobalInstallDirs(payload.packageName, installCommand.surface);
   const spec = `${payload.packageName}@${payload.targetVersion || "latest"}`;
   appendUpgradeLog(`Installing ${spec}`);
-  const installOutput = execFileSync3(
+  const installOutput = execFileSync2(
     installCommand.command,
     installCommand.args,
     {
@@ -25061,9 +25183,10 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
 }
 
 // src/commands/router.ts
+init_mesh_work_queue();
 import { homedir as homedir19 } from "os";
 import { join as pathJoin, resolve as pathResolve } from "path";
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
 var CHANNEL_SERVER_URL = {
   stable: "https://api.adhf.dev",
@@ -25707,7 +25830,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) {
@@ -25874,14 +25997,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",
@@ -25892,8 +26015,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
@@ -25941,6 +26064,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 = pathResolve(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 {
@@ -25962,8 +26160,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",
@@ -26053,9 +26251,9 @@ function resolveHermesUserHome() {
 function loadHermesCoordinatorBaseConfig(targetConfigPath) {
   const sourceHome = resolveHermesUserHome();
   const sourceConfigPath = pathJoin(sourceHome, "config.yaml");
-  if (!fs10.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+  if (!fs11.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
   if (pathResolve(sourceConfigPath) === pathResolve(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 };
 }
@@ -26092,9 +26290,9 @@ function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
   for (const fileName of [".env", "auth.json"]) {
     const sourcePath = pathJoin(sourceHome, fileName);
     const targetPath = pathJoin(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}`);
     }
@@ -26307,6 +26505,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;
@@ -26344,7 +26543,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) {
@@ -26447,13 +26646,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",
@@ -26473,7 +26672,7 @@ var DaemonCommandRouter = class {
     const normalizePath = (value) => {
       const resolved = pathResolve(value);
       try {
-        return fs10.realpathSync(resolved);
+        return fs11.realpathSync(resolved);
       } catch {
         return resolved;
       }
@@ -26546,8 +26745,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,
@@ -26957,8 +27156,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();
@@ -27049,6 +27248,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 {
@@ -27236,8 +27466,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 };
@@ -28660,7 +28890,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;
@@ -28696,14 +28926,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));
@@ -28733,7 +28963,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);
@@ -28961,7 +29191,7 @@ ${block2}`);
               }
             }
             if (workspace) {
-              if (!fs10.existsSync(workspace)) {
+              if (!fs11.existsSync(workspace)) {
                 const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
                 let remoteProbeApplied = false;
                 if (inlineTransitGit) {
@@ -29170,7 +29400,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);
@@ -29196,6 +29426,8 @@ var DaemonStatusReporter = class {
   lastStatusSentAt = 0;
   statusPendingThrottle = false;
   lastP2PStatusHash = "";
+  lastP2PStatusSentAt = 0;
+  p2pDebounceTimer = null;
   lastServerStatusHash = "";
   lastStatusSummary = "";
   statusTimer = null;
@@ -29447,7 +29679,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;
     }
@@ -30782,11 +31025,11 @@ var ProviderInstanceManager = class {
 };
 
 // src/providers/version-archive.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as path23 from "path";
 import * as os20 from "os";
-import { execSync as execSync5 } from "child_process";
 import { platform as platform8 } from "os";
+import { exec as exec5 } from "child_process";
 var ARCHIVE_PATH = path23.join(os20.homedir(), ".adhdev", "version-history.json");
 var MAX_ENTRIES_PER_PROVIDER = 20;
 var VersionArchive = class {
@@ -30796,8 +31039,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 = {};
@@ -30834,27 +31077,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 execSync5(cmd, {
+async function runCommand(cmd, timeout = 1e4) {
+  return new Promise((resolve16) => {
+    exec5(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 = platform8() === "win32" ? `where ${name}` : `which ${name}`;
-  const result = runCommand(cmd, 5e3);
-  return result ? result.split("\n")[0] : null;
+  const isWin = platform8() === "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.]+)?)/);
@@ -30876,13 +31135,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;
@@ -30892,18 +31151,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 (platform8() !== "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) {
@@ -30928,16 +31187,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;
@@ -30945,7 +31204,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;
@@ -30967,7 +31226,7 @@ async function detectAllVersions(loader, archive) {
 
 // src/daemon/dev-server.ts
 import * as http2 from "http";
-import * as fs15 from "fs";
+import * as fs16 from "fs";
 import * as path27 from "path";
 init_config();
 
@@ -31319,7 +31578,7 @@ init_logger();
 
 // src/daemon/dev-cdp-handlers.ts
 init_logger();
-import * as fs12 from "fs";
+import * as fs13 from "fs";
 import * as path24 from "path";
 async function handleCdpEvaluate(ctx, req, res) {
   const body = await ctx.readBody(req);
@@ -31499,17 +31758,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;
         }
@@ -31521,7 +31780,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;
@@ -32336,7 +32595,7 @@ async function handleDomContext(ctx, type, req, res) {
 }
 
 // src/daemon/dev-cli-debug.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as path25 from "path";
 function slugifyFixtureName(value) {
   const normalized = String(value || "").trim().toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -32352,10 +32611,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 = [];
@@ -33091,7 +33350,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 = {
@@ -33119,7 +33378,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,
@@ -33137,14 +33396,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,
@@ -33277,7 +33536,7 @@ async function handleCliRaw(ctx, req, res) {
 }
 
 // src/daemon/dev-auto-implement.ts
-import * as fs14 from "fs";
+import * as fs15 from "fs";
 import * as path26 from "path";
 import * as os21 from "os";
 function getAutoImplPid(ctx) {
@@ -33325,10 +33584,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;
     }
@@ -33350,13 +33609,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 };
@@ -33364,15 +33623,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 {
     }
   }
@@ -33481,15 +33740,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.` });
@@ -33591,7 +33850,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})`);
@@ -33817,7 +34076,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"}` : ""}`);
@@ -33922,10 +34181,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);
@@ -33935,14 +34194,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);
@@ -33987,7 +34246,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;
@@ -34231,11 +34490,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);
@@ -34244,14 +34503,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);
@@ -34288,7 +34547,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;
@@ -35028,7 +35287,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;
   }
@@ -35040,7 +35299,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) {
@@ -35070,7 +35329,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" });
@@ -35179,14 +35438,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" });
           }
         }
@@ -35214,11 +35473,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 } */
@@ -35240,9 +35499,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 });
@@ -35259,8 +35518,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;
       }
@@ -35279,11 +35538,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 });
@@ -35428,20 +35687,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);
         }
       }
@@ -35490,10 +35749,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;
       }
@@ -35515,13 +35774,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 };
@@ -35564,10 +35823,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);
@@ -35577,14 +35836,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);
@@ -35629,7 +35888,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;
@@ -35810,11 +36069,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);
@@ -35823,14 +36082,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);
@@ -35867,7 +36126,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;
@@ -36649,7 +36908,8 @@ function shouldAutoRestoreHostedSessionsOnStartup(env = process.env) {
 }
 
 // src/installer.ts
-import { execSync as execSync6, exec as exec2 } from "child_process";
+import { exec as exec6 } from "child_process";
+import { promisify as promisify5 } from "util";
 var EXTENSION_CATALOG = [
   // AI Agent extensions
   {
@@ -36736,15 +36996,15 @@ var EXTENSION_CATALOG = [
     apiKeyName: "OpenAI/Anthropic API key"
   }
 ];
-function isExtensionInstalled(ide, marketplaceId) {
+var execAsync4 = promisify5(exec6);
+async function isExtensionInstalled(ide, marketplaceId) {
   if (!ide.cliCommand) return false;
   try {
-    const result = execSync6(`"${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;
@@ -36760,7 +37020,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,
@@ -36776,11 +37036,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`;
-          exec2(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
+          exec6(cmd, { timeout: 6e4 }, (error, _stdout, stderr) => {
             resolve16({
               extensionId: extension.id,
               marketplaceId: extension.marketplaceId,
@@ -36796,7 +37056,7 @@ async function installExtension(ide, extension) {
   }
   return new Promise((resolve16) => {
     const cmd = `"${ide.cliCommand}" --install-extension ${extension.marketplaceId} --force`;
-    exec2(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
+    exec6(cmd, { timeout: 6e4 }, (error, stdout, stderr) => {
       if (error) {
         resolve16({
           extensionId: extension.id,
@@ -36833,7 +37093,7 @@ function launchIDE(ide, workspacePath) {
   if (!ide.cliCommand) return false;
   try {
     const args = workspacePath ? `"${workspacePath}"` : "";
-    exec2(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
+    exec6(`"${ide.cliCommand}" ${args}`, { timeout: 1e4 });
     return true;
   } catch {
     return false;
@@ -37268,6 +37528,7 @@ export {
   getLogLevel,
   getMesh,
   getMeshByRepo,
+  getMeshQueueRevision,
   getMeshQueueStats,
   getNpmExecOptions,
   getPendingMeshCoordinatorEvents,