@adhdev/daemon-standalone 0.9.82-rc.22 → 0.9.82-rc.24

package/dist/index.js

@@ -23490,6 +23490,36 @@ Follow these recovery rules:
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
       return (0, import_path4.join)(getLedgerDir(), `${safe}.queue.json`);
     }
+    function getLockPath(meshId) {
+      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+      return (0, import_path4.join)(getLedgerDir(), `${safe}.queue.lock`);
+    }
+    function withQueueLock(meshId, fn) {
+      const lockPath = getLockPath(meshId);
+      let fd = -1;
+      for (let i = 0; i < 10; i++) {
+        try {
+          fd = (0, import_fs4.openSync)(lockPath, "wx");
+          break;
+        } catch {
+          const deadline = Date.now() + 30;
+          while (Date.now() < deadline) {
+          }
+        }
+      }
+      try {
+        return fn();
+      } finally {
+        if (fd !== -1) try {
+          (0, import_fs4.closeSync)(fd);
+        } catch {
+        }
+        try {
+          (0, import_fs4.unlinkSync)(lockPath);
+        } catch {
+        }
+      }
+    }
     function readQueue(meshId) {
       const path28 = getQueuePath(meshId);
       if (!(0, import_fs4.existsSync)(path28)) return [];
@@ -23505,20 +23535,22 @@ Follow these recovery rules:
       (0, import_fs4.writeFileSync)(path28, JSON.stringify(queue, null, 2), "utf-8");
     }
     function enqueueTask(meshId, message, opts) {
-      const queue = readQueue(meshId);
-      const entry = {
-        id: (0, import_crypto5.randomUUID)(),
-        meshId,
-        message,
-        status: "pending",
-        targetNodeId: opts?.targetNodeId,
-        targetSessionId: opts?.targetSessionId,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      queue.push(entry);
-      writeQueue(meshId, queue);
-      return entry;
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const entry = {
+          id: (0, import_crypto5.randomUUID)(),
+          meshId,
+          message,
+          status: "pending",
+          targetNodeId: opts?.targetNodeId,
+          targetSessionId: opts?.targetSessionId,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        queue.push(entry);
+        writeQueue(meshId, queue);
+        return entry;
+      });
     }
     function getQueue(meshId, opts) {
       let queue = readQueue(meshId);
@@ -23529,100 +23561,109 @@ Follow these recovery rules:
       return queue;
     }
     function claimNextTask(meshId, nodeId, sessionId) {
-      const queue = readQueue(meshId);
-      const hasActiveAssignment = queue.some((q) => q.status === "assigned" && (q.assignedSessionId === sessionId || q.assignedNodeId === nodeId));
-      if (hasActiveAssignment) return null;
-      let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetSessionId === sessionId);
-      if (targetIdx === -1) {
-        targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
-      }
-      if (targetIdx === -1) {
-        targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
-      }
-      if (targetIdx === -1) return null;
-      const entry = queue[targetIdx];
-      entry.status = "assigned";
-      entry.assignedNodeId = nodeId;
-      entry.assignedSessionId = sessionId;
-      entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-      entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      writeQueue(meshId, queue);
-      return entry;
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const hasActiveAssignment = queue.some((q) => q.status === "assigned" && (q.assignedSessionId === sessionId || q.assignedNodeId === nodeId));
+        if (hasActiveAssignment) return null;
+        let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetSessionId === sessionId);
+        if (targetIdx === -1) {
+          targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
+        }
+        if (targetIdx === -1) {
+          targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
+        }
+        if (targetIdx === -1) return null;
+        const entry = queue[targetIdx];
+        entry.status = "assigned";
+        entry.assignedNodeId = nodeId;
+        entry.assignedSessionId = sessionId;
+        entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+        entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        writeQueue(meshId, queue);
+        return entry;
+      });
     }
     function updateTaskStatus(meshId, taskId, status) {
-      const queue = readQueue(meshId);
-      const idx = queue.findIndex((q) => q.id === taskId);
-      if (idx === -1) return null;
-      queue[idx].status = status;
-      queue[idx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      writeQueue(meshId, queue);
-      return queue[idx];
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const idx = queue.findIndex((q) => q.id === taskId);
+        if (idx === -1) return null;
+        queue[idx].status = status;
+        queue[idx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        writeQueue(meshId, queue);
+        return queue[idx];
+      });
     }
     function recordTaskAutoLaunch(meshId, taskId, autoLaunch) {
-      const queue = readQueue(meshId);
-      const idx = queue.findIndex((q) => q.id === taskId);
-      if (idx === -1) return null;
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      queue[idx].autoLaunch = {
-        ...autoLaunch,
-        updatedAt: now
-      };
-      queue[idx].updatedAt = now;
-      writeQueue(meshId, queue);
-      return queue[idx];
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const idx = queue.findIndex((q) => q.id === taskId);
+        if (idx === -1) return null;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        queue[idx].autoLaunch = { ...autoLaunch, updatedAt: now };
+        queue[idx].updatedAt = now;
+        writeQueue(meshId, queue);
+        return queue[idx];
+      });
     }
     function cancelTask(meshId, taskId, opts) {
-      const queue = readQueue(meshId);
-      const idx = queue.findIndex((q) => q.id === taskId);
-      if (idx === -1) return null;
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      queue[idx].status = "cancelled";
-      queue[idx].updatedAt = now;
-      queue[idx].cancelledAt = now;
-      if (opts?.reason) queue[idx].cancelReason = opts.reason;
-      writeQueue(meshId, queue);
-      return queue[idx];
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const idx = queue.findIndex((q) => q.id === taskId);
+        if (idx === -1) return null;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        queue[idx].status = "cancelled";
+        queue[idx].updatedAt = now;
+        queue[idx].cancelledAt = now;
+        if (opts?.reason) queue[idx].cancelReason = opts.reason;
+        writeQueue(meshId, queue);
+        return queue[idx];
+      });
     }
     function requeueTask(meshId, taskId, opts) {
-      const queue = readQueue(meshId);
-      const idx = queue.findIndex((q) => q.id === taskId);
-      if (idx === -1) return null;
-      const entry = queue[idx];
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      entry.status = "pending";
-      delete entry.assignedNodeId;
-      delete entry.assignedSessionId;
-      delete entry.cancelledAt;
-      delete entry.cancelReason;
-      if (opts?.clearTargetNode) delete entry.targetNodeId;
-      if (typeof opts?.targetNodeId === "string") entry.targetNodeId = opts.targetNodeId;
-      if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
-      if (typeof opts?.targetSessionId === "string") entry.targetSessionId = opts.targetSessionId;
-      entry.updatedAt = now;
-      entry.requeuedAt = now;
-      entry.requeueCount = (entry.requeueCount || 0) + 1;
-      if (opts?.reason) entry.requeueReason = opts.reason;
-      writeQueue(meshId, queue);
-      return entry;
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const idx = queue.findIndex((q) => q.id === taskId);
+        if (idx === -1) return null;
+        const entry = queue[idx];
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        entry.status = "pending";
+        delete entry.assignedNodeId;
+        delete entry.assignedSessionId;
+        delete entry.cancelledAt;
+        delete entry.cancelReason;
+        if (opts?.clearTargetNode) delete entry.targetNodeId;
+        if (typeof opts?.targetNodeId === "string") entry.targetNodeId = opts.targetNodeId;
+        if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
+        if (typeof opts?.targetSessionId === "string") entry.targetSessionId = opts.targetSessionId;
+        entry.updatedAt = now;
+        entry.requeuedAt = now;
+        entry.requeueCount = (entry.requeueCount || 0) + 1;
+        if (opts?.reason) entry.requeueReason = opts.reason;
+        writeQueue(meshId, queue);
+        return entry;
+      });
     }
     function updateSessionTaskStatus(meshId, sessionId, status) {
-      const queue = readQueue(meshId);
-      let bestIdx = -1;
-      let bestTime = 0;
-      for (let i = queue.length - 1; i >= 0; i--) {
-        if (queue[i].assignedSessionId === sessionId && queue[i].status === "assigned") {
-          const time3 = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
-          if (time3 > bestTime) {
-            bestTime = time3;
-            bestIdx = i;
-          }
-        }
-      }
-      if (bestIdx === -1) return null;
-      queue[bestIdx].status = status;
-      queue[bestIdx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      writeQueue(meshId, queue);
-      return queue[bestIdx];
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        let bestIdx = -1;
+        let bestTime = 0;
+        for (let i = queue.length - 1; i >= 0; i--) {
+          if (queue[i].assignedSessionId === sessionId && queue[i].status === "assigned") {
+            const time3 = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
+            if (time3 > bestTime) {
+              bestTime = time3;
+              bestIdx = i;
+            }
+          }
+        }
+        if (bestIdx === -1) return null;
+        queue[bestIdx].status = status;
+        queue[bestIdx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        writeQueue(meshId, queue);
+        return queue[bestIdx];
+      });
     }
     function getMeshQueueStats(meshId) {
       const queue = readQueue(meshId);
@@ -24051,21 +24092,70 @@ Follow these recovery rules:
       triggerMeshQueue: () => triggerMeshQueue,
       tryAssignQueueTask: () => tryAssignQueueTask
     });
