@adhdev/daemon-core 0.9.82-rc.139 → 0.9.82-rc.140

package/dist/index.js

@@ -434,6 +434,7 @@ var config_exports = {};
 __export(config_exports, {
   generateMachineId: () => generateMachineId,
   getConfigDir: () => getConfigDir,
+  getDaemonDataDir: () => getDaemonDataDir,
   isSetupComplete: () => isSetupComplete,
   isStableMachineId: () => isStableMachineId,
   loadConfig: () => loadConfig,
@@ -542,6 +543,13 @@ function getConfigDir() {
   }
   return dir;
 }
+function getDaemonDataDir() {
+  const dir = (0, import_path.join)(getConfigDir(), "daemon");
+  if (!(0, import_fs.existsSync)(dir)) {
+    (0, import_fs.mkdirSync)(dir, { recursive: true });
+  }
+  return dir;
+}
 function getConfigPath() {
   return (0, import_path.join)(getConfigDir(), "config.json");
 }
@@ -1308,41 +1316,41 @@ function isIntentionalCleanupStopEntry(entry) {
   return payload.intentional === true && (payload.reason === "operator_cleanup" || payload.intentionalStopReason === "operator_cleanup" || payload.source === "mesh_cleanup_sessions" || payload.source === "mesh_remove_node");
 }
 function getLedgerDir() {
-  const dir = (0, import_path5.join)(getConfigDir(), LEDGER_DIR_NAME);
-  if (!(0, import_fs5.existsSync)(dir)) {
-    (0, import_fs5.mkdirSync)(dir, { recursive: true, mode: 448 });
+  const dir = (0, import_path6.join)(getConfigDir(), LEDGER_DIR_NAME);
+  if (!(0, import_fs6.existsSync)(dir)) {
+    (0, import_fs6.mkdirSync)(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function getLedgerPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path5.join)(getLedgerDir(), `${safe}.jsonl`);
+  return (0, import_path6.join)(getLedgerDir(), `${safe}.jsonl`);
 }
 function getRotatedPath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path5.join)(getLedgerDir(), `${safe}.${index}.jsonl`);
+  return (0, import_path6.join)(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
 function getArchivePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path5.join)(getLedgerDir(), `${safe}.archive.jsonl`);
+  return (0, import_path6.join)(getLedgerDir(), `${safe}.archive.jsonl`);
 }
 function getRotatedArchivePath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path5.join)(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
+  return (0, import_path6.join)(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
 }
 function getArchivedCountsPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return (0, import_path5.join)(getLedgerDir(), `${safe}.archived-counts.json`);
+  return (0, import_path6.join)(getLedgerDir(), `${safe}.archived-counts.json`);
 }
 function rotateArchiveFile(meshId, archivePath) {
   let index = 1;
-  while ((0, import_fs5.existsSync)(getRotatedArchivePath(meshId, index))) {
+  while ((0, import_fs6.existsSync)(getRotatedArchivePath(meshId, index))) {
     index++;
     if (index > 5) break;
   }
   if (index > 5) index = 5;
   try {
-    (0, import_fs5.renameSync)(archivePath, getRotatedArchivePath(meshId, index));
+    (0, import_fs6.renameSync)(archivePath, getRotatedArchivePath(meshId, index));
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Archive rotation failed for mesh ${meshId}: ${e?.message || e}
 `);
@@ -1350,9 +1358,9 @@ function rotateArchiveFile(meshId, archivePath) {
 }
 function readArchivedCounts(meshId) {
   const path28 = getArchivedCountsPath(meshId);
-  if (!(0, import_fs5.existsSync)(path28)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
+  if (!(0, import_fs6.existsSync)(path28)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   try {
-    return JSON.parse((0, import_fs5.readFileSync)(path28, "utf-8"));
+    return JSON.parse((0, import_fs6.readFileSync)(path28, "utf-8"));
   } catch {
     return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   }
@@ -1368,7 +1376,7 @@ function updateArchivedCounts(meshId, archived) {
   counts.totalArchived += archived.length;
   counts.lastArchivedAt = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    (0, import_fs5.writeFileSync)(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
+    (0, import_fs6.writeFileSync)(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
   } catch {
   }
 }
@@ -1391,7 +1399,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
 }
 function compactLedger(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!(0, import_fs5.existsSync)(filePath)) return { archivedCount: 0, retainedCount: 0 };
+  if (!(0, import_fs6.existsSync)(filePath)) return { archivedCount: 0, retainedCount: 0 };
   const cutoff = Date.now() - ARCHIVE_TERMINAL_OLDER_THAN_MS;
   const entries = readLedgerEntries(meshId);
   const keep = [];
@@ -1406,11 +1414,11 @@ function compactLedger(meshId) {
   if (archive.length === 0) return { archivedCount: 0, retainedCount: keep.length };
   const archivePath = getArchivePath(meshId);
   try {
-    if ((0, import_fs5.existsSync)(archivePath) && (0, import_fs5.statSync)(archivePath).size > 50 * 1024 * 1024) {
+    if ((0, import_fs6.existsSync)(archivePath) && (0, import_fs6.statSync)(archivePath).size > 50 * 1024 * 1024) {
       rotateArchiveFile(meshId, archivePath);
     }
     const archiveLines = archive.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    (0, import_fs5.appendFileSync)(archivePath, archiveLines, { encoding: "utf-8", mode: 384 });
+    (0, import_fs6.appendFileSync)(archivePath, archiveLines, { encoding: "utf-8", mode: 384 });
     updateArchivedCounts(meshId, archive);
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Ledger archive write failed for mesh ${meshId}: ${e?.message || e}
@@ -1419,7 +1427,7 @@ function compactLedger(meshId) {
   }
   try {
     const keepLines = keep.length ? keep.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
-    (0, import_fs5.writeFileSync)(filePath, keepLines, { encoding: "utf-8", mode: 384 });
+    (0, import_fs6.writeFileSync)(filePath, keepLines, { encoding: "utf-8", mode: 384 });
     invalidateLedgerCache(meshId);
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Ledger compaction rewrite failed for mesh ${meshId}: ${e?.message || e}
@@ -1551,9 +1559,9 @@ function appendLedgerEntry(meshId, partial) {
     ...partial
   };
   const filePath = getLedgerPath(meshId);
-  if ((0, import_fs5.existsSync)(filePath)) {
+  if ((0, import_fs6.existsSync)(filePath)) {
     try {
-      const stat2 = (0, import_fs5.statSync)(filePath);
+      const stat2 = (0, import_fs6.statSync)(filePath);
       if (stat2.size >= MAX_FILE_SIZE_BYTES) {
         rotateLedgerFile(meshId, filePath);
       } else if (stat2.size >= COMPACT_THRESHOLD_BYTES) {
@@ -1564,7 +1572,7 @@ function appendLedgerEntry(meshId, partial) {
   }
   try {
     const line = JSON.stringify(entry) + "\n";
-    (0, import_fs5.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
+    (0, import_fs6.appendFileSync)(filePath, line, { encoding: "utf-8", mode: 384 });
     invalidateLedgerCache(meshId);
     meshLedgerEvents.emit("append", meshId, entry);
     return entry;
@@ -1610,7 +1618,7 @@ function appendRemoteLedgerEntries(meshId, entries) {
   }
   try {
     const lines = validEntries.map((e) => JSON.stringify(e)).join("\n") + "\n";
-    (0, import_fs5.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
+    (0, import_fs6.appendFileSync)(ledgerPath, lines, { encoding: "utf-8", mode: 384 });
     invalidateLedgerCache(meshId);
     for (const entry of validEntries) {
       meshLedgerEvents.emit("append", meshId, entry);
@@ -1622,10 +1630,10 @@ function appendRemoteLedgerEntries(meshId, entries) {
 }
 function readLedgerFile(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!(0, import_fs5.existsSync)(filePath)) return [];
+  if (!(0, import_fs6.existsSync)(filePath)) return [];
   let content;
   try {
-    content = (0, import_fs5.readFileSync)(filePath, "utf-8");
+    content = (0, import_fs6.readFileSync)(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -1826,24 +1834,24 @@ function getSessionRecoveryContext(meshId, opts) {
 }
 function rotateLedgerFile(meshId, currentPath) {
   let index = 1;
-  while ((0, import_fs5.existsSync)(getRotatedPath(meshId, index))) {
+  while ((0, import_fs6.existsSync)(getRotatedPath(meshId, index))) {
     index++;
     if (index > 10) break;
   }
   if (index > 10) index = 10;
   try {
-    (0, import_fs5.renameSync)(currentPath, getRotatedPath(meshId, index));
+    (0, import_fs6.renameSync)(currentPath, getRotatedPath(meshId, index));
   } catch (e) {
     process.stderr.write(`[adhdev-mesh] Ledger rotation failed for mesh ${meshId}: ${e?.message || e}. File will continue to grow.
 `);
   }
 }
-var import_fs5, import_path5, import_crypto4, import_events, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS;
+var import_fs6, import_path6, import_crypto4, import_events, LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS;
 var init_mesh_ledger = __esm({
   "src/mesh/mesh-ledger.ts"() {
     "use strict";
-    import_fs5 = require("fs");
-    import_path5 = require("path");
+    import_fs6 = require("fs");
+    import_path6 = require("path");
     import_crypto4 = require("crypto");
     init_config();
     import_events = require("events");
@@ -1877,14 +1885,14 @@ function safeMeshId(meshId) {
   return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function legacyQueuePath(meshId) {
-  return (0, import_path6.join)(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+  return (0, import_path7.join)(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
-var import_fs6, import_path6, import_module, import_meta, DatabaseCtor, BeadsDB;
+var import_fs7, import_path7, import_module, import_meta, DatabaseCtor, BeadsDB;
 var init_beads_db = __esm({
   "src/mesh/beads-db.ts"() {
     "use strict";
-    import_fs6 = require("fs");
-    import_path6 = require("path");
+    import_fs7 = require("fs");
+    import_path7 = require("path");
     import_module = require("module");
     init_mesh_ledger();
     import_meta = {};
@@ -1899,8 +1907,8 @@ var init_beads_db = __esm({
       static WAL_MAX_BYTES = 50 * 1024 * 1024;
       // 50 MB
       constructor(dbPath) {
-        const dir = (0, import_path6.dirname)(dbPath);
-        if (!(0, import_fs6.existsSync)(dir)) (0, import_fs6.mkdirSync)(dir, { recursive: true });
+        const dir = (0, import_path7.dirname)(dbPath);
+        if (!(0, import_fs7.existsSync)(dir)) (0, import_fs7.mkdirSync)(dir, { recursive: true });
         this.dbPath = dbPath;
         this.db = new (loadDatabaseCtor())(dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -1911,7 +1919,7 @@ var init_beads_db = __esm({
       }
       static getInstance() {
         if (!this.instance) {
-          this.instance = new _BeadsDB((0, import_path6.join)(getLedgerDir(), "beads.db"));
+          this.instance = new _BeadsDB((0, import_path7.join)(getLedgerDir(), "beads.db"));
         }
         return this.instance;
       }
@@ -1991,8 +1999,8 @@ var init_beads_db = __esm({
         this.walWriteCounter = 0;
         try {
           const walPath = `${this.dbPath}-wal`;
-          if (!(0, import_fs6.existsSync)(walPath)) return;
-          const size = (0, import_fs6.statSync)(walPath).size;
+          if (!(0, import_fs7.existsSync)(walPath)) return;
+          const size = (0, import_fs7.statSync)(walPath).size;
           if (size < _BeadsDB.WAL_MAX_BYTES) return;
           process.stderr.write(
             `[adhdev-mesh] WAL file ${Math.round(size / 1024 / 1024)}MB exceeds threshold; forcing checkpoint
@@ -2008,9 +2016,9 @@ var init_beads_db = __esm({
         const count = this.db.prepare("SELECT COUNT(*) AS count FROM mesh_queue WHERE mesh_id = ?").get(meshId);
         if (count.count > 0) return;
         const path28 = legacyQueuePath(meshId);
-        if (!(0, import_fs6.existsSync)(path28)) return;
+        if (!(0, import_fs7.existsSync)(path28)) return;
         try {
-          const entries = JSON.parse((0, import_fs6.readFileSync)(path28, "utf-8"));
+          const entries = JSON.parse((0, import_fs7.readFileSync)(path28, "utf-8"));
           if (!Array.isArray(entries)) return;
           const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -2527,7 +2535,7 @@ function resolveCommandPath(command) {
   if (isExplicitCommandPath(trimmed)) {
     const expanded = expandHome(trimmed);
     const candidate = path8.isAbsolute(expanded) ? expanded : path8.resolve(expanded);
-    return (0, import_fs7.existsSync)(candidate) ? candidate : null;
+    return (0, import_fs8.existsSync)(candidate) ? candidate : null;
   }
   return null;
 }
@@ -2627,14 +2635,14 @@ async function detectCLI(cliId, providerLoader, options) {
   const all = await detectCLIs(providerLoader, options);
   return all.find((c) => c.id === resolvedId && c.installed) || null;
 }
-var import_child_process, os2, path8, import_fs7;
+var import_child_process, os2, path8, import_fs8;
 var init_cli_detector = __esm({
   "src/detection/cli-detector.ts"() {
     "use strict";
     import_child_process = require("child_process");
     os2 = __toESM(require("os"));
     path8 = __toESM(require("path"));
-    import_fs7 = require("fs");
+    import_fs8 = require("fs");
   }
 });
 
@@ -2981,18 +2989,18 @@ function getPendingEventsPath(meshId, coordinatorDaemonId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
   if (coordinatorDaemonId) {
     const safeDaemon = coordinatorDaemonId.replace(/[^a-zA-Z0-9_-]/g, "_");
-    return (0, import_path7.join)(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
+    return (0, import_path8.join)(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
   }
-  return (0, import_path7.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
+  return (0, import_path8.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
 }
 function readPendingMeshCoordinatorEventsFromDisk(meshId, coordinatorDaemonId) {
   if (!meshId) return [];
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   const events = [];
   for (const path28 of paths) {
-    if (!(0, import_fs8.existsSync)(path28)) continue;
+    if (!(0, import_fs9.existsSync)(path28)) continue;
     try {
-      const raw = (0, import_fs8.readFileSync)(path28, "utf-8");
+      const raw = (0, import_fs9.readFileSync)(path28, "utf-8");
       const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -3071,11 +3079,11 @@ function reconcilePendingMeshCoordinatorEvents(meshId, events) {
 }
 function trimPendingEventsIfNeeded(path28) {
   try {
-    if (!(0, import_fs8.existsSync)(path28)) return;
-    if ((0, import_fs8.statSync)(path28).size <= MAX_PENDING_EVENTS_BYTES) return;
-    const lines = (0, import_fs8.readFileSync)(path28, "utf-8").split("\n").filter(Boolean);
+    if (!(0, import_fs9.existsSync)(path28)) return;
+    if ((0, import_fs9.statSync)(path28).size <= MAX_PENDING_EVENTS_BYTES) return;
+    const lines = (0, import_fs9.readFileSync)(path28, "utf-8").split("\n").filter(Boolean);
     if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
-    (0, import_fs8.writeFileSync)(path28, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
+    (0, import_fs9.writeFileSync)(path28, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
   } catch {
   }
 }
@@ -3091,7 +3099,7 @@ function queuePendingMeshCoordinatorEvent(event) {
     }
     const path28 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
     trimPendingEventsIfNeeded(path28);
-    (0, import_fs8.appendFileSync)(path28, JSON.stringify(event) + "\n", "utf-8");
+    (0, import_fs9.appendFileSync)(path28, JSON.stringify(event) + "\n", "utf-8");
     return true;
   } catch (e) {
     LOG.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
@@ -3101,20 +3109,20 @@ function queuePendingMeshCoordinatorEvent(event) {
 function atomicDrainFile(path28) {
   const tmpPath = `${path28}.draining`;
   try {
-    (0, import_fs8.renameSync)(path28, tmpPath);
+    (0, import_fs9.renameSync)(path28, tmpPath);
   } catch {
     return null;
   }
   try {
-    const content = (0, import_fs8.readFileSync)(tmpPath, "utf-8");
+    const content = (0, import_fs9.readFileSync)(tmpPath, "utf-8");
     try {
-      (0, import_fs8.unlinkSync)(tmpPath);
+      (0, import_fs9.unlinkSync)(tmpPath);
     } catch {
     }
     return content;
   } catch {
     try {
-      (0, import_fs8.unlinkSync)(tmpPath);
+      (0, import_fs9.unlinkSync)(tmpPath);
     } catch {
     }
     return null;
@@ -3148,8 +3156,8 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   if (!meshId) return;
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   for (const path28 of paths) {
-    if ((0, import_fs8.existsSync)(path28)) try {
-      (0, import_fs8.unlinkSync)(path28);
+    if ((0, import_fs9.existsSync)(path28)) try {
+      (0, import_fs9.unlinkSync)(path28);
     } catch {
     }
   }
@@ -4167,12 +4175,12 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var import_fs8, import_path7, REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, REFINE_TERMINAL_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
+var import_fs9, import_path8, REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, REFINE_TERMINAL_EVENTS, MAX_PENDING_EVENTS_BYTES, MAX_PENDING_EVENTS_KEEP, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
 var init_mesh_events = __esm({
   "src/mesh/mesh-events.ts"() {
     "use strict";
-    import_fs8 = require("fs");
-    import_path7 = require("path");
+    import_fs9 = require("fs");
+    import_path8 = require("path");
     init_config();
     init_mesh_config();
     init_cli_detector();
@@ -5192,6 +5200,15 @@ var init_cli_state_engine = __esm({
       // ── Approval ─────────────────────────────────────
       lastApprovalResolvedAt = 0;
       lastResolvedModalMessage = "";
+      /**
+       * When the engine previously held a modal but the latest parse failed
+       * to extract one, we record the timestamp here and only drop the modal
+       * after the configured `approvalCooldown` to avoid flapping between
+       * waiting_approval and generating on every Claude TUI redraw — that
+       * flapping is what fed auto-approve a fresh modal signature on each
+       * paint and made the engine type "1" repeatedly into the prompt.
+       */
+      modalLostAt = 0;
       approvalExitTimeout = null;
       // ── Response tracking ────────────────────────────
       responseEpoch = 0;
@@ -5296,7 +5313,9 @@ var init_cli_state_engine = __esm({
           } catch {
           }
         }
-        if (!this.transport.isAlive() || this.currentStatus !== "waiting_approval" && !modal) return;
+        if (!this.transport.isAlive()) return;
+        const buttonsValid = Array.isArray(modal?.buttons) && modal.buttons.some((b) => typeof b === "string" && b.trim());
+        if (!modal || !buttonsValid) return;
         const currentModalMessage = typeof modal?.message === "string" ? modal.message.trim() : "";
         const inCooldown = !!this.lastApprovalResolvedAt && Date.now() - this.lastApprovalResolvedAt < this.timeouts.approvalCooldown;
         if (inCooldown && currentModalMessage === this.lastResolvedModalMessage) return;
@@ -5646,13 +5665,19 @@ var init_cli_state_engine = __esm({
         if (!inCooldown) {
           if (!modal) {
             LOG.warn("CLI", `[${this.provider.type}] detectStatus=waiting_approval but parseApproval returned null; ignoring`);
-            if (this.currentStatus === "waiting_approval") {
-              this.activeModal = null;
-              this.setStatus("generating", "approval_lost_modal");
-              this.callbacks.onStatusChange();
+            if (this.currentStatus === "waiting_approval" && this.activeModal) {
+              const lostAt = this.modalLostAt || Date.now();
+              if (!this.modalLostAt) this.modalLostAt = lostAt;
+              if (Date.now() - lostAt >= this.timeouts.approvalCooldown) {
+                this.activeModal = null;
+                this.modalLostAt = 0;
+                this.setStatus("generating", "approval_lost_modal");
+                this.callbacks.onStatusChange();
+              }
             }
             return;
           }
+          this.modalLostAt = 0;
           this.isWaitingForResponse = true;
           this.setStatus("waiting_approval", "script_detect");
           const prev = this.activeModal;
@@ -6780,19 +6805,12 @@ ${lastSnapshot}`;
           const liveDetect = this.runDetectStatus(this.recentOutputBuffer || this.terminalScreen.getText());
           if (liveDetect === "waiting_approval") {
             const liveModal = this.runParseApproval(this.terminalScreen.getText()) || this.runParseApproval(this.recentOutputBuffer);
-            if (liveModal) {
+            const buttonsOk = liveModal && Array.isArray(liveModal.buttons) && liveModal.buttons.some((b) => typeof b === "string" && b.trim());
+            if (liveModal && buttonsOk) {
               effectiveModal = liveModal;
               if (!this.engine.activeModal) this.engine.activeModal = liveModal;
-            } else {
-              LOG.warn("CLI", `[${this.cliType}] getStatus live re-extract: detect=waiting_approval but parseApproval still null (recentLen=${this.recentOutputBuffer.length} screenLen=${this.terminalScreen.getText().length})`);
             }
-          } else if (liveDetect && liveDetect !== "generating" && liveDetect !== "idle") {
-            LOG.warn("CLI", `[${this.cliType}] getStatus live re-extract: detect=${liveDetect} (not waiting_approval)`);
-          } else if (this.engine.currentStatus === "waiting_approval" && liveDetect !== "waiting_approval") {
-            LOG.warn("CLI", `[${this.cliType}] getStatus live re-extract: engine.status=waiting_approval but live detect=${liveDetect}`);
           }
-        } else if (!effectiveModal && this.engine.currentStatus === "waiting_approval") {
-          LOG.warn("CLI", `[${this.cliType}] getStatus skipped live re-extract: allowParse=${allowParse} isWaitingForResponse=${this.engine.isWaitingForResponse}`);
         }
         if (startupDetectedStatus === "waiting_approval" && effectiveModal) {
           effectiveStatus = "waiting_approval";
@@ -7705,7 +7723,8 @@ ${lastSnapshot}`;
         if (parsedDebugState?.status === "error") {
           effectiveStatus = "error";
         }
-        if (startupDetectedStatus === "waiting_approval") {
+        const debugEffectiveModal = startupModal || this.engine.activeModal;
+        if (startupDetectedStatus === "waiting_approval" && debugEffectiveModal) {
           effectiveStatus = "waiting_approval";
         }
         if (effectiveStatus === "idle" && parsedDebugState?.status === "generating" && !hasFinalAssistant(parsedDebugState)) {
@@ -7936,7 +7955,9 @@ __export(index_exports, {
   getAIExtensions: () => getAIExtensions,
   getActiveDirectDispatches: () => getActiveDirectDispatches,
   getAvailableIdeIds: () => getAvailableIdeIds,
+  getCoordinatorForSession: () => getCoordinatorForSession,
   getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
+  getDaemonDataDir: () => getDaemonDataDir,
   getDaemonLogDir: () => getDaemonLogDir,
   getDebugRuntimeConfig: () => getDebugRuntimeConfig,
   getGitDiffSummary: () => getGitDiffSummary,
@@ -7988,10 +8009,12 @@ __export(index_exports, {
   killIdeProcess: () => killIdeProcess,
   launchIDE: () => launchIDE,
   launchWithCdp: () => launchWithCdp,
+  listCoordinatorsForWorkspace: () => listCoordinatorsForWorkspace,
   listHostedCliRuntimes: () => listHostedCliRuntimes,
   listMeshes: () => listMeshes,
   listWorktrees: () => listWorktrees,
   loadConfig: () => loadConfig,
+  loadMeshCoordinatorRegistry: () => loadMeshCoordinatorRegistry,
   loadMeshRefineConfig: () => loadMeshRefineConfig,
   loadMeshWorktreeBootstrapConfig: () => loadMeshWorktreeBootstrapConfig,
   loadState: () => loadState,
@@ -8028,6 +8051,7 @@ __export(index_exports, {
   readLedgerSlice: () => readLedgerSlice,
   recordDebugTrace: () => recordDebugTrace,
   registerExtensionProviders: () => registerExtensionProviders,
+  registerMeshCoordinator: () => registerMeshCoordinator,
   removeNode: () => removeNode,
   removeWorktree: () => removeWorktree,
   requeueTask: () => requeueTask,
@@ -8061,6 +8085,7 @@ __export(index_exports, {
   summarizeGitStatus: () => summarizeGitStatus,
   syncMeshes: () => syncMeshes,
   triggerMeshQueue: () => triggerMeshQueue,
+  unregisterMeshCoordinator: () => unregisterMeshCoordinator,
   updateConfig: () => updateConfig,
   updateDirectDispatchStatus: () => updateDirectDispatchStatus,
   updateMesh: () => updateMesh,
@@ -9816,9 +9841,58 @@ function getSavedProviderSessions(state, filters) {
 init_mesh_config();
 init_coordinator_prompt();
 
-// src/mesh/refine-config.ts
-var import_fs3 = require("fs");
+// src/mesh/coordinator-registry.ts
 var import_path3 = require("path");
+var import_fs3 = require("fs");
+init_config();
+var _registry = /* @__PURE__ */ new Map();
+function getRegistryPath() {
+  return (0, import_path3.join)(getDaemonDataDir(), "mesh-coordinators.json");
+}
+function loadMeshCoordinatorRegistry() {
+  const path28 = getRegistryPath();
+  if (!(0, import_fs3.existsSync)(path28)) return;
+  try {
+    const raw = JSON.parse((0, import_fs3.readFileSync)(path28, "utf-8"));
+    if (!Array.isArray(raw)) return;
+    _registry.clear();
+    for (const entry of raw) {
+      if (typeof entry?.sessionId === "string" && typeof entry?.meshId === "string") {
+        _registry.set(entry.sessionId, entry);
+      }
+    }
+  } catch {
+  }
+}
+function saveRegistry() {
+  try {
+    (0, import_fs3.writeFileSync)(
+      getRegistryPath(),
+      JSON.stringify([..._registry.values()], null, 2),
+      { encoding: "utf-8", mode: 384 }
+    );
+  } catch {
+  }
+}
+function registerMeshCoordinator(entry) {
+  _registry.set(entry.sessionId, entry);
+  saveRegistry();
+}
+function unregisterMeshCoordinator(sessionId) {
+  if (_registry.delete(sessionId)) {
+    saveRegistry();
+  }
+}
+function getCoordinatorForSession(sessionId) {
+  return _registry.get(sessionId);
+}
+function listCoordinatorsForWorkspace(workspace) {
+  return [..._registry.values()].filter((e) => e.workspace === workspace);
+}
+
+// src/mesh/refine-config.ts
+var import_fs4 = require("fs");
+var import_path4 = require("path");
 var yaml = __toESM(require("js-yaml"));
 var MESH_REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
 var MESH_REFINE_CONFIG_LOCATIONS = [
@@ -10001,10 +10075,10 @@ function loadMeshRefineConfig(mesh, workspace) {
     return { config: inline, source: "mesh.policy.refineConfig", sourceType: "mesh_policy" };
   }
   for (const relative3 of MESH_REFINE_CONFIG_LOCATIONS) {
-    const configPath = (0, import_path3.join)(workspace, relative3);
-    if (!(0, import_fs3.existsSync)(configPath)) continue;
+    const configPath = (0, import_path4.join)(workspace, relative3);
+    if (!(0, import_fs4.existsSync)(configPath)) continue;
     try {
-      const parsed = parseConfigText(configPath, (0, import_fs3.readFileSync)(configPath, "utf-8"));
+      const parsed = parseConfigText(configPath, (0, import_fs4.readFileSync)(configPath, "utf-8"));
       const validation = validateMeshRefineConfig(parsed, relative3);
       if (!validation.valid) return { source: relative3, sourceType: "invalid", path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
       return { config: parsed, source: relative3, sourceType: "repo_file", path: configPath };
@@ -10020,7 +10094,7 @@ function loadMeshRefineConfig(mesh, workspace) {
 }
 function readPackageScripts(workspace) {
   try {
-    const parsed = JSON.parse((0, import_fs3.readFileSync)((0, import_path3.join)(workspace, "package.json"), "utf-8"));
+    const parsed = JSON.parse((0, import_fs4.readFileSync)((0, import_path4.join)(workspace, "package.json"), "utf-8"));
     return isRecord(parsed?.scripts) ? parsed.scripts : {};
   } catch {
     return {};
@@ -10093,8 +10167,8 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
 }
 
 // src/mesh/worktree-bootstrap-config.ts
-var import_fs4 = require("fs");
-var import_path4 = require("path");
+var import_fs5 = require("fs");
+var import_path5 = require("path");
 var import_node_child_process3 = require("child_process");
 var import_node_util3 = require("util");
 var yaml2 = __toESM(require("js-yaml"));
@@ -10184,10 +10258,10 @@ function loadMeshWorktreeBootstrapConfig(mesh, workspace) {
     return { config: inline, source: "mesh.policy.worktreeBootstrapConfig", sourceType: "mesh_policy" };
   }
   for (const relative3 of MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS) {
-    const configPath = (0, import_path4.join)(workspace, relative3);
-    if (!(0, import_fs4.existsSync)(configPath)) continue;
+    const configPath = (0, import_path5.join)(workspace, relative3);
+    if (!(0, import_fs5.existsSync)(configPath)) continue;
     try {
-      const parsed = parseConfigText2(configPath, (0, import_fs4.readFileSync)(configPath, "utf-8"));
+      const parsed = parseConfigText2(configPath, (0, import_fs5.readFileSync)(configPath, "utf-8"));
       const validation = validateMeshWorktreeBootstrapConfig(parsed, relative3);
       if (!validation.valid) return { source: relative3, sourceType: "invalid", path: configPath, error: String(validation.rejectedCommands[0]?.reason || validation.errors.join("; ")) };
       return { config: parsed, source: relative3, sourceType: "repo_file", path: configPath };
@@ -10221,10 +10295,10 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
     staleInputs: loaded.config.staleInputs
   };
   const staleInputPaths = loaded.config.staleInputs ?? [];
-  const initiallyAbsent = staleInputPaths.filter((p) => !(0, import_fs4.existsSync)((0, import_path4.join)(workspace, p)));
+  const initiallyAbsent = staleInputPaths.filter((p) => !(0, import_fs5.existsSync)((0, import_path5.join)(workspace, p)));
   for (const command of validation.commands) {
     if (initiallyAbsent.length > 0) {
-      const appearedNow = initiallyAbsent.filter((p) => (0, import_fs4.existsSync)((0, import_path4.join)(workspace, p)));
+      const appearedNow = initiallyAbsent.filter((p) => (0, import_fs5.existsSync)((0, import_path5.join)(workspace, p)));
       if (appearedNow.length > 0) {
         state.status = "stale";
         state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -10232,7 +10306,7 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
         return state;
       }
     }
-    const cwd = command.cwd ? (0, import_path4.resolve)(workspace, command.cwd) : workspace;
+    const cwd = command.cwd ? (0, import_path5.resolve)(workspace, command.cwd) : workspace;
     const startedAt = Date.now();
     state.lastCommand = command.displayCommand;
     try {
@@ -11287,8 +11361,8 @@ var P2pRelayFailureError = class extends Error {
 };
 
 // src/config/state-store.ts
-var import_fs9 = require("fs");
-var import_path8 = require("path");
+var import_fs10 = require("fs");
+var import_path9 = require("path");
 init_config();
 var DEFAULT_STATE = {
   recentActivity: [],
@@ -11302,7 +11376,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return (0, import_path8.join)(getConfigDir(), "state.json");
+  return (0, import_path9.join)(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -11338,11 +11412,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!(0, import_fs9.existsSync)(statePath)) {
+  if (!(0, import_fs10.existsSync)(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = (0, import_fs9.readFileSync)(statePath, "utf-8");
+    const raw = (0, import_fs10.readFileSync)(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -11351,7 +11425,7 @@ function loadState() {
 function saveState(state) {
   const statePath = getStatePath();
   const normalized = normalizeState(state);
-  (0, import_fs9.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs10.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function resetState() {
   saveState({ ...DEFAULT_STATE });
@@ -11360,7 +11434,7 @@ function resetState() {
 // src/detection/ide-detector.ts
 var import_child_process2 = require("child_process");
 var import_util = require("util");
-var import_fs10 = require("fs");
+var import_fs11 = require("fs");
 var import_os2 = require("os");
 var path10 = __toESM(require("path"));
 var execAsync2 = (0, import_util.promisify)(import_child_process2.exec);
@@ -11385,7 +11459,7 @@ function findCliCommand(command) {
   if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
     const candidate = trimmed.startsWith("~") ? path10.join((0, import_os2.homedir)(), trimmed.slice(1)) : trimmed;
     const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
-    return (0, import_fs10.existsSync)(resolved) ? resolved : null;
+    return (0, import_fs11.existsSync)(resolved) ? resolved : null;
   }
   const isWin = (0, import_os2.platform)() === "win32";
   const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
@@ -11395,8 +11469,8 @@ function findCliCommand(command) {
     for (const ext of exes) {
       const fullPath = path10.join(p, trimmed + ext);
       try {
-        if ((0, import_fs10.existsSync)(fullPath)) {
-          const stat2 = (0, import_fs10.statSync)(fullPath);
+        if ((0, import_fs11.existsSync)(fullPath)) {
+          const stat2 = (0, import_fs11.statSync)(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
           }
@@ -11425,9 +11499,9 @@ function checkPathExists(paths) {
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if ((0, import_fs10.existsSync)(resolved)) return resolved;
+      if ((0, import_fs11.existsSync)(resolved)) return resolved;
     } else {
-      if ((0, import_fs10.existsSync)(normalized)) return normalized;
+      if ((0, import_fs11.existsSync)(normalized)) return normalized;
     }
   }
   return null;
@@ -11441,7 +11515,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if ((0, import_fs10.existsSync)(bundledCli)) resolvedCli = bundledCli;
+      if ((0, import_fs11.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname9 } = await import("path");
@@ -11454,7 +11528,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if ((0, import_fs10.existsSync)(c)) {
+        if ((0, import_fs11.existsSync)(c)) {
           resolvedCli = c;
           break;
         }
@@ -17191,7 +17265,7 @@ var ACP_SESSION_CAPABILITIES = [
   "set_mode",
   "set_thought_level"
 ];
-function buildIdeWorkspaceSession(state, cdpManagers, options) {
+function buildWorkspaceSession(state, cdpManagers, options) {
   const profile = options.profile || "full";
   const activeChat = normalizeActiveChatData(state.activeChat, getActiveChatOptions(profile));
   const summaryMetadata = normalizeProviderSummaryMetadata(state.summaryMetadata);
@@ -17202,7 +17276,10 @@ function buildIdeWorkspaceSession(state, cdpManagers, options) {
   const git = getGitSummaryForWorkspace(workspace, options);
   const title = activeChat?.title || state.name;
   const meshCoordinatorFor = state.settings?.meshCoordinatorFor;
-  const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : void 0;
+  const registryEntry = state.instanceId ? getCoordinatorForSession(state.instanceId) : void 0;
+  const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+  const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: "coordinator" } : void 0;
+  const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : void 0;
   return {
     id: state.instanceId || state.type,
     parentId: null,
@@ -17226,6 +17303,7 @@ function buildIdeWorkspaceSession(state, cdpManagers, options) {
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated,
     settings: state.settings,
+    ...coordinator && { coordinator },
     ...meshQueueStats && { meshQueueStats }
   };
 }
@@ -17239,7 +17317,10 @@ function buildExtensionAgentSession(parent, ext, options) {
   const workspace = parent.workspace || null;
   const git = getGitSummaryForWorkspace(workspace, options);
   const meshCoordinatorFor = ext.settings?.meshCoordinatorFor;
-  const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : void 0;
+  const registryEntry = ext.instanceId ? getCoordinatorForSession(ext.instanceId) : void 0;
+  const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+  const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: "coordinator" } : void 0;
+  const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : void 0;
   return {
     id: ext.instanceId || `${parent.instanceId}:${ext.type}`,
     parentId: parent.instanceId || parent.type,
@@ -17263,6 +17344,7 @@ function buildExtensionAgentSession(parent, ext, options) {
     errorReason: ext.errorReason,
     lastUpdated: ext.lastUpdated,
     settings: ext.settings,
+    ...coordinator && { coordinator },
     ...meshQueueStats && { meshQueueStats }
   };
 }
@@ -17292,7 +17374,10 @@ function buildCliSession(state, options) {
   const workspace = state.workspace || null;
   const git = getGitSummaryForWorkspace(workspace, options);
   const meshCoordinatorFor = state.settings?.meshCoordinatorFor;
-  const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : void 0;
+  const registryEntry = state.instanceId ? getCoordinatorForSession(state.instanceId) : void 0;
+  const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+  const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: "coordinator" } : void 0;
+  const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : void 0;
   return {
     id: state.instanceId,
     parentId: null,
@@ -17332,6 +17417,7 @@ function buildCliSession(state, options) {
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated,
     settings: state.settings,
+    ...coordinator && { coordinator },
     ...meshQueueStats && { meshQueueStats }
   };
 }
@@ -17345,7 +17431,10 @@ function buildAcpSession(state, options) {
   const workspace = state.workspace || null;
   const git = getGitSummaryForWorkspace(workspace, options);
   const meshCoordinatorFor = state.settings?.meshCoordinatorFor;
-  const meshQueueStats = meshCoordinatorFor ? getMeshQueueStats(meshCoordinatorFor) : void 0;
+  const registryEntry = state.instanceId ? getCoordinatorForSession(state.instanceId) : void 0;
+  const effectiveMeshId = meshCoordinatorFor || registryEntry?.meshId;
+  const coordinator = effectiveMeshId ? { meshId: effectiveMeshId, role: "coordinator" } : void 0;
+  const meshQueueStats = effectiveMeshId ? getMeshQueueStats(effectiveMeshId) : void 0;
   return {
     id: state.instanceId,
     parentId: null,
@@ -17368,6 +17457,7 @@ function buildAcpSession(state, options) {
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated,
     settings: state.settings,
+    ...coordinator && { coordinator },
     ...meshQueueStats && { meshQueueStats }
   };
 }
@@ -17377,7 +17467,7 @@ function buildSessionEntries(allStates, cdpManagers, options = {}) {
   const cliStates = allStates.filter((s) => s.category === "cli");
   const acpStates = allStates.filter((s) => s.category === "acp");
   for (const state of ideStates) {
-    sessions.push(buildIdeWorkspaceSession(state, cdpManagers, options));
+    sessions.push(buildWorkspaceSession(state, cdpManagers, options));
     for (const ext of state.extensions) {
       if (!shouldIncludeExtensionSession(ext)) continue;
       sessions.push(buildExtensionAgentSession(state, ext, options));
@@ -21894,7 +21984,7 @@ var DaemonCommandHandler = class {
 var os13 = __toESM(require("os"));
 var path18 = __toESM(require("path"));
 var crypto4 = __toESM(require("crypto"));
-var import_fs11 = require("fs");
+var import_fs12 = require("fs");
 var import_child_process5 = require("child_process");
 var import_chalk = __toESM(require("chalk"));
 init_provider_cli_adapter();
@@ -22705,10 +22795,17 @@ var CliProviderInstance = class {
       return autoApproveActive;
     }
     const modal = adapterStatus.activeModal;
-    const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(modal?.buttons, this.provider);
+    const buttons = Array.isArray(modal?.buttons) ? modal.buttons.map((b) => String(b || "").trim()).filter(Boolean) : [];
+    if (!modal || buttons.length === 0) {
+      return autoApproveActive;
+    }
+    const { index: buttonIndex, label: buttonLabel } = pickApprovalButton(buttons, this.provider);
+    if (buttonIndex < 0) {
+      return autoApproveActive;
+    }
     const signature = [
       typeof modal?.message === "string" ? modal.message.trim() : "",
-      Array.isArray(modal?.buttons) ? modal.buttons.join("|") : "",
+      buttons.join("|"),
       buttonIndex
     ].join("::");
     if (!this.autoApproveBusy || signature !== this.lastAutoApprovalSignature) {
@@ -24606,7 +24703,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return (0, import_fs11.existsSync)(expandExecutable(trimmed));
+    return (0, import_fs12.existsSync)(expandExecutable(trimmed));
   }
   try {
     (0, import_child_process5.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -24728,10 +24825,10 @@ function hasCliArg(args, flag) {
 }
 function ensureEmptyDelegatedMcpConfig(workspace) {
   const baseDir = path18.join(os13.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-  (0, import_fs11.mkdirSync)(baseDir, { recursive: true });
+  (0, import_fs12.mkdirSync)(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`);
-  (0, import_fs11.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+  (0, import_fs12.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
   return filePath;
 }
 function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -24962,6 +25059,7 @@ var DaemonCliManager = class {
               this.deps.removeAgentTracking(key);
               sessionRegistry?.unregisterByInstanceKey(key);
               instanceManager?.removeInstance(key);
+              unregisterMeshCoordinator(key);
               LOG.info("CLI", `\u{1F9F9} Auto-cleaned ${status.status} CLI: ${cliType}`);
               this.deps.onStatusChange();
             }
@@ -25233,6 +25331,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       this.deps.removeAgentTracking(key);
       this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
       this.deps.getInstanceManager()?.removeInstance(key);
+      unregisterMeshCoordinator(key);
       LOG.info("CLI", `\u{1F6D1} Agent stopped: ${adapter.cliType} in ${adapter.workingDir}`);
       this.deps.onStatusChange();
     } else {
@@ -25241,6 +25340,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
         this.deps.getSessionRegistry?.()?.unregisterByInstanceKey(key);
         im.removeInstance(key);
         this.deps.removeAgentTracking(key);
+        unregisterMeshCoordinator(key);
         LOG.warn("CLI", `\u{1F9F9} Force-removed orphan entry: ${key}`);
         this.deps.onStatusChange();
       }
@@ -28946,7 +29046,7 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
 // src/commands/router.ts
 init_mesh_work_queue();
 var import_os3 = require("os");
-var import_path9 = require("path");
+var import_path10 = require("path");
 var fs11 = __toESM(require("fs"));
 var import_node_child_process5 = require("child_process");
 var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
@@ -29094,7 +29194,7 @@ function buildMeshNodeDisplayLabel(node, nodeId, providerPriority) {
   const explicit = readStringValue(node.machineLabel, node.machine_label, node.machineNickname, node.machine_nickname, node.alias);
   if (explicit) return explicit;
   const workspace = readStringValue(node.workspace, node.repoRoot, node.repo_root);
-  const workspaceName = workspace ? (0, import_path9.basename)(workspace) : void 0;
+  const workspaceName = workspace ? (0, import_path10.basename)(workspace) : void 0;
   const host = readStringValue(node.machineName, node.machine_name, node.hostname, node.host, node.daemonId, node.daemon_id, node.machineId, node.machine_id);
   const provider = providerPriority[0] || (Array.isArray(node.providers) ? readStringValue(...node.providers) : void 0);
   const parts = [workspaceName, host, provider].filter(Boolean);
@@ -30200,7 +30300,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
       return match ? { commit: match[1], path: match[2] } : null;
     }).filter((entry) => !!entry);
     for (const gitlink of gitlinks) {
-      const submodulePath = (0, import_path9.resolve)(repoRoot, gitlink.path);
+      const submodulePath = (0, import_path10.resolve)(repoRoot, gitlink.path);
       const entry = {
         path: gitlink.path,
         commit: gitlink.commit,
@@ -30228,7 +30328,7 @@ async function runMeshRefineSubmoduleReachabilityGate(repoRoot, mergedTree, opti
             try {
               const imported = await importCommitFromWorktreeSubmodule(
                 submodulePath,
-                (0, import_path9.resolve)(options.worktreeRoot, gitlink.path),
+                (0, import_path10.resolve)(options.worktreeRoot, gitlink.path),
                 gitlink.commit
               );
               if (imported) {
@@ -30395,17 +30495,17 @@ async function runMeshRefineValidationGate(mesh, workspace) {
     ...extras
   });
   const isPackageManagerValidation = (candidate) => {
-    const command = (0, import_path9.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
+    const command = (0, import_path10.basename)(candidate.command).replace(/\.(?:cmd|exe)$/i, "");
     return ["npm", "pnpm", "yarn", "bun"].includes(command) && candidate.args.some((arg) => arg === "run" || arg === "test" || arg === "exec");
   };
   const dependenciesLikelyMissing = (cwd) => {
-    if (!fs11.existsSync((0, import_path9.join)(cwd, "package.json"))) return false;
-    if (fs11.existsSync((0, import_path9.join)(cwd, "node_modules"))) return false;
-    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs11.existsSync((0, import_path9.join)(cwd, lock)));
+    if (!fs11.existsSync((0, import_path10.join)(cwd, "package.json"))) return false;
+    if (fs11.existsSync((0, import_path10.join)(cwd, "node_modules"))) return false;
+    return ["package-lock.json", "npm-shrinkwrap.json", "pnpm-lock.yaml", "yarn.lock", "bun.lockb", "bun.lock"].some((lock) => fs11.existsSync((0, import_path10.join)(cwd, lock)));
   };
   for (const candidate of selection.bootstrapCommands) {
     const startedAt = Date.now();
-    const cwd = candidate.cwd ? (0, import_path9.resolve)(workspace, candidate.cwd) : workspace;
+    const cwd = candidate.cwd ? (0, import_path10.resolve)(workspace, candidate.cwd) : workspace;
     const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
     try {
       const result = await execFileAsync3(candidate.command, candidate.args, {
@@ -30431,7 +30531,7 @@ async function runMeshRefineValidationGate(mesh, workspace) {
   }
   for (const candidate of selection.commands) {
     const startedAt = Date.now();
-    const cwd = candidate.cwd ? (0, import_path9.resolve)(workspace, candidate.cwd) : workspace;
+    const cwd = candidate.cwd ? (0, import_path10.resolve)(workspace, candidate.cwd) : workspace;
     const timeout = candidate.timeoutMs || REFINE_VALIDATION_TIMEOUT_MS;
     if (selection.bootstrapCommands.length === 0 && isPackageManagerValidation(candidate) && dependenciesLikelyMissing(cwd)) {
       summary.commandsRun.push(commandRecord(candidate, cwd, startedAt, {
@@ -30493,13 +30593,13 @@ function serializeMeshCoordinatorMcpConfig(config, format) {
 }
 function resolveHermesUserHome() {
   const explicitHome = process.env.HERMES_HOME?.trim();
-  return explicitHome || (0, import_path9.join)((0, import_os3.homedir)(), ".hermes");
+  return explicitHome || (0, import_path10.join)((0, import_os3.homedir)(), ".hermes");
 }
 function loadHermesCoordinatorBaseConfig(targetConfigPath) {
   const sourceHome = resolveHermesUserHome();
-  const sourceConfigPath = (0, import_path9.join)(sourceHome, "config.yaml");
+  const sourceConfigPath = (0, import_path10.join)(sourceHome, "config.yaml");
   if (!fs11.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-  if ((0, import_path9.resolve)(sourceConfigPath) === (0, import_path9.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+  if ((0, import_path10.resolve)(sourceConfigPath) === (0, import_path10.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
   const parsed = parseMeshCoordinatorMcpConfig(fs11.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
   const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
   return { config: baseConfig, sourceHome, sourceConfigPath };
@@ -30533,10 +30633,10 @@ function stripHermesCoordinatorTempModelProviderOverrides(config) {
   return sanitized;
 }
 function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-  if ((0, import_path9.resolve)(sourceHome) === (0, import_path9.resolve)(targetHome)) return;
+  if ((0, import_path10.resolve)(sourceHome) === (0, import_path10.resolve)(targetHome)) return;
   for (const fileName of [".env", "auth.json"]) {
-    const sourcePath = (0, import_path9.join)(sourceHome, fileName);
-    const targetPath = (0, import_path9.join)(targetHome, fileName);
+    const sourcePath = (0, import_path10.join)(sourceHome, fileName);
+    const targetPath = (0, import_path10.join)(targetHome, fileName);
     if (!fs11.existsSync(sourcePath)) continue;
     try {
       fs11.copyFileSync(sourcePath, targetPath);
@@ -30918,7 +31018,7 @@ var DaemonCommandRouter = class {
     }
     const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
     const normalizePath = (value) => {
-      const resolved = (0, import_path9.resolve)(value);
+      const resolved = (0, import_path10.resolve)(value);
       try {
         return fs11.realpathSync(resolved);
       } catch {
@@ -33334,11 +33434,15 @@ ${block2}`);
               return { success: false, error: cliCmdLaunch?.error || "Failed to launch CLI session" };
             }
             LOG.info("MeshCoordinator", `Launched ${cliType} coordinator (cli_command) for mesh ${meshId}`);
+            const cliCmdSessionId = cliCmdLaunch.sessionId || cliCmdLaunch.id;
+            if (cliCmdSessionId) {
+              registerMeshCoordinator({ meshId, sessionId: cliCmdSessionId, workspace, startedAt: Date.now() });
+            }
             try {
               const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
               appendLedgerEntry2(meshId, {
                 kind: "coordinator_started",
-                sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+                sessionId: cliCmdSessionId,
                 providerType: cliType,
                 payload: { workspace }
               });
@@ -33349,7 +33453,7 @@ ${block2}`);
               meshId,
               cliType,
               workspace,
-              sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+              sessionId: cliCmdSessionId,
               mcpRegistered: true
             };
           }
@@ -33379,7 +33483,7 @@ ${block2}`);
               workspace
             };
           }
-          const { existsSync: existsSync28, readFileSync: readFileSync21, writeFileSync: writeFileSync16, copyFileSync: copyFileSync4, mkdirSync: mkdirSync18 } = await import("fs");
+          const { existsSync: existsSync29, readFileSync: readFileSync22, writeFileSync: writeFileSync17, 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;
@@ -33422,14 +33526,14 @@ ${block2}`);
             if (hermesManualFallback) return returnManualFallback(message);
             return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
           }
-          const hadExistingMcpConfig = existsSync28(mcpConfigPath);
+          const hadExistingMcpConfig = existsSync29(mcpConfigPath);
           let existingMcpConfig = hermesBaseConfig?.config || {};
           if (hermesBaseConfig) {
             copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname9(mcpConfigPath));
           }
           if (hadExistingMcpConfig) {
             try {
-              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync21(mcpConfigPath, "utf-8"), configFormat);
+              const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync22(mcpConfigPath, "utf-8"), configFormat);
               const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
               existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
               copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
@@ -33452,7 +33556,7 @@ ${block2}`);
             }
           };
           try {
-            writeFileSync16(mcpConfigPath, serializeMeshCoordinatorMcpConfig(mcpConfig, configFormat), "utf-8");
+            writeFileSync17(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);
@@ -33489,11 +33593,15 @@ ${block2}`);
             return { success: false, error: launchResult?.error || "Failed to launch CLI session" };
           }
           LOG.info("MeshCoordinator", `Launched ${cliType} coordinator for mesh ${meshId} in ${workspace}`);
+          const launchSessionId = launchResult.sessionId || launchResult.id;
+          if (launchSessionId) {
+            registerMeshCoordinator({ meshId, sessionId: launchSessionId, workspace, startedAt: Date.now() });
+          }
           try {
             const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
             appendLedgerEntry2(meshId, {
               kind: "coordinator_started",
-              sessionId: launchResult.sessionId || launchResult.id,
+              sessionId: launchSessionId,
               providerType: cliType,
               payload: { workspace }
             });
@@ -33504,7 +33612,7 @@ ${block2}`);
             meshId,
             cliType,
             workspace,
-            sessionId: launchResult.sessionId || launchResult.id,
+            sessionId: launchSessionId,
             mcpConfigWritten: true
           };
         } catch (e) {
@@ -41704,6 +41812,7 @@ init_config();
 init_mesh_events();
 async function initDaemonComponents(config) {
   installGlobalInterceptor();
+  loadMeshCoordinatorRegistry();
   const appConfig = loadConfig();
   const providerSourceMode = appConfig.providerSourceMode || "normal";
   const disableUpstream = providerSourceMode === "no-upstream";
@@ -42061,7 +42170,9 @@ async function shutdownDaemonComponents(components) {
   getAIExtensions,
   getActiveDirectDispatches,
   getAvailableIdeIds,
+  getCoordinatorForSession,
   getCurrentDaemonLogPath,
+  getDaemonDataDir,
   getDaemonLogDir,
   getDebugRuntimeConfig,
   getGitDiffSummary,
@@ -42113,10 +42224,12 @@ async function shutdownDaemonComponents(components) {
   killIdeProcess,
   launchIDE,
   launchWithCdp,
+  listCoordinatorsForWorkspace,
   listHostedCliRuntimes,
   listMeshes,
   listWorktrees,
   loadConfig,
+  loadMeshCoordinatorRegistry,
   loadMeshRefineConfig,
   loadMeshWorktreeBootstrapConfig,
   loadState,
@@ -42153,6 +42266,7 @@ async function shutdownDaemonComponents(components) {
   readLedgerSlice,
   recordDebugTrace,
   registerExtensionProviders,
+  registerMeshCoordinator,
   removeNode,
   removeWorktree,
   requeueTask,
@@ -42186,6 +42300,7 @@ async function shutdownDaemonComponents(components) {
   summarizeGitStatus,
   syncMeshes,
   triggerMeshQueue,
+  unregisterMeshCoordinator,
   updateConfig,
   updateDirectDispatchStatus,
   updateMesh,