@adhdev/daemon-core 0.9.82-rc.4 → 0.9.82-rc.41

package/dist/index.js

@@ -1360,6 +1360,36 @@ function getQueuePath(meshId) {
   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 [];
@@ -1375,20 +1405,22 @@ function writeQueue(meshId, queue) {
   (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);
@@ -1399,100 +1431,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);
@@ -1896,18 +1939,75 @@ __export(mesh_events_exports, {
   drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
   getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
   handleMeshForwardEvent: () => handleMeshForwardEvent,
+  queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   setupMeshEventForwarding: () => setupMeshEventForwarding,
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
-function drainPendingMeshCoordinatorEvents() {
-  return pendingMeshCoordinatorEvents.splice(0);
+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 getPendingMeshCoordinatorEvents() {
-  return pendingMeshCoordinatorEvents.slice();
+function queuePendingMeshCoordinatorEvent(event) {
+  try {
+    (0, import_fs6.appendFileSync)(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;
+  }
 }
-function clearPendingMeshCoordinatorEvents() {
-  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(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(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() : "";
@@ -1953,6 +2053,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) {
@@ -1971,7 +2103,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;
     }
@@ -2305,18 +2446,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") {
@@ -2354,13 +2513,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);
@@ -2471,17 +2634,18 @@ function injectMeshSystemMessage(components, args) {
     return true;
   });
   if (coordinatorInstances.length === 0) {
-    if (pendingMeshCoordinatorEvents.length < MAX_PENDING_EVENTS) {
-      pendingMeshCoordinatorEvents.push({
-        event: args.event,
-        meshId: args.meshId,
-        nodeLabel: args.nodeLabel,
-        metadataEvent: {
-          ...args.metadataEvent,
-          ...recoveryContext ? { recoveryContext } : {}
-        },
-        queuedAt: Date.now()
-      });
+    if (queuePendingMeshCoordinatorEvent({
+      event: args.event,
+      meshId: args.meshId,
+      nodeLabel: args.nodeLabel,
+      nodeId: args.nodeId || void 0,
+      workspace: readNonEmptyString(args.metadataEvent.workspace),
+      metadataEvent: {
+        ...args.metadataEvent,
+        ...recoveryContext ? { recoveryContext } : {}
+      },
+      queuedAt: Date.now()
+    })) {
       LOG.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
     }
     return { success: true, forwarded: 0 };
@@ -2520,6 +2684,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,
@@ -2562,19 +2727,20 @@ 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 import_fs6, import_path5, 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";
+    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",
@@ -2590,6 +2756,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;
@@ -5860,6 +6028,7 @@ __export(index_exports, {
   prepareSessionChatTailUpdate: () => prepareSessionChatTailUpdate,
   prepareSessionModalUpdate: () => prepareSessionModalUpdate,
   probeCdpPort: () => probeCdpPort,
+  queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   readChatHistory: () => readChatHistory,
   readLedgerEntries: () => readLedgerEntries,
   readLedgerSlice: () => readLedgerSlice,
@@ -5913,8 +6082,14 @@ async function getGitRepoStatus(workspace, options = {}) {
   const includeSubmodules = options.includeSubmodules !== false;
   try {
     const repo = await resolveGitRepository(workspace, options);
-    const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
-    const parsed = parsePorcelainV2Status(statusOutput.stdout);
+    let parsed = await readPorcelainStatus(repo, options);
+    let upstreamProbe = getInitialUpstreamProbe(parsed);
+    if (options.refreshUpstream) {
+      upstreamProbe = await refreshTrackedUpstream(repo, parsed, options);
+      if (upstreamProbe.upstreamStatus === "fresh") {
+        parsed = await readPorcelainStatus(repo, options);
+      }
+    }
     const head = await readHead(repo, options);
     const stashCount = await readStashCount(repo, options);
     let submodules;
@@ -5929,6 +6104,9 @@ async function getGitRepoStatus(workspace, options = {}) {
       headCommit: head.commit,
       headMessage: head.message,
       upstream: parsed.upstream,
+      upstreamStatus: parsed.upstream ? upstreamProbe.upstreamStatus : "no_upstream",
+      upstreamFetchedAt: upstreamProbe.upstreamFetchedAt,
+      upstreamFetchError: upstreamProbe.upstreamFetchError,
       ahead: parsed.ahead,
       behind: parsed.behind,
       staged: parsed.staged,
@@ -5953,6 +6131,60 @@ async function getGitRepoStatus(workspace, options = {}) {
     );
   }
 }
+async function readPorcelainStatus(repo, options) {
+  const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
+  return parsePorcelainV2Status(statusOutput.stdout);
+}
+function getInitialUpstreamProbe(parsed) {
+  return {
+    upstreamStatus: parsed.upstream ? "unchecked" : "no_upstream"
+  };
+}
+async function refreshTrackedUpstream(repo, parsed, options) {
+  if (!parsed.upstream || !parsed.branch) {
+    return { upstreamStatus: "no_upstream" };
+  }
+  const remoteName = await readBranchRemote(repo, parsed.branch, options) ?? inferRemoteName(parsed.upstream);
+  if (!remoteName) {
+    return {
+      upstreamStatus: "stale",
+      upstreamFetchError: `Unable to resolve remote for upstream '${parsed.upstream}'`
+    };
+  }
+  try {
+    await runGit(repo, ["fetch", "--quiet", "--prune", "--no-tags", remoteName], options);
+    return {
+      upstreamStatus: "fresh",
+      upstreamFetchedAt: Date.now()
+    };
+  } catch (error) {
+    return {
+      upstreamStatus: "stale",
+      upstreamFetchError: formatGitError(error)
+    };
+  }
+}
+async function readBranchRemote(repo, branch, options) {
+  try {
+    const result = await runGit(repo, ["config", "--get", `branch.${branch}.remote`], options);
+    return result.stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+function inferRemoteName(upstream) {
+  const [remoteName] = upstream.split("/");
+  return remoteName?.trim() || null;
+}
+function formatGitError(error) {
+  if (error instanceof GitCommandError) {
+    return error.stderr || error.message;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return String(error);
+}
 function parsePorcelainV2Status(output) {
   const parsed = {
     branch: null,
@@ -6047,6 +6279,7 @@ function emptyStatus(workspace, lastCheckedAt, error) {
     headCommit: null,
     headMessage: null,
     upstream: null,
+    upstreamStatus: "unavailable",
     ahead: 0,
     behind: 0,
     staged: 0,
@@ -6327,6 +6560,9 @@ function createGitCompactSummary(status, diffSummary) {
     isGitRepo: status.isGitRepo,
     repoRoot: status.repoRoot,
     branch: status.branch,
+    upstreamStatus: status.upstreamStatus,
+    upstreamFetchedAt: status.upstreamFetchedAt,
+    upstreamFetchError: status.upstreamFetchError,
     dirty: status.staged > 0 || status.modified > 0 || status.untracked > 0 || status.deleted > 0 || status.renamed > 0 || conflictCount > 0 || changedFiles > 0,
     changedFiles,
     ahead: status.ahead,
@@ -6671,7 +6907,7 @@ var defaultSnapshotStore = createGitSnapshotStore({
 });
 function createDefaultGitCommandServices() {
   return {
-    getStatus: ({ workspace }) => getGitRepoStatus(workspace),
+    getStatus: ({ workspace, refreshUpstream }) => getGitRepoStatus(workspace, { refreshUpstream }),
     getDiffSummary: ({ workspace }) => getGitDiffSummary(workspace),
     getDiffFile: ({ workspace, path: filePath }) => getGitFileDiff(workspace, filePath),
     createSnapshot: ({ workspace, reason, sessionId, turnId }) => defaultSnapshotStore.create({
@@ -6757,7 +6993,7 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
   switch (command) {
     case "git_status": {
       if (!services.getStatus) return serviceNotImplemented(command);
-      const status = await runService(() => services.getStatus({ workspace }));
+      const status = await runService(() => services.getStatus({ workspace, refreshUpstream: optionalBoolean(args?.refreshUpstream) }));
       return "success" in status ? status : { success: true, status };
     }
     case "git_diff_summary": {
@@ -7795,8 +8031,8 @@ var P2pRelayFailureError = class extends Error {
 };
 
 // src/config/state-store.ts
-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: [],
@@ -7810,7 +8046,7 @@ function isPlainObject2(value) {
   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 = isPlainObject2(raw) ? raw : {};
@@ -7846,11 +8082,11 @@ function normalizeState(raw) {
 }
 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 };
@@ -7859,7 +8095,7 @@ function loadState() {
 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 });
@@ -7867,7 +8103,7 @@ function resetState() {
 
 // src/detection/ide-detector.ts
 var import_child_process2 = require("child_process");
-var import_fs7 = require("fs");
+var import_fs8 = require("fs");
 var import_os2 = require("os");
 var path10 = __toESM(require("path"));
 var BUILTIN_IDE_DEFINITIONS = [];
@@ -7891,7 +8127,7 @@ function findCliCommand(command) {
   if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
     const candidate = trimmed.startsWith("~") ? path10.join((0, import_os2.homedir)(), trimmed.slice(1)) : trimmed;
     const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
-    return (0, import_fs7.existsSync)(resolved) ? resolved : null;
+    return (0, import_fs8.existsSync)(resolved) ? resolved : null;
   }
   try {
     const result = (0, import_child_process2.execSync)(
@@ -7922,9 +8158,9 @@ function checkPathExists(paths) {
     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;
@@ -7938,7 +8174,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os22 === "darwin") {
       const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-      if ((0, import_fs7.existsSync)(bundledCli)) resolvedCli = bundledCli;
+      if ((0, import_fs8.existsSync)(bundledCli)) resolvedCli = bundledCli;
     }
     if (!resolvedCli && appPath && os22 === "win32") {
       const { dirname: dirname9 } = await import("path");
@@ -7951,7 +8187,7 @@ async function detectIDEs(providerLoader) {
         `${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;
         }
@@ -9843,7 +10079,8 @@ var StatusMonitor = class {
 };
 
 // src/providers/chat-message-normalization.ts
-function extractFinalSummaryFromMessages(messages, maxChars = 500) {
+var DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4e3;
+function extractFinalSummaryFromMessages(messages, maxChars = DEFAULT_FINAL_SUMMARY_MAX_CHARS) {
   if (!Array.isArray(messages) || messages.length === 0) return "";
   for (let i = messages.length - 1; i >= 0; i--) {
     const msg = messages[i];
@@ -17103,7 +17340,7 @@ var DaemonCommandHandler = class {
 var os13 = __toESM(require("os"));
 var path18 = __toESM(require("path"));
 var crypto4 = __toESM(require("crypto"));
-var import_fs8 = require("fs");
+var import_fs9 = require("fs");
 var import_child_process6 = require("child_process");
 var import_chalk = __toESM(require("chalk"));
 init_provider_cli_adapter();
@@ -19575,7 +19812,7 @@ function commandExists(command) {
   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], {
@@ -19604,10 +19841,10 @@ function hasCliArg(args, flag) {
 }
 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) {
@@ -23786,7 +24023,7 @@ async function maybeRunDaemonUpgradeHelperFromEnv() {
 
 // src/commands/router.ts
 var import_os3 = require("os");
-var import_path6 = require("path");
+var import_path7 = require("path");
 var fs10 = __toESM(require("fs"));
 var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
 var CHANNEL_SERVER_URL = {
@@ -23835,55 +24072,45 @@ function readBooleanValue(...values) {
   }
   return void 0;
 }
-function buildCachedInlineMeshGitStatus(node) {
-  const cachedStatus = readObjectRecord(node?.cachedStatus);
-  const cachedGit = readObjectRecord(cachedStatus.git);
-  if (Object.keys(cachedGit).length) {
-    const conflictFiles2 = Array.isArray(cachedGit.conflictFiles) ? cachedGit.conflictFiles.filter((value) => typeof value === "string") : [];
-    const conflictCount2 = readNumberValue(cachedGit.conflicts) ?? conflictFiles2.length;
-    const hasConflicts2 = readBooleanValue(cachedGit.hasConflicts) ?? conflictCount2 > 0;
-    const isGitRepo2 = readBooleanValue(cachedGit.isGitRepo);
-    if (isGitRepo2 !== void 0) {
-      return {
-        workspace: readStringValue(cachedGit.workspace, node?.workspace) || "",
-        repoRoot: readStringValue(cachedGit.repoRoot, node?.repoRoot, node?.workspace) || null,
-        isGitRepo: isGitRepo2,
-        branch: readStringValue(cachedGit.branch) ?? null,
-        headCommit: readStringValue(cachedGit.headCommit) ?? null,
-        headMessage: readStringValue(cachedGit.headMessage) ?? null,
-        upstream: readStringValue(cachedGit.upstream) ?? null,
-        ahead: readNumberValue(cachedGit.ahead) ?? 0,
-        behind: readNumberValue(cachedGit.behind) ?? 0,
-        staged: readNumberValue(cachedGit.staged) ?? 0,
-        modified: readNumberValue(cachedGit.modified) ?? 0,
-        untracked: readNumberValue(cachedGit.untracked) ?? 0,
-        deleted: readNumberValue(cachedGit.deleted) ?? 0,
-        renamed: readNumberValue(cachedGit.renamed) ?? 0,
-        hasConflicts: hasConflicts2,
-        conflictFiles: conflictFiles2,
-        stashCount: readNumberValue(cachedGit.stashCount) ?? 0,
-        lastCheckedAt: readNumberValue(cachedGit.lastCheckedAt) ?? Date.now()
-      };
-    }
-  }
-  const rawGit = readObjectRecord(node?.lastGit ?? node?.last_git);
-  const gitResult = readObjectRecord(rawGit.result);
-  const directStatus = readObjectRecord(rawGit.status);
-  const nestedStatus = readObjectRecord(gitResult.status);
-  const rawProbe = readObjectRecord(node?.lastProbe ?? node?.last_probe);
-  const probeGit = readObjectRecord(rawProbe.git);
-  const probeGitResult = readObjectRecord(probeGit.result);
-  const probeDirectStatus = readObjectRecord(probeGit.status);
-  const probeNestedStatus = readObjectRecord(probeGitResult.status);
-  const status = Object.keys(directStatus).length ? directStatus : Object.keys(nestedStatus).length ? nestedStatus : Object.keys(probeDirectStatus).length ? probeDirectStatus : Object.keys(probeNestedStatus).length ? probeNestedStatus : {};
+function joinRepoPath(root, relativePath) {
+  const normalizedRoot = typeof root === "string" ? root.trim().replace(/[\\/]+$/, "") : "";
+  const normalizedPath = typeof relativePath === "string" ? relativePath.trim() : "";
+  if (!normalizedPath) return void 0;
+  if (/^(?:[A-Za-z]:[\\/]|\/)/.test(normalizedPath)) return normalizedPath;
+  if (!normalizedRoot) return void 0;
+  return `${normalizedRoot}/${normalizedPath.replace(/^[\\/]+/, "")}`;
+}
+function readGitSubmodules(value, parentRepoRoot) {
+  if (!Array.isArray(value)) return void 0;
+  const submodules = value.map((entry) => {
+    const submodule = readObjectRecord(entry);
+    const path28 = readStringValue(submodule.path);
+    const commit = readStringValue(submodule.commit);
+    const repoPath = readStringValue(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path28);
+    if (!path28 || !commit || !repoPath) return null;
+    return {
+      path: path28,
+      commit,
+      repoPath,
+      dirty: readBooleanValue(submodule.dirty) ?? false,
+      outOfSync: readBooleanValue(submodule.outOfSync, submodule.out_of_sync) ?? false,
+      lastCheckedAt: readNumberValue(submodule.lastCheckedAt, submodule.last_checked_at) ?? Date.now(),
+      ...readStringValue(submodule.error) ? { error: readStringValue(submodule.error) } : {}
+    };
+  }).filter((entry) => entry !== null);
+  return submodules.length > 0 ? submodules : void 0;
+}
+function normalizeInlineMeshGitStatus(status, node, options) {
   const isGitRepo = readBooleanValue(status.isGitRepo);
   if (!Object.keys(status).length || isGitRepo === void 0) return void 0;
   const conflictFiles = Array.isArray(status.conflictFiles) ? status.conflictFiles.filter((value) => typeof value === "string") : [];
   const conflictCount = readNumberValue(status.conflicts) ?? conflictFiles.length;
   const hasConflicts = readBooleanValue(status.hasConflicts) ?? conflictCount > 0;
+  const repoRoot = readStringValue(status.repoRoot, status.repo_root, node?.repoRoot, node?.repo_root, status.workspace, node?.workspace) || void 0;
+  const submodules = readGitSubmodules(status.submodules, repoRoot);
   return {
     workspace: readStringValue(status.workspace, node?.workspace) || "",
-    repoRoot: readStringValue(status.repoRoot, node?.repoRoot, node?.workspace) || null,
+    repoRoot: repoRoot ?? null,
     isGitRepo,
     branch: readStringValue(status.branch) ?? null,
     headCommit: readStringValue(status.headCommit) ?? null,
@@ -23899,29 +24126,412 @@ function buildCachedInlineMeshGitStatus(node) {
     hasConflicts,
     conflictFiles,
     stashCount: readNumberValue(status.stashCount) ?? 0,
-    lastCheckedAt: Date.now()
+    lastCheckedAt: options?.lastCheckedAt ?? readNumberValue(status.lastCheckedAt) ?? Date.now(),
+    ...submodules ? { submodules } : {}
   };
 }
-function applyCachedInlineMeshNodeStatus(status, node) {
+function buildInlineMeshTransitGitStatus(node) {
+  const rawGit = readObjectRecord(node?.lastGit ?? node?.last_git);
+  const gitResult = readObjectRecord(rawGit.result);
+  const directStatus = readObjectRecord(rawGit.status);
+  const nestedStatus = readObjectRecord(gitResult.status);
+  const rawProbe = readObjectRecord(node?.lastProbe ?? node?.last_probe);
+  const probeGit = readObjectRecord(rawProbe.git);
+  const probeGitResult = readObjectRecord(probeGit.result);
+  const probeDirectStatus = readObjectRecord(probeGit.status);
+  const probeNestedStatus = readObjectRecord(probeGitResult.status);
+  const status = Object.keys(directStatus).length ? directStatus : Object.keys(nestedStatus).length ? nestedStatus : Object.keys(probeDirectStatus).length ? probeDirectStatus : Object.keys(probeNestedStatus).length ? probeNestedStatus : {};
+  return normalizeInlineMeshGitStatus(status, node, { lastCheckedAt: Date.now() });
+}
+function recordInlineMeshDirectGitTruth(node, git, source) {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return;
+  const checkedAt = readNumberValue(git.lastCheckedAt) ?? Date.now();
+  const updatedAt = new Date(checkedAt).toISOString();
+  const nextGit = {
+    ...git,
+    lastCheckedAt: checkedAt
+  };
+  node.lastGit = {
+    source,
+    checkedAt,
+    status: nextGit
+  };
+  node.last_git = node.lastGit;
+  node.machineStatus = "online";
+  node.updatedAt = updatedAt;
+  node.lastSeenAt = updatedAt;
+  const repoRoot = readStringValue(nextGit.repoRoot);
+  if (repoRoot && !readStringValue(node.repoRoot)) node.repoRoot = repoRoot;
+}
+function buildCachedInlineMeshGitStatus(node) {
+  const liveGit = buildInlineMeshTransitGitStatus(node);
+  if (liveGit) return liveGit;
   const cachedStatus = readObjectRecord(node?.cachedStatus);
-  const git = buildCachedInlineMeshGitStatus(node);
-  const error = readStringValue(cachedStatus.error, node?.error);
-  const health = readStringValue(cachedStatus.health, node?.health);
+  const cachedGit = readObjectRecord(cachedStatus.git);
+  if (!Object.keys(cachedGit).length) return void 0;
+  return normalizeInlineMeshGitStatus(cachedGit, node);
+}
+function shouldDiscardCachedInlineMeshStatus(node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  if (!Object.keys(cachedStatus).length) return false;
+  const cachedGit = readObjectRecord(cachedStatus.git);
+  const workspaceError = readStringValue(cachedStatus.error, node?.error);
+  if (workspaceError && /workspace must be an existing directory/i.test(workspaceError)) return true;
+  const isGitRepo = readBooleanValue(cachedGit.isGitRepo);
+  const branch = readStringValue(cachedGit.branch);
+  const headCommit = readStringValue(cachedGit.headCommit);
+  return isGitRepo === false && !branch && !headCommit;
+}
+function stripInlineMeshTransientNodeState(node) {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return node;
+  const {
+    cachedStatus,
+    lastGit: _lastGit,
+    last_git: _lastGitLegacy,
+    lastProbe: _lastProbe,
+    last_probe: _lastProbeLegacy,
+    error: _error,
+    health: _health,
+    machineStatus: _machineStatus,
+    lastSeenAt: _lastSeenAt,
+    last_seen_at: _lastSeenAtLegacy,
+    updatedAt: _updatedAt,
+    updated_at: _updatedAtLegacy,
+    activeSession: _activeSession,
+    active_session: _activeSessionLegacy,
+    activeSessionId: _activeSessionId,
+    active_session_id: _activeSessionIdLegacy,
+    sessionId: _sessionId,
+    session_id: _sessionIdLegacy,
+    providerType: _providerType,
+    provider_type: _providerTypeLegacy,
+    ...rest
+  } = node;
+  if (cachedStatus && !shouldDiscardCachedInlineMeshStatus(node)) {
+    return { ...rest, cachedStatus };
+  }
+  return rest;
+}
+function hasInlineMeshTransientNodeState(node) {
+  if (!node || typeof node !== "object" || Array.isArray(node)) return false;
+  return "cachedStatus" in node || "lastGit" in node || "last_git" in node || "lastProbe" in node || "last_probe" in node || "error" in node || "health" in node || "machineStatus" in node || "lastSeenAt" in node || "last_seen_at" in node || "updatedAt" in node || "updated_at" in node || "activeSession" in node || "active_session" in node || "activeSessionId" in node || "active_session_id" in node || "sessionId" in node || "session_id" in node || "providerType" in node || "provider_type" in node;
+}
+function inlineMeshCarriesTransientNodeTruth(inlineMesh) {
+  if (!inlineMesh || typeof inlineMesh !== "object" || Array.isArray(inlineMesh)) return false;
+  if (!Array.isArray(inlineMesh.nodes) || inlineMesh.nodes.length === 0) return false;
+  return inlineMesh.nodes.some((node) => hasInlineMeshTransientNodeState(node));
+}
+function readInlineMeshNodeId(node) {
+  return readStringValue(node?.id, node?.nodeId) || "";
+}
+function sanitizeInlineMesh(inlineMesh) {
+  if (!inlineMesh || typeof inlineMesh !== "object" || Array.isArray(inlineMesh)) return inlineMesh;
+  if (!Array.isArray(inlineMesh.nodes)) return inlineMesh;
+  let changed = false;
+  const nodes = inlineMesh.nodes.map((node) => {
+    if (!hasInlineMeshTransientNodeState(node)) return node;
+    changed = true;
+    return stripInlineMeshTransientNodeState(node);
+  });
+  if (!changed) return inlineMesh;
+  return {
+    ...inlineMesh,
+    nodes
+  };
+}
+function reconcileInlineMeshCache(cached, incoming) {
+  if (!cached || typeof cached !== "object" || Array.isArray(cached)) return incoming;
+  if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached;
+  const cachedNodes = Array.isArray(cached.nodes) ? cached.nodes : [];
+  const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
+  if (!cachedNodes.length || !incomingNodes.length) return { ...cached, ...incoming };
+  const incomingById = /* @__PURE__ */ new Map();
+  for (const node of incomingNodes) {
+    const nodeId = readInlineMeshNodeId(node);
+    if (nodeId) incomingById.set(nodeId, node);
+  }
+  const nodes = cachedNodes.map((cachedNode) => {
+    const nodeId = readInlineMeshNodeId(cachedNode);
+    const incomingNode = nodeId ? incomingById.get(nodeId) : void 0;
+    if (!incomingNode) return cachedNode;
+    if (hasInlineMeshTransientNodeState(incomingNode)) {
+      return { ...cachedNode, ...incomingNode };
+    }
+    return { ...stripInlineMeshTransientNodeState(cachedNode), ...incomingNode };
+  });
+  return {
+    ...cached,
+    ...incoming,
+    nodes
+  };
+}
+function hasGitWorktreeChanges(git) {
+  if (!git) return false;
+  return Number(git.staged || 0) + Number(git.modified || 0) + Number(git.untracked || 0) + Number(git.deleted || 0) + Number(git.renamed || 0) > 0;
+}
+function getGitSubmoduleDriftState(git) {
+  const submodules = Array.isArray(git?.submodules) ? git.submodules : [];
+  let dirty = false;
+  let outOfSync = false;
+  for (const entry of submodules) {
+    const submodule = readObjectRecord(entry);
+    if (readBooleanValue(submodule.dirty) === true) dirty = true;
+    if (readBooleanValue(submodule.outOfSync) === true || !!readStringValue(submodule.error)) outOfSync = true;
+  }
+  return { dirty, outOfSync };
+}
+function deriveMeshNodeHealthFromGit(git) {
+  if (!git || readBooleanValue(git.isGitRepo) === false) return "degraded";
+  const branch = readStringValue(git.branch);
+  if (!branch) return "degraded";
+  const submoduleDrift = getGitSubmoduleDriftState(git);
+  if (submoduleDrift.outOfSync) return "degraded";
+  if (submoduleDrift.dirty || hasGitWorktreeChanges(git)) return "dirty";
+  return "online";
+}
+function readCachedInlineMeshActiveSessions(node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const activeSession = readObjectRecord(cachedStatus.activeSession);
+  const fallbackSession = Object.keys(activeSession).length ? activeSession : readObjectRecord(node?.activeSession ?? node?.active_session);
+  const sessionId = readStringValue(fallbackSession.id, fallbackSession.sessionId, fallbackSession.session_id, node?.activeSessionId, node?.active_session_id, node?.sessionId, node?.session_id);
+  return sessionId ? [sessionId] : [];
+}
+function readCachedInlineMeshActiveSessionDetails(node) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const activeSession = readObjectRecord(cachedStatus.activeSession);
+  const fallbackSession = Object.keys(activeSession).length ? activeSession : readObjectRecord(node?.activeSession ?? node?.active_session);
+  const sessionId = readStringValue(
+    fallbackSession.id,
+    fallbackSession.sessionId,
+    fallbackSession.session_id,
+    node?.activeSessionId,
+    node?.active_session_id,
+    node?.sessionId,
+    node?.session_id
+  );
+  if (!sessionId) return [];
+  return [{
+    sessionId,
+    providerType: readStringValue(
+      fallbackSession.providerType,
+      fallbackSession.provider_type,
+      fallbackSession.cliType,
+      fallbackSession.cli_type,
+      fallbackSession.provider,
+      node?.providerType,
+      node?.provider_type
+    ),
+    state: readStringValue(fallbackSession.status, fallbackSession.state, fallbackSession.lifecycle),
+    lifecycle: readStringValue(fallbackSession.lifecycle),
+    title: readStringValue(fallbackSession.title, fallbackSession.displayName, fallbackSession.display_name) ?? null,
+    workspace: readStringValue(fallbackSession.workspace, node?.workspace) ?? null,
+    lastActivityAt: readStringValue(fallbackSession.lastActivityAt, fallbackSession.last_activity_at) ?? null,
+    recoveryState: readStringValue(fallbackSession.recoveryState, fallbackSession.recovery_state) ?? null,
+    isCached: true
+  }];
+}
+function readLiveMeshSessionState(record) {
+  return readStringValue(
+    record?.meta?.sessionStatus,
+    record?.meta?.status,
+    record?.meta?.providerStatus,
+    record?.status,
+    record?.state,
+    record?.lifecycle
+  );
+}
+function toIsoTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return new Date(value).toISOString();
+  const stringValue = readStringValue(value);
+  return stringValue || null;
+}
+function synthesizeMeshNodeFreshnessFromConnection(status) {
+  const connection = readObjectRecord(status.connection);
+  const connectionFreshAt = toIsoTimestamp(connection.lastCommandAt ?? connection.lastConnectedAt ?? connection.lastStateChangeAt);
+  const git = readObjectRecord(status.git);
+  const gitCheckedAt = toIsoTimestamp(git.lastCheckedAt);
+  if (!status.lastSeenAt && connectionFreshAt) status.lastSeenAt = connectionFreshAt;
+  if (!status.updatedAt && (gitCheckedAt || connectionFreshAt)) {
+    status.updatedAt = gitCheckedAt ?? connectionFreshAt;
+  }
+}
+function finalizeMeshNodeStatus(args) {
+  const { status, node, daemonId, isSelfNode } = args;
+  if (!readStringValue(status.machineStatus)) {
+    const cachedStatus = readObjectRecord(node?.cachedStatus);
+    const machineStatus = readStringValue(cachedStatus.machineStatus, cachedStatus.machine_status, node?.machineStatus);
+    if (machineStatus) status.machineStatus = machineStatus;
+  }
+  synthesizeMeshNodeFreshnessFromConnection(status);
+  const connectionState = readStringValue(readObjectRecord(status.connection).state);
+  status.launchReady = !!daemonId && (readStringValue(status.machineStatus) === "online" || connectionState === "connected" || isSelfNode);
+}
+async function probeRemoteMeshGitStatus(args) {
+  if (!args.dispatchMeshCommand) return null;
+  const remoteResult = await Promise.race([
+    args.dispatchMeshCommand(args.daemonId, "git_status", { workspace: args.workspace }),
+    new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), args.timeoutMs))
+  ]);
+  const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
+  return remoteGit && typeof remoteGit === "object" && typeof remoteGit.isGitRepo === "boolean" ? remoteGit : null;
+}
+async function hydrateInlineMeshDirectTruth(args) {
+  const nodes = Array.isArray(args.mesh?.nodes) ? args.mesh.nodes : [];
+  if (!nodes.length) {
+    return {
+      directEvidenceCount: 0,
+      localConfirmedCount: 0,
+      peerAttemptedCount: 0,
+      peerConfirmedCount: 0,
+      unavailableNodeIds: []
+    };
+  }
+  const selectedCoordinatorNodeId = readStringValue(
+    args.mesh?.coordinator?.preferredNodeId,
+    nodes[0]?.id,
+    nodes[0]?.nodeId
+  );
+  let localConfirmedCount = 0;
+  let peerAttemptedCount = 0;
+  let peerConfirmedCount = 0;
+  const unavailableNodeIds = [];
+  for (const [nodeIndex, node] of nodes.entries()) {
+    const nodeId = readStringValue(node?.id, node?.nodeId) || `node_${nodeIndex}`;
+    const workspace = readStringValue(node?.workspace);
+    const daemonId = readStringValue(node?.daemonId);
+    const isSelfNode = Boolean(
+      nodeId && selectedCoordinatorNodeId && nodeId === selectedCoordinatorNodeId
+    ) || Boolean(
+      daemonId && (daemonId === args.localMachineId || daemonId === args.statusInstanceId)
+    ) || Boolean(args.meshSource !== "local_config" && nodeIndex === 0);
+    if (!workspace) {
+      if (!isSelfNode && daemonId) unavailableNodeIds.push(nodeId);
+      continue;
+    }
+    if (isSelfNode && fs10.existsSync(workspace)) {
+      try {
+        const localGit = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+        if (localGit?.isGitRepo) {
+          recordInlineMeshDirectGitTruth(node, localGit, "selected_coordinator_local_git");
+          localConfirmedCount += 1;
+          continue;
+        }
+      } catch {
+      }
+    }
+    if (!daemonId || !args.dispatchMeshCommand) {
+      if (!isSelfNode) unavailableNodeIds.push(nodeId);
+      continue;
+    }
+    peerAttemptedCount += 1;
+    try {
+      const remoteGit = await probeRemoteMeshGitStatus({
+        dispatchMeshCommand: args.dispatchMeshCommand,
+        daemonId,
+        workspace,
+        timeoutMs: 8e3
+      });
+      if (remoteGit) {
+        recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+        peerConfirmedCount += 1;
+        continue;
+      }
+    } catch {
+    }
+    unavailableNodeIds.push(nodeId);
+  }
+  return {
+    directEvidenceCount: localConfirmedCount + peerConfirmedCount,
+    localConfirmedCount,
+    peerAttemptedCount,
+    peerConfirmedCount,
+    unavailableNodeIds
+  };
+}
+function summarizeMeshSessionRecord(record) {
+  return {
+    sessionId: readStringValue(record?.sessionId) || "unknown",
+    providerType: readStringValue(record?.providerType),
+    state: readLiveMeshSessionState(record),
+    lifecycle: readStringValue(record?.lifecycle),
+    surfaceKind: getSessionHostSurfaceKind(record),
+    recoveryState: readStringValue(record?.meta?.runtimeRecoveryState) ?? null,
+    workspace: readStringValue(record?.workspace) ?? null,
+    title: readStringValue(record?.displayName, record?.workspaceLabel) ?? null,
+    lastActivityAt: toIsoTimestamp(record?.updatedAt ?? record?.lastActivityAt ?? record?.last_activity_at),
+    isCached: false
+  };
+}
+function liveSessionRecordMatchesMeshNode(record, meshId, nodeId) {
+  const recordNodeId = readStringValue(record?.meta?.meshNodeId);
+  if (!recordNodeId || recordNodeId !== nodeId) return false;
+  const recordMeshId = readStringValue(record?.meta?.meshNodeFor);
+  return !recordMeshId || recordMeshId === meshId;
+}
+function liveSessionRecordMatchesMeshWorkspace(record, meshId, workspace) {
+  const recordWorkspace = readStringValue(record?.workspace);
+  if (!recordWorkspace || !workspace || recordWorkspace !== workspace) return false;
+  const recordMeshId = readStringValue(record?.meta?.meshNodeFor);
+  if (recordMeshId) return recordMeshId === meshId;
+  return record?.meta?.launchedByCoordinator === true || !!readStringValue(record?.meta?.meshNodeId);
+}
+function readLiveMeshNodeWorkspace(args) {
+  const directNodeWorkspace = args.liveSessionRecords.find((record) => liveSessionRecordMatchesMeshNode(record, args.meshId, args.nodeId) && readStringValue(record?.workspace));
+  if (directNodeWorkspace) {
+    return readStringValue(directNodeWorkspace.workspace) || "";
+  }
+  if (args.allowCoordinatorSession) {
+    const coordinatorWorkspace = args.liveSessionRecords.find((record) => readStringValue(record?.meta?.meshCoordinatorFor) === args.meshId && readStringValue(record?.workspace));
+    if (coordinatorWorkspace) {
+      return readStringValue(coordinatorWorkspace.workspace) || "";
+    }
+  }
+  return "";
+}
+function collectLiveMeshSessionRecords(args) {
+  const matches = args.liveSessionRecords.filter((record) => {
+    const nodeWorkspace = readStringValue(args.node?.workspace);
+    if (liveSessionRecordMatchesMeshNode(record, args.meshId, args.nodeId)) return true;
+    return !!nodeWorkspace && liveSessionRecordMatchesMeshWorkspace(record, args.meshId, nodeWorkspace);
+  });
+  if (args.allowCoordinatorSession) {
+    for (const record of args.liveSessionRecords) {
+      if (readStringValue(record?.meta?.meshCoordinatorFor) !== args.meshId) continue;
+      const sessionId = readStringValue(record?.sessionId);
+      if (sessionId && matches.some((entry) => readStringValue(entry?.sessionId) === sessionId)) continue;
+      matches.push(record);
+    }
+  }
+  return matches;
+}
+function applyCachedInlineMeshNodeStatus(status, node, options) {
+  const cachedStatus = readObjectRecord(node?.cachedStatus);
+  const liveGit = buildInlineMeshTransitGitStatus(node);
+  const git = options?.skipGit ? void 0 : liveGit ?? buildCachedInlineMeshGitStatus(node);
+  const error = options?.skipError ? void 0 : liveGit ? void 0 : readStringValue(cachedStatus.error, node?.error);
+  const health = options?.skipHealth ? void 0 : liveGit ? void 0 : readStringValue(cachedStatus.health, node?.health);
   const machineStatus = readStringValue(cachedStatus.machineStatus, node?.machineStatus);
-  if (!git && !error && !health) return false;
-  if (!machineStatus && !git && !error) return false;
+  const lastSeenAt = toIsoTimestamp(cachedStatus.lastSeenAt ?? cachedStatus.last_seen_at ?? node?.lastSeenAt ?? node?.last_seen_at);
+  const updatedAt = toIsoTimestamp(cachedStatus.updatedAt ?? cachedStatus.updated_at ?? node?.updatedAt ?? node?.updated_at);
+  const activeSessions = readCachedInlineMeshActiveSessions(node);
+  const activeSessionDetails = readCachedInlineMeshActiveSessionDetails(node);
+  if (!git && !error && !health && !machineStatus && !lastSeenAt && !updatedAt && activeSessions.length === 0) return false;
   if (git) status.git = git;
   if (error) status.error = error;
+  if (machineStatus) status.machineStatus = machineStatus;
+  if (lastSeenAt) status.lastSeenAt = lastSeenAt;
+  if (updatedAt) status.updatedAt = updatedAt;
+  if (activeSessions.length > 0) status.activeSessions = activeSessions;
+  if (activeSessionDetails.length > 0) status.activeSessionDetails = activeSessionDetails;
   if (health) {
     status.health = health;
     return true;
   }
   if (git) {
-    const dirty = Number(git.staged || 0) + Number(git.modified || 0) + Number(git.untracked || 0) + Number(git.deleted || 0) + Number(git.renamed || 0) > 0;
-    status.health = git.isGitRepo === false ? "degraded" : dirty ? "dirty" : "online";
+    status.health = deriveMeshNodeHealthFromGit(git);
     return true;
   }
-  return false;
+  return activeSessions.length > 0 || !!machineStatus || !!lastSeenAt || !!updatedAt;
 }
 async function resolveProviderTypeFromPriority(args) {
   if (!args.providerPriority.length) {
@@ -23951,15 +24561,92 @@ var REFINE_VALIDATION_TIMEOUT_MS = 12e4;
 var REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
 var REFINE_VALIDATION_SUMMARY_CHARS = 2e3;
 var REFINE_VALIDATION_MAX_COMMANDS = 4;
+var REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
 function truncateValidationOutput(value) {
   const text = typeof value === "string" ? value : value == null ? "" : String(value);
   if (text.length <= REFINE_VALIDATION_SUMMARY_CHARS) return text;
   return `${text.slice(0, REFINE_VALIDATION_SUMMARY_CHARS)}
 [truncated ${text.length - REFINE_VALIDATION_SUMMARY_CHARS} chars]`;
 }
+function recordMeshRefineStage(stages, stage, status, startedAt, details) {
+  stages.push({
+    stage,
+    status,
+    durationMs: Date.now() - startedAt,
+    ...details || {}
+  });
+}
+async function computeGitPatchId(cwd, fromRef, toRef) {
+  const { execFileSync: execFileSync4 } = await import("child_process");
+  const diff = execFileSync4("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+  });
+  if (!diff.trim()) return "";
+  const patchId = execFileSync4("git", ["patch-id", "--stable"], {
+    cwd,
+    input: diff,
+    encoding: "utf8",
+    maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+  }).trim();
+  return patchId.split(/\s+/)[0] || "";
+}
+async function runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead) {
+  const startedAt = Date.now();
+  try {
+    const { execFileSync: execFileSync4 } = await import("child_process");
+    const git = (args) => execFileSync4("git", args, {
+      cwd: repoRoot,
+      encoding: "utf8",
+      maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+    });
+    const mergeBase = git(["merge-base", baseHead, branchHead]).trim();
+    const mergeTreeStdout = git(["merge-tree", "--write-tree", baseHead, branchHead]);
+    const mergedTree = mergeTreeStdout.trim().split(/\s+/)[0] || "";
+    if (!mergeBase || !mergedTree) {
+      return {
+        status: "failed",
+        equivalent: false,
+        baseHead,
+        branchHead,
+        mergeBase: mergeBase || void 0,
+        mergedTree: mergedTree || void 0,
+        durationMs: Date.now() - startedAt,
+        error: "patch equivalence preflight could not resolve merge-base or synthetic merge tree",
+        stdout: truncateValidationOutput(mergeTreeStdout)
+      };
+    }
+    const expectedPatchId = await computeGitPatchId(repoRoot, mergeBase, branchHead);
+    const actualPatchId = await computeGitPatchId(repoRoot, baseHead, mergedTree);
+    const equivalent = expectedPatchId === actualPatchId;
+    return {
+      status: equivalent ? "passed" : "failed",
+      equivalent,
+      baseHead,
+      branchHead,
+      mergeBase,
+      mergedTree,
+      expectedPatchId,
+      actualPatchId,
+      durationMs: Date.now() - startedAt
+    };
+  } catch (e) {
+    return {
+      status: "failed",
+      equivalent: false,
+      baseHead,
+      branchHead,
+      durationMs: Date.now() - startedAt,
+      error: e?.message || String(e),
+      stdout: truncateValidationOutput(e?.stdout),
+      stderr: truncateValidationOutput(e?.stderr)
+    };
+  }
+}
 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 {
@@ -24167,13 +24854,13 @@ function serializeMeshCoordinatorMcpConfig(config, format) {
 }
 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 };
@@ -24207,10 +24894,10 @@ function stripHermesCoordinatorTempModelProviderOverrides(config) {
   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);
@@ -24314,30 +25001,97 @@ var DaemonCommandRouter = class {
    *  Allows the MCP server to query mesh data via get_mesh even when
    *  the mesh doesn't exist in the local meshes.json file. */
   inlineMeshCache = /* @__PURE__ */ new Map();
+  /** Coordinator-owned whole-mesh aggregate status snapshots. Browser callers read this by default. */
+  aggregateMeshStatusCache = /* @__PURE__ */ new Map();
   constructor(deps) {
     this.deps = deps;
   }
+  cloneJsonValue(value) {
+    if (typeof structuredClone === "function") return structuredClone(value);
+    return JSON.parse(JSON.stringify(value));
+  }
+  getCachedAggregateMeshStatus(meshId) {
+    const cached = this.aggregateMeshStatusCache.get(meshId);
+    if (!cached?.snapshot || cached.snapshot.success !== true || !Array.isArray(cached.snapshot.nodes)) return null;
+    const snapshot = this.cloneJsonValue(cached.snapshot);
+    const ageMs = Math.max(0, Date.now() - cached.builtAt);
+    const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
+    snapshot.sourceOfTruth = {
+      ...sourceOfTruth,
+      aggregateSnapshot: {
+        ...sourceOfTruth.aggregateSnapshot && typeof sourceOfTruth.aggregateSnapshot === "object" ? sourceOfTruth.aggregateSnapshot : {},
+        owner: "coordinator_daemon_memory",
+        cached: true,
+        source: "memory",
+        refreshReason: "memory_cache_hit",
+        ageMs,
+        cachedAt: new Date(cached.builtAt).toISOString(),
+        returnedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    };
+    return snapshot;
+  }
+  rememberAggregateMeshStatus(meshId, snapshot, refreshReason) {
+    if (!snapshot || typeof snapshot !== "object" || snapshot.success !== true || !Array.isArray(snapshot.nodes)) return snapshot;
+    const builtAt = Date.now();
+    const next = this.cloneJsonValue(snapshot);
+    const sourceOfTruth = next.sourceOfTruth && typeof next.sourceOfTruth === "object" ? next.sourceOfTruth : {};
+    next.sourceOfTruth = {
+      ...sourceOfTruth,
+      aggregateSnapshot: {
+        owner: "coordinator_daemon_memory",
+        cached: false,
+        source: "live_refresh",
+        refreshReason,
+        ageMs: 0,
+        cachedAt: new Date(builtAt).toISOString(),
+        returnedAt: new Date(builtAt).toISOString()
+      }
+    };
+    this.aggregateMeshStatusCache.set(meshId, { builtAt, snapshot: this.cloneJsonValue(next) });
+    return next;
+  }
   getCachedInlineMesh(meshId, inlineMesh) {
     if (inlineMesh && typeof inlineMesh === "object") {
-      this.inlineMeshCache.set(meshId, inlineMesh);
-      return inlineMesh;
+      return this.warmInlineMeshCache(meshId, inlineMesh);
     }
     return this.inlineMeshCache.get(meshId);
   }
+  warmInlineMeshCache(meshId, inlineMesh) {
+    if (!inlineMesh || typeof inlineMesh !== "object") return void 0;
+    const sanitizedInlineMesh = sanitizeInlineMesh(inlineMesh);
+    const cached = this.inlineMeshCache.get(meshId);
+    if (cached) {
+      const merged = reconcileInlineMeshCache(cached, sanitizedInlineMesh);
+      this.inlineMeshCache.set(meshId, merged);
+      return merged;
+    }
+    this.inlineMeshCache.set(meshId, sanitizedInlineMesh);
+    return sanitizedInlineMesh;
+  }
   async getMeshForCommand(meshId, inlineMesh, options) {
     const preferInline = options?.preferInline === true;
     if (preferInline) {
-      const cached2 = this.getCachedInlineMesh(meshId, inlineMesh);
-      if (cached2) return { mesh: cached2, inline: true };
+      const cached2 = this.getCachedInlineMesh(meshId);
+      if (cached2) return { mesh: cached2, inline: true, source: "inline_cache" };
+      if (inlineMeshCarriesTransientNodeTruth(inlineMesh)) {
+        this.warmInlineMeshCache(meshId, inlineMesh);
+        return { mesh: inlineMesh, inline: true, source: "inline_bootstrap" };
+      }
     }
     try {
       const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
       const mesh = getMesh3(meshId);
-      if (mesh) return { mesh, inline: false };
+      if (mesh) return { mesh, inline: false, source: "local_config" };
     } catch {
     }
-    const cached = this.getCachedInlineMesh(meshId, inlineMesh);
-    return cached ? { mesh: cached, inline: true } : null;
+    const cached = this.getCachedInlineMesh(meshId);
+    if (cached) return { mesh: cached, inline: true, source: "inline_cache" };
+    const warmedInline = this.warmInlineMeshCache(meshId, inlineMesh);
+    return warmedInline ? { mesh: warmedInline, inline: true, source: "inline_bootstrap" } : null;
+  }
+  invalidateAggregateMeshStatus(meshId) {
+    this.aggregateMeshStatusCache.delete(meshId);
   }
   updateInlineMeshNode(meshId, mesh, node) {
     if (!mesh || !Array.isArray(mesh.nodes) || !node?.id) return;
@@ -24346,6 +25100,7 @@ var DaemonCommandRouter = class {
     else mesh.nodes.push(node);
     mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.inlineMeshCache.set(meshId, mesh);
+    this.invalidateAggregateMeshStatus(meshId);
   }
   removeInlineMeshNode(meshId, mesh, nodeId) {
     if (!mesh || !Array.isArray(mesh.nodes)) return false;
@@ -24354,6 +25109,7 @@ var DaemonCommandRouter = class {
     mesh.nodes.splice(idx, 1);
     mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.inlineMeshCache.set(meshId, mesh);
+    this.invalidateAggregateMeshStatus(meshId);
     return true;
   }
   normalizeMeshSessionCleanupMode(value) {
@@ -24402,7 +25158,7 @@ var DaemonCommandRouter = class {
     }
     const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
     const normalizePath = (value) => {
-      const resolved = (0, import_path6.resolve)(value);
+      const resolved = (0, import_path7.resolve)(value);
       try {
         return fs10.realpathSync(resolved);
       } catch {
@@ -24566,6 +25322,7 @@ var DaemonCommandRouter = class {
     const deletedSessionIds = [];
     const skippedSessionIds = [];
     const skippedLiveSessionIds = [];
+    const skippedCoordinatorSessionIds = [];
     const deleteUnsupportedSessionIds = [];
     const recordsRemainSessionIds = [];
     const errors = [];
@@ -24598,6 +25355,12 @@ var DaemonCommandRouter = class {
       const completed = this.isCompletedHostedSession(record);
       const surfaceKind = getSessionHostSurfaceKind(record);
       const liveRuntime = surfaceKind === "live_runtime";
+      const coordinatorSession = readStringValue(record?.meta?.meshCoordinatorFor) === args.meshId;
+      if (!hasExplicitSessionIds && coordinatorSession) {
+        skippedSessionIds.push(sessionId);
+        skippedCoordinatorSessionIds.push(sessionId);
+        continue;
+      }
       if (!hasExplicitSessionIds && liveRuntime) {
         skippedSessionIds.push(sessionId);
         skippedLiveSessionIds.push(sessionId);
@@ -24663,6 +25426,7 @@ var DaemonCommandRouter = class {
       deletedSessionIds,
       skippedSessionIds,
       skippedLiveSessionIds,
+      skippedCoordinatorSessionIds,
       ...deleteUnsupported ? {
         deleteUnsupported: true,
         effectiveCleanup: args.mode === "stop_and_delete" ? "stopped_only_records_remain" : "delete_unsupported_records_remain",
@@ -24795,7 +25559,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":
@@ -25324,15 +26089,39 @@ var DaemonCommandRouter = class {
       case "get_mesh": {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         if (!meshId) return { success: false, error: "meshId required" };
-        try {
-          const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-          const mesh = getMesh3(meshId);
-          if (mesh) return { success: true, mesh };
-        } catch {
+        const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+        if (!meshRecord?.mesh) return { success: false, error: "Mesh not found" };
+        const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+        const directTruth = await hydrateInlineMeshDirectTruth({
+          mesh: meshRecord.mesh,
+          meshSource: meshRecord.source,
+          dispatchMeshCommand: this.deps.dispatchMeshCommand,
+          statusInstanceId: this.deps.statusInstanceId,
+          localMachineId: loadConfig().machineId || ""
+        });
+        const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
+        const sourceOfTruth = {
+          membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+          coordinatorOwnsLiveTruth: directTruthSatisfied,
+          directPeerTruth: {
+            required: requireDirectPeerTruth,
+            satisfied: directTruthSatisfied,
+            directEvidenceCount: directTruth.directEvidenceCount,
+            localConfirmedCount: directTruth.localConfirmedCount,
+            peerAttemptedCount: directTruth.peerAttemptedCount,
+            peerConfirmedCount: directTruth.peerConfirmedCount,
+            unavailableNodeIds: directTruth.unavailableNodeIds
+          }
+        };
+        if (requireDirectPeerTruth && !directTruthSatisfied) {
+          return {
+            success: false,
+            code: "mesh_direct_peer_truth_unavailable",
+            error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct get_mesh probes succeed.",
+            sourceOfTruth
+          };
         }
-        const cached = this.inlineMeshCache.get(meshId);
-        if (cached) return { success: true, mesh: cached };
-        return { success: false, error: "Mesh not found" };
+        return { success: true, mesh: meshRecord.mesh, sourceOfTruth };
       }
       case "create_mesh": {
         const name = typeof args?.name === "string" ? args.name.trim() : "";
@@ -25362,6 +26151,7 @@ var DaemonCommandRouter = class {
           const mesh = updateMesh2(meshId, patch);
           if (!mesh) return { success: false, error: "Mesh not found" };
           this.inlineMeshCache.set(meshId, mesh);
+          this.invalidateAggregateMeshStatus(meshId);
           return { success: true, mesh };
         } catch (e) {
           return { success: false, error: e.message };
@@ -25551,26 +26341,41 @@ var DaemonCommandRouter = class {
         const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
         const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
         if (!meshId || !nodeId) return { success: false, error: "meshId and nodeId required" };
+        const refineStages = [];
         try {
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh);
           const mesh = meshRecord?.mesh;
           const node = mesh?.nodes?.find((n) => n.id === nodeId || n.nodeId === nodeId);
-          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh` };
+          if (!node) return { success: false, error: `Node '${nodeId}' not found in mesh`, refineStages };
           if (!node.isLocalWorktree || !node.workspace) {
-            return { success: false, error: `Refinery requires a local worktree node` };
+            return { success: false, error: `Refinery requires a local worktree node`, refineStages };
           }
           const sourceNode = node.clonedFromNodeId ? mesh?.nodes.find((n) => n.id === node.clonedFromNodeId || n.nodeId === node.clonedFromNodeId) : mesh?.nodes.find((n) => !n.isLocalWorktree);
           const repoRoot = sourceNode?.repoRoot || sourceNode?.workspace;
-          if (!repoRoot) return { success: false, error: "Source node repoRoot not found" };
+          if (!repoRoot) return { success: false, error: "Source node repoRoot not found", refineStages };
           const { execFile: execFile3 } = await import("child_process");
           const { promisify: promisify3 } = await import("util");
           const execFileAsync3 = promisify3(execFile3);
+          const resolveStarted = Date.now();
           const { stdout: branchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: node.workspace, encoding: "utf8" });
           const branch = branchStdout.trim();
-          if (!branch) return { success: false, error: "Could not determine branch of the worktree node" };
+          if (!branch) return { success: false, error: "Could not determine branch of the worktree node", refineStages };
           const { stdout: baseBranchStdout } = await execFileAsync3("git", ["branch", "--show-current"], { cwd: repoRoot, encoding: "utf8" });
           const baseBranch = baseBranchStdout.trim();
+          const { stdout: baseHeadStdout } = await execFileAsync3("git", ["rev-parse", "HEAD"], { cwd: repoRoot, encoding: "utf8" });
+          const { stdout: branchHeadStdout } = await execFileAsync3("git", ["rev-parse", branch], { cwd: node.workspace, encoding: "utf8" });
+          const baseHead = baseHeadStdout.trim();
+          const branchHead = branchHeadStdout.trim();
+          recordMeshRefineStage(refineStages, "resolve_refs", "passed", resolveStarted, { branch, baseBranch, baseHead, branchHead });
+          const validationStarted = Date.now();
           const validationSummary = await runMeshRefineValidationGate(mesh, node.workspace);
+          recordMeshRefineStage(
+            refineStages,
+            "validation",
+            validationSummary.status === "passed" ? "passed" : validationSummary.status === "failed" ? "failed" : "skipped",
+            validationStarted,
+            { validationStatus: validationSummary.status, commandsRun: validationSummary.commandsRun.length }
+          );
           if (validationSummary.status === "failed") {
             return {
               success: false,
@@ -25580,6 +26385,7 @@ var DaemonCommandRouter = class {
               branch,
               into: baseBranch,
               validationSummary,
+              refineStages,
               finalBranchConvergenceState: {
                 branch,
                 baseBranch,
@@ -25599,6 +26405,7 @@ var DaemonCommandRouter = class {
               branch,
               into: baseBranch,
               validationSummary,
+              refineStages,
               finalBranchConvergenceState: {
                 branch,
                 baseBranch,
@@ -25609,37 +26416,121 @@ var DaemonCommandRouter = class {
               }
             };
           }
+          const patchEquivalenceStarted = Date.now();
+          const patchEquivalence = await runMeshRefinePatchEquivalenceGate(repoRoot, baseHead, branchHead);
+          recordMeshRefineStage(refineStages, "patch_equivalence", patchEquivalence.status, patchEquivalenceStarted, {
+            equivalent: patchEquivalence.equivalent,
+            expectedPatchId: patchEquivalence.expectedPatchId,
+            actualPatchId: patchEquivalence.actualPatchId,
+            error: patchEquivalence.error
+          });
+          if (!patchEquivalence.equivalent) {
+            return {
+              success: false,
+              code: "patch_equivalence_failed",
+              convergenceStatus: "blocked_review",
+              error: "Refinery patch-equivalence preflight failed; merge/refine was not attempted.",
+              branch,
+              into: baseBranch,
+              validationSummary,
+              patchEquivalence,
+              refineStages,
+              finalBranchConvergenceState: {
+                branch,
+                baseBranch,
+                merged: false,
+                removed: false,
+                validation: "passed",
+                patchEquivalence: "failed",
+                status: "blocked_review"
+              }
+            };
+          }
+          let mergeResult;
+          const mergeStarted = Date.now();
           try {
-            await execFileAsync3("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
+            const result = await execFileAsync3("git", ["merge", "--no-ff", branch, "-m", `Auto-merge branch '${branch}' via Refinery`], { cwd: repoRoot, encoding: "utf8" });
+            mergeResult = {
+              stdout: truncateValidationOutput(result.stdout),
+              stderr: truncateValidationOutput(result.stderr),
+              durationMs: Date.now() - mergeStarted
+            };
+            recordMeshRefineStage(refineStages, "merge", "passed", mergeStarted, mergeResult);
           } catch (e) {
+            recordMeshRefineStage(refineStages, "merge", "failed", mergeStarted, {
+              error: e?.message || String(e),
+              stdout: truncateValidationOutput(e?.stdout),
+              stderr: truncateValidationOutput(e?.stderr)
+            });
             return {
               success: false,
               error: `Merge failed (conflicts?): ${e.message}`,
               validationSummary,
+              patchEquivalence,
+              refineStages,
               finalBranchConvergenceState: {
                 branch,
                 baseBranch,
                 merged: false,
                 removed: false,
                 validation: "passed",
+                patchEquivalence: "passed",
                 status: "not_mergeable"
               }
             };
           }
+          const cleanupStarted = Date.now();
           const removeResult = await this.execute("remove_mesh_node", {
             meshId,
             nodeId,
-            sessionCleanupMode: "kill",
+            sessionCleanupMode: "preserve",
             inlineMesh: args?.inlineMesh
           });
+          recordMeshRefineStage(refineStages, "cleanup", removeResult?.success === false ? "failed" : "passed", cleanupStarted, {
+            removed: removeResult?.removed,
+            code: removeResult?.code,
+            error: removeResult?.error
+          });
+          let ledgerError;
+          const ledgerStarted = Date.now();
           try {
             const { appendLedgerEntry: appendLedgerEntry2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
             appendLedgerEntry2(meshId, {
               kind: "node_removed",
               nodeId,
-              payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary }
+              payload: { refined: true, mergedBranch: branch, into: baseBranch, validationSummary, patchEquivalence }
             });
-          } catch {
+            recordMeshRefineStage(refineStages, "ledger", "passed", ledgerStarted);
+          } catch (e) {
+            ledgerError = e?.message || String(e);
+            recordMeshRefineStage(refineStages, "ledger", "failed", ledgerStarted, { error: ledgerError });
+          }
+          const finalBranchConvergenceState = {
+            branch: baseBranch,
+            mergedBranch: branch,
+            baseBranch,
+            merged: true,
+            removed: removeResult?.success !== false,
+            validation: "passed",
+            patchEquivalence: "passed",
+            status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
+          };
+          if (removeResult?.success === false) {
+            return {
+              success: false,
+              code: "cleanup_failed",
+              error: "Refinery merge completed but worktree cleanup failed; manual cleanup/retry is required.",
+              merged: true,
+              branch,
+              into: baseBranch,
+              removeResult,
+              validationSummary,
+              patchEquivalence,
+              mergeResult,
+              refineStages,
+              ...ledgerError ? { ledgerError } : {},
+              finalBranchConvergenceState
+            };
           }
           return {
             success: true,
@@ -25648,18 +26539,14 @@ var DaemonCommandRouter = class {
             into: baseBranch,
             removeResult,
             validationSummary,
-            finalBranchConvergenceState: {
-              branch: baseBranch,
-              mergedBranch: branch,
-              baseBranch,
-              merged: true,
-              removed: removeResult?.success !== false,
-              validation: "passed",
-              status: removeResult?.success === false ? "merged_cleanup_failed" : "merged"
-            }
+            patchEquivalence,
+            mergeResult,
+            refineStages,
+            ...ledgerError ? { ledgerError } : {},
+            finalBranchConvergenceState
           };
         } catch (e) {
-          return { success: false, error: e.message };
+          return { success: false, error: e.message, refineStages };
         }
       }
       case "remove_mesh_node": {
@@ -25700,6 +26587,7 @@ var DaemonCommandRouter = class {
           } else {
             const { removeNode: removeNode3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
             removed = removeNode3(meshId, nodeId);
+            if (removed) this.invalidateAggregateMeshStatus(meshId);
           }
           if (removed) {
             try {
@@ -25778,6 +26666,7 @@ var DaemonCommandRouter = class {
               policy: { ...sourceNode.policy || {} }
             });
             if (!node) return { success: false, error: "Failed to register worktree node" };
+            this.invalidateAggregateMeshStatus(meshId);
           }
           const initSubmodules = sourceNode.policy?.initSubmodulesOnClone !== false;
           if (initSubmodules) {
@@ -25853,7 +26742,14 @@ var DaemonCommandRouter = class {
               cliType
             };
           }
-          const workspace = typeof coordinatorNode.workspace === "string" ? coordinatorNode.workspace.trim() : "";
+          const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
+          const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
+          const workspace = readLiveMeshNodeWorkspace({
+            meshId,
+            nodeId: String(coordinatorNode.id || coordinatorNode.nodeId || preferredCoordinatorNodeId || ""),
+            liveSessionRecords: liveMeshSessions,
+            allowCoordinatorSession: true
+          }) || (typeof coordinatorNode.workspace === "string" ? coordinatorNode.workspace.trim() : "");
           if (!workspace) return { success: false, error: "Coordinator node workspace required", meshId, cliType };
           if (!cliType) {
             const resolved = await resolveProviderTypeFromPriority({
@@ -26015,7 +26911,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;
@@ -26058,14 +26954,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");
@@ -26155,110 +27051,264 @@ ${block}`);
           const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
           const mesh = meshRecord?.mesh;
           if (!mesh) return { success: false, error: "Mesh not found" };
+          const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
+          if (!refreshRequested) {
+            const cachedStatus = this.getCachedAggregateMeshStatus(meshId);
+            if (cachedStatus) return cachedStatus;
+          }
+          const refreshReason = refreshRequested ? "explicit_refresh" : "cold_cache_miss";
           const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
           const queue = getQueue2(meshId);
           const queueSummary = getMeshQueueStats2(meshId);
           const { readLedgerEntries: readLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const ledgerEntries = readLedgerEntries2(meshId, { tail: 20 });
           const ledgerSummary = getLedgerSummary2(meshId);
+          const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
+          const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
+          const localMachineId = loadConfig().machineId || "";
+          const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+          const directTruth = requireDirectPeerTruth ? await hydrateInlineMeshDirectTruth({
+            mesh,
+            meshSource: meshRecord.source,
+            dispatchMeshCommand: this.deps.dispatchMeshCommand,
+            statusInstanceId: this.deps.statusInstanceId,
+            localMachineId
+          }) : {
+            directEvidenceCount: 0,
+            localConfirmedCount: 0,
+            peerAttemptedCount: 0,
+            peerConfirmedCount: 0,
+            unavailableNodeIds: []
+          };
+          const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
+          if (requireDirectPeerTruth && !directTruthSatisfied) {
+            return {
+              success: false,
+              code: "mesh_direct_peer_truth_unavailable",
+              error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct mesh_status probes succeed.",
+              sourceOfTruth: {
+                membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+                coordinatorOwnsLiveTruth: false,
+                currentStatus: "direct_peer_truth_unavailable",
+                directPeerTruth: {
+                  required: true,
+                  satisfied: false,
+                  directEvidenceCount: directTruth.directEvidenceCount,
+                  localConfirmedCount: directTruth.localConfirmedCount,
+                  peerAttemptedCount: directTruth.peerAttemptedCount,
+                  peerConfirmedCount: directTruth.peerConfirmedCount,
+                  unavailableNodeIds: directTruth.unavailableNodeIds
+                }
+              }
+            };
+          }
+          const directTruthUnavailableNodeIds = new Set(directTruth.unavailableNodeIds);
+          const selectedCoordinatorNodeId = readStringValue(
+            mesh.coordinator?.preferredNodeId,
+            mesh.nodes?.[0]?.id,
+            mesh.nodes?.[0]?.nodeId
+          );
+          const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? selectedCoordinatorNodeId : void 0;
+          const refreshedAt = (/* @__PURE__ */ new Date()).toISOString();
           const nodeStatuses = [];
-          for (const node of mesh.nodes || []) {
+          for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
+            const nodeId = String(node.id || node.nodeId || "");
+            const daemonId = readStringValue(node.daemonId);
+            const providerPriority = readProviderPriorityFromPolicy(node.policy);
+            const isSelfNode = Boolean(
+              nodeId && inlineCoordinatorNodeId && nodeId === inlineCoordinatorNodeId
+            ) || Boolean(
+              daemonId && (daemonId === localMachineId || daemonId === this.deps.statusInstanceId)
+            ) || Boolean(meshRecord?.inline && nodeIndex === 0);
             const status = {
-              nodeId: node.id || node.nodeId,
+              nodeId,
               machineLabel: node.machineLabel || node.id || node.nodeId,
               workspace: node.workspace,
               repoRoot: node.repoRoot,
               isLocalWorktree: node.isLocalWorktree,
               worktreeBranch: node.worktreeBranch,
-              daemonId: node.daemonId,
+              daemonId,
               machineId: node.machineId,
+              machineStatus: node.machineStatus,
               health: "unknown",
               providers: node.providers || [],
-              activeSessions: []
+              providerPriority,
+              activeSessions: [],
+              activeSessionDetails: [],
+              launchReady: false
             };
-            if (node.workspace && typeof node.workspace === "string") {
-              if (!fs10.existsSync(node.workspace) && applyCachedInlineMeshNodeStatus(status, node)) {
-                nodeStatuses.push(status);
-                continue;
+            if (isSelfNode) {
+              status.connection = {
+                perspective: "selected_coordinator",
+                source: "mesh_peer_status",
+                state: "self",
+                transport: "local",
+                reported: true,
+                reason: "Selected coordinator daemon",
+                lastStateChangeAt: refreshedAt
+              };
+            } else if (daemonId) {
+              const connection = this.deps.getMeshPeerConnectionStatus?.(daemonId);
+              status.connection = connection ?? {
+                perspective: "selected_coordinator",
+                source: "not_reported",
+                state: "unknown",
+                transport: "unknown",
+                reported: false,
+                reason: "No live mesh peer telemetry reported by the selected coordinator yet."
+              };
+            } else {
+              status.connection = {
+                perspective: "selected_coordinator",
+                source: "not_reported",
+                state: "unknown",
+                transport: "unknown",
+                reported: false,
+                reason: "Node has no daemon id, so mesh transport cannot be reported from the selected coordinator."
+              };
+            }
+            const matchedLiveSessionRecords = collectLiveMeshSessionRecords({
+              meshId,
+              node,
+              nodeId,
+              liveSessionRecords: liveMeshSessions,
+              allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
+            });
+            const workspace = readLiveMeshNodeWorkspace({
+              meshId,
+              nodeId,
+              liveSessionRecords: matchedLiveSessionRecords,
+              allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
+            }) || (typeof node.workspace === "string" ? node.workspace : "");
+            status.workspace = workspace || node.workspace;
+            if (matchedLiveSessionRecords.length > 0) {
+              const sessionIds = matchedLiveSessionRecords.map((record) => typeof record?.sessionId === "string" ? record.sessionId : "").filter(Boolean);
+              const providerTypes = matchedLiveSessionRecords.map((record) => readStringValue(record?.providerType)).filter(Boolean);
+              status.activeSessions = sessionIds;
+              status.activeSessionDetails = matchedLiveSessionRecords.map(summarizeMeshSessionRecord);
+              if (providerTypes.length > 0) {
+                status.providers = Array.from(/* @__PURE__ */ new Set([...Array.isArray(status.providers) ? status.providers : [], ...providerTypes]));
               }
-              try {
-                const { execFile: execFile3 } = await import("child_process");
-                const { promisify: promisify3 } = await import("util");
-                const execFileAsync3 = promisify3(execFile3);
-                const runGit2 = async (args2) => {
-                  const result = await execFileAsync3("git", ["-C", node.workspace, ...args2], {
-                    encoding: "utf8",
-                    timeout: 1e4
-                  });
-                  return result.stdout.trim();
-                };
-                const branch = await runGit2(["branch", "--show-current"]).catch(() => "");
-                const porc = await runGit2(["status", "--porcelain"]).catch(() => "");
-                const headCommit = await runGit2(["rev-parse", "--short", "HEAD"]).catch(() => null);
-                const headMessage = await runGit2(["log", "-1", "--format=%s"]).catch(() => null);
-                const upstream = await runGit2(["rev-parse", "--abbrev-ref", "@{upstream}"]).catch(() => null);
-                const aheadBehind = await runGit2(["rev-list", "--left-right", "--count", "@{upstream}...HEAD"]).catch(() => "");
-                const stashCount = await runGit2(["stash", "list"]).catch(() => "");
-                let ahead = 0, behind = 0;
-                if (aheadBehind) {
-                  const parts = aheadBehind.split(/\s+/);
-                  if (parts.length >= 2) {
-                    behind = parseInt(parts[0], 10) || 0;
-                    ahead = parseInt(parts[1], 10) || 0;
+            }
+            if (workspace) {
+              if (!fs10.existsSync(workspace)) {
+                const inlineTransitGit = buildInlineMeshTransitGitStatus(node);
+                let remoteProbeApplied = false;
+                if (inlineTransitGit) {
+                  status.git = inlineTransitGit;
+                  status.health = inlineTransitGit.isGitRepo ? deriveMeshNodeHealthFromGit(inlineTransitGit) : "degraded";
+                  remoteProbeApplied = true;
+                } else if (!isSelfNode && daemonId && this.deps.dispatchMeshCommand && !directTruthUnavailableNodeIds.has(nodeId)) {
+                  try {
+                    const remoteGit = await probeRemoteMeshGitStatus({
+                      dispatchMeshCommand: this.deps.dispatchMeshCommand,
+                      daemonId,
+                      workspace,
+                      timeoutMs: 8e3
+                    });
+                    if (remoteGit) {
+                      status.git = remoteGit;
+                      status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
+                      recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+                      remoteProbeApplied = true;
+                    }
+                  } catch {
+                    const refreshedConnection = this.deps.getMeshPeerConnectionStatus?.(daemonId);
+                    const refreshedConnectionState = readStringValue(refreshedConnection?.state);
+                    if (refreshedConnection && refreshedConnectionState === "connected") {
+                      status.connection = refreshedConnection;
+                      try {
+                        const remoteGit = await probeRemoteMeshGitStatus({
+                          dispatchMeshCommand: this.deps.dispatchMeshCommand,
+                          daemonId,
+                          workspace,
+                          timeoutMs: 12e3
+                        });
+                        if (remoteGit) {
+                          status.git = remoteGit;
+                          status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
+                          recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+                          remoteProbeApplied = true;
+                        }
+                      } catch {
+                      }
+                    }
                   }
                 }
-                const dirty = porc.length > 0;
-                const lines = porc ? porc.split("\n").filter(Boolean) : [];
-                let staged = 0, modified = 0, untracked = 0, deleted = 0, renamed = 0;
-                for (const line of lines) {
-                  const xy = line.slice(0, 2);
-                  if (xy[0] !== " " && xy[0] !== "?") staged++;
-                  if (xy[1] === "M") modified++;
-                  if (xy[1] === "D") deleted++;
-                  if (xy[0] === "R" || xy[1] === "R") renamed++;
-                  if (xy === "??") untracked++;
+                if (!remoteProbeApplied) {
+                  const connectionState = readStringValue(status.connection?.state);
+                  const pendingPeerGitProbe = !inlineTransitGit && !isSelfNode && !!daemonId && (readStringValue(status.machineStatus) === "online" || readStringValue(status.health) === "online" || connectionState === "connecting" || connectionState === "connected" || connectionState === "unknown");
+                  if (pendingPeerGitProbe) {
+                    status.gitProbePending = true;
+                    status.health = "unknown";
+                  }
+                  if (applyCachedInlineMeshNodeStatus(
+                    status,
+                    node,
+                    pendingPeerGitProbe ? { skipGit: true, skipError: true, skipHealth: true } : void 0
+                  )) {
+                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
+                    nodeStatuses.push(status);
+                    continue;
+                  }
+                  if (meshRecord?.source === "inline_cache" && !isSelfNode) {
+                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
+                    nodeStatuses.push(status);
+                    continue;
+                  }
                 }
-                status.git = {
-                  workspace: node.workspace,
-                  repoRoot: node.workspace,
-                  isGitRepo: true,
-                  branch: branch || null,
-                  headCommit,
-                  headMessage,
-                  upstream,
-                  ahead,
-                  behind,
-                  staged,
-                  modified,
-                  untracked,
-                  deleted,
-                  renamed,
-                  hasConflicts: false,
-                  conflictFiles: [],
-                  stashCount: stashCount ? stashCount.split("\n").filter(Boolean).length : 0,
-                  lastCheckedAt: Date.now()
-                };
-                status.health = branch ? dirty ? "dirty" : "online" : "degraded";
-              } catch {
-                if (!applyCachedInlineMeshNodeStatus(status, node)) {
-                  status.health = "degraded";
+              } else {
+                try {
+                  const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+                  status.git = gitStatus;
+                  recordInlineMeshDirectGitTruth(node, gitStatus, "selected_coordinator_local_git");
+                  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 {
               applyCachedInlineMeshNodeStatus(status, node);
             }
+            finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
             nodeStatuses.push(status);
           }
-          return {
+          const statusResult = {
             success: true,
             meshId: mesh.id,
             meshName: mesh.name,
             repoIdentity: mesh.repoIdentity,
             defaultBranch: mesh.defaultBranch,
+            refreshedAt,
+            sourceOfTruth: {
+              membership: meshRecord?.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord?.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+              coordinatorOwnsLiveTruth: directTruthSatisfied,
+              ...requireDirectPeerTruth ? {
+                currentStatus: directTruthSatisfied ? "live_git_and_session_probes" : "direct_peer_truth_unavailable",
+                directPeerTruth: {
+                  required: true,
+                  satisfied: directTruthSatisfied,
+                  directEvidenceCount: directTruth.directEvidenceCount,
+                  localConfirmedCount: directTruth.localConfirmedCount,
+                  peerAttemptedCount: directTruth.peerAttemptedCount,
+                  peerConfirmedCount: directTruth.peerConfirmedCount,
+                  unavailableNodeIds: directTruth.unavailableNodeIds
+                }
+              } : {},
+              historicalEvidenceOnly: ["recoveryHints", "ledger.summary", "queue.summary"]
+            },
             nodes: nodeStatuses,
             queue: { tasks: queue, summary: queueSummary },
             ledger: { entries: ledgerEntries, summary: ledgerSummary }
           };
+          return this.rememberAggregateMeshStatus(meshId, statusResult, refreshReason);
         } catch (e) {
           return { success: false, error: e.message };
         }
@@ -34184,6 +35234,7 @@ async function initDaemonComponents(config) {
     sessionHostControl: config.sessionHostControl,
     statusInstanceId: config.statusInstanceId,
     statusVersion: config.statusVersion,
+    getMeshPeerConnectionStatus: config.getMeshPeerConnectionStatus,
     getCdpLogFn: config.getCdpLogFn || ((ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn())
   });
   poller = new AgentStreamPoller({
@@ -34459,6 +35510,7 @@ async function shutdownDaemonComponents(components) {
   prepareSessionChatTailUpdate,
   prepareSessionModalUpdate,
   probeCdpPort,
+  queuePendingMeshCoordinatorEvent,
   readChatHistory,
   readLedgerEntries,
   readLedgerSlice,