@adhdev/daemon-standalone 0.9.82-rc.4 → 0.9.82-rc.40

package/dist/index.js

@@ -23490,6 +23490,36 @@ Follow these recovery rules:
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
       return (0, import_path4.join)(getLedgerDir(), `${safe}.queue.json`);
     }
+    function getLockPath(meshId) {
+      const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+      return (0, import_path4.join)(getLedgerDir(), `${safe}.queue.lock`);
+    }
+    function withQueueLock(meshId, fn) {
+      const lockPath = getLockPath(meshId);
+      let fd = -1;
+      for (let i = 0; i < 10; i++) {
+        try {
+          fd = (0, import_fs4.openSync)(lockPath, "wx");
+          break;
+        } catch {
+          const deadline = Date.now() + 30;
+          while (Date.now() < deadline) {
+          }
+        }
+      }
+      try {
+        return fn();
+      } finally {
+        if (fd !== -1) try {
+          (0, import_fs4.closeSync)(fd);
+        } catch {
+        }
+        try {
+          (0, import_fs4.unlinkSync)(lockPath);
+        } catch {
+        }
+      }
+    }
     function readQueue(meshId) {
       const path28 = getQueuePath(meshId);
       if (!(0, import_fs4.existsSync)(path28)) return [];
@@ -23505,20 +23535,22 @@ Follow these recovery rules:
       (0, import_fs4.writeFileSync)(path28, JSON.stringify(queue, null, 2), "utf-8");
     }
     function enqueueTask(meshId, message, opts) {
-      const queue = readQueue(meshId);
-      const entry = {
-        id: (0, import_crypto5.randomUUID)(),
-        meshId,
-        message,
-        status: "pending",
-        targetNodeId: opts?.targetNodeId,
-        targetSessionId: opts?.targetSessionId,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
-      queue.push(entry);
-      writeQueue(meshId, queue);
-      return entry;
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const entry = {
+          id: (0, import_crypto5.randomUUID)(),
+          meshId,
+          message,
+          status: "pending",
+          targetNodeId: opts?.targetNodeId,
+          targetSessionId: opts?.targetSessionId,
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        queue.push(entry);
+        writeQueue(meshId, queue);
+        return entry;
+      });
     }
     function getQueue(meshId, opts) {
       let queue = readQueue(meshId);
@@ -23529,100 +23561,111 @@ Follow these recovery rules:
       return queue;
     }
     function claimNextTask(meshId, nodeId, sessionId) {
-      const queue = readQueue(meshId);
-      const hasActiveAssignment = queue.some((q) => q.status === "assigned" && (q.assignedSessionId === sessionId || q.assignedNodeId === nodeId));
-      if (hasActiveAssignment) return null;
-      let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetSessionId === sessionId);
-      if (targetIdx === -1) {
-        targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
-      }
-      if (targetIdx === -1) {
-        targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
-      }
-      if (targetIdx === -1) return null;
-      const entry = queue[targetIdx];
-      entry.status = "assigned";
-      entry.assignedNodeId = nodeId;
-      entry.assignedSessionId = sessionId;
-      entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-      entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      writeQueue(meshId, queue);
-      return entry;
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const hasActiveAssignment = queue.some((q) => q.status === "assigned" && (q.assignedSessionId === sessionId || q.assignedNodeId === nodeId));
+        if (hasActiveAssignment) return null;
+        let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetSessionId === sessionId);
+        if (targetIdx === -1) {
+          targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
+        }
+        if (targetIdx === -1) {
+          targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
+        }
+        if (targetIdx === -1) return null;
+        const entry = queue[targetIdx];
+        entry.status = "assigned";
+        entry.assignedNodeId = nodeId;
+        entry.assignedSessionId = sessionId;
+        entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+        entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        writeQueue(meshId, queue);
+        return entry;
+      });
     }
     function updateTaskStatus(meshId, taskId, status) {
-      const queue = readQueue(meshId);
-      const idx = queue.findIndex((q) => q.id === taskId);
-      if (idx === -1) return null;
-      queue[idx].status = status;
-      queue[idx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      writeQueue(meshId, queue);
-      return queue[idx];
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const idx = queue.findIndex((q) => q.id === taskId);
+        if (idx === -1) return null;
+        queue[idx].status = status;
+        queue[idx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+        writeQueue(meshId, queue);
+        return queue[idx];
+      });
     }
     function recordTaskAutoLaunch(meshId, taskId, autoLaunch) {
-      const queue = readQueue(meshId);
-      const idx = queue.findIndex((q) => q.id === taskId);
-      if (idx === -1) return null;
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      queue[idx].autoLaunch = {
-        ...autoLaunch,
-        updatedAt: now
-      };
-      queue[idx].updatedAt = now;
-      writeQueue(meshId, queue);
-      return queue[idx];
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const idx = queue.findIndex((q) => q.id === taskId);
+        if (idx === -1) return null;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        queue[idx].autoLaunch = { ...autoLaunch, updatedAt: now };
+        queue[idx].updatedAt = now;
+        writeQueue(meshId, queue);
+        return queue[idx];
+      });
     }
     function cancelTask(meshId, taskId, opts) {
-      const queue = readQueue(meshId);
-      const idx = queue.findIndex((q) => q.id === taskId);
-      if (idx === -1) return null;
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      queue[idx].status = "cancelled";
-      queue[idx].updatedAt = now;
-      queue[idx].cancelledAt = now;
-      if (opts?.reason) queue[idx].cancelReason = opts.reason;
-      writeQueue(meshId, queue);
-      return queue[idx];
+      return withQueueLock(meshId, () => {
+        const queue = readQueue(meshId);
+        const idx = queue.findIndex((q) => q.id === taskId);
+        if (idx === -1) return null;
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        queue[idx].status = "cancelled";
+        queue[idx].updatedAt = now;
+        queue[idx].cancelledAt = now;
+        if (opts?.reason) queue[idx].cancelReason = opts.reason;
+        writeQueue(meshId, queue);
+        return queue[idx];
+      });
     }
     function requeueTask(meshId, taskId, opts) {
-      const queue = readQueue(meshId);
-      const idx = queue.findIndex((q) => q.id === taskId);
-      if (idx === -1) return null;
-      const entry = queue[idx];
-      const now = (/* @__PURE__ */ new Date()).toISOString();
-      entry.status = "pending";
-      delete entry.assignedNodeId;
-      delete entry.assignedSessionId;
-      delete entry.cancelledAt;
-      delete entry.cancelReason;
-      if (opts?.clearTargetNode) delete entry.targetNodeId;
-      if (typeof opts?.targetNodeId === "string") entry.targetNodeId = opts.targetNodeId;
-      if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
-      if (typeof opts?.targetSessionId === "string") entry.targetSessionId = opts.targetSessionId;
-      entry.updatedAt = now;
-      entry.requeuedAt = now;
-      entry.requeueCount = (entry.requeueCount || 0) + 1;
-      if (opts?.reason) entry.requeueReason = opts.reason;
-      writeQueue(meshId, queue);
-      return entry;
-    }
-    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 time3 = new Date(queue[i].dispatchTimestamp || queue[i].updatedAt).getTime();
+          if (hasOccurredAt && Number.isFinite(time3) && time3 > occurredAtTime) continue;
           if (time3 > bestTime) {
             bestTime = time3;
             bestIdx = i;
           }
         }
