@adhdev/daemon-core 0.9.82-rc.23 → 0.9.82-rc.25

package/dist/index.mjs

@@ -1351,13 +1351,43 @@ __export(mesh_work_queue_exports, {
   updateSessionTaskStatus: () => updateSessionTaskStatus,
   updateTaskStatus: () => updateTaskStatus
 });
-import { existsSync as existsSync6, writeFileSync as writeFileSync3, readFileSync as readFileSync4 } from "fs";
+import { existsSync as existsSync6, writeFileSync as writeFileSync3, readFileSync as readFileSync4, openSync, closeSync, unlinkSync } from "fs";
 import { join as join6 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 function getQueuePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
   return join6(getLedgerDir(), `${safe}.queue.json`);
 }
+function getLockPath(meshId) {
+  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return join6(getLedgerDir(), `${safe}.queue.lock`);
+}
+function withQueueLock(meshId, fn) {
+  const lockPath = getLockPath(meshId);
+  let fd = -1;
+  for (let i = 0; i < 10; i++) {
+    try {
+      fd = openSync(lockPath, "wx");
+      break;
+    } catch {
+      const deadline = Date.now() + 30;
+      while (Date.now() < deadline) {
+      }
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    if (fd !== -1) try {
+      closeSync(fd);
+    } catch {
+    }
+    try {
+      unlinkSync(lockPath);
+    } catch {
+    }
+  }
+}
 function readQueue(meshId) {
   const path28 = getQueuePath(meshId);
   if (!existsSync6(path28)) return [];
@@ -1373,20 +1403,22 @@ function writeQueue(meshId, queue) {
   writeFileSync3(path28, JSON.stringify(queue, null, 2), "utf-8");
 }
 function enqueueTask(meshId, message, opts) {
-  const queue = readQueue(meshId);
-  const entry = {
-    id: randomUUID5(),
-    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: randomUUID5(),
+      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);
@@ -1397,100 +1429,111 @@ function getQueue(meshId, opts) {
   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;
-}
-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") {
+  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, opts) {
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const occurredAtTime = opts?.occurredAt ? new Date(opts.occurredAt).getTime() : Number.NaN;
+    const hasOccurredAt = Number.isFinite(occurredAtTime);
+    let bestIdx = -1;
+    let bestTime = 0;
+    for (let i = queue.length - 1; i >= 0; i--) {
+      if (queue[i].assignedSessionId !== sessionId || queue[i].status !== "assigned") continue;
       const time = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
+      if (hasOccurredAt && Number.isFinite(time) && time > occurredAtTime) continue;
       if (time > bestTime) {
         bestTime = time;
         bestIdx = i;
       }
     }
-  }
-  if (bestIdx === -1) return null;
-  queue[bestIdx].status = status;
-  queue[bestIdx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeQueue(meshId, queue);
-  return queue[bestIdx];
+    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);
@@ -1895,21 +1938,72 @@ __export(mesh_events_exports, {
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
+import { appendFileSync as appendFileSync3, existsSync as existsSync9, readFileSync as readFileSync5, unlinkSync as unlinkSync3 } from "fs";
+import { join as join9 } from "path";
+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 join9(getLedgerDir(), `${safe}.pending-events.jsonl`);
+}
 function queuePendingMeshCoordinatorEvent(event) {
-  if (pendingMeshCoordinatorEvents.length >= MAX_PENDING_EVENTS) {
+  try {
+    appendFileSync3(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
+    return true;
+  } catch (e) {
+    LOG.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
     return false;
   }
-  pendingMeshCoordinatorEvents.push(event);
-  return true;
 }
-function drainPendingMeshCoordinatorEvents() {
-  return pendingMeshCoordinatorEvents.splice(0);
+function drainPendingMeshCoordinatorEvents(meshId) {
+  if (!meshId) return [];
+  const path28 = getPendingEventsPath(meshId);
+  if (!existsSync9(path28)) return [];
+  try {
+    const raw = readFileSync5(path28, "utf-8");
+    try {
+      unlinkSync3(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 (!existsSync9(path28)) return [];
+  try {
+    const raw = readFileSync5(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 (existsSync9(path28)) try {
+    unlinkSync3(path28);
+  } catch {
+  }
 }
 function readNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
@@ -1955,6 +2049,38 @@ function shouldSuppressIntentionalCleanupStop(args) {
   if (isIntentionalCleanupStopMetadata(args.metadataEvent)) return true;
   return hasRecentIntentionalCleanupStop(args.meshId, args.sessionId, args.nodeId);
 }
+function readEventTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric;
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+}
+function buildMeshCompletionFingerprint(args) {
+  const timestampPart = Number.isFinite(args.timestamp) ? String(args.timestamp) : readNonEmptyString(args.finalSummary).slice(0, 200);
+  return [
+    args.meshId,
+    args.event,
+    args.sessionId,
+    args.providerType || "",
+    args.providerSessionId || "",
+    timestampPart
+  ].join("::");
+}
+function isDuplicateMeshCompletionEvent(args) {
+  const fingerprint = buildMeshCompletionFingerprint(args);
+  if (!fingerprint) return false;
+  const now = Date.now();
+  for (const [key, seenAt] of recentCompletionFingerprints.entries()) {
+    if (now - seenAt > RECENT_COMPLETION_FINGERPRINT_TTL_MS) recentCompletionFingerprints.delete(key);
+  }
+  if (recentCompletionFingerprints.has(fingerprint)) return true;
+  recentCompletionFingerprints.set(fingerprint, now);
+  return false;
+}
 function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
   const task = claimNextTask(meshId, nodeId, sessionId);
   if (!task) {
@@ -1973,7 +2099,16 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
         message: task.message
       }).catch((e) => {
         LOG.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;
     }
@@ -2307,18 +2442,36 @@ function injectMeshSystemMessage(components, args) {
     LOG.info("MeshEvents", `Suppressed ${args.event} for intentionally cleanup-stopped session ${eventSessionId || "(unknown session)"}`);
     return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
   }
+  const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
+  if (args.event === "agent:generating_completed" && eventSessionId) {
+    const duplicateCompletion = isDuplicateMeshCompletionEvent({
+      meshId: args.meshId,
+      event: args.event,
+      sessionId: eventSessionId,
+      providerType: readNonEmptyString(args.metadataEvent.providerType) || void 0,
+      providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
+      timestamp: eventTimestamp,
+      finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
+    });
+    if (duplicateCompletion) {
+      LOG.info("MeshEvents", `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
+      return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true };
+    }
+  }
   let completedTaskForLedger = null;
   if (args.event === "agent:generating_completed") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
     const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
     const providerType = readNonEmptyString(args.metadataEvent.providerType);
     if (sessionId) {
-      const completedTask = updateSessionTaskStatus(args.meshId, sessionId, "completed");
+      const completedTask = updateSessionTaskStatus(args.meshId, sessionId, "completed", {
+        occurredAt: eventTimestamp !== null ? new Date(eventTimestamp).toISOString() : void 0
+      });
       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") {
@@ -2356,13 +2509,17 @@ function injectMeshSystemMessage(components, args) {
       }
     }
     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);
@@ -2523,6 +2680,7 @@ function handleMeshForwardEvent(components, payload) {
       providerType: readNonEmptyString(payload.providerType),
       providerSessionId: readNonEmptyString(payload.providerSessionId),
       finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
+      ...payload.timestamp !== void 0 ? { timestamp: payload.timestamp } : {},
       intentional: payload.intentional === true,
       intentionalStop: payload.intentionalStop === true,
       operatorCleanup: payload.operatorCleanup === true,
@@ -2565,7 +2723,7 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
+var REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, recentCompletionFingerprints, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
 var init_mesh_events = __esm({
   "src/mesh/mesh-events.ts"() {
     "use strict";
@@ -2575,9 +2733,8 @@ var init_mesh_events = __esm({
     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",
@@ -2593,6 +2750,8 @@ var init_mesh_events = __esm({
       "monitor:long_generating": "task_stalled"
     };
     INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
+    RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
+    recentCompletionFingerprints = /* @__PURE__ */ new Map();
     autoLaunchInProgress = /* @__PURE__ */ new Set();
     autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
     AUTO_LAUNCH_COOLDOWN_MS = 5e3;
@@ -7635,8 +7794,8 @@ var P2pRelayFailureError = class extends Error {
 
 // src/config/state-store.ts
 init_config();
-import { existsSync as existsSync9, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join10 } from "path";
 var DEFAULT_STATE = {
   recentActivity: [],
   savedProviderSessions: [],
@@ -7649,7 +7808,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return join9(getConfigDir(), "state.json");
+  return join10(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -7685,11 +7844,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!existsSync9(statePath)) {
+  if (!existsSync10(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = readFileSync5(statePath, "utf-8");
+    const raw = readFileSync6(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -7706,7 +7865,7 @@ function resetState() {
 
 // src/detection/ide-detector.ts
 import { execSync } from "child_process";
-import { existsSync as existsSync10 } from "fs";
+import { existsSync as existsSync11 } from "fs";
 import { platform as platform2, homedir as homedir5 } from "os";
 import * as path10 from "path";
 var BUILTIN_IDE_DEFINITIONS = [];
@@ -7730,7 +7889,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 existsSync10(resolved) ? resolved : null;
+    return existsSync11(resolved) ? resolved : null;
   }
   try {
     const result = execSync(
@@ -7761,9 +7920,9 @@ function checkPathExists(paths) {
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if (existsSync10(resolved)) return resolved;
+      if (existsSync11(resolved)) return resolved;
     } else {
-      if (existsSync10(normalized)) return normalized;
+      if (existsSync11(normalized)) return normalized;
     }
   }
   return null;
@@ -7777,7 +7936,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if (existsSync10(bundledCli)) resolvedCli = bundledCli;
+      if (existsSync11(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname9 } = await import("path");
@@ -7790,7 +7949,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if (existsSync10(c)) {
+        if (existsSync11(c)) {
           resolvedCli = c;
           break;
         }
@@ -16946,7 +17105,7 @@ init_config();
 import * as os13 from "os";
 import * as path18 from "path";
 import * as crypto4 from "crypto";
-import { existsSync as existsSync14, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9 } from "fs";
 import { execFileSync } from "child_process";
 import chalk from "chalk";
 
@@ -19420,7 +19579,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return existsSync14(expandExecutable(trimmed));
+    return existsSync15(expandExecutable(trimmed));
   }
   try {
     execFileSync(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -22689,10 +22848,10 @@ import * as yaml from "js-yaml";
 // src/commands/mesh-coordinator.ts
 import { execFileSync as execFileSync2 } from "child_process";
 import { createHash as createHash2 } from "crypto";
-import { existsSync as existsSync17, readdirSync as readdirSync7, realpathSync as realpathSync2 } from "fs";
+import { existsSync as existsSync18, readdirSync as readdirSync7, realpathSync as realpathSync2 } from "fs";
 import { createRequire as createRequire2 } from "module";
 import * as os17 from "os";
-import { dirname as dirname4, isAbsolute as isAbsolute11, join as join20, resolve as resolve13 } from "path";
+import { dirname as dirname4, isAbsolute as isAbsolute11, join as join21, resolve as resolve13 } from "path";
 var DEFAULT_SERVER_NAME = "adhdev-mesh";
 var DEFAULT_ADHDEV_MCP_COMMAND = "adhdev-mcp";
 var HERMES_CLI_TYPE = "hermes-cli";
@@ -22715,7 +22874,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 = join20(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
+  const configPath = join21(resolveHermesCoordinatorHome(options.meshId, options.workspace), "config.yaml");
   if (!configPath.trim()) {
     return createHermesManualMeshCoordinatorSetup(options.meshId, options.workspace);
   }
@@ -22836,14 +22995,14 @@ function resolveHermesCoordinatorHome(meshId, workspace) {
   const key = `${meshId || "mesh"}
 ${resolve13(workspace || os17.tmpdir())}`;
   const hash = createHash2("sha256").update(key).digest("hex").slice(0, 16);
-  return join20(os17.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
+  return join21(os17.tmpdir(), `adhdev-hermes-mesh-coordinator-${hash}`);
 }
 function resolveMcpConfigPath(configPath, workspace) {
   const trimmed = configPath.trim();
   if (trimmed === "~") return os17.homedir();
-  if (trimmed.startsWith("~/")) return join20(os17.homedir(), trimmed.slice(2));
+  if (trimmed.startsWith("~/")) return join21(os17.homedir(), trimmed.slice(2));
   if (isAbsolute11(trimmed)) return trimmed;
-  return join20(workspace, trimmed);
+  return join21(workspace, trimmed);
 }
 function resolveAdhdevMcpServerLaunch(options) {
   const entryPath = resolveAdhdevMcpEntryPath(options.adhdevMcpEntryPath);
@@ -22899,15 +23058,15 @@ function addNodeCandidatesFromPath(pathValue, addCandidate) {
   for (const entry of (pathValue || "").split(":")) {
     const dir = entry.trim();
     if (!dir) continue;
-    addCandidate(join20(dir, "node"));
+    addCandidate(join21(dir, "node"));
   }
 }
 function addNodeCandidatesFromNvm(homeDir, addCandidate) {
-  const versionsDir = join20(homeDir, ".nvm", "versions", "node");
+  const versionsDir = join21(homeDir, ".nvm", "versions", "node");
   try {
     const versionDirs = readdirSync7(versionsDir, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort(compareNodeVersionNamesDescending);
     for (const versionDir of versionDirs) {
-      addCandidate(join20(versionsDir, versionDir, "bin", "node"));
+      addCandidate(join21(versionsDir, versionDir, "bin", "node"));
     }
   } catch {
   }
@@ -22958,7 +23117,7 @@ function resolveAdhdevMcpEntryPath(explicitPath) {
     if (normalized) return normalized;
   }
   try {
-    const requireBase = process.argv[1] ? normalizeExistingPath(process.argv[1]) || process.argv[1] : join20(process.cwd(), "adhdev-daemon.js");
+    const requireBase = process.argv[1] ? normalizeExistingPath(process.argv[1]) || process.argv[1] : join21(process.cwd(), "adhdev-daemon.js");
     const req = createRequire2(requireBase);
     const resolvedModule = req.resolve("@adhdev/mcp-server");
     return normalizeExistingPath(resolvedModule) || resolvedModule;
@@ -22968,7 +23127,7 @@ function resolveAdhdevMcpEntryPath(explicitPath) {
 }
 function normalizeExistingPath(filePath) {
   try {
-    if (!existsSync17(filePath)) return null;
+    if (!existsSync18(filePath)) return null;
     return realpathSync2.native(filePath);
   } catch {
     return null;
@@ -24920,7 +25079,8 @@ var DaemonCommandRouter = class {
         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":
@@ -26141,7 +26301,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;
@@ -26184,14 +26344,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");
@@ -26379,29 +26539,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 {