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

package/dist/index.mjs

@@ -429,6 +429,7 @@ var config_exports = {};
 __export(config_exports, {
   generateMachineId: () => generateMachineId,
   getConfigDir: () => getConfigDir,
+  getDaemonDataDir: () => getDaemonDataDir,
   isSetupComplete: () => isSetupComplete,
   isStableMachineId: () => isStableMachineId,
   loadConfig: () => loadConfig,
@@ -541,6 +542,13 @@ function getConfigDir() {
   }
   return dir;
 }
+function getDaemonDataDir() {
+  const dir = join2(getConfigDir(), "daemon");
+  if (!existsSync2(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
 function getConfigPath() {
   return join2(getConfigDir(), "config.json");
 }
@@ -1297,8 +1305,8 @@ __export(mesh_ledger_exports, {
   readLedgerEntries: () => readLedgerEntries,
   readLedgerSlice: () => readLedgerSlice
 });
-import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync3, readFileSync as readFileSync5, statSync as statSync2, renameSync, writeFileSync as writeFileSync3 } from "fs";
-import { join as join7 } from "path";
+import { appendFileSync, existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync6, statSync as statSync2, renameSync, writeFileSync as writeFileSync4 } from "fs";
+import { join as join8 } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import { EventEmitter } from "events";
 function isIntentionalCleanupStopEntry(entry) {
@@ -1307,35 +1315,35 @@ 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 = join7(getConfigDir(), LEDGER_DIR_NAME);
-  if (!existsSync7(dir)) {
+  const dir = join8(getConfigDir(), LEDGER_DIR_NAME);
+  if (!existsSync8(dir)) {
     mkdirSync3(dir, { recursive: true, mode: 448 });
   }
   return dir;
 }
 function getLedgerPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join7(getLedgerDir(), `${safe}.jsonl`);
+  return join8(getLedgerDir(), `${safe}.jsonl`);
 }
 function getRotatedPath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join7(getLedgerDir(), `${safe}.${index}.jsonl`);
+  return join8(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
 function getArchivePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join7(getLedgerDir(), `${safe}.archive.jsonl`);
+  return join8(getLedgerDir(), `${safe}.archive.jsonl`);
 }
 function getRotatedArchivePath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join7(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
+  return join8(getLedgerDir(), `${safe}.archive.${index}.jsonl`);
 }
 function getArchivedCountsPath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
-  return join7(getLedgerDir(), `${safe}.archived-counts.json`);
+  return join8(getLedgerDir(), `${safe}.archived-counts.json`);
 }
 function rotateArchiveFile(meshId, archivePath) {
   let index = 1;
-  while (existsSync7(getRotatedArchivePath(meshId, index))) {
+  while (existsSync8(getRotatedArchivePath(meshId, index))) {
     index++;
     if (index > 5) break;
   }
@@ -1349,9 +1357,9 @@ function rotateArchiveFile(meshId, archivePath) {
 }
 function readArchivedCounts(meshId) {
   const path28 = getArchivedCountsPath(meshId);
-  if (!existsSync7(path28)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
+  if (!existsSync8(path28)) return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   try {
-    return JSON.parse(readFileSync5(path28, "utf-8"));
+    return JSON.parse(readFileSync6(path28, "utf-8"));
   } catch {
     return { taskCompleted: 0, taskFailed: 0, taskStalled: 0, recoveryAttempted: 0, totalArchived: 0, lastArchivedAt: "" };
   }
@@ -1367,7 +1375,7 @@ function updateArchivedCounts(meshId, archived) {
   counts.totalArchived += archived.length;
   counts.lastArchivedAt = (/* @__PURE__ */ new Date()).toISOString();
   try {
-    writeFileSync3(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
+    writeFileSync4(getArchivedCountsPath(meshId), JSON.stringify(counts), { encoding: "utf-8", mode: 384 });
   } catch {
   }
 }
@@ -1390,7 +1398,7 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
 }
 function compactLedger(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!existsSync7(filePath)) return { archivedCount: 0, retainedCount: 0 };
+  if (!existsSync8(filePath)) return { archivedCount: 0, retainedCount: 0 };
   const cutoff = Date.now() - ARCHIVE_TERMINAL_OLDER_THAN_MS;
   const entries = readLedgerEntries(meshId);
   const keep = [];
@@ -1405,7 +1413,7 @@ function compactLedger(meshId) {
   if (archive.length === 0) return { archivedCount: 0, retainedCount: keep.length };
   const archivePath = getArchivePath(meshId);
   try {
-    if (existsSync7(archivePath) && statSync2(archivePath).size > 50 * 1024 * 1024) {
+    if (existsSync8(archivePath) && statSync2(archivePath).size > 50 * 1024 * 1024) {
       rotateArchiveFile(meshId, archivePath);
     }
     const archiveLines = archive.map((e) => JSON.stringify(e)).join("\n") + "\n";
@@ -1418,7 +1426,7 @@ function compactLedger(meshId) {
   }
   try {
     const keepLines = keep.length ? keep.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
-    writeFileSync3(filePath, keepLines, { encoding: "utf-8", mode: 384 });
+    writeFileSync4(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}
@@ -1550,7 +1558,7 @@ function appendLedgerEntry(meshId, partial) {
     ...partial
   };
   const filePath = getLedgerPath(meshId);
-  if (existsSync7(filePath)) {
+  if (existsSync8(filePath)) {
     try {
       const stat2 = statSync2(filePath);
       if (stat2.size >= MAX_FILE_SIZE_BYTES) {
@@ -1621,10 +1629,10 @@ function appendRemoteLedgerEntries(meshId, entries) {
 }
 function readLedgerFile(meshId) {
   const filePath = getLedgerPath(meshId);
-  if (!existsSync7(filePath)) return [];
+  if (!existsSync8(filePath)) return [];
   let content;
   try {
-    content = readFileSync5(filePath, "utf-8");
+    content = readFileSync6(filePath, "utf-8");
   } catch {
     return [];
   }
@@ -1825,7 +1833,7 @@ function getSessionRecoveryContext(meshId, opts) {
 }
 function rotateLedgerFile(meshId, currentPath) {
   let index = 1;
-  while (existsSync7(getRotatedPath(meshId, index))) {
+  while (existsSync8(getRotatedPath(meshId, index))) {
     index++;
     if (index > 10) break;
   }
@@ -1862,8 +1870,8 @@ var init_mesh_ledger = __esm({
 });
 
 // src/mesh/beads-db.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6, statSync as statSync3 } from "fs";
-import { dirname as dirname2, join as join8 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync7, statSync as statSync3 } from "fs";
+import { dirname as dirname2, join as join9 } from "path";
 import { createRequire } from "module";
 function loadDatabaseCtor() {
   if (DatabaseCtor) return DatabaseCtor;
@@ -1875,7 +1883,7 @@ function safeMeshId(meshId) {
   return meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
 }
 function legacyQueuePath(meshId) {
-  return join8(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
+  return join9(getLedgerDir(), `${safeMeshId(meshId)}.queue.json`);
 }
 var DatabaseCtor, BeadsDB;
 var init_beads_db = __esm({
@@ -1894,7 +1902,7 @@ var init_beads_db = __esm({
       // 50 MB
       constructor(dbPath) {
         const dir = dirname2(dbPath);
-        if (!existsSync8(dir)) mkdirSync4(dir, { recursive: true });
+        if (!existsSync9(dir)) mkdirSync4(dir, { recursive: true });
         this.dbPath = dbPath;
         this.db = new (loadDatabaseCtor())(dbPath);
         this.db.pragma("journal_mode = WAL");
@@ -1905,7 +1913,7 @@ var init_beads_db = __esm({
       }
       static getInstance() {
         if (!this.instance) {
-          this.instance = new _BeadsDB(join8(getLedgerDir(), "beads.db"));
+          this.instance = new _BeadsDB(join9(getLedgerDir(), "beads.db"));
         }
         return this.instance;
       }
@@ -1985,7 +1993,7 @@ var init_beads_db = __esm({
         this.walWriteCounter = 0;
         try {
           const walPath = `${this.dbPath}-wal`;
-          if (!existsSync8(walPath)) return;
+          if (!existsSync9(walPath)) return;
           const size = statSync3(walPath).size;
           if (size < _BeadsDB.WAL_MAX_BYTES) return;
           process.stderr.write(
@@ -2002,9 +2010,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 (!existsSync8(path28)) return;
+        if (!existsSync9(path28)) return;
         try {
-          const entries = JSON.parse(readFileSync6(path28, "utf-8"));
+          const entries = JSON.parse(readFileSync7(path28, "utf-8"));
           if (!Array.isArray(entries)) return;
           const insert = this.db.prepare(`
                 INSERT OR REPLACE INTO mesh_queue (
@@ -2501,7 +2509,7 @@ var init_mesh_work_queue = __esm({
 import { exec } from "child_process";
 import * as os2 from "os";
 import * as path8 from "path";
-import { existsSync as existsSync9 } from "fs";
+import { existsSync as existsSync10 } from "fs";
 function parseVersion(raw) {
   const match = raw.match(/v?(\d+\.\d+(?:\.\d+)?(?:-[a-zA-Z0-9.]+)?)/);
   return match ? match[1] : raw.split("\n")[0].slice(0, 100);
@@ -2525,7 +2533,7 @@ function resolveCommandPath(command) {
   if (isExplicitCommandPath(trimmed)) {
     const expanded = expandHome(trimmed);
     const candidate = path8.isAbsolute(expanded) ? expanded : path8.resolve(expanded);
-    return existsSync9(candidate) ? candidate : null;
+    return existsSync10(candidate) ? candidate : null;
   }
   return null;
 }
@@ -2912,8 +2920,8 @@ __export(mesh_events_exports, {
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
-import { appendFileSync as appendFileSync2, existsSync as existsSync11, readFileSync as readFileSync7, renameSync as renameSync3, statSync as statSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync4 } from "fs";
-import { join as join11 } from "path";
+import { appendFileSync as appendFileSync2, existsSync as existsSync12, readFileSync as readFileSync8, renameSync as renameSync3, statSync as statSync5, unlinkSync as unlinkSync2, writeFileSync as writeFileSync5 } from "fs";
+import { join as join12 } from "path";
 function getCachedMeshByWorkspace(workspace) {
   const now = Date.now();
   const cached = meshByWorkspaceCache.get(workspace);
@@ -2976,18 +2984,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 join11(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
+    return join12(getLedgerDir(), `${safe}-${safeDaemon}.pending-events.jsonl`);
   }
-  return join11(getLedgerDir(), `${safe}.pending-events.jsonl`);
+  return join12(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 (!existsSync11(path28)) continue;
+    if (!existsSync12(path28)) continue;
     try {
-      const raw = readFileSync7(path28, "utf-8");
+      const raw = readFileSync8(path28, "utf-8");
       const parsed = raw.split("\n").filter(Boolean).flatMap((line) => {
         try {
           return [JSON.parse(line)];
@@ -3066,11 +3074,11 @@ function reconcilePendingMeshCoordinatorEvents(meshId, events) {
 }
 function trimPendingEventsIfNeeded(path28) {
   try {
-    if (!existsSync11(path28)) return;
+    if (!existsSync12(path28)) return;
     if (statSync5(path28).size <= MAX_PENDING_EVENTS_BYTES) return;
-    const lines = readFileSync7(path28, "utf-8").split("\n").filter(Boolean);
+    const lines = readFileSync8(path28, "utf-8").split("\n").filter(Boolean);
     if (lines.length <= MAX_PENDING_EVENTS_KEEP) return;
-    writeFileSync4(path28, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
+    writeFileSync5(path28, lines.slice(-MAX_PENDING_EVENTS_KEEP).join("\n") + "\n", "utf-8");
   } catch {
   }
 }
@@ -3101,7 +3109,7 @@ function atomicDrainFile(path28) {
     return null;
   }
   try {
-    const content = readFileSync7(tmpPath, "utf-8");
+    const content = readFileSync8(tmpPath, "utf-8");
     try {
       unlinkSync2(tmpPath);
     } catch {
@@ -3143,7 +3151,7 @@ function clearPendingMeshCoordinatorEvents(meshId, coordinatorDaemonId) {
   if (!meshId) return;
   const paths = coordinatorDaemonId ? [getPendingEventsPath(meshId, coordinatorDaemonId), getPendingEventsPath(meshId)] : [getPendingEventsPath(meshId)];
   for (const path28 of paths) {
-    if (existsSync11(path28)) try {
+    if (existsSync12(path28)) try {
       unlinkSync2(path28);
     } catch {
     }
@@ -5188,6 +5196,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;
@@ -5292,7 +5309,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;
@@ -5642,13 +5661,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;
@@ -6775,19 +6800,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";
@@ -7700,7 +7718,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)) {
@@ -9545,9 +9564,58 @@ function getSavedProviderSessions(state, filters) {
 init_mesh_config();
 init_coordinator_prompt();
 
-// src/mesh/refine-config.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
+// src/mesh/coordinator-registry.ts
+init_config();
 import { join as join5 } from "path";
+import { existsSync as existsSync5, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+var _registry = /* @__PURE__ */ new Map();
+function getRegistryPath() {
+  return join5(getDaemonDataDir(), "mesh-coordinators.json");
+}
+function loadMeshCoordinatorRegistry() {
+  const path28 = getRegistryPath();
+  if (!existsSync5(path28)) return;
+  try {
+    const raw = JSON.parse(readFileSync3(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 {
+    writeFileSync3(
+      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
+import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
+import { join as join6 } from "path";
 import * as yaml from "js-yaml";
 var MESH_REFINE_VALIDATION_CATEGORIES = ["typecheck", "test", "lint", "build"];
 var MESH_REFINE_CONFIG_LOCATIONS = [
@@ -9730,10 +9798,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 = join5(workspace, relative3);
-    if (!existsSync5(configPath)) continue;
+    const configPath = join6(workspace, relative3);
+    if (!existsSync6(configPath)) continue;
     try {
-      const parsed = parseConfigText(configPath, readFileSync3(configPath, "utf-8"));
+      const parsed = parseConfigText(configPath, readFileSync4(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 };
@@ -9749,7 +9817,7 @@ function loadMeshRefineConfig(mesh, workspace) {
 }
 function readPackageScripts(workspace) {
   try {
-    const parsed = JSON.parse(readFileSync3(join5(workspace, "package.json"), "utf-8"));
+    const parsed = JSON.parse(readFileSync4(join6(workspace, "package.json"), "utf-8"));
     return isRecord(parsed?.scripts) ? parsed.scripts : {};
   } catch {
     return {};
@@ -9822,8 +9890,8 @@ function resolveMeshRefineValidationPlan(mesh, workspace) {
 }
 
 // src/mesh/worktree-bootstrap-config.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4 } from "fs";
-import { join as join6, resolve as pathResolve } from "path";
+import { existsSync as existsSync7, readFileSync as readFileSync5 } from "fs";
+import { join as join7, resolve as pathResolve } from "path";
 import { execFile as execFile3 } from "child_process";
 import { promisify as promisify3 } from "util";
 import * as yaml2 from "js-yaml";
@@ -9913,10 +9981,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 = join6(workspace, relative3);
-    if (!existsSync6(configPath)) continue;
+    const configPath = join7(workspace, relative3);
+    if (!existsSync7(configPath)) continue;
     try {
-      const parsed = parseConfigText2(configPath, readFileSync4(configPath, "utf-8"));
+      const parsed = parseConfigText2(configPath, readFileSync5(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 };
@@ -9950,10 +10018,10 @@ async function runMeshWorktreeBootstrap(mesh, workspace) {
     staleInputs: loaded.config.staleInputs
   };
   const staleInputPaths = loaded.config.staleInputs ?? [];
-  const initiallyAbsent = staleInputPaths.filter((p) => !existsSync6(join6(workspace, p)));
+  const initiallyAbsent = staleInputPaths.filter((p) => !existsSync7(join7(workspace, p)));
   for (const command of validation.commands) {
     if (initiallyAbsent.length > 0) {
-      const appearedNow = initiallyAbsent.filter((p) => existsSync6(join6(workspace, p)));
+      const appearedNow = initiallyAbsent.filter((p) => existsSync7(join7(workspace, p)));
       if (appearedNow.length > 0) {
         state.status = "stale";
         state.completedAt = (/* @__PURE__ */ new Date()).toISOString();
@@ -11017,8 +11085,8 @@ var P2pRelayFailureError = class extends Error {
 
 // src/config/state-store.ts
 init_config();
-import { existsSync as existsSync12, readFileSync as readFileSync8, writeFileSync as writeFileSync5 } from "fs";
-import { join as join12 } from "path";
+import { existsSync as existsSync13, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { join as join13 } from "path";
 var DEFAULT_STATE = {
   recentActivity: [],
   savedProviderSessions: [],
@@ -11031,7 +11099,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return join12(getConfigDir(), "state.json");
+  return join13(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -11067,11 +11135,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!existsSync12(statePath)) {
+  if (!existsSync13(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = readFileSync8(statePath, "utf-8");
+    const raw = readFileSync9(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -11080,7 +11148,7 @@ function loadState() {
 function saveState(state) {
   const statePath = getStatePath();
   const normalized = normalizeState(state);
-  writeFileSync5(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  writeFileSync6(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function resetState() {
   saveState({ ...DEFAULT_STATE });
@@ -11089,7 +11157,7 @@ function resetState() {
 // src/detection/ide-detector.ts
 import { exec as exec2 } from "child_process";
 import { promisify as promisify4 } from "util";
-import { existsSync as existsSync13, statSync as statSync6 } from "fs";
+import { existsSync as existsSync14, statSync as statSync6 } from "fs";
 import { platform as platform2, homedir as homedir5 } from "os";
 import * as path10 from "path";
 var execAsync2 = promisify4(exec2);
@@ -11114,7 +11182,7 @@ function findCliCommand(command) {
   if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
     const candidate = trimmed.startsWith("~") ? path10.join(homedir5(), trimmed.slice(1)) : trimmed;
     const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
-    return existsSync13(resolved) ? resolved : null;
+    return existsSync14(resolved) ? resolved : null;
   }
   const isWin = platform2() === "win32";
   const paths = (process.env.PATH || "").split(isWin ? ";" : ":");
@@ -11124,7 +11192,7 @@ function findCliCommand(command) {
     for (const ext of exes) {
       const fullPath = path10.join(p, trimmed + ext);
       try {
-        if (existsSync13(fullPath)) {
+        if (existsSync14(fullPath)) {
           const stat2 = statSync6(fullPath);
           if (stat2.isFile() && (isWin || stat2.mode & 73)) {
             return fullPath;
@@ -11154,9 +11222,9 @@ function checkPathExists(paths) {
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if (existsSync13(resolved)) return resolved;
+      if (existsSync14(resolved)) return resolved;
     } else {
-      if (existsSync13(normalized)) return normalized;
+      if (existsSync14(normalized)) return normalized;
     }
   }
   return null;
@@ -11170,7 +11238,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if (existsSync13(bundledCli)) resolvedCli = bundledCli;
+      if (existsSync14(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname9 } = await import("path");
@@ -11183,7 +11251,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if (existsSync13(c)) {
+        if (existsSync14(c)) {
           resolvedCli = c;
           break;
         }
@@ -16920,7 +16988,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);
@@ -16931,7 +16999,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,
@@ -16955,6 +17026,7 @@ function buildIdeWorkspaceSession(state, cdpManagers, options) {
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated,
     settings: state.settings,
+    ...coordinator && { coordinator },
     ...meshQueueStats && { meshQueueStats }
   };
 }
@@ -16968,7 +17040,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,
@@ -16992,6 +17067,7 @@ function buildExtensionAgentSession(parent, ext, options) {
     errorReason: ext.errorReason,
     lastUpdated: ext.lastUpdated,
     settings: ext.settings,
+    ...coordinator && { coordinator },
     ...meshQueueStats && { meshQueueStats }
   };
 }
@@ -17021,7 +17097,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,
@@ -17061,6 +17140,7 @@ function buildCliSession(state, options) {
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated,
     settings: state.settings,
+    ...coordinator && { coordinator },
     ...meshQueueStats && { meshQueueStats }
   };
 }
@@ -17074,7 +17154,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,
@@ -17097,6 +17180,7 @@ function buildAcpSession(state, options) {
     errorReason: state.errorReason,
     lastUpdated: state.lastUpdated,
     settings: state.settings,
+    ...coordinator && { coordinator },
     ...meshQueueStats && { meshQueueStats }
   };
 }
@@ -17106,7 +17190,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));
@@ -21626,7 +21710,7 @@ init_config();
 import * as os13 from "os";
 import * as path18 from "path";
 import * as crypto4 from "crypto";
-import { existsSync as existsSync17, mkdirSync as mkdirSync10, writeFileSync as writeFileSync10 } from "fs";
+import { existsSync as existsSync18, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11 } from "fs";
 import { execFileSync } from "child_process";
 import chalk from "chalk";
 
@@ -22434,10 +22518,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) {
@@ -24340,7 +24431,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return existsSync17(expandExecutable(trimmed));
+    return existsSync18(expandExecutable(trimmed));
   }
   try {
     execFileSync(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -24465,7 +24556,7 @@ function ensureEmptyDelegatedMcpConfig(workspace) {
   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`);
-  writeFileSync10(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+  writeFileSync11(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
   return filePath;
 }
 function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -24696,6 +24787,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();
             }
@@ -24967,6 +25059,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 {
@@ -24975,6 +25068,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();
       }
@@ -27754,7 +27848,7 @@ import * as yaml3 from "js-yaml";
 // src/commands/mesh-coordinator.ts
 import { createHash as createHash4 } from "crypto";
 import * as os17 from "os";
-import { isAbsolute as isAbsolute11, join as join23, resolve as resolve14 } from "path";
+import { isAbsolute as isAbsolute11, join as join24, resolve as resolve14 } from "path";
 var DEFAULT_SERVER_NAME = "adhdev-mesh";
 var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev";
 var HERMES_CLI_TYPE = "hermes-cli";
@@ -27776,7 +27870,7 @@ function resolveHermesMeshCoordinatorSetup(options) {
       reason: "Could not resolve the ADHDev MCP server entrypoint and a Node runtime with WebSocket support for daemon IPC mode"
     };
   }
-  const configPath = join23(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
+  const configPath = join24(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
   if (!configPath.trim()) {
     return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace);
   }
@@ -27896,14 +27990,14 @@ function resolveHermesCoordinatorHome(meshId, workspace) {
   const key = `${meshId || "mesh"}
 ${resolve14(workspace || os17.tmpdir())}`;
   const hash = createHash4("sha256").update(key).digest("hex").slice(0, 16);
-  return join23(os17.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
+  return join24(os17.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
   const trimmed = configPath.trim();
   if (trimmed === "~") return os17.homedir();
-  if (trimmed.startsWith("~/")) return join23(os17.homedir(), trimmed.slice(2));
+  if (trimmed.startsWith("~/")) return join24(os17.homedir(), trimmed.slice(2));
   if (isAbsolute11(trimmed)) return trimmed;
-  return join23(workspace, trimmed);
+  return join24(workspace, trimmed);
 }
 function resolveAdhdevMcpServerLaunch(options) {
   const command = resolveAdhdevCommand(options.adhdevMcpCommand);
@@ -27938,7 +28032,7 @@ init_mesh_host_ownership();
 
 // src/mesh/preview-freshness.ts
 import { execFileSync as execFileSync2 } from "child_process";
-import { existsSync as existsSync20, readFileSync as readFileSync13 } from "fs";
+import { existsSync as existsSync21, readFileSync as readFileSync14 } from "fs";
 import { resolve as resolve15 } from "path";
 var PREVIEW_DEPLOY_RECORD = ".adhdev/preview-deploy.json";
 function runGit2(repoRoot, args) {
@@ -27955,9 +28049,9 @@ function runGit2(repoRoot, args) {
 }
 function readRecord3(repoRoot) {
   const path28 = resolve15(repoRoot, PREVIEW_DEPLOY_RECORD);
-  if (!existsSync20(path28)) return null;
+  if (!existsSync21(path28)) return null;
   try {
-    const parsed = JSON.parse(readFileSync13(path28, "utf8"));
+    const parsed = JSON.parse(readFileSync14(path28, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -33068,11 +33162,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 }
               });
@@ -33083,7 +33181,7 @@ ${block2}`);
               meshId,
               cliType,
               workspace,
-              sessionId: cliCmdLaunch.sessionId || cliCmdLaunch.id,
+              sessionId: cliCmdSessionId,
               mcpRegistered: true
             };
           }
@@ -33113,7 +33211,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;
@@ -33156,14 +33254,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");
@@ -33186,7 +33284,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);
@@ -33223,11 +33321,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 }
             });
@@ -33238,7 +33340,7 @@ ${block2}`);
             meshId,
             cliType,
             workspace,
-            sessionId: launchResult.sessionId || launchResult.id,
+            sessionId: launchSessionId,
             mcpConfigWritten: true
           };
         } catch (e) {
@@ -41443,6 +41545,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";
@@ -41799,7 +41902,9 @@ export {
   getAIExtensions,
   getActiveDirectDispatches,
   getAvailableIdeIds,
+  getCoordinatorForSession,
   getCurrentDaemonLogPath,
+  getDaemonDataDir,
   getDaemonLogDir,
   getDebugRuntimeConfig,
   getGitDiffSummary,
@@ -41851,10 +41956,12 @@ export {
   killIdeProcess,
   launchIDE,
   launchWithCdp,
+  listCoordinatorsForWorkspace,
   listHostedCliRuntimes,
   listMeshes,
   listWorktrees,
   loadConfig,
+  loadMeshCoordinatorRegistry,
   loadMeshRefineConfig,
   loadMeshWorktreeBootstrapConfig,
   loadState,
@@ -41891,6 +41998,7 @@ export {
   readLedgerSlice,
   recordDebugTrace,
   registerExtensionProviders,
+  registerMeshCoordinator,
   removeNode,
   removeWorktree,
   requeueTask,
@@ -41924,6 +42032,7 @@ export {
   summarizeGitStatus,
   syncMeshes,
   triggerMeshQueue,
+  unregisterMeshCoordinator,
   updateConfig,
   updateDirectDispatchStatus,
   updateMesh,