+    function sweepExpiredRemoteIdleSessions() {
+      const now = Date.now();
+      for (const [key, session] of remoteIdleSessions) {
+        if (session.expiresAt <= now) remoteIdleSessions.delete(key);
+      }
+    }
+    function getPendingEventsPath(meshId) {
+      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+      return (0, import_path5.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
+    }
     function queuePendingMeshCoordinatorEvent(event) {
-      if (pendingMeshCoordinatorEvents.length >= MAX_PENDING_EVENTS) {
+      try {
+        (0, import_fs6.appendFileSync)(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
+        return true;
+      } catch (e) {
+        LOG2.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
         return false;
       }
-      pendingMeshCoordinatorEvents.push(event);
-      return true;
     }
-    function drainPendingMeshCoordinatorEvents() {
-      return pendingMeshCoordinatorEvents.splice(0);
+    function drainPendingMeshCoordinatorEvents(meshId) {
+      if (!meshId) return [];
+      const path28 = getPendingEventsPath(meshId);
+      if (!(0, import_fs6.existsSync)(path28)) return [];
+      try {
+        const raw = (0, import_fs6.readFileSync)(path28, "utf-8");
+        try {
+          (0, import_fs6.unlinkSync)(path28);
+        } catch {
+        }
+        return raw.split("\n").filter(Boolean).flatMap((line) => {
+          try {
+            return [JSON.parse(line)];
+          } catch {
+            return [];
+          }
+        });
+      } catch {
+        return [];
+      }
     }
-    function getPendingMeshCoordinatorEvents() {
-      return pendingMeshCoordinatorEvents.slice();
+    function getPendingMeshCoordinatorEvents(meshId) {
+      if (!meshId) return [];
+      const path28 = getPendingEventsPath(meshId);
+      if (!(0, import_fs6.existsSync)(path28)) return [];
+      try {
+        const raw = (0, import_fs6.readFileSync)(path28, "utf-8");
+        return raw.split("\n").filter(Boolean).flatMap((line) => {
+          try {
+            return [JSON.parse(line)];
+          } catch {
+            return [];
+          }
+        });
+      } catch {
+        return [];
+      }
     }
-    function clearPendingMeshCoordinatorEvents() {
-      pendingMeshCoordinatorEvents.splice(0);
+    function clearPendingMeshCoordinatorEvents(meshId) {
+      if (!meshId) return;
+      const path28 = getPendingEventsPath(meshId);
+      if ((0, import_fs6.existsSync)(path28)) try {
+        (0, import_fs6.unlinkSync)(path28);
+      } catch {
+      }
     }
     function readNonEmptyString(value) {
       return typeof value === "string" && value.trim() ? value.trim() : "";
@@ -24129,7 +24219,16 @@ Follow these recovery rules:
             message: task.message
           }).catch((e) => {
             LOG2.error("MeshQueue", `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
-            updateTaskStatus(meshId, task.id, "failed");
+            updateTaskStatus(meshId, task.id, "pending");
+            try {
+              appendLedgerEntry(meshId, {
+                kind: "dispatch_failed",
+                nodeId,
+                sessionId,
+                payload: { taskId: task.id, error: e?.message, retryable: true }
+              });
+            } catch {
+            }
           });
           return true;
         }
@@ -24472,9 +24571,9 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           const completedTask = updateSessionTaskStatus(args.meshId, sessionId, "completed");
           completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
           if (nodeId && providerType) {
-            setTimeout(() => {
+            setImmediate(() => {
               tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-            }, 500);
+            });
           }
         }
       } else if (args.event === "agent:ready") {
@@ -24512,13 +24611,17 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           }
         }
         if (sessionId && nodeId && providerType) {
-          remoteIdleSessions.set(`${nodeId}:${sessionId}`, { nodeId, sessionId, providerType });
-          setTimeout(() => {
+          sweepExpiredRemoteIdleSessions();
+          remoteIdleSessions.set(`${nodeId}:${sessionId}`, {
+            nodeId,
+            sessionId,
+            providerType,
+            expiresAt: Date.now() + REMOTE_IDLE_SESSION_TTL_MS
+          });
+          setImmediate(() => {
             const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-            if (assigned) {
-              remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
-            }
-          }, 500);
+            if (assigned) remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+          });
         }
       } else if (args.event === "agent:generating_started") {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
@@ -24721,9 +24824,10 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         });
       });
     }
+    var import_fs6;
+    var import_path5;
+    var REMOTE_IDLE_SESSION_TTL_MS;
     var remoteIdleSessions;
-    var MAX_PENDING_EVENTS;
-    var pendingMeshCoordinatorEvents;
     var MESH_COORDINATOR_EVENTS;
     var EVENT_TO_LEDGER_KIND;
     var INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
@@ -24733,15 +24837,16 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
     var init_mesh_events = __esm2({
       "src/mesh/mesh-events.ts"() {
         "use strict";
+        import_fs6 = require("fs");
+        import_path5 = require("path");
         init_config();
         init_mesh_config();
         init_cli_detector();
         init_logger();
         init_mesh_ledger();
         init_mesh_work_queue();
+        REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
         remoteIdleSessions = /* @__PURE__ */ new Map();
-        MAX_PENDING_EVENTS = 50;
-        pendingMeshCoordinatorEvents = [];
         MESH_COORDINATOR_EVENTS = /* @__PURE__ */ new Set([
           "agent:generating_started",
           "agent:generating_completed",
@@ -29981,8 +30086,8 @@ ${lastSnapshot}`;
         this.targetDaemonId = context.targetDaemonId;
       }
     };
-    var import_fs6 = require("fs");
-    var import_path5 = require("path");
+    var import_fs7 = require("fs");
+    var import_path6 = require("path");
     init_config();
     var DEFAULT_STATE = {
       recentActivity: [],
@@ -29996,7 +30101,7 @@ ${lastSnapshot}`;
       return !!value && typeof value === "object" && !Array.isArray(value);
     }
     function getStatePath() {
-      return (0, import_path5.join)(getConfigDir(), "state.json");
+      return (0, import_path6.join)(getConfigDir(), "state.json");
     }
     function normalizeState(raw) {
       const parsed = isPlainObject22(raw) ? raw : {};
@@ -30032,11 +30137,11 @@ ${lastSnapshot}`;
     }
     function loadState() {
       const statePath = getStatePath();
-      if (!(0, import_fs6.existsSync)(statePath)) {
+      if (!(0, import_fs7.existsSync)(statePath)) {
         return { ...DEFAULT_STATE };
       }
       try {
-        const raw = (0, import_fs6.readFileSync)(statePath, "utf-8");
+        const raw = (0, import_fs7.readFileSync)(statePath, "utf-8");
         return normalizeState(JSON.parse(raw));
       } catch {
         return { ...DEFAULT_STATE };
@@ -30045,13 +30150,13 @@ ${lastSnapshot}`;
     function saveState(state) {
       const statePath = getStatePath();
       const normalized = normalizeState(state);
-      (0, import_fs6.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+      (0, import_fs7.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
     }
     function resetState() {
       saveState({ ...DEFAULT_STATE });
     }
     var import_child_process2 = require("child_process");
-    var import_fs7 = require("fs");
+    var import_fs8 = require("fs");
     var import_os22 = require("os");
     var path10 = __toESM2(require("path"));
     var BUILTIN_IDE_DEFINITIONS = [];
@@ -30075,7 +30180,7 @@ ${lastSnapshot}`;
       if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
         const candidate = trimmed.startsWith("~") ? path10.join((0, import_os22.homedir)(), trimmed.slice(1)) : trimmed;
         const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
-        return (0, import_fs7.existsSync)(resolved) ? resolved : null;
+        return (0, import_fs8.existsSync)(resolved) ? resolved : null;
       }
       try {
         const result = (0, import_child_process2.execSync)(
@@ -30106,9 +30211,9 @@ ${lastSnapshot}`;
         if (normalized.includes("*")) {
           const username = home.split(/[\\/]/).pop() || "";
           const resolved = normalized.replace("*", username);
-          if ((0, import_fs7.existsSync)(resolved)) return resolved;
+          if ((0, import_fs8.existsSync)(resolved)) return resolved;
         } else {
-          if ((0, import_fs7.existsSync)(normalized)) return normalized;
+          if ((0, import_fs8.existsSync)(normalized)) return normalized;
         }
       }
       return null;
@@ -30122,7 +30227,7 @@ ${lastSnapshot}`;
         let resolvedCli = cliPath;
         if (!resolvedCli && appPath && os222 === "darwin") {
           const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-          if ((0, import_fs7.existsSync)(bundledCli)) resolvedCli = bundledCli;
+          if ((0, import_fs8.existsSync)(bundledCli)) resolvedCli = bundledCli;
         }
         if (!resolvedCli && appPath && os222 === "win32") {
           const { dirname: dirname9 } = await import("path");
@@ -30135,7 +30240,7 @@ ${lastSnapshot}`;
             `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
           ];
           for (const c of candidates) {
-            if ((0, import_fs7.existsSync)(c)) {
+            if ((0, import_fs8.existsSync)(c)) {
               resolvedCli = c;
               break;
             }
@@ -39200,7 +39305,7 @@ ${effect.notification.body || ""}`.trim();
     var os13 = __toESM2(require("os"));
     var path18 = __toESM2(require("path"));
     var crypto4 = __toESM2(require("crypto"));
-    var import_fs8 = require("fs");
+    var import_fs9 = require("fs");
     var import_child_process6 = require("child_process");
     var import_chalk = __toESM2((init_source(), __toCommonJS(source_exports)));
     init_provider_cli_adapter();
@@ -41658,7 +41763,7 @@ ${rawInput}` : rawInput;
       const trimmed = command.trim();
       if (!trimmed) return false;
       if (isExplicitCommand(trimmed)) {
-        return (0, import_fs8.existsSync)(expandExecutable(trimmed));
+        return (0, import_fs9.existsSync)(expandExecutable(trimmed));
       }
       try {
         (0, import_child_process6.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -41687,10 +41792,10 @@ ${rawInput}` : rawInput;
     }
     function ensureEmptyDelegatedMcpConfig(workspace) {
       const baseDir = path18.join(os13.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-      (0, import_fs8.mkdirSync)(baseDir, { recursive: true });
+      (0, import_fs9.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_fs8.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+      (0, import_fs9.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
       return filePath;
     }
     function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -45841,7 +45946,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       }
     }
     var import_os3 = require("os");
-    var import_path6 = require("path");
+    var import_path7 = require("path");
     var fs10 = __toESM2(require("fs"));
     var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
     var CHANNEL_SERVER_URL = {
@@ -46165,8 +46270,21 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         isCached: false
       };
     }
+    function liveSessionRecordMatchesMeshNode(record2, meshId, nodeId) {
+      const recordNodeId = readStringValue(record2?.meta?.meshNodeId);
+      if (!recordNodeId || recordNodeId !== nodeId) return false;
+      const recordMeshId = readStringValue(record2?.meta?.meshNodeFor);
+      return !recordMeshId || recordMeshId === meshId;
+    }
+    function liveSessionRecordMatchesMeshWorkspace(record2, meshId, workspace) {
+      const recordWorkspace = readStringValue(record2?.workspace);
+      if (!recordWorkspace || !workspace || recordWorkspace !== workspace) return false;
+      const recordMeshId = readStringValue(record2?.meta?.meshNodeFor);
+      if (recordMeshId) return recordMeshId === meshId;
+      return record2?.meta?.launchedByCoordinator === true || !!readStringValue(record2?.meta?.meshNodeId);
+    }
     function readLiveMeshNodeWorkspace(args) {
-      const directNodeWorkspace = args.liveSessionRecords.find((record2) => readStringValue(record2?.meta?.meshNodeId) === args.nodeId && readStringValue(record2?.workspace));
+      const directNodeWorkspace = args.liveSessionRecords.find((record2) => liveSessionRecordMatchesMeshNode(record2, args.meshId, args.nodeId) && readStringValue(record2?.workspace));
       if (directNodeWorkspace) {
         return readStringValue(directNodeWorkspace.workspace) || "";
       }
@@ -46180,10 +46298,9 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     }
     function collectLiveMeshSessionRecords(args) {
       const matches = args.liveSessionRecords.filter((record2) => {
-        if (readStringValue(record2?.meta?.meshNodeId) === args.nodeId) return true;
-        const recordWorkspace = readStringValue(record2?.workspace);
         const nodeWorkspace = readStringValue(args.node?.workspace);
-        return !!recordWorkspace && !!nodeWorkspace && recordWorkspace === nodeWorkspace;
+        if (liveSessionRecordMatchesMeshNode(record2, args.meshId, args.nodeId)) return true;
+        return !!nodeWorkspace && liveSessionRecordMatchesMeshWorkspace(record2, args.meshId, nodeWorkspace);
       });
       if (args.allowCoordinatorSession) {
         for (const record2 of args.liveSessionRecords) {
@@ -46259,7 +46376,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     }
     function readPackageScripts(workspace) {
       try {
-        const packageJsonPath = (0, import_path6.join)(workspace, "package.json");
+        const packageJsonPath = (0, import_path7.join)(workspace, "package.json");
         const parsed = JSON.parse(fs10.readFileSync(packageJsonPath, "utf-8"));
         return parsed?.scripts && typeof parsed.scripts === "object" && !Array.isArray(parsed.scripts) ? parsed.scripts : {};
       } catch {
@@ -46467,13 +46584,13 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     }
     function resolveHermesUserHome() {
       const explicitHome = process.env.HERMES_HOME?.trim();
-      return explicitHome || (0, import_path6.join)((0, import_os3.homedir)(), ".hermes");
+      return explicitHome || (0, import_path7.join)((0, import_os3.homedir)(), ".hermes");
     }
     function loadHermesCoordinatorBaseConfig(targetConfigPath) {
       const sourceHome = resolveHermesUserHome();
-      const sourceConfigPath = (0, import_path6.join)(sourceHome, "config.yaml");
+      const sourceConfigPath = (0, import_path7.join)(sourceHome, "config.yaml");
       if (!fs10.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      if ((0, import_path6.resolve)(sourceConfigPath) === (0, import_path6.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if ((0, import_path7.resolve)(sourceConfigPath) === (0, import_path7.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
       const parsed = parseMeshCoordinatorMcpConfig(fs10.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
@@ -46507,10 +46624,10 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       return sanitized;
     }
     function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-      if ((0, import_path6.resolve)(sourceHome) === (0, import_path6.resolve)(targetHome)) return;
+      if ((0, import_path7.resolve)(sourceHome) === (0, import_path7.resolve)(targetHome)) return;
       for (const fileName of [".env", "auth.json"]) {
-        const sourcePath = (0, import_path6.join)(sourceHome, fileName);
-        const targetPath = (0, import_path6.join)(targetHome, fileName);
+        const sourcePath = (0, import_path7.join)(sourceHome, fileName);
+        const targetPath = (0, import_path7.join)(targetHome, fileName);
         if (!fs10.existsSync(sourcePath)) continue;
         try {
           fs10.copyFileSync(sourcePath, targetPath);
@@ -46717,7 +46834,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         }
         const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
         const normalizePath = (value) => {
-          const resolved = (0, import_path6.resolve)(value);
+          const resolved = (0, import_path7.resolve)(value);
           try {
             return fs10.realpathSync(resolved);
           } catch {
@@ -47118,7 +47235,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             return handleMeshForwardEvent({ instanceManager: this.deps.instanceManager }, args);
           }
           case "get_pending_mesh_events": {
-            const events = drainPendingMeshCoordinatorEvents();
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            const events = drainPendingMeshCoordinatorEvents(meshId || void 0);
             return { success: true, events };
           }
           case "launch_cli":
@@ -48339,7 +48457,7 @@ ${block}`);
                   workspace
                 };
               }
-              const { existsSync: existsSync25, readFileSync: readFileSync17, writeFileSync: writeFileSync15, copyFileSync: copyFileSync4, mkdirSync: mkdirSync17 } = await import("fs");
+              const { existsSync: existsSync26, readFileSync: readFileSync18, writeFileSync: writeFileSync15, copyFileSync: copyFileSync4, mkdirSync: mkdirSync17 } = 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;
@@ -48382,14 +48500,14 @@ ${block}`);
                 if (hermesManualFallback) return returnManualFallback(message);
                 return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
               }
-              const hadExistingMcpConfig = existsSync25(mcpConfigPath);
+              const hadExistingMcpConfig = existsSync26(mcpConfigPath);
               let existingMcpConfig = hermesBaseConfig?.config || {};
               if (hermesBaseConfig) {
                 copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname9(mcpConfigPath));
               }
               if (hadExistingMcpConfig) {
                 try {
-                  const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync17(mcpConfigPath, "utf-8"), configFormat);
+                  const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync18(mcpConfigPath, "utf-8"), configFormat);
                   const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
                   existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
                   copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
@@ -48577,29 +48695,48 @@ ${block}`);
                 }
                 if (workspace) {
                   if (!fs10.existsSync(workspace)) {
-                    if (applyCachedInlineMeshNodeStatus(status, node)) {
-                      status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
-                      nodeStatuses.push(status);
-                      continue;
-                    }
-                    if (meshRecord?.source === "inline_cache" && !isSelfNode) {
-                      status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
-                      nodeStatuses.push(status);
-                      continue;
+                    let remoteProbeApplied = false;
+                    if (!isSelfNode && daemonId && this.deps.dispatchMeshCommand) {
+                      try {
+                        const remoteResult = await Promise.race([
+                          this.deps.dispatchMeshCommand(daemonId, "git_status", { workspace }),
+                          new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), 8e3))
+                        ]);
+                        const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
+                        if (remoteGit && typeof remoteGit === "object" && typeof remoteGit.isGitRepo === "boolean") {
+                          status.git = remoteGit;
+                          status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
+                          remoteProbeApplied = true;
+                        }
+                      } catch {
+                      }
                     }
-                  }
-                  try {
-                    const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
-                    status.git = gitStatus;
-                    if (gitStatus.isGitRepo) {
-                      status.health = deriveMeshNodeHealthFromGit(gitStatus);
-                    } else {
-                      status.health = "degraded";
-                      if (gitStatus.error && !status.error) status.error = gitStatus.error;
+                    if (!remoteProbeApplied) {
+                      if (applyCachedInlineMeshNodeStatus(status, node)) {
+                        status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                        nodeStatuses.push(status);
+                        continue;
+                      }
+                      if (meshRecord?.source === "inline_cache" && !isSelfNode) {
+                        status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || isSelfNode);
+                        nodeStatuses.push(status);
+                        continue;
+                      }
                     }
-                  } catch {
-                    if (!applyCachedInlineMeshNodeStatus(status, node)) {
-                      status.health = "degraded";
+                  } else {
+                    try {
+                      const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+                      status.git = gitStatus;
+                      if (gitStatus.isGitRepo) {
+                        status.health = deriveMeshNodeHealthFromGit(gitStatus);
+                      } else {
+                        status.health = "degraded";
+                        if (gitStatus.error && !status.error) status.error = gitStatus.error;
+                      }
+                    } catch {
+                      if (!applyCachedInlineMeshNodeStatus(status, node)) {
+                        status.health = "degraded";
+                      }
                     }
                   }
                 } else {