-      }
-      if (bestIdx === -1) return null;
-      queue[bestIdx].status = status;
-      queue[bestIdx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-      writeQueue(meshId, queue);
-      return queue[bestIdx];
+        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);
@@ -24046,18 +24089,75 @@ Follow these recovery rules:
       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 queuePendingMeshCoordinatorEvent(event) {
+      try {
+        (0, import_fs6.appendFileSync)(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
+        return true;
+      } catch (e) {
+        LOG2.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
+        return false;
+      }
+    }
+    function drainPendingMeshCoordinatorEvents(meshId) {
+      if (!meshId) return [];
+      const path28 = getPendingEventsPath(meshId);
+      if (!(0, import_fs6.existsSync)(path28)) return [];
+      try {
+        const raw = (0, import_fs6.readFileSync)(path28, "utf-8");
+        try {
+          (0, import_fs6.unlinkSync)(path28);
+        } catch {
+        }
+        return raw.split("\n").filter(Boolean).flatMap((line) => {
+          try {
+            return [JSON.parse(line)];
+          } catch {
+            return [];
+          }
+        });
+      } catch {
+        return [];
+      }
     }
-    function getPendingMeshCoordinatorEvents() {
-      return pendingMeshCoordinatorEvents.slice();
+    function getPendingMeshCoordinatorEvents(meshId) {
+      if (!meshId) return [];
+      const path28 = getPendingEventsPath(meshId);
+      if (!(0, import_fs6.existsSync)(path28)) return [];
+      try {
+        const raw = (0, import_fs6.readFileSync)(path28, "utf-8");
+        return raw.split("\n").filter(Boolean).flatMap((line) => {
+          try {
+            return [JSON.parse(line)];
+          } catch {
+            return [];
+          }
+        });
+      } catch {
+        return [];
+      }
     }
-    function clearPendingMeshCoordinatorEvents() {
-      pendingMeshCoordinatorEvents.splice(0);
+    function clearPendingMeshCoordinatorEvents(meshId) {
+      if (!meshId) return;
+      const path28 = getPendingEventsPath(meshId);
+      if ((0, import_fs6.existsSync)(path28)) try {
+        (0, import_fs6.unlinkSync)(path28);
+      } catch {
+      }
     }
     function readNonEmptyString(value) {
       return typeof value === "string" && value.trim() ? value.trim() : "";
@@ -24103,6 +24203,38 @@ Follow these recovery rules:
       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) {
@@ -24121,7 +24253,16 @@ Follow these recovery rules:
             message: task.message
           }).catch((e) => {
             LOG2.error("MeshQueue", `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
-            updateTaskStatus(meshId, task.id, "failed");
+            updateTaskStatus(meshId, task.id, "pending");
+            try {
+              appendLedgerEntry(meshId, {
+                kind: "dispatch_failed",
+                nodeId,
+                sessionId,
+                payload: { taskId: task.id, error: e?.message, retryable: true }
+              });
+            } catch {
+            }
           });
           return true;
         }
@@ -24455,18 +24596,36 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         LOG2.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) {
+          LOG2.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") {
@@ -24504,13 +24663,17 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           }
         }
         if (sessionId && nodeId && providerType) {
-          remoteIdleSessions.set(`${nodeId}:${sessionId}`, { nodeId, sessionId, providerType });
-          setTimeout(() => {
+          sweepExpiredRemoteIdleSessions();
+          remoteIdleSessions.set(`${nodeId}:${sessionId}`, {
+            nodeId,
+            sessionId,
+            providerType,
+            expiresAt: Date.now() + REMOTE_IDLE_SESSION_TTL_MS
+          });
+          setImmediate(() => {
             const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-            if (assigned) {
-              remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
-            }
-          }, 500);
+            if (assigned) remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+          });
         }
       } else if (args.event === "agent:generating_started") {
         const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
@@ -24621,17 +24784,18 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         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()
+        })) {
           LOG2.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
         }
         return { success: true, forwarded: 0 };
@@ -24670,6 +24834,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           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,
@@ -24712,27 +24877,31 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         });
       });
     }
+    var import_fs6;
+    var import_path5;
+    var REMOTE_IDLE_SESSION_TTL_MS;
     var remoteIdleSessions;
-    var MAX_PENDING_EVENTS;
-    var pendingMeshCoordinatorEvents;
     var MESH_COORDINATOR_EVENTS;
     var EVENT_TO_LEDGER_KIND;
     var INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
+    var RECENT_COMPLETION_FINGERPRINT_TTL_MS;
+    var recentCompletionFingerprints;
     var autoLaunchInProgress;
     var autoLaunchCooldownUntil;
     var AUTO_LAUNCH_COOLDOWN_MS;
     var init_mesh_events = __esm2({
       "src/mesh/mesh-events.ts"() {
         "use strict";
+        import_fs6 = require("fs");
+        import_path5 = require("path");
         init_config();
         init_mesh_config();
         init_cli_detector();
         init_logger();
         init_mesh_ledger();
         init_mesh_work_queue();
+        REMOTE_IDLE_SESSION_TTL_MS = 5 * 60 * 1e3;
         remoteIdleSessions = /* @__PURE__ */ new Map();
-        MAX_PENDING_EVENTS = 50;
-        pendingMeshCoordinatorEvents = [];
         MESH_COORDINATOR_EVENTS = /* @__PURE__ */ new Set([
           "agent:generating_started",
           "agent:generating_completed",
@@ -24748,6 +24917,8 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           "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;
@@ -28013,6 +28184,7 @@ ${lastSnapshot}`;
       prepareSessionChatTailUpdate: () => prepareSessionChatTailUpdate2,
       prepareSessionModalUpdate: () => prepareSessionModalUpdate2,
       probeCdpPort: () => probeCdpPort,
+      queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
       readChatHistory: () => readChatHistory,
       readLedgerEntries: () => readLedgerEntries,
       readLedgerSlice: () => readLedgerSlice,
@@ -28062,8 +28234,14 @@ ${lastSnapshot}`;
       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;
@@ -28078,6 +28256,9 @@ ${lastSnapshot}`;
           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,
@@ -28102,6 +28283,60 @@ ${lastSnapshot}`;
         );
       }
     }
+    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 (error48) {
+        return {
+          upstreamStatus: "stale",
+          upstreamFetchError: formatGitError(error48)
+        };
+      }
+    }
+    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(error48) {
+      if (error48 instanceof GitCommandError) {
+        return error48.stderr || error48.message;
+      }
+      if (error48 instanceof Error) {
+        return error48.message;
+      }
+      return String(error48);
+    }
     function parsePorcelainV2Status(output) {
       const parsed = {
         branch: null,
@@ -28196,6 +28431,7 @@ ${lastSnapshot}`;
         headCommit: null,
         headMessage: null,
         upstream: null,
+        upstreamStatus: "unavailable",
         ahead: 0,
         behind: 0,
         staged: 0,
@@ -28472,6 +28708,9 @@ ${lastSnapshot}`;
         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,
@@ -28810,7 +29049,7 @@ ${lastSnapshot}`;
     });
     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({
@@ -28896,7 +29135,7 @@ ${lastSnapshot}`;
       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": {
@@ -29904,8 +30143,8 @@ ${lastSnapshot}`;
         this.targetDaemonId = context.targetDaemonId;
       }
     };
-    var import_fs6 = require("fs");
-    var import_path5 = require("path");
+    var import_fs7 = require("fs");
+    var import_path6 = require("path");
     init_config();
     var DEFAULT_STATE = {
       recentActivity: [],
@@ -29919,7 +30158,7 @@ ${lastSnapshot}`;
       return !!value && typeof value === "object" && !Array.isArray(value);
     }
     function getStatePath() {
-      return (0, import_path5.join)(getConfigDir(), "state.json");
+      return (0, import_path6.join)(getConfigDir(), "state.json");
     }
     function normalizeState(raw) {
       const parsed = isPlainObject22(raw) ? raw : {};
@@ -29955,11 +30194,11 @@ ${lastSnapshot}`;
     }
     function loadState() {
       const statePath = getStatePath();
-      if (!(0, import_fs6.existsSync)(statePath)) {
+      if (!(0, import_fs7.existsSync)(statePath)) {
         return { ...DEFAULT_STATE };
       }
       try {
-        const raw = (0, import_fs6.readFileSync)(statePath, "utf-8");
+        const raw = (0, import_fs7.readFileSync)(statePath, "utf-8");
         return normalizeState(JSON.parse(raw));
       } catch {
         return { ...DEFAULT_STATE };
@@ -29968,13 +30207,13 @@ ${lastSnapshot}`;
     function saveState(state) {
       const statePath = getStatePath();
       const normalized = normalizeState(state);
-      (0, import_fs6.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+      (0, import_fs7.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
     }
     function resetState() {
       saveState({ ...DEFAULT_STATE });
     }
     var import_child_process2 = require("child_process");
-    var import_fs7 = require("fs");
+    var import_fs8 = require("fs");
     var import_os22 = require("os");
     var path10 = __toESM2(require("path"));
     var BUILTIN_IDE_DEFINITIONS = [];
@@ -29998,7 +30237,7 @@ ${lastSnapshot}`;
       if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
         const candidate = trimmed.startsWith("~") ? path10.join((0, import_os22.homedir)(), trimmed.slice(1)) : trimmed;
         const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
-        return (0, import_fs7.existsSync)(resolved) ? resolved : null;
+        return (0, import_fs8.existsSync)(resolved) ? resolved : null;
       }
       try {
         const result = (0, import_child_process2.execSync)(
@@ -30029,9 +30268,9 @@ ${lastSnapshot}`;
         if (normalized.includes("*")) {
           const username = home.split(/[\\/]/).pop() || "";
           const resolved = normalized.replace("*", username);
-          if ((0, import_fs7.existsSync)(resolved)) return resolved;
+          if ((0, import_fs8.existsSync)(resolved)) return resolved;
         } else {
-          if ((0, import_fs7.existsSync)(normalized)) return normalized;
+          if ((0, import_fs8.existsSync)(normalized)) return normalized;
         }
       }
       return null;
@@ -30045,7 +30284,7 @@ ${lastSnapshot}`;
         let resolvedCli = cliPath;
         if (!resolvedCli && appPath && os222 === "darwin") {
           const bundledCli = `${appPath}/Contents/Resources/app/bin/${def.cli}`;
-          if ((0, import_fs7.existsSync)(bundledCli)) resolvedCli = bundledCli;
+          if ((0, import_fs8.existsSync)(bundledCli)) resolvedCli = bundledCli;
         }
         if (!resolvedCli && appPath && os222 === "win32") {
           const { dirname: dirname9 } = await import("path");
@@ -30058,7 +30297,7 @@ ${lastSnapshot}`;
             `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
           ];
           for (const c of candidates) {
-            if ((0, import_fs7.existsSync)(c)) {
+            if ((0, import_fs8.existsSync)(c)) {
               resolvedCli = c;
               break;
             }
@@ -31928,7 +32167,8 @@ ${lastSnapshot}`;
         }
       }
     };
-    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];
@@ -39122,7 +39362,7 @@ ${effect.notification.body || ""}`.trim();
     var os13 = __toESM2(require("os"));
     var path18 = __toESM2(require("path"));
     var crypto4 = __toESM2(require("crypto"));
-    var import_fs8 = require("fs");
+    var import_fs9 = require("fs");
     var import_child_process6 = require("child_process");
     var import_chalk = __toESM2((init_source(), __toCommonJS(source_exports)));
     init_provider_cli_adapter();
@@ -41580,7 +41820,7 @@ ${rawInput}` : rawInput;
       const trimmed = command.trim();
       if (!trimmed) return false;
       if (isExplicitCommand(trimmed)) {
-        return (0, import_fs8.existsSync)(expandExecutable(trimmed));
+        return (0, import_fs9.existsSync)(expandExecutable(trimmed));
       }
       try {
         (0, import_child_process6.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -41609,10 +41849,10 @@ ${rawInput}` : rawInput;
     }
     function ensureEmptyDelegatedMcpConfig(workspace) {
       const baseDir = path18.join(os13.tmpdir(), "adhdev-delegated-agent-empty-mcp");
-      (0, import_fs8.mkdirSync)(baseDir, { recursive: true });
+      (0, import_fs9.mkdirSync)(baseDir, { recursive: true });
       const workspaceHash = crypto4.createHash("sha256").update(path18.resolve(workspace || os13.tmpdir())).digest("hex").slice(0, 16);
       const filePath = path18.join(baseDir, `${workspaceHash}.json`);
-      (0, import_fs8.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
+      (0, import_fs9.writeFileSync)(filePath, JSON.stringify({ mcpServers: {} }, null, 2), "utf-8");
       return filePath;
     }
     function buildCoordinatorDelegatedCliLaunchOptions(input) {
@@ -45763,7 +46003,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       }
     }
     var import_os3 = require("os");
-    var import_path6 = require("path");
+    var import_path7 = require("path");
     var fs10 = __toESM2(require("fs"));
     var CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
     var CHANNEL_SERVER_URL = {
@@ -45812,55 +46052,45 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       }
       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,
@@ -45876,29 +46106,412 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         hasConflicts,
         conflictFiles,
         stashCount: readNumberValue(status.stashCount) ?? 0,
-        lastCheckedAt: Date.now()
+        lastCheckedAt: options?.lastCheckedAt ?? readNumberValue(status.lastCheckedAt) ?? Date.now(),
+        ...submodules ? { submodules } : {}
+      };
+    }
+    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 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(cached2, incoming) {
+      if (!cached2 || typeof cached2 !== "object" || Array.isArray(cached2)) return incoming;
+      if (!incoming || typeof incoming !== "object" || Array.isArray(incoming)) return cached2;
+      const cachedNodes = Array.isArray(cached2.nodes) ? cached2.nodes : [];
+      const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
+      if (!cachedNodes.length || !incomingNodes.length) return { ...cached2, ...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 {
+        ...cached2,
+        ...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(record2) {
+      return readStringValue(
+        record2?.meta?.sessionStatus,
+        record2?.meta?.status,
+        record2?.meta?.providerStatus,
+        record2?.status,
+        record2?.state,
+        record2?.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 applyCachedInlineMeshNodeStatus(status, node) {
+    function summarizeMeshSessionRecord(record2) {
+      return {
+        sessionId: readStringValue(record2?.sessionId) || "unknown",
+        providerType: readStringValue(record2?.providerType),
+        state: readLiveMeshSessionState(record2),
+        lifecycle: readStringValue(record2?.lifecycle),
+        surfaceKind: getSessionHostSurfaceKind(record2),
+        recoveryState: readStringValue(record2?.meta?.runtimeRecoveryState) ?? null,
+        workspace: readStringValue(record2?.workspace) ?? null,
+        title: readStringValue(record2?.displayName, record2?.workspaceLabel) ?? null,
+        lastActivityAt: toIsoTimestamp(record2?.updatedAt ?? record2?.lastActivityAt ?? record2?.last_activity_at),
+        isCached: false
+      };
+    }
+    function liveSessionRecordMatchesMeshNode(record2, meshId, nodeId) {
+      const recordNodeId = readStringValue(record2?.meta?.meshNodeId);
+      if (!recordNodeId || recordNodeId !== nodeId) return false;
+      const recordMeshId = readStringValue(record2?.meta?.meshNodeFor);
+      return !recordMeshId || recordMeshId === meshId;
+    }
+    function liveSessionRecordMatchesMeshWorkspace(record2, meshId, workspace) {
+      const recordWorkspace = readStringValue(record2?.workspace);
+      if (!recordWorkspace || !workspace || recordWorkspace !== workspace) return false;
+      const recordMeshId = readStringValue(record2?.meta?.meshNodeFor);
+      if (recordMeshId) return recordMeshId === meshId;
+      return record2?.meta?.launchedByCoordinator === true || !!readStringValue(record2?.meta?.meshNodeId);
+    }
+    function readLiveMeshNodeWorkspace(args) {
+      const directNodeWorkspace = args.liveSessionRecords.find((record2) => liveSessionRecordMatchesMeshNode(record2, args.meshId, args.nodeId) && readStringValue(record2?.workspace));
+      if (directNodeWorkspace) {
+        return readStringValue(directNodeWorkspace.workspace) || "";
+      }
+      if (args.allowCoordinatorSession) {
+        const coordinatorWorkspace = args.liveSessionRecords.find((record2) => readStringValue(record2?.meta?.meshCoordinatorFor) === args.meshId && readStringValue(record2?.workspace));
+        if (coordinatorWorkspace) {
+          return readStringValue(coordinatorWorkspace.workspace) || "";
+        }
+      }
+      return "";
+    }
+    function collectLiveMeshSessionRecords(args) {
+      const matches = args.liveSessionRecords.filter((record2) => {
+        const nodeWorkspace = readStringValue(args.node?.workspace);
+        if (liveSessionRecordMatchesMeshNode(record2, args.meshId, args.nodeId)) return true;
+        return !!nodeWorkspace && liveSessionRecordMatchesMeshWorkspace(record2, args.meshId, nodeWorkspace);
+      });
+      if (args.allowCoordinatorSession) {
+        for (const record2 of args.liveSessionRecords) {
+          if (readStringValue(record2?.meta?.meshCoordinatorFor) !== args.meshId) continue;
+          const sessionId = readStringValue(record2?.sessionId);
+          if (sessionId && matches.some((entry) => readStringValue(entry?.sessionId) === sessionId)) continue;
+          matches.push(record2);
+        }
+      }
+      return matches;
+    }
+    function applyCachedInlineMeshNodeStatus(status, node, options) {
       const cachedStatus = readObjectRecord(node?.cachedStatus);
-      const git = buildCachedInlineMeshGitStatus(node);
-      const error48 = readStringValue(cachedStatus.error, node?.error);
-      const health = readStringValue(cachedStatus.health, node?.health);
+      const liveGit = buildInlineMeshTransitGitStatus(node);
+      const git = options?.skipGit ? void 0 : liveGit ?? buildCachedInlineMeshGitStatus(node);
+      const error48 = 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 && !error48 && !health) return false;
-      if (!machineStatus && !git && !error48) 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 && !error48 && !health && !machineStatus && !lastSeenAt && !updatedAt && activeSessions.length === 0) return false;
       if (git) status.git = git;
       if (error48) status.error = error48;
+      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) {
@@ -45928,15 +46541,92 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     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 {
@@ -46144,13 +46834,13 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
     }
     function resolveHermesUserHome() {
       const explicitHome = process.env.HERMES_HOME?.trim();
-      return explicitHome || (0, import_path6.join)((0, import_os3.homedir)(), ".hermes");
+      return explicitHome || (0, import_path7.join)((0, import_os3.homedir)(), ".hermes");
     }
     function loadHermesCoordinatorBaseConfig(targetConfigPath) {
       const sourceHome = resolveHermesUserHome();
-      const sourceConfigPath = (0, import_path6.join)(sourceHome, "config.yaml");
+      const sourceConfigPath = (0, import_path7.join)(sourceHome, "config.yaml");
       if (!fs10.existsSync(sourceConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
-      if ((0, import_path6.resolve)(sourceConfigPath) === (0, import_path6.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
+      if ((0, import_path7.resolve)(sourceConfigPath) === (0, import_path7.resolve)(targetConfigPath)) return { config: {}, sourceHome, sourceConfigPath };
       const parsed = parseMeshCoordinatorMcpConfig(fs10.readFileSync(sourceConfigPath, "utf-8"), "hermes_config_yaml");
       const { mcp_servers: _mcpServers, ...baseConfig } = parsed;
       return { config: baseConfig, sourceHome, sourceConfigPath };
@@ -46184,10 +46874,10 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       return sanitized;
     }
     function copyHermesCoordinatorCredentialFiles(sourceHome, targetHome) {
-      if ((0, import_path6.resolve)(sourceHome) === (0, import_path6.resolve)(targetHome)) return;
+      if ((0, import_path7.resolve)(sourceHome) === (0, import_path7.resolve)(targetHome)) return;
       for (const fileName of [".env", "auth.json"]) {
-        const sourcePath = (0, import_path6.join)(sourceHome, fileName);
-        const targetPath = (0, import_path6.join)(targetHome, fileName);
+        const sourcePath = (0, import_path7.join)(sourceHome, fileName);
+        const targetPath = (0, import_path7.join)(targetHome, fileName);
         if (!fs10.existsSync(sourcePath)) continue;
         try {
           fs10.copyFileSync(sourcePath, targetPath);
@@ -46291,30 +46981,97 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
        *  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 cached2 = this.aggregateMeshStatusCache.get(meshId);
+        if (!cached2?.snapshot || cached2.snapshot.success !== true || !Array.isArray(cached2.snapshot.nodes)) return null;
+        const snapshot = this.cloneJsonValue(cached2.snapshot);
+        const ageMs = Math.max(0, Date.now() - cached2.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(cached2.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 cached2 = this.inlineMeshCache.get(meshId);
+        if (cached2) {
+          const merged = reconcileInlineMeshCache(cached2, 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 cached22 = this.getCachedInlineMesh(meshId, inlineMesh);
-          if (cached22) return { mesh: cached22, inline: true };
+          const cached22 = this.getCachedInlineMesh(meshId);
+          if (cached22) return { mesh: cached22, 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 cached2 = this.getCachedInlineMesh(meshId, inlineMesh);
-        return cached2 ? { mesh: cached2, inline: true } : null;
+        const cached2 = this.getCachedInlineMesh(meshId);
+        if (cached2) return { mesh: cached2, 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;
@@ -46323,6 +47080,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         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;
@@ -46331,6 +47089,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         mesh.nodes.splice(idx, 1);
         mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         this.inlineMeshCache.set(meshId, mesh);
+        this.invalidateAggregateMeshStatus(meshId);
         return true;
       }
       normalizeMeshSessionCleanupMode(value) {
@@ -46379,7 +47138,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         }
         const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
         const normalizePath = (value) => {
-          const resolved = (0, import_path6.resolve)(value);
+          const resolved = (0, import_path7.resolve)(value);
           try {
             return fs10.realpathSync(resolved);
           } catch {
@@ -46543,6 +47302,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
         const deletedSessionIds = [];
         const skippedSessionIds = [];
         const skippedLiveSessionIds = [];
+        const skippedCoordinatorSessionIds = [];
         const deleteUnsupportedSessionIds = [];
         const recordsRemainSessionIds = [];
         const errors = [];
@@ -46575,6 +47335,12 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           const completed = this.isCompletedHostedSession(record2);
           const surfaceKind = getSessionHostSurfaceKind(record2);
           const liveRuntime = surfaceKind === "live_runtime";
+          const coordinatorSession = readStringValue(record2?.meta?.meshCoordinatorFor) === args.meshId;
+          if (!hasExplicitSessionIds && coordinatorSession) {
+            skippedSessionIds.push(sessionId);
+            skippedCoordinatorSessionIds.push(sessionId);
+            continue;
+          }
           if (!hasExplicitSessionIds && liveRuntime) {
             skippedSessionIds.push(sessionId);
             skippedLiveSessionIds.push(sessionId);
@@ -46640,6 +47406,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           deletedSessionIds,
           skippedSessionIds,
           skippedLiveSessionIds,
+          skippedCoordinatorSessionIds,
           ...deleteUnsupported ? {
             deleteUnsupported: true,
             effectiveCleanup: args.mode === "stop_and_delete" ? "stopped_only_records_remain" : "delete_unsupported_records_remain",
@@ -46772,7 +47539,8 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             return handleMeshForwardEvent({ instanceManager: this.deps.instanceManager }, args);
           }
           case "get_pending_mesh_events": {
-            const events = drainPendingMeshCoordinatorEvents();
+            const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+            const events = drainPendingMeshCoordinatorEvents(meshId || void 0);
             return { success: true, events };
           }
           case "launch_cli":
@@ -47301,15 +48069,39 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
           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: loadConfig2().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 cached2 = this.inlineMeshCache.get(meshId);
-            if (cached2) return { success: true, mesh: cached2 };
-            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() : "";
@@ -47339,6 +48131,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               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 };
@@ -47528,26 +48321,41 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
             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,
@@ -47557,6 +48365,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   branch,
                   into: baseBranch,
                   validationSummary,
+                  refineStages,
                   finalBranchConvergenceState: {
                     branch,
                     baseBranch,
@@ -47576,6 +48385,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   branch,
                   into: baseBranch,
                   validationSummary,
+                  refineStages,
                   finalBranchConvergenceState: {
                     branch,
                     baseBranch,
@@ -47586,37 +48396,121 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   }
                 };
               }
+              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,
@@ -47625,18 +48519,14 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                 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": {
@@ -47677,6 +48567,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
               } 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 {
@@ -47755,6 +48646,7 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   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) {
@@ -47830,7 +48722,14 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
                   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({
@@ -47992,7 +48891,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;
@@ -48035,14 +48934,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");
@@ -48132,110 +49031,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 = loadConfig2().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((record2) => typeof record2?.sessionId === "string" ? record2.sessionId : "").filter(Boolean);
+                  const providerTypes = matchedLiveSessionRecords.map((record2) => readStringValue(record2?.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 };
             }
@@ -56107,6 +57160,7 @@ data: ${JSON.stringify(msg.data)}
         sessionHostControl: config2.sessionHostControl,
         statusInstanceId: config2.statusInstanceId,
         statusVersion: config2.statusVersion,
+        getMeshPeerConnectionStatus: config2.getMeshPeerConnectionStatus,
         getCdpLogFn: config2.getCdpLogFn || ((ideType) => LOG2.forComponent(`CDP:${ideType}`).asLogFn())
       });
       poller = new AgentStreamPoller({