adhdev 0.9.82-rc.4 → 0.9.82-rc.40

package/dist/index.js

@@ -264,8 +264,14 @@ async function getGitRepoStatus(workspace, options = {}) {
   const includeSubmodules = options.includeSubmodules !== false;
   try {
     const repo = await resolveGitRepository(workspace, options);
-    const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
-    const parsed = parsePorcelainV2Status(statusOutput.stdout);
+    let parsed = await readPorcelainStatus(repo, options);
+    let upstreamProbe = getInitialUpstreamProbe(parsed);
+    if (options.refreshUpstream) {
+      upstreamProbe = await refreshTrackedUpstream(repo, parsed, options);
+      if (upstreamProbe.upstreamStatus === "fresh") {
+        parsed = await readPorcelainStatus(repo, options);
+      }
+    }
     const head = await readHead(repo, options);
     const stashCount = await readStashCount(repo, options);
     let submodules;
@@ -280,6 +286,9 @@ async function getGitRepoStatus(workspace, options = {}) {
       headCommit: head.commit,
       headMessage: head.message,
       upstream: parsed.upstream,
+      upstreamStatus: parsed.upstream ? upstreamProbe.upstreamStatus : "no_upstream",
+      upstreamFetchedAt: upstreamProbe.upstreamFetchedAt,
+      upstreamFetchError: upstreamProbe.upstreamFetchError,
       ahead: parsed.ahead,
       behind: parsed.behind,
       staged: parsed.staged,
@@ -304,6 +313,60 @@ async function getGitRepoStatus(workspace, options = {}) {
     );
   }
 }
+async function readPorcelainStatus(repo, options) {
+  const statusOutput = await runGit(repo, ["status", "--porcelain=v2", "--branch"], options);
+  return parsePorcelainV2Status(statusOutput.stdout);
+}
+function getInitialUpstreamProbe(parsed) {
+  return {
+    upstreamStatus: parsed.upstream ? "unchecked" : "no_upstream"
+  };
+}
+async function refreshTrackedUpstream(repo, parsed, options) {
+  if (!parsed.upstream || !parsed.branch) {
+    return { upstreamStatus: "no_upstream" };
+  }
+  const remoteName = await readBranchRemote(repo, parsed.branch, options) ?? inferRemoteName(parsed.upstream);
+  if (!remoteName) {
+    return {
+      upstreamStatus: "stale",
+      upstreamFetchError: `Unable to resolve remote for upstream '${parsed.upstream}'`
+    };
+  }
+  try {
+    await runGit(repo, ["fetch", "--quiet", "--prune", "--no-tags", remoteName], options);
+    return {
+      upstreamStatus: "fresh",
+      upstreamFetchedAt: Date.now()
+    };
+  } catch (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,
@@ -398,6 +461,7 @@ function emptyStatus(workspace, lastCheckedAt, error48) {
     headCommit: null,
     headMessage: null,
     upstream: null,
+    upstreamStatus: "unavailable",
     ahead: 0,
     behind: 0,
     staged: 0,
@@ -690,6 +754,9 @@ function createGitCompactSummary(status, diffSummary) {
     isGitRepo: status.isGitRepo,
     repoRoot: status.repoRoot,
     branch: status.branch,
+    upstreamStatus: status.upstreamStatus,
+    upstreamFetchedAt: status.upstreamFetchedAt,
+    upstreamFetchError: status.upstreamFetchError,
     dirty: status.staged > 0 || status.modified > 0 || status.untracked > 0 || status.deleted > 0 || status.renamed > 0 || conflictCount > 0 || changedFiles > 0,
     changedFiles,
     ahead: status.ahead,
@@ -1017,7 +1084,7 @@ function serviceNotImplemented(command) {
 }
 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({
@@ -1102,7 +1169,7 @@ async function handleGitCommand(command, args, services = defaultGitCommandServi
   switch (command) {
     case "git_status": {
       if (!services.getStatus) return serviceNotImplemented(command);
-      const status = await runService(() => services.getStatus({ workspace }));
+      const status = await runService(() => services.getStatus({ workspace, refreshUpstream: optionalBoolean(args?.refreshUpstream) }));
       return "success" in status ? status : { success: true, status };
     }
     case "git_diff_summary": {
@@ -3223,6 +3290,36 @@ function getQueuePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
   return (0, import_path4.join)(getLedgerDir(), `${safe}.queue.json`);
 }
+function getLockPath(meshId) {
+  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return (0, import_path4.join)(getLedgerDir(), `${safe}.queue.lock`);
+}
+function withQueueLock(meshId, fn) {
+  const lockPath = getLockPath(meshId);
+  let fd = -1;
+  for (let i = 0; i < 10; i++) {
+    try {
+      fd = (0, import_fs4.openSync)(lockPath, "wx");
+      break;
+    } catch {
+      const deadline = Date.now() + 30;
+      while (Date.now() < deadline) {
+      }
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    if (fd !== -1) try {
+      (0, import_fs4.closeSync)(fd);
+    } catch {
+    }
+    try {
+      (0, import_fs4.unlinkSync)(lockPath);
+    } catch {
+    }
+  }
+}
 function readQueue(meshId) {
   const path35 = getQueuePath(meshId);
   if (!(0, import_fs4.existsSync)(path35)) return [];
@@ -3238,20 +3335,22 @@ function writeQueue(meshId, queue) {
   (0, import_fs4.writeFileSync)(path35, 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);
@@ -3262,100 +3361,111 @@ function getQueue(meshId, opts) {
   return queue;
 }
 function claimNextTask(meshId, nodeId, sessionId) {
-  const queue = readQueue(meshId);
-  const hasActiveAssignment = queue.some((q) => q.status === "assigned" && (q.assignedSessionId === sessionId || q.assignedNodeId === nodeId));
-  if (hasActiveAssignment) return null;
-  let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetSessionId === sessionId);
-  if (targetIdx === -1) {
-    targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
-  }
-  if (targetIdx === -1) {
-    targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
-  }
-  if (targetIdx === -1) return null;
-  const entry = queue[targetIdx];
-  entry.status = "assigned";
-  entry.assignedNodeId = nodeId;
-  entry.assignedSessionId = sessionId;
-  entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
-  entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeQueue(meshId, queue);
-  return entry;
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const hasActiveAssignment = queue.some((q) => q.status === "assigned" && (q.assignedSessionId === sessionId || q.assignedNodeId === nodeId));
+    if (hasActiveAssignment) return null;
+    let targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetSessionId === sessionId);
+    if (targetIdx === -1) {
+      targetIdx = queue.findIndex((q) => q.status === "pending" && q.targetNodeId === nodeId && !q.targetSessionId);
+    }
+    if (targetIdx === -1) {
+      targetIdx = queue.findIndex((q) => q.status === "pending" && !q.targetNodeId && !q.targetSessionId);
+    }
+    if (targetIdx === -1) return null;
+    const entry = queue[targetIdx];
+    entry.status = "assigned";
+    entry.assignedNodeId = nodeId;
+    entry.assignedSessionId = sessionId;
+    entry.dispatchTimestamp = (/* @__PURE__ */ new Date()).toISOString();
+    entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeQueue(meshId, queue);
+    return entry;
+  });
 }
 function updateTaskStatus(meshId, taskId, status) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  queue[idx].status = status;
-  queue[idx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  writeQueue(meshId, queue);
-  return queue[idx];
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    queue[idx].status = status;
+    queue[idx].updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    writeQueue(meshId, queue);
+    return queue[idx];
+  });
 }
 function recordTaskAutoLaunch(meshId, taskId, autoLaunch) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  queue[idx].autoLaunch = {
-    ...autoLaunch,
-    updatedAt: now
-  };
-  queue[idx].updatedAt = now;
-  writeQueue(meshId, queue);
-  return queue[idx];
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    queue[idx].autoLaunch = { ...autoLaunch, updatedAt: now };
+    queue[idx].updatedAt = now;
+    writeQueue(meshId, queue);
+    return queue[idx];
+  });
 }
 function cancelTask(meshId, taskId, opts) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  queue[idx].status = "cancelled";
-  queue[idx].updatedAt = now;
-  queue[idx].cancelledAt = now;
-  if (opts?.reason) queue[idx].cancelReason = opts.reason;
-  writeQueue(meshId, queue);
-  return queue[idx];
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    queue[idx].status = "cancelled";
+    queue[idx].updatedAt = now;
+    queue[idx].cancelledAt = now;
+    if (opts?.reason) queue[idx].cancelReason = opts.reason;
+    writeQueue(meshId, queue);
+    return queue[idx];
+  });
 }
 function requeueTask(meshId, taskId, opts) {
-  const queue = readQueue(meshId);
-  const idx = queue.findIndex((q) => q.id === taskId);
-  if (idx === -1) return null;
-  const entry = queue[idx];
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  entry.status = "pending";
-  delete entry.assignedNodeId;
-  delete entry.assignedSessionId;
-  delete entry.cancelledAt;
-  delete entry.cancelReason;
-  if (opts?.clearTargetNode) delete entry.targetNodeId;
-  if (typeof opts?.targetNodeId === "string") entry.targetNodeId = opts.targetNodeId;
-  if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
-  if (typeof opts?.targetSessionId === "string") entry.targetSessionId = opts.targetSessionId;
-  entry.updatedAt = now;
-  entry.requeuedAt = now;
-  entry.requeueCount = (entry.requeueCount || 0) + 1;
-  if (opts?.reason) entry.requeueReason = opts.reason;
-  writeQueue(meshId, queue);
-  return entry;
-}
-function updateSessionTaskStatus(meshId, sessionId, status) {
-  const queue = readQueue(meshId);
-  let bestIdx = -1;
-  let bestTime = 0;
-  for (let i = queue.length - 1; i >= 0; i--) {
-    if (queue[i].assignedSessionId === sessionId && queue[i].status === "assigned") {
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const idx = queue.findIndex((q) => q.id === taskId);
+    if (idx === -1) return null;
+    const entry = queue[idx];
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    entry.status = "pending";
+    delete entry.assignedNodeId;
+    delete entry.assignedSessionId;
+    delete entry.cancelledAt;
+    delete entry.cancelReason;
+    if (opts?.clearTargetNode) delete entry.targetNodeId;
+    if (typeof opts?.targetNodeId === "string") entry.targetNodeId = opts.targetNodeId;
+    if (opts?.clearTargetSession !== false) delete entry.targetSessionId;
+    if (typeof opts?.targetSessionId === "string") entry.targetSessionId = opts.targetSessionId;
+    entry.updatedAt = now;
+    entry.requeuedAt = now;
+    entry.requeueCount = (entry.requeueCount || 0) + 1;
+    if (opts?.reason) entry.requeueReason = opts.reason;
+    writeQueue(meshId, queue);
+    return entry;
+  });
+}
+function updateSessionTaskStatus(meshId, sessionId, status, opts) {
+  return withQueueLock(meshId, () => {
+    const queue = readQueue(meshId);
+    const occurredAtTime = opts?.occurredAt ? new Date(opts.occurredAt).getTime() : Number.NaN;
+    const hasOccurredAt = Number.isFinite(occurredAtTime);
+    let bestIdx = -1;
+    let bestTime = 0;
+    for (let i = queue.length - 1; i >= 0; i--) {
+      if (queue[i].assignedSessionId !== sessionId || queue[i].status !== "assigned") continue;
       const 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);
@@ -3759,18 +3869,75 @@ __export(mesh_events_exports, {
   drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
   getPendingMeshCoordinatorEvents: () => getPendingMeshCoordinatorEvents,
   handleMeshForwardEvent: () => handleMeshForwardEvent,
+  queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   setupMeshEventForwarding: () => setupMeshEventForwarding,
   triggerMeshQueue: () => triggerMeshQueue,
   tryAssignQueueTask: () => tryAssignQueueTask
 });
-function drainPendingMeshCoordinatorEvents() {
-  return pendingMeshCoordinatorEvents.splice(0);
+function sweepExpiredRemoteIdleSessions() {
+  const now = Date.now();
+  for (const [key, session] of remoteIdleSessions) {
+    if (session.expiresAt <= now) remoteIdleSessions.delete(key);
+  }
+}
+function getPendingEventsPath(meshId) {
+  const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return (0, import_path5.join)(getLedgerDir(), `${safe}.pending-events.jsonl`);
+}
+function queuePendingMeshCoordinatorEvent(event) {
+  try {
+    (0, import_fs6.appendFileSync)(getPendingEventsPath(event.meshId), JSON.stringify(event) + "\n", "utf-8");
+    return true;
+  } catch (e) {
+    LOG.warn("MeshEvents", `Failed to persist pending coordinator event: ${e?.message || e}`);
+    return false;
+  }
+}
+function drainPendingMeshCoordinatorEvents(meshId) {
+  if (!meshId) return [];
+  const path35 = getPendingEventsPath(meshId);
+  if (!(0, import_fs6.existsSync)(path35)) return [];
+  try {
+    const raw = (0, import_fs6.readFileSync)(path35, "utf-8");
+    try {
+      (0, import_fs6.unlinkSync)(path35);
+    } 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 path35 = getPendingEventsPath(meshId);
+  if (!(0, import_fs6.existsSync)(path35)) return [];
+  try {
+    const raw = (0, import_fs6.readFileSync)(path35, "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 path35 = getPendingEventsPath(meshId);
+  if ((0, import_fs6.existsSync)(path35)) try {
+    (0, import_fs6.unlinkSync)(path35);
+  } catch {
+  }
 }
 function readNonEmptyString(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
@@ -3816,6 +3983,38 @@ function shouldSuppressIntentionalCleanupStop(args) {
   if (isIntentionalCleanupStopMetadata(args.metadataEvent)) return true;
   return hasRecentIntentionalCleanupStop(args.meshId, args.sessionId, args.nodeId);
 }
+function readEventTimestamp(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim()) {
+    const numeric = Number(value);
+    if (Number.isFinite(numeric)) return numeric;
+    const parsed = Date.parse(value);
+    if (Number.isFinite(parsed)) return parsed;
+  }
+  return null;
+}
+function buildMeshCompletionFingerprint(args) {
+  const timestampPart = Number.isFinite(args.timestamp) ? String(args.timestamp) : readNonEmptyString(args.finalSummary).slice(0, 200);
+  return [
+    args.meshId,
+    args.event,
+    args.sessionId,
+    args.providerType || "",
+    args.providerSessionId || "",
+    timestampPart
+  ].join("::");
+}
+function isDuplicateMeshCompletionEvent(args) {
+  const fingerprint = buildMeshCompletionFingerprint(args);
+  if (!fingerprint) return false;
+  const now = Date.now();
+  for (const [key, seenAt] of recentCompletionFingerprints.entries()) {
+    if (now - seenAt > RECENT_COMPLETION_FINGERPRINT_TTL_MS) recentCompletionFingerprints.delete(key);
+  }
+  if (recentCompletionFingerprints.has(fingerprint)) return true;
+  recentCompletionFingerprints.set(fingerprint, now);
+  return false;
+}
 function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
   const task = claimNextTask(meshId, nodeId, sessionId);
   if (!task) {
@@ -3834,7 +4033,16 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
         message: task.message
       }).catch((e) => {
         LOG.error("MeshQueue", `Failed to dispatch task via P2P to remote node ${nodeId}: ${e?.message}`);
-        updateTaskStatus(meshId, task.id, "failed");
+        updateTaskStatus(meshId, task.id, "pending");
+        try {
+          appendLedgerEntry(meshId, {
+            kind: "dispatch_failed",
+            nodeId,
+            sessionId,
+            payload: { taskId: task.id, error: e?.message, retryable: true }
+          });
+        } catch {
+        }
       });
       return true;
     }
@@ -4168,18 +4376,36 @@ function injectMeshSystemMessage(components, args) {
     LOG.info("MeshEvents", `Suppressed ${args.event} for intentionally cleanup-stopped session ${eventSessionId || "(unknown session)"}`);
     return { success: true, forwarded: 0, suppressed: true, intentionalCleanupStop: true };
   }
+  const eventTimestamp = readEventTimestamp(args.metadataEvent.timestamp);
+  if (args.event === "agent:generating_completed" && eventSessionId) {
+    const duplicateCompletion = isDuplicateMeshCompletionEvent({
+      meshId: args.meshId,
+      event: args.event,
+      sessionId: eventSessionId,
+      providerType: readNonEmptyString(args.metadataEvent.providerType) || void 0,
+      providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
+      timestamp: eventTimestamp,
+      finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
+    });
+    if (duplicateCompletion) {
+      LOG.info("MeshEvents", `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
+      return { success: true, forwarded: 0, suppressed: true, duplicateCompletion: true };
+    }
+  }
   let completedTaskForLedger = null;
   if (args.event === "agent:generating_completed") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
     const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
     const providerType = readNonEmptyString(args.metadataEvent.providerType);
     if (sessionId) {
-      const completedTask = updateSessionTaskStatus(args.meshId, sessionId, "completed");
+      const completedTask = updateSessionTaskStatus(args.meshId, sessionId, "completed", {
+        occurredAt: eventTimestamp !== null ? new Date(eventTimestamp).toISOString() : void 0
+      });
       completedTaskForLedger = completedTask ? { id: completedTask.id } : null;
       if (nodeId && providerType) {
-        setTimeout(() => {
+        setImmediate(() => {
           tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-        }, 500);
+        });
       }
     }
   } else if (args.event === "agent:ready") {
@@ -4217,13 +4443,17 @@ function injectMeshSystemMessage(components, args) {
       }
     }
     if (sessionId && nodeId && providerType) {
-      remoteIdleSessions.set(`${nodeId}:${sessionId}`, { nodeId, sessionId, providerType });
-      setTimeout(() => {
+      sweepExpiredRemoteIdleSessions();
+      remoteIdleSessions.set(`${nodeId}:${sessionId}`, {
+        nodeId,
+        sessionId,
+        providerType,
+        expiresAt: Date.now() + REMOTE_IDLE_SESSION_TTL_MS
+      });
+      setImmediate(() => {
         const assigned = tryAssignQueueTask(components, args.meshId, nodeId, sessionId, providerType);
-        if (assigned) {
-          remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
-        }
-      }, 500);
+        if (assigned) remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
+      });
     }
   } else if (args.event === "agent:generating_started") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
@@ -4334,17 +4564,18 @@ function injectMeshSystemMessage(components, args) {
     return true;
   });
   if (coordinatorInstances.length === 0) {
-    if (pendingMeshCoordinatorEvents.length < MAX_PENDING_EVENTS) {
-      pendingMeshCoordinatorEvents.push({
-        event: args.event,
-        meshId: args.meshId,
-        nodeLabel: args.nodeLabel,
-        metadataEvent: {
-          ...args.metadataEvent,
-          ...recoveryContext ? { recoveryContext } : {}
-        },
-        queuedAt: Date.now()
-      });
+    if (queuePendingMeshCoordinatorEvent({
+      event: args.event,
+      meshId: args.meshId,
+      nodeLabel: args.nodeLabel,
+      nodeId: args.nodeId || void 0,
+      workspace: readNonEmptyString(args.metadataEvent.workspace),
+      metadataEvent: {
+        ...args.metadataEvent,
+        ...recoveryContext ? { recoveryContext } : {}
+      },
+      queuedAt: Date.now()
+    })) {
       LOG.info("MeshEvents", `Queued ${args.event} for MCP coordinator (mesh ${args.meshId})`);
     }
     return { success: true, forwarded: 0 };
@@ -4383,6 +4614,7 @@ function handleMeshForwardEvent(components, payload) {
       providerType: readNonEmptyString(payload.providerType),
       providerSessionId: readNonEmptyString(payload.providerSessionId),
       finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
+      ...payload.timestamp !== void 0 ? { timestamp: payload.timestamp } : {},
       intentional: payload.intentional === true,
       intentionalStop: payload.intentionalStop === true,
       operatorCleanup: payload.operatorCleanup === true,
@@ -4425,19 +4657,20 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var remoteIdleSessions, MAX_PENDING_EVENTS, pendingMeshCoordinatorEvents, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
+var import_fs6, import_path5, REMOTE_IDLE_SESSION_TTL_MS, remoteIdleSessions, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, recentCompletionFingerprints, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS;
 var init_mesh_events = __esm({
   "../../oss/packages/daemon-core/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",
@@ -4453,6 +4686,8 @@ var init_mesh_events = __esm({
       "monitor:long_generating": "task_stalled"
     };
     INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
+    RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
+    recentCompletionFingerprints = /* @__PURE__ */ new Map();
     autoLaunchInProgress = /* @__PURE__ */ new Set();
     autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
     AUTO_LAUNCH_COOLDOWN_MS = 5e3;
@@ -4580,7 +4815,7 @@ function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 function getStatePath() {
-  return (0, import_path5.join)(getConfigDir(), "state.json");
+  return (0, import_path6.join)(getConfigDir(), "state.json");
 }
 function normalizeState(raw) {
   const parsed = isPlainObject2(raw) ? raw : {};
@@ -4616,11 +4851,11 @@ function normalizeState(raw) {
 }
 function loadState() {
   const statePath = getStatePath();
-  if (!(0, import_fs6.existsSync)(statePath)) {
+  if (!(0, import_fs7.existsSync)(statePath)) {
     return { ...DEFAULT_STATE };
   }
   try {
-    const raw = (0, import_fs6.readFileSync)(statePath, "utf-8");
+    const raw = (0, import_fs7.readFileSync)(statePath, "utf-8");
     return normalizeState(JSON.parse(raw));
   } catch {
     return { ...DEFAULT_STATE };
@@ -4629,17 +4864,17 @@ function loadState() {
 function saveState(state) {
   const statePath = getStatePath();
   const normalized = normalizeState(state);
-  (0, import_fs6.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
+  (0, import_fs7.writeFileSync)(statePath, JSON.stringify(normalized, null, 2), { encoding: "utf-8", mode: 384 });
 }
 function resetState() {
   saveState({ ...DEFAULT_STATE });
 }
-var import_fs6, import_path5, DEFAULT_STATE;
+var import_fs7, import_path6, DEFAULT_STATE;
 var init_state_store = __esm({
   "../../oss/packages/daemon-core/src/config/state-store.ts"() {
     "use strict";
-    import_fs6 = require("fs");
-    import_path5 = require("path");
+    import_fs7 = require("fs");
+    import_path6 = require("path");
     init_config();
     DEFAULT_STATE = {
       recentActivity: [],
@@ -4672,7 +4907,7 @@ function findCliCommand(command) {
   if (path10.isAbsolute(trimmed) || trimmed.includes("/") || trimmed.includes("\\") || trimmed.startsWith("~")) {
     const candidate = trimmed.startsWith("~") ? path10.join((0, import_os2.homedir)(), trimmed.slice(1)) : trimmed;
     const resolved = path10.isAbsolute(candidate) ? candidate : path10.resolve(candidate);
-    return (0, import_fs7.existsSync)(resolved) ? resolved : null;
+    return (0, import_fs8.existsSync)(resolved) ? resolved : null;
   }
   try {
     const result = (0, import_child_process2.execSync)(
@@ -4703,9 +4938,9 @@ function checkPathExists(paths) {
     if (normalized.includes("*")) {
       const username = home.split(/[\\/]/).pop() || "";
       const resolved = normalized.replace("*", username);
-      if ((0, import_fs7.existsSync)(resolved)) return resolved;
+      if ((0, import_fs8.existsSync)(resolved)) return resolved;
     } else {
-      if ((0, import_fs7.existsSync)(normalized)) return normalized;
+      if ((0, import_fs8.existsSync)(normalized)) return normalized;
     }
   }
   return null;
@@ -4719,7 +4954,7 @@ async function detectIDEs(providerLoader) {
     let resolvedCli = cliPath;
     if (!resolvedCli && appPath && os30 === "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 && os30 === "win32") {
       const { dirname: dirname12 } = await import("path");
@@ -4732,7 +4967,7 @@ async function detectIDEs(providerLoader) {
         `${appDir}\\\\resources\\\\app\\\\bin\\\\${def.cli}.cmd`
       ];
       for (const c of candidates) {
-        if ((0, import_fs7.existsSync)(c)) {
+        if ((0, import_fs8.existsSync)(c)) {
           resolvedCli = c;
           break;
         }
@@ -4753,12 +4988,12 @@ async function detectIDEs(providerLoader) {
   }
   return results;
 }
-var import_child_process2, import_fs7, import_os2, path10, BUILTIN_IDE_DEFINITIONS, registeredIDEs;
+var import_child_process2, import_fs8, import_os2, path10, BUILTIN_IDE_DEFINITIONS, registeredIDEs;
 var init_ide_detector = __esm({
   "../../oss/packages/daemon-core/src/detection/ide-detector.ts"() {
     "use strict";
     import_child_process2 = require("child_process");
-    import_fs7 = require("fs");
+    import_fs8 = require("fs");
     import_os2 = require("os");
     path10 = __toESM(require("path"));
     BUILTIN_IDE_DEFINITIONS = [];
@@ -6679,7 +6914,7 @@ var init_status_monitor = __esm({
 });
 
 // ../../oss/packages/daemon-core/src/providers/chat-message-normalization.ts
-function extractFinalSummaryFromMessages(messages, maxChars = 500) {
+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];
@@ -6981,11 +7216,12 @@ function filterInternalChatMessages(messages) {
 function filterChatMessagesByVisibility(messages, surface) {
   return (Array.isArray(messages) ? messages : []).filter((message) => classifyChatMessageVisibility(message).surface === surface);
 }
-var BUILTIN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_VISIBILITIES, CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES, CHAT_MESSAGE_AUDIENCES, CHAT_MESSAGE_SOURCES, CHAT_MESSAGE_ACTIVITY_SOURCES, CHAT_MESSAGE_INTERNAL_SOURCES, KNOWN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_KIND_ALIASES, EXPLICIT_HIDDEN_VISIBILITIES, EXPLICIT_VISIBLE_VISIBILITIES, HIDDEN_AUDIENCES, ACTIVITY_SOURCE_SET, INTERNAL_SOURCE_SET;
+var DEFAULT_FINAL_SUMMARY_MAX_CHARS, BUILTIN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_VISIBILITIES, CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES, CHAT_MESSAGE_AUDIENCES, CHAT_MESSAGE_SOURCES, CHAT_MESSAGE_ACTIVITY_SOURCES, CHAT_MESSAGE_INTERNAL_SOURCES, KNOWN_CHAT_MESSAGE_KINDS, CHAT_MESSAGE_KIND_ALIASES, EXPLICIT_HIDDEN_VISIBILITIES, EXPLICIT_VISIBLE_VISIBILITIES, HIDDEN_AUDIENCES, ACTIVITY_SOURCE_SET, INTERNAL_SOURCE_SET;
 var init_chat_message_normalization = __esm({
   "../../oss/packages/daemon-core/src/providers/chat-message-normalization.ts"() {
     "use strict";
     init_contracts();
+    DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4e3;
     BUILTIN_CHAT_MESSAGE_KINDS = ["standard", "thought", "tool", "terminal", "system"];
     CHAT_MESSAGE_VISIBILITIES = ["user", "debug", "internal", "hidden"];
     CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES = ["visible", "chat", "user", "debug", "internal", "hidden"];
@@ -36737,7 +36973,7 @@ function commandExists(command) {
   const trimmed = command.trim();
   if (!trimmed) return false;
   if (isExplicitCommand(trimmed)) {
-    return (0, import_fs8.existsSync)(expandExecutable(trimmed));
+    return (0, import_fs9.existsSync)(expandExecutable(trimmed));
   }
   try {
     (0, import_child_process6.execFileSync)(process.platform === "win32" ? "where" : "which", [trimmed], {
@@ -36758,10 +36994,10 @@ function hasCliArg(args, flag) {
 }
 function ensureEmptyDelegatedMcpConfig(workspace) {
   const baseDir = path18.join(os15.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 || os15.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) {
@@ -36888,14 +37124,14 @@ function resolveCliSessionBinding(provider, normalizedType, cliArgs, requestedRe
     launchMode: "new"
   };
 }
-var os15, path18, crypto4, import_fs8, import_child_process6, chalkModule, chalkApi, COORDINATOR_DELEGATED_ENV_UNSETS, DaemonCliManager;
+var os15, path18, crypto4, import_fs9, import_child_process6, chalkModule, chalkApi, COORDINATOR_DELEGATED_ENV_UNSETS, DaemonCliManager;
 var init_cli_manager = __esm({
   "../../oss/packages/daemon-core/src/commands/cli-manager.ts"() {
     "use strict";
     os15 = __toESM(require("os"));
     path18 = __toESM(require("path"));
     crypto4 = __toESM(require("crypto"));
-    import_fs8 = require("fs");
+    import_fs9 = require("fs");
     import_child_process6 = require("child_process");
     init_source();
     init_provider_cli_adapter();
@@ -37809,7 +38045,7 @@ function createFsWatchInstance(path35, options, listener, errHandler, emitRaw) {
     }
   };
   try {
-    return (0, import_fs9.watch)(path35, {
+    return (0, import_fs10.watch)(path35, {
       persistent: options.persistent
     }, handleEvent);
   } catch (error48) {
@@ -37817,11 +38053,11 @@ function createFsWatchInstance(path35, options, listener, errHandler, emitRaw) {
     return void 0;
   }
 }
-var import_fs9, import_promises5, sysPath, import_os3, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
+var import_fs10, import_promises5, sysPath, import_os3, STR_DATA, STR_END, STR_CLOSE, EMPTY_FN, pl, isWindows, isMacos, isLinux, isFreeBSD, isIBMi, EVENTS, EV, THROTTLE_MODE_WATCH, statMethods, KEY_LISTENERS, KEY_ERR, KEY_RAW, HANDLER_KEYS, binaryExtensions, isBinaryPath, foreach, addAndConvert, clearItem, delFromSet, isEmptySet, FsWatchInstances, fsWatchBroadcast, setFsWatchListener, FsWatchFileInstances, setFsWatchFileListener, NodeFsHandler;
 var init_handler2 = __esm({
   "../../oss/node_modules/chokidar/esm/handler.js"() {
     "use strict";
-    import_fs9 = require("fs");
+    import_fs10 = require("fs");
     import_promises5 = require("fs/promises");
     sysPath = __toESM(require("path"), 1);
     import_os3 = require("os");
@@ -38225,7 +38461,7 @@ var init_handler2 = __esm({
       let cont = FsWatchFileInstances.get(fullPath);
       const copts = cont && cont.options;
       if (copts && (copts.persistent < options.persistent || copts.interval > options.interval)) {
-        (0, import_fs9.unwatchFile)(fullPath);
+        (0, import_fs10.unwatchFile)(fullPath);
         cont = void 0;
       }
       if (cont) {
@@ -38236,7 +38472,7 @@ var init_handler2 = __esm({
           listeners: listener,
           rawEmitters: rawEmitter,
           options,
-          watcher: (0, import_fs9.watchFile)(fullPath, options, (curr, prev) => {
+          watcher: (0, import_fs10.watchFile)(fullPath, options, (curr, prev) => {
             foreach(cont.rawEmitters, (rawEmitter2) => {
               rawEmitter2(EV.CHANGE, fullPath, { curr, prev });
             });
@@ -38253,7 +38489,7 @@ var init_handler2 = __esm({
         delFromSet(cont, KEY_RAW, rawEmitter);
         if (isEmptySet(cont.listeners)) {
           FsWatchFileInstances.delete(fullPath);
-          (0, import_fs9.unwatchFile)(fullPath);
+          (0, import_fs10.unwatchFile)(fullPath);
           cont.options = cont.watcher = void 0;
           Object.freeze(cont);
         }
@@ -38631,11 +38867,11 @@ function watch(paths, options = {}) {
   watcher.add(paths);
   return watcher;
 }
-var import_fs10, import_promises6, import_events2, sysPath2, SLASH, SLASH_SLASH, ONE_DOT, TWO_DOTS, STRING_TYPE, BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject, unifyPaths, toUnix, normalizePathToUnix, normalizeIgnored, getAbsolutePath, EMPTY_SET, DirEntry, STAT_METHOD_F, STAT_METHOD_L, WatchHelper, FSWatcher;
+var import_fs11, import_promises6, import_events2, sysPath2, SLASH, SLASH_SLASH, ONE_DOT, TWO_DOTS, STRING_TYPE, BACK_SLASH_RE, DOUBLE_SLASH_RE, DOT_RE, REPLACER_RE, isMatcherObject, unifyPaths, toUnix, normalizePathToUnix, normalizeIgnored, getAbsolutePath, EMPTY_SET, DirEntry, STAT_METHOD_F, STAT_METHOD_L, WatchHelper, FSWatcher;
 var init_esm2 = __esm({
   "../../oss/node_modules/chokidar/esm/index.js"() {
     "use strict";
-    import_fs10 = require("fs");
+    import_fs11 = require("fs");
     import_promises6 = require("fs/promises");
     import_events2 = require("events");
     sysPath2 = __toESM(require("path"), 1);
@@ -39113,7 +39349,7 @@ var init_esm2 = __esm({
         const now = /* @__PURE__ */ new Date();
         const writes = this._pendingWrites;
         function awaitWriteFinishFn(prevStat) {
-          (0, import_fs10.stat)(fullPath, (err, curStat) => {
+          (0, import_fs11.stat)(fullPath, (err, curStat) => {
             if (err || !writes.has(path35)) {
               if (err && err.code !== "ENOENT")
                 awfEmit(err);
@@ -45414,55 +45650,45 @@ function readBooleanValue(...values) {
   }
   return void 0;
 }
-function buildCachedInlineMeshGitStatus(node) {
-  const cachedStatus = readObjectRecord(node?.cachedStatus);
-  const cachedGit = readObjectRecord(cachedStatus.git);
-  if (Object.keys(cachedGit).length) {
-    const conflictFiles2 = Array.isArray(cachedGit.conflictFiles) ? cachedGit.conflictFiles.filter((value) => typeof value === "string") : [];
-    const conflictCount2 = readNumberValue(cachedGit.conflicts) ?? conflictFiles2.length;
-    const hasConflicts2 = readBooleanValue(cachedGit.hasConflicts) ?? conflictCount2 > 0;
-    const isGitRepo2 = readBooleanValue(cachedGit.isGitRepo);
-    if (isGitRepo2 !== void 0) {
-      return {
-        workspace: readStringValue(cachedGit.workspace, node?.workspace) || "",
-        repoRoot: readStringValue(cachedGit.repoRoot, node?.repoRoot, node?.workspace) || null,
-        isGitRepo: isGitRepo2,
-        branch: readStringValue(cachedGit.branch) ?? null,
-        headCommit: readStringValue(cachedGit.headCommit) ?? null,
-        headMessage: readStringValue(cachedGit.headMessage) ?? null,
-        upstream: readStringValue(cachedGit.upstream) ?? null,
-        ahead: readNumberValue(cachedGit.ahead) ?? 0,
-        behind: readNumberValue(cachedGit.behind) ?? 0,
-        staged: readNumberValue(cachedGit.staged) ?? 0,
-        modified: readNumberValue(cachedGit.modified) ?? 0,
-        untracked: readNumberValue(cachedGit.untracked) ?? 0,
-        deleted: readNumberValue(cachedGit.deleted) ?? 0,
-        renamed: readNumberValue(cachedGit.renamed) ?? 0,
-        hasConflicts: hasConflicts2,
-        conflictFiles: conflictFiles2,
-        stashCount: readNumberValue(cachedGit.stashCount) ?? 0,
-        lastCheckedAt: readNumberValue(cachedGit.lastCheckedAt) ?? Date.now()
-      };
-    }
-  }
-  const rawGit = readObjectRecord(node?.lastGit ?? node?.last_git);
-  const gitResult = readObjectRecord(rawGit.result);
-  const directStatus = readObjectRecord(rawGit.status);
-  const nestedStatus = readObjectRecord(gitResult.status);
-  const rawProbe = readObjectRecord(node?.lastProbe ?? node?.last_probe);
-  const probeGit = readObjectRecord(rawProbe.git);
-  const probeGitResult = readObjectRecord(probeGit.result);
-  const probeDirectStatus = readObjectRecord(probeGit.status);
-  const probeNestedStatus = readObjectRecord(probeGitResult.status);
-  const status = Object.keys(directStatus).length ? directStatus : Object.keys(nestedStatus).length ? nestedStatus : Object.keys(probeDirectStatus).length ? probeDirectStatus : Object.keys(probeNestedStatus).length ? probeNestedStatus : {};
+function joinRepoPath(root, relativePath) {
+  const normalizedRoot = typeof root === "string" ? root.trim().replace(/[\\/]+$/, "") : "";
+  const normalizedPath = typeof relativePath === "string" ? relativePath.trim() : "";
+  if (!normalizedPath) return void 0;
+  if (/^(?:[A-Za-z]:[\\/]|\/)/.test(normalizedPath)) return normalizedPath;
+  if (!normalizedRoot) return void 0;
+  return `${normalizedRoot}/${normalizedPath.replace(/^[\\/]+/, "")}`;
+}
+function readGitSubmodules(value, parentRepoRoot) {
+  if (!Array.isArray(value)) return void 0;
+  const submodules = value.map((entry) => {
+    const submodule = readObjectRecord(entry);
+    const path35 = readStringValue(submodule.path);
+    const commit = readStringValue(submodule.commit);
+    const repoPath = readStringValue(submodule.repoPath, submodule.repo_root) ?? joinRepoPath(parentRepoRoot, path35);
+    if (!path35 || !commit || !repoPath) return null;
+    return {
+      path: path35,
+      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,
@@ -45478,29 +45704,412 @@ function buildCachedInlineMeshGitStatus(node) {
     hasConflicts,
     conflictFiles,
     stashCount: readNumberValue(status.stashCount) ?? 0,
-    lastCheckedAt: Date.now()
+    lastCheckedAt: options?.lastCheckedAt ?? readNumberValue(status.lastCheckedAt) ?? Date.now(),
+    ...submodules ? { submodules } : {}
+  };
+}
+function 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 applyCachedInlineMeshNodeStatus(status, node) {
+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 git = buildCachedInlineMeshGitStatus(node);
-  const error48 = readStringValue(cachedStatus.error, node?.error);
-  const health = readStringValue(cachedStatus.health, node?.health);
+  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((_2, reject) => setTimeout(() => reject(new Error("timeout")), args.timeoutMs))
+  ]);
+  const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
+  return remoteGit && typeof remoteGit === "object" && typeof remoteGit.isGitRepo === "boolean" ? remoteGit : null;
+}
+async function hydrateInlineMeshDirectTruth(args) {
+  const nodes = Array.isArray(args.mesh?.nodes) ? args.mesh.nodes : [];
+  if (!nodes.length) {
+    return {
+      directEvidenceCount: 0,
+      localConfirmedCount: 0,
+      peerAttemptedCount: 0,
+      peerConfirmedCount: 0,
+      unavailableNodeIds: []
+    };
+  }
+  const selectedCoordinatorNodeId = readStringValue(
+    args.mesh?.coordinator?.preferredNodeId,
+    nodes[0]?.id,
+    nodes[0]?.nodeId
+  );
+  let localConfirmedCount = 0;
+  let peerAttemptedCount = 0;
+  let peerConfirmedCount = 0;
+  const unavailableNodeIds = [];
+  for (const [nodeIndex, node] of nodes.entries()) {
+    const nodeId = readStringValue(node?.id, node?.nodeId) || `node_${nodeIndex}`;
+    const workspace = readStringValue(node?.workspace);
+    const daemonId = readStringValue(node?.daemonId);
+    const isSelfNode = Boolean(
+      nodeId && selectedCoordinatorNodeId && nodeId === selectedCoordinatorNodeId
+    ) || Boolean(
+      daemonId && (daemonId === args.localMachineId || daemonId === args.statusInstanceId)
+    ) || Boolean(args.meshSource !== "local_config" && nodeIndex === 0);
+    if (!workspace) {
+      if (!isSelfNode && daemonId) unavailableNodeIds.push(nodeId);
+      continue;
+    }
+    if (isSelfNode && fs10.existsSync(workspace)) {
+      try {
+        const localGit = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+        if (localGit?.isGitRepo) {
+          recordInlineMeshDirectGitTruth(node, localGit, "selected_coordinator_local_git");
+          localConfirmedCount += 1;
+          continue;
+        }
+      } catch {
+      }
+    }
+    if (!daemonId || !args.dispatchMeshCommand) {
+      if (!isSelfNode) unavailableNodeIds.push(nodeId);
+      continue;
+    }
+    peerAttemptedCount += 1;
+    try {
+      const remoteGit = await probeRemoteMeshGitStatus({
+        dispatchMeshCommand: args.dispatchMeshCommand,
+        daemonId,
+        workspace,
+        timeoutMs: 8e3
+      });
+      if (remoteGit) {
+        recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
+        peerConfirmedCount += 1;
+        continue;
+      }
+    } catch {
+    }
+    unavailableNodeIds.push(nodeId);
+  }
+  return {
+    directEvidenceCount: localConfirmedCount + peerConfirmedCount,
+    localConfirmedCount,
+    peerAttemptedCount,
+    peerConfirmedCount,
+    unavailableNodeIds
+  };
+}
+function summarizeMeshSessionRecord(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 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) {
@@ -45531,9 +46140,85 @@ function truncateValidationOutput(value) {
   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: execFileSync6 } = await import("child_process");
+  const diff = execFileSync6("git", ["diff", "--patch", "--full-index", fromRef, toRef], {
+    cwd,
+    encoding: "utf8",
+    maxBuffer: REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES
+  });
+  if (!diff.trim()) return "";
+  const patchId = execFileSync6("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: execFileSync6 } = await import("child_process");
+    const git = (args) => execFileSync6("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 {
@@ -45741,13 +46426,13 @@ function serializeMeshCoordinatorMcpConfig(config2, format) {
 }
 function resolveHermesUserHome() {
   const explicitHome = process.env.HERMES_HOME?.trim();
-  return explicitHome || (0, import_path6.join)((0, import_os4.homedir)(), ".hermes");
+  return explicitHome || (0, import_path7.join)((0, import_os4.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 };
@@ -45781,10 +46466,10 @@ function stripHermesCoordinatorTempModelProviderOverrides(config2) {
   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);
@@ -45874,7 +46559,7 @@ function summarizeSessionHostPruneResult(result) {
     keptCount: Array.isArray(value.keptSessionIds) ? value.keptSessionIds.length : void 0
   };
 }
-var import_os4, import_path6, fs10, CHANNEL_NPM_TAG, CHANNEL_SERVER_URL, REFINE_VALIDATION_CATEGORIES, REFINE_VALIDATION_TIMEOUT_MS, REFINE_VALIDATION_OUTPUT_LIMIT_BYTES, REFINE_VALIDATION_SUMMARY_CHARS, REFINE_VALIDATION_MAX_COMMANDS, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
+var import_os4, import_path7, fs10, CHANNEL_NPM_TAG, CHANNEL_SERVER_URL, REFINE_VALIDATION_CATEGORIES, REFINE_VALIDATION_TIMEOUT_MS, REFINE_VALIDATION_OUTPUT_LIMIT_BYTES, REFINE_VALIDATION_SUMMARY_CHARS, REFINE_VALIDATION_MAX_COMMANDS, REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES, CHAT_COMMANDS, READ_DEBUG_ENABLED2, DaemonCommandRouter;
 var init_router = __esm({
   "../../oss/packages/daemon-core/src/commands/router.ts"() {
     "use strict";
@@ -45890,6 +46575,7 @@ var init_router = __esm({
     init_chat_history();
     init_ide_detector();
     init_cli_detector();
+    init_git_status();
     init_logger();
     init_command_log();
     init_js_yaml();
@@ -45903,7 +46589,7 @@ var init_router = __esm({
     init_snapshot();
     init_upgrade_helper();
     import_os4 = require("os");
-    import_path6 = require("path");
+    import_path7 = require("path");
     fs10 = __toESM(require("fs"));
     CHANNEL_NPM_TAG = { stable: "latest", preview: "next" };
     CHANNEL_SERVER_URL = {
@@ -45915,6 +46601,7 @@ var init_router = __esm({
     REFINE_VALIDATION_OUTPUT_LIMIT_BYTES = 128 * 1024;
     REFINE_VALIDATION_SUMMARY_CHARS = 2e3;
     REFINE_VALIDATION_MAX_COMMANDS = 4;
+    REFINE_PATCH_EQUIVALENCE_OUTPUT_LIMIT_BYTES = 4 * 1024 * 1024;
     CHAT_COMMANDS = [
       "send_chat",
       "new_chat",
@@ -45929,30 +46616,97 @@ var init_router = __esm({
        *  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 cached3 = this.getCachedInlineMesh(meshId, inlineMesh);
-          if (cached3) return { mesh: cached3, inline: true };
+          const cached3 = this.getCachedInlineMesh(meshId);
+          if (cached3) return { mesh: cached3, 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;
@@ -45961,6 +46715,7 @@ var init_router = __esm({
         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;
@@ -45969,6 +46724,7 @@ var init_router = __esm({
         mesh.nodes.splice(idx, 1);
         mesh.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
         this.inlineMeshCache.set(meshId, mesh);
+        this.invalidateAggregateMeshStatus(meshId);
         return true;
       }
       normalizeMeshSessionCleanupMode(value) {
@@ -46017,7 +46773,7 @@ var init_router = __esm({
         }
         const { resolveWorktreePath: resolveWorktreePath2, listWorktrees: listWorktrees2, removeWorktree: removeWorktree2 } = await Promise.resolve().then(() => (init_git_worktree(), git_worktree_exports));
         const normalizePath2 = (value) => {
-          const resolved = (0, import_path6.resolve)(value);
+          const resolved = (0, import_path7.resolve)(value);
           try {
             return fs10.realpathSync(resolved);
           } catch {
@@ -46181,6 +46937,7 @@ var init_router = __esm({
         const deletedSessionIds = [];
         const skippedSessionIds = [];
         const skippedLiveSessionIds = [];
+        const skippedCoordinatorSessionIds = [];
         const deleteUnsupportedSessionIds = [];
         const recordsRemainSessionIds = [];
         const errors = [];
@@ -46213,6 +46970,12 @@ var init_router = __esm({
           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);
@@ -46278,6 +47041,7 @@ var init_router = __esm({
           deletedSessionIds,
           skippedSessionIds,
           skippedLiveSessionIds,
+          skippedCoordinatorSessionIds,
           ...deleteUnsupported ? {
             deleteUnsupported: true,
             effectiveCleanup: args.mode === "stop_and_delete" ? "stopped_only_records_remain" : "delete_unsupported_records_remain",
@@ -46410,7 +47174,8 @@ var init_router = __esm({
             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":
@@ -46939,15 +47704,39 @@ var init_router = __esm({
           case "get_mesh": {
             const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
             if (!meshId) return { success: false, error: "meshId required" };
-            try {
-              const { getMesh: getMesh3 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
-              const mesh = getMesh3(meshId);
-              if (mesh) return { success: true, mesh };
-            } catch {
+            const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+            if (!meshRecord?.mesh) return { success: false, error: "Mesh not found" };
+            const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+            const directTruth = await hydrateInlineMeshDirectTruth({
+              mesh: meshRecord.mesh,
+              meshSource: meshRecord.source,
+              dispatchMeshCommand: this.deps.dispatchMeshCommand,
+              statusInstanceId: this.deps.statusInstanceId,
+              localMachineId: loadConfig().machineId || ""
+            });
+            const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
+            const sourceOfTruth = {
+              membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+              coordinatorOwnsLiveTruth: directTruthSatisfied,
+              directPeerTruth: {
+                required: requireDirectPeerTruth,
+                satisfied: directTruthSatisfied,
+                directEvidenceCount: directTruth.directEvidenceCount,
+                localConfirmedCount: directTruth.localConfirmedCount,
+                peerAttemptedCount: directTruth.peerAttemptedCount,
+                peerConfirmedCount: directTruth.peerConfirmedCount,
+                unavailableNodeIds: directTruth.unavailableNodeIds
+              }
+            };
+            if (requireDirectPeerTruth && !directTruthSatisfied) {
+              return {
+                success: false,
+                code: "mesh_direct_peer_truth_unavailable",
+                error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct get_mesh probes succeed.",
+                sourceOfTruth
+              };
             }
-            const 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() : "";
@@ -46977,6 +47766,7 @@ var init_router = __esm({
               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 };
@@ -47166,26 +47956,41 @@ var init_router = __esm({
             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,
@@ -47195,6 +48000,7 @@ var init_router = __esm({
                   branch,
                   into: baseBranch,
                   validationSummary,
+                  refineStages,
                   finalBranchConvergenceState: {
                     branch,
                     baseBranch,
@@ -47214,6 +48020,7 @@ var init_router = __esm({
                   branch,
                   into: baseBranch,
                   validationSummary,
+                  refineStages,
                   finalBranchConvergenceState: {
                     branch,
                     baseBranch,
@@ -47224,37 +48031,121 @@ var init_router = __esm({
                   }
                 };
               }
+              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,
@@ -47263,18 +48154,14 @@ var init_router = __esm({
                 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": {
@@ -47315,6 +48202,7 @@ var init_router = __esm({
               } 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 {
@@ -47393,6 +48281,7 @@ var init_router = __esm({
                   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) {
@@ -47468,7 +48357,14 @@ var init_router = __esm({
                   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({
@@ -47630,7 +48526,7 @@ ${block}`);
                   workspace
                 };
               }
-              const { existsSync: existsSync29, readFileSync: readFileSync22, writeFileSync: writeFileSync17, copyFileSync: copyFileSync5, mkdirSync: mkdirSync21 } = await import("fs");
+              const { existsSync: existsSync30, readFileSync: readFileSync23, writeFileSync: writeFileSync17, copyFileSync: copyFileSync5, mkdirSync: mkdirSync21 } = await import("fs");
               const { dirname: dirname12 } = await import("path");
               const mcpConfigPath = coordinatorSetup.configPath;
               const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -47673,14 +48569,14 @@ ${block}`);
                 if (hermesManualFallback) return returnManualFallback(message);
                 return { success: false, code: "mesh_coordinator_config_write_failed", error: message, meshId, cliType, workspace };
               }
-              const hadExistingMcpConfig = existsSync29(mcpConfigPath);
+              const hadExistingMcpConfig = existsSync30(mcpConfigPath);
               let existingMcpConfig = hermesBaseConfig?.config || {};
               if (hermesBaseConfig) {
                 copyHermesCoordinatorCredentialFiles(hermesBaseConfig.sourceHome, dirname12(mcpConfigPath));
               }
               if (hadExistingMcpConfig) {
                 try {
-                  const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync22(mcpConfigPath, "utf-8"), configFormat);
+                  const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync23(mcpConfigPath, "utf-8"), configFormat);
                   const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
                   existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
                   copyFileSync5(mcpConfigPath, mcpConfigPath + ".backup");
@@ -47770,110 +48666,264 @@ ${block}`);
               const meshRecord = await this.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
               const mesh = meshRecord?.mesh;
               if (!mesh) return { success: false, error: "Mesh not found" };
+              const refreshRequested = args?.refresh === true || args?.forceRefresh === true;
+              if (!refreshRequested) {
+                const cachedStatus = this.getCachedAggregateMeshStatus(meshId);
+                if (cachedStatus) return cachedStatus;
+              }
+              const refreshReason = refreshRequested ? "explicit_refresh" : "cold_cache_miss";
               const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
               const queue = getQueue2(meshId);
               const queueSummary = getMeshQueueStats2(meshId);
               const { readLedgerEntries: readLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
               const ledgerEntries = readLedgerEntries2(meshId, { tail: 20 });
               const ledgerSummary = getLedgerSummary2(meshId);
+              const sessionHostRecords = this.deps.sessionHostControl?.listSessions ? await this.deps.sessionHostControl.listSessions().catch(() => []) : [];
+              const liveMeshSessions = partitionSessionHostRecords(Array.isArray(sessionHostRecords) ? sessionHostRecords : []).liveRuntimes;
+              const localMachineId = loadConfig().machineId || "";
+              const requireDirectPeerTruth = args?.requireDirectPeerTruth === true;
+              const directTruth = requireDirectPeerTruth ? await hydrateInlineMeshDirectTruth({
+                mesh,
+                meshSource: meshRecord.source,
+                dispatchMeshCommand: this.deps.dispatchMeshCommand,
+                statusInstanceId: this.deps.statusInstanceId,
+                localMachineId
+              }) : {
+                directEvidenceCount: 0,
+                localConfirmedCount: 0,
+                peerAttemptedCount: 0,
+                peerConfirmedCount: 0,
+                unavailableNodeIds: []
+              };
+              const directTruthSatisfied = meshRecord.source !== "inline_bootstrap" || directTruth.directEvidenceCount > 0;
+              if (requireDirectPeerTruth && !directTruthSatisfied) {
+                return {
+                  success: false,
+                  code: "mesh_direct_peer_truth_unavailable",
+                  error: "Selected coordinator could not confirm direct mesh truth yet. Bootstrap inventory stays unavailable until direct mesh_status probes succeed.",
+                  sourceOfTruth: {
+                    membership: meshRecord.source === "inline_cache" ? "coordinator_inline_mesh_cache" : meshRecord.source === "local_config" ? "local_mesh_config" : "inline_bootstrap_snapshot",
+                    coordinatorOwnsLiveTruth: false,
+                    currentStatus: "direct_peer_truth_unavailable",
+                    directPeerTruth: {
+                      required: true,
+                      satisfied: false,
+                      directEvidenceCount: directTruth.directEvidenceCount,
+                      localConfirmedCount: directTruth.localConfirmedCount,
+                      peerAttemptedCount: directTruth.peerAttemptedCount,
+                      peerConfirmedCount: directTruth.peerConfirmedCount,
+                      unavailableNodeIds: directTruth.unavailableNodeIds
+                    }
+                  }
+                };
+              }
+              const directTruthUnavailableNodeIds = new Set(directTruth.unavailableNodeIds);
+              const selectedCoordinatorNodeId = readStringValue(
+                mesh.coordinator?.preferredNodeId,
+                mesh.nodes?.[0]?.id,
+                mesh.nodes?.[0]?.nodeId
+              );
+              const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? selectedCoordinatorNodeId : void 0;
+              const refreshedAt = (/* @__PURE__ */ new Date()).toISOString();
               const nodeStatuses = [];
-              for (const node of mesh.nodes || []) {
+              for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
+                const nodeId = String(node.id || node.nodeId || "");
+                const daemonId = readStringValue(node.daemonId);
+                const providerPriority = readProviderPriorityFromPolicy(node.policy);
+                const isSelfNode = Boolean(
+                  nodeId && inlineCoordinatorNodeId && nodeId === inlineCoordinatorNodeId
+                ) || Boolean(
+                  daemonId && (daemonId === localMachineId || daemonId === this.deps.statusInstanceId)
+                ) || Boolean(meshRecord?.inline && nodeIndex === 0);
                 const status = {
-                  nodeId: node.id || node.nodeId,
+                  nodeId,
                   machineLabel: node.machineLabel || node.id || node.nodeId,
                   workspace: node.workspace,
                   repoRoot: node.repoRoot,
                   isLocalWorktree: node.isLocalWorktree,
                   worktreeBranch: node.worktreeBranch,
-                  daemonId: node.daemonId,
+                  daemonId,
                   machineId: node.machineId,
+                  machineStatus: node.machineStatus,
                   health: "unknown",
                   providers: node.providers || [],
-                  activeSessions: []
+                  providerPriority,
+                  activeSessions: [],
+                  activeSessionDetails: [],
+                  launchReady: false
                 };
-                if (node.workspace && typeof node.workspace === "string") {
-                  if (!fs10.existsSync(node.workspace) && applyCachedInlineMeshNodeStatus(status, node)) {
-                    nodeStatuses.push(status);
-                    continue;
+                if (isSelfNode) {
+                  status.connection = {
+                    perspective: "selected_coordinator",
+                    source: "mesh_peer_status",
+                    state: "self",
+                    transport: "local",
+                    reported: true,
+                    reason: "Selected coordinator daemon",
+                    lastStateChangeAt: refreshedAt
+                  };
+                } else if (daemonId) {
+                  const connection = this.deps.getMeshPeerConnectionStatus?.(daemonId);
+                  status.connection = connection ?? {
+                    perspective: "selected_coordinator",
+                    source: "not_reported",
+                    state: "unknown",
+                    transport: "unknown",
+                    reported: false,
+                    reason: "No live mesh peer telemetry reported by the selected coordinator yet."
+                  };
+                } else {
+                  status.connection = {
+                    perspective: "selected_coordinator",
+                    source: "not_reported",
+                    state: "unknown",
+                    transport: "unknown",
+                    reported: false,
+                    reason: "Node has no daemon id, so mesh transport cannot be reported from the selected coordinator."
+                  };
+                }
+                const matchedLiveSessionRecords = collectLiveMeshSessionRecords({
+                  meshId,
+                  node,
+                  nodeId,
+                  liveSessionRecords: liveMeshSessions,
+                  allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
+                });
+                const workspace = readLiveMeshNodeWorkspace({
+                  meshId,
+                  nodeId,
+                  liveSessionRecords: matchedLiveSessionRecords,
+                  allowCoordinatorSession: nodeId === selectedCoordinatorNodeId
+                }) || (typeof node.workspace === "string" ? node.workspace : "");
+                status.workspace = workspace || node.workspace;
+                if (matchedLiveSessionRecords.length > 0) {
+                  const sessionIds = matchedLiveSessionRecords.map((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, renamed2 = 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") renamed2++;
-                      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: renamed2,
-                      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 };
             }
@@ -55948,6 +56998,7 @@ async function initDaemonComponents(config2) {
     sessionHostControl: config2.sessionHostControl,
     statusInstanceId: config2.statusInstanceId,
     statusVersion: config2.statusVersion,
+    getMeshPeerConnectionStatus: config2.getMeshPeerConnectionStatus,
     getCdpLogFn: config2.getCdpLogFn || ((ideType) => LOG.forComponent(`CDP:${ideType}`).asLogFn())
   });
   poller = new AgentStreamPoller({
@@ -56249,6 +57300,7 @@ __export(src_exports, {
   prepareSessionChatTailUpdate: () => prepareSessionChatTailUpdate,
   prepareSessionModalUpdate: () => prepareSessionModalUpdate,
   probeCdpPort: () => probeCdpPort,
+  queuePendingMeshCoordinatorEvent: () => queuePendingMeshCoordinatorEvent,
   readChatHistory: () => readChatHistory,
   readLedgerEntries: () => readLedgerEntries,
   readLedgerSlice: () => readLedgerSlice,
@@ -56477,7 +57529,9 @@ var init_server_connection = __esm({
           const requestId = `mesh_${crypto.randomUUID()}`;
           const timer = setTimeout(() => {
             this.off("daemon_mesh_result", handler);
-            reject(new Error(`Mesh command timed out after ${timeoutMs}ms`));
+            reject(new Error(
+              `Mesh command '${command}' to ${targetDaemonId.slice(0, 12)} timed out after ${timeoutMs}ms (requestId=${requestId})`
+            ));
           }, timeoutMs);
           const handler = (msg) => {
             const body = msg.payload && typeof msg.payload === "object" ? { ...msg, ...msg.payload } : msg;
@@ -58292,7 +59346,7 @@ var require_filesystem = __commonJS({
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync22 = (path35) => {
+    var readFileSync23 = (path35) => {
       const fd = fs20.openSync(path35, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
       const bytesRead = fs20.readSync(fd, buffer, 0, MAX_LENGTH, 0);
@@ -58317,7 +59371,7 @@ var require_filesystem = __commonJS({
     module2.exports = {
       LDD_PATH,
       SELF_PATH,
-      readFileSync: readFileSync22,
+      readFileSync: readFileSync23,
       readFile: readFile2
     };
   }
@@ -58366,7 +59420,7 @@ var require_detect_libc = __commonJS({
     "use strict";
     var childProcess = require("child_process");
     var { isLinux: isLinux2, getReport } = require_process();
-    var { LDD_PATH, SELF_PATH, readFile: readFile2, readFileSync: readFileSync22 } = require_filesystem();
+    var { LDD_PATH, SELF_PATH, readFile: readFile2, readFileSync: readFileSync23 } = require_filesystem();
     var { interpreterPath } = require_elf();
     var cachedFamilyInterpreter;
     var cachedFamilyFilesystem;
@@ -58458,7 +59512,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyFilesystem = null;
       try {
-        const lddContent = readFileSync22(LDD_PATH);
+        const lddContent = readFileSync23(LDD_PATH);
         cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
       } catch (e) {
       }
@@ -58483,7 +59537,7 @@ var require_detect_libc = __commonJS({
       }
       cachedFamilyInterpreter = null;
       try {
-        const selfContent = readFileSync22(SELF_PATH);
+        const selfContent = readFileSync23(SELF_PATH);
         const path35 = interpreterPath(selfContent);
         cachedFamilyInterpreter = familyFromInterpreterPath(path35);
       } catch (e) {
@@ -58547,7 +59601,7 @@ var require_detect_libc = __commonJS({
       }
       cachedVersionFilesystem = null;
       try {
-        const lddContent = readFileSync22(LDD_PATH);
+        const lddContent = readFileSync23(LDD_PATH);
         const versionMatch = lddContent.match(RE_GLIBC_VERSION);
         if (versionMatch) {
           cachedVersionFilesystem = versionMatch[1];
@@ -65989,25 +67043,25 @@ function resolvePackageVersion(options) {
   const injectedVersion = options?.injectedVersion || "unknown";
   const dir = options?.dirname || __dirname;
   const possiblePaths = [
-    (0, import_path7.join)(dir, "..", "..", "package.json"),
-    (0, import_path7.join)(dir, "..", "package.json"),
-    (0, import_path7.join)(dir, "package.json")
+    (0, import_path8.join)(dir, "..", "..", "package.json"),
+    (0, import_path8.join)(dir, "..", "package.json"),
+    (0, import_path8.join)(dir, "package.json")
   ];
   for (const p of possiblePaths) {
     try {
-      const data = JSON.parse((0, import_fs11.readFileSync)(p, "utf-8"));
+      const data = JSON.parse((0, import_fs12.readFileSync)(p, "utf-8"));
       if (data.version) return data.version;
     } catch {
     }
   }
   return injectedVersion;
 }
-var import_fs11, import_path7;
+var import_fs12, import_path8;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    import_fs11 = require("fs");
-    import_path7 = require("path");
+    import_fs12 = require("fs");
+    import_path8 = require("path");
   }
 });
 
@@ -66040,11 +67094,37 @@ var init_daemon_mesh_manager = __esm({
       nodeDatachannel = null;
       peers = /* @__PURE__ */ new Map();
       // Map<targetDaemonId, PeerEntry>
+      peerSnapshots = /* @__PURE__ */ new Map();
       pendingRequests = /* @__PURE__ */ new Map();
       commandCallback;
       p2pFailure(message, command, targetDaemonId) {
         return new P2pRelayFailureError(message, { command, targetDaemonId });
       }
+      logMeshCommandEvent(event, fields) {
+        try {
+          LOG.info("Mesh", `[MeshCommand] ${JSON.stringify({ event, ...fields })}`);
+        } catch {
+          LOG.info("Mesh", `[MeshCommand] ${event}`);
+        }
+      }
+      updatePeerSnapshot(targetDaemonId, state, patch = {}) {
+        const previous = this.peerSnapshots.get(targetDaemonId);
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        this.peerSnapshots.set(targetDaemonId, {
+          perspective: "selected_coordinator",
+          source: "mesh_peer_status",
+          reported: true,
+          state,
+          transport: patch.transport ?? previous?.transport ?? "unknown",
+          reason: patch.reason ?? previous?.reason,
+          lastStateChangeAt: now,
+          lastConnectedAt: patch.lastConnectedAt ?? previous?.lastConnectedAt,
+          lastCommandAt: patch.lastCommandAt ?? previous?.lastCommandAt
+        });
+      }
+      getPeerConnectionStatus(targetDaemonId) {
+        return this.peerSnapshots.get(targetDaemonId) ?? null;
+      }
       invalidatePeer(targetDaemonId, reason, options = {}) {
         const peer = this.peers.get(targetDaemonId);
         if (peer?.commandQueue) {
@@ -66059,6 +67139,11 @@ var init_daemon_mesh_manager = __esm({
             pending.reject(this.p2pFailure(reason, pending.command, targetDaemonId));
           }
         }
+        const snapshotState = peer?.state === "closed" ? "closed" : peer?.state === "disconnected" ? "disconnected" : "failed";
+        this.updatePeerSnapshot(targetDaemonId, snapshotState, {
+          reason,
+          transport: peer?.isRelay === true ? "relay" : peer?.isRelay === false ? "direct" : "unknown"
+        });
         if (options.closeResources !== false && peer) {
           try {
             peer.dataChannel?.close?.();
@@ -66091,6 +67176,7 @@ var init_daemon_mesh_manager = __esm({
         "send_chat",
         "read_chat",
         "get_chat_debug_bundle",
+        "get_pending_mesh_events",
         "git_status",
         "git_diff_summary",
         "launch_cli",
@@ -66151,6 +67237,13 @@ var init_daemon_mesh_manager = __esm({
         const peer = this.peers.get(targetDaemonId);
         if (!peer || peer.state !== "connected" || !peer.dataChannel?.isOpen()) {
           LOG.warn("Mesh", `[Mesh] Cannot send result for ${requestId}, P2P not open with ${targetDaemonId.slice(0, 12)}`);
+          this.logMeshCommandEvent("response_send_failed", {
+            requestId,
+            targetDaemonId,
+            sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+            peerState: peer?.state ?? "missing",
+            error: "P2P not open"
+          });
           return;
         }
         try {
@@ -66161,8 +67254,22 @@ var init_daemon_mesh_manager = __esm({
             result,
             error: error48
           }));
+          this.logMeshCommandEvent("response_sent", {
+            requestId,
+            targetDaemonId,
+            sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+            peerState: peer.state,
+            success: !error48
+          });
         } catch (err) {
           LOG.warn("Mesh", `[Mesh] Failed to send command result: ${err.message}`);
+          this.logMeshCommandEvent("response_send_failed", {
+            requestId,
+            targetDaemonId,
+            sentAt: (/* @__PURE__ */ new Date()).toISOString(),
+            peerState: peer.state,
+            error: err?.message || "Failed to send command result"
+          });
         }
       }
       /** Convenience: send a one-off mesh command without a rule. */
@@ -66178,11 +67285,37 @@ var init_daemon_mesh_manager = __esm({
         if (!peer) {
           throw this.p2pFailure("Failed to initiate P2P connection entry", command, targetDaemonId);
         }
+        const lastCommandAt = (/* @__PURE__ */ new Date()).toISOString();
+        if (peer.state === "connected") {
+          this.updatePeerSnapshot(targetDaemonId, "connected", {
+            transport: peer.isRelay === true ? "relay" : peer.isRelay === false ? "direct" : "unknown",
+            lastConnectedAt: this.peerSnapshots.get(targetDaemonId)?.lastConnectedAt,
+            lastCommandAt
+          });
+        } else {
+          this.updatePeerSnapshot(targetDaemonId, "connecting", {
+            transport: peer.isRelay === true ? "relay" : peer.isRelay === false ? "direct" : "unknown",
+            reason: "Waiting for mesh DataChannel to open.",
+            lastCommandAt
+          });
+        }
         return new Promise((resolve20, reject) => {
           const requestId = `req_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+          const queuedAt = (/* @__PURE__ */ new Date()).toISOString();
           const timer = setTimeout(() => {
+            const pending = this.pendingRequests.get(requestId);
             this.pendingRequests.delete(requestId);
+            const timedOutAt = (/* @__PURE__ */ new Date()).toISOString();
             const message = `P2P DataChannel command '${command}' to ${targetDaemonId.slice(0, 12)} timed out after 30s`;
+            this.logMeshCommandEvent("timeout", {
+              requestId,
+              command,
+              targetDaemonId,
+              queuedAt: pending?.queuedAt ?? queuedAt,
+              sentAt: pending?.sentAt,
+              timedOutAt,
+              peerState: peer?.state
+            });
             this.invalidatePeer(targetDaemonId, message, { rejectPending: true, excludeRequestId: requestId });
             reject(this.p2pFailure(message, command, targetDaemonId));
           }, 3e4);
@@ -66199,7 +67332,8 @@ var init_daemon_mesh_manager = __esm({
             },
             timer,
             targetDaemonId,
-            command
+            command,
+            queuedAt
           });
           const payload = {
             type: "mesh_command",
@@ -66208,18 +67342,47 @@ var init_daemon_mesh_manager = __esm({
             args
           };
           if (peer.state === "connected" && peer.dataChannel?.isOpen()) {
+            const sentAt = (/* @__PURE__ */ new Date()).toISOString();
+            const pending = this.pendingRequests.get(requestId);
+            if (pending) pending.sentAt = sentAt;
             LOG.info("Mesh", `[Mesh] Sending '${command}' via P2P DataChannel to ${targetDaemonId.slice(0, 12)}`);
+            this.logMeshCommandEvent("sent", {
+              requestId,
+              command,
+              targetDaemonId,
+              queuedAt,
+              sentAt,
+              peerState: peer.state,
+              transport: peer.isRelay === true ? "relay" : peer.isRelay === false ? "direct" : "unknown"
+            });
             try {
               peer.dataChannel.sendMessage(JSON.stringify(payload));
             } catch (err) {
               const req = this.pendingRequests.get(requestId);
               const message = err?.message || "P2P DataChannel send failed";
+              this.logMeshCommandEvent("send_failed", {
+                requestId,
+                command,
+                targetDaemonId,
+                queuedAt,
+                sentAt,
+                failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                error: message
+              });
               this.invalidatePeer(targetDaemonId, message, { rejectPending: true, excludeRequestId: requestId });
               if (req) req.reject(this.p2pFailure(message, command, targetDaemonId));
             }
             return;
           }
           LOG.info("Mesh", `[Mesh] Queuing '${command}' for ${targetDaemonId.slice(0, 12)} (state: ${peer.state})`);
+          this.logMeshCommandEvent("queued", {
+            requestId,
+            command,
+            targetDaemonId,
+            queuedAt,
+            peerState: peer.state,
+            transport: peer.isRelay === true ? "relay" : peer.isRelay === false ? "direct" : "unknown"
+          });
           if (!peer.commandQueue) {
             peer.commandQueue = [];
           }
@@ -66227,6 +67390,7 @@ var init_daemon_mesh_manager = __esm({
             command,
             args,
             requestId,
+            queuedAt,
             reject: (err) => {
               const req = this.pendingRequests.get(requestId);
               if (req) req.reject(err);
@@ -66265,7 +67429,18 @@ var init_daemon_mesh_manager = __esm({
               peer.pendingCandidates = [];
             }
           } catch (err) {
-            LOG.warn("Mesh", `[Mesh] Failed to set remote desc: ${err.message}`);
+            const errorMessage = err?.message || "Failed to set remote description";
+            const isDuplicateStableAnswer = type2 === "mesh_p2p_answer" && /Unexpected remote answer description in signaling state stable/i.test(errorMessage);
+            this.logMeshCommandEvent(isDuplicateStableAnswer ? "remote_desc_duplicate_ignored" : "remote_desc_failed", {
+              targetDaemonId,
+              signalType: type2,
+              receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              peerState: peer.state,
+              error: errorMessage
+            });
+            if (isDuplicateStableAnswer) return;
+            LOG.warn("Mesh", `[Mesh] Failed to set remote desc for ${type2} from ${targetDaemonId.slice(0, 12)}: ${errorMessage}`);
+            this.invalidatePeer(targetDaemonId, `P2P remote description failed: ${errorMessage}`, { rejectPending: true, closeResources: true });
           }
         } else if (type2 === "mesh_p2p_ice") {
           try {
@@ -66321,6 +67496,9 @@ var init_daemon_mesh_manager = __esm({
           remoteDescriptionSet: false
         };
         this.peers.set(targetDaemonId, entry);
+        this.updatePeerSnapshot(targetDaemonId, "connecting", {
+          reason: isInitiator ? "P2P mesh connection initiated by the selected coordinator." : "Waiting for the remote daemon to finish the mesh DataChannel handshake."
+        });
         pc.onLocalDescription((sdp, type2) => {
           this.serverConn.sendMeshCommand(targetDaemonId, type2 === "offer" ? "mesh_p2p_offer" : "mesh_p2p_answer", { sdp, type: type2 });
         });
@@ -66331,7 +67509,26 @@ var init_daemon_mesh_manager = __esm({
           LOG.info("Mesh", `[Mesh] P2P state with ${targetDaemonId.slice(0, 12)}: ${state}`);
           if (state === "connected") {
             entry.state = "connected";
+            let transport = "unknown";
+            try {
+              const pair = pc.getSelectedCandidatePair?.();
+              if (pair) {
+                const localType = pair.local?.type || "unknown";
+                const remoteType = pair.remote?.type || "unknown";
+                entry.isRelay = localType === "relay" || remoteType === "relay";
+                transport = entry.isRelay ? "relay" : "direct";
+                LOG.info("Mesh", `[Mesh] Candidate pair with ${targetDaemonId.slice(0, 12)}: local=${localType} remote=${remoteType} \u2192 ${transport}`);
+              }
+            } catch {
+              transport = entry.isRelay === true ? "relay" : entry.isRelay === false ? "direct" : "unknown";
+            }
+            this.updatePeerSnapshot(targetDaemonId, "connected", {
+              transport,
+              reason: transport === "relay" ? "Connected over TURN relay." : transport === "direct" ? "Connected directly peer-to-peer." : "Connected, but selected candidate pair details are unavailable.",
+              lastConnectedAt: (/* @__PURE__ */ new Date()).toISOString()
+            });
           } else if (state === "failed" || state === "closed" || state === "disconnected") {
+            entry.state = state;
             this.invalidatePeer(targetDaemonId, `P2P state changed to ${state}`, { rejectPending: true, closeResources: false });
           }
         });
@@ -66349,12 +67546,30 @@ var init_daemon_mesh_manager = __esm({
         dc.onOpen(() => {
           LOG.info("Mesh", `[Mesh] DataChannel OPEN with ${targetDaemonId.slice(0, 12)}`);
           entry.state = "connected";
+          this.updatePeerSnapshot(targetDaemonId, "connected", {
+            transport: entry.isRelay === true ? "relay" : entry.isRelay === false ? "direct" : "unknown",
+            reason: entry.isRelay === true ? "Connected over TURN relay." : entry.isRelay === false ? "Connected directly peer-to-peer." : "DataChannel open; transport details not reported yet.",
+            lastConnectedAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
           if (entry.commandQueue) {
             const queue = entry.commandQueue;
             entry.commandQueue = [];
             for (const item of queue) {
               try {
+                const sentAt = (/* @__PURE__ */ new Date()).toISOString();
+                const pending = this.pendingRequests.get(item.requestId);
+                if (pending) pending.sentAt = sentAt;
                 LOG.info("Mesh", `[Mesh] Flushing queued '${item.command}' to ${targetDaemonId.slice(0, 12)}`);
+                this.logMeshCommandEvent("sent", {
+                  requestId: item.requestId,
+                  command: item.command,
+                  targetDaemonId,
+                  queuedAt: item.queuedAt,
+                  sentAt,
+                  peerState: entry.state,
+                  transport: entry.isRelay === true ? "relay" : entry.isRelay === false ? "direct" : "unknown",
+                  flushed: true
+                });
                 dc.sendMessage(JSON.stringify({
                   type: "mesh_command",
                   requestId: item.requestId,
@@ -66362,6 +67577,14 @@ var init_daemon_mesh_manager = __esm({
                   args: item.args
                 }));
               } catch (err) {
+                this.logMeshCommandEvent("send_failed", {
+                  requestId: item.requestId,
+                  command: item.command,
+                  targetDaemonId,
+                  queuedAt: item.queuedAt,
+                  failedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  error: err?.message || "P2P DataChannel send failed while flushing command queue"
+                });
                 item.reject(this.p2pFailure(err?.message || "P2P DataChannel send failed while flushing command queue", item.command, targetDaemonId));
               }
             }
@@ -66376,6 +67599,12 @@ var init_daemon_mesh_manager = __esm({
             const str2 = typeof msg === "string" ? msg : msg.toString("utf8");
             const data = JSON.parse(str2);
             if (data.type === "mesh_command" && data.command) {
+              this.logMeshCommandEvent("incoming", {
+                requestId: data.requestId,
+                command: data.command,
+                senderDaemonId: targetDaemonId,
+                receivedAt: (/* @__PURE__ */ new Date()).toISOString()
+              });
               if (this.commandCallback) {
                 this.commandCallback(targetDaemonId, data.command, data.args, data.requestId).catch((e) => {
                   LOG.warn("Mesh", `[Mesh] Error handling incoming P2P command: ${e.message}`);
@@ -66384,11 +67613,27 @@ var init_daemon_mesh_manager = __esm({
             } else if (data.type === "mesh_command_result" && data.requestId) {
               const pending = this.pendingRequests.get(data.requestId);
               if (pending) {
+                this.logMeshCommandEvent("response_received", {
+                  requestId: data.requestId,
+                  command: pending.command,
+                  targetDaemonId: pending.targetDaemonId,
+                  queuedAt: pending.queuedAt,
+                  sentAt: pending.sentAt,
+                  receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  success: data.success === true
+                });
                 if (data.success) {
                   pending.resolve(data.result);
                 } else {
                   pending.reject(new Error(data.error || "P2P Command failed"));
                 }
+              } else {
+                this.logMeshCommandEvent("response_orphan", {
+                  requestId: data.requestId,
+                  targetDaemonId,
+                  receivedAt: (/* @__PURE__ */ new Date()).toISOString(),
+                  success: data.success === true
+                });
               }
             }
           } catch (e) {
@@ -66628,6 +67873,7 @@ var init_adhdev_daemon = __esm({
     "use strict";
     init_server_connection();
     init_src();
+    init_mesh_events();
     init_daemon_p2p2();
     init_screenshot_controller();
     init_session_host();
@@ -66644,7 +67890,7 @@ var init_adhdev_daemon = __esm({
     init_version();
     init_src();
     init_runtime_defaults();
-    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.4" });
+    pkgVersion = resolvePackageVersion({ injectedVersion: "0.9.82-rc.40" });
     AdhdevDaemon = class _AdhdevDaemon {
       localHttpServer = null;
       localWss = null;
@@ -67168,6 +68414,7 @@ ${err?.stack || ""}`);
               if (!this.meshManager) throw new Error("Mesh manager not initialized");
               return this.meshManager.sendCommand(daemonId, command, args);
             },
+            getMeshPeerConnectionStatus: (daemonId) => this.meshManager?.getPeerConnectionStatus(daemonId) ?? null,
             onStatusChange: () => {
               this.invalidateHotChatSnapshotCache();
               this.statusReporter?.onStatusChange();
@@ -67537,6 +68784,7 @@ ${err?.stack || ""}`);
         const meshId = this.readMeshString(settings.meshNodeFor);
         const coordinatorDaemonId = this.readMeshString(settings.meshCoordinatorDaemonId);
         if (!meshId || !coordinatorDaemonId) return;
+        const relayTimestamp = typeof event.timestamp === "number" && Number.isFinite(event.timestamp) ? event.timestamp : this.readMeshString(event.timestamp) || void 0;
         const payload = {
           event: this.readMeshString(event.event),
           meshId,
@@ -67545,7 +68793,8 @@ ${err?.stack || ""}`);
           targetSessionId: this.readMeshString(event.targetSessionId) || instanceId,
           providerType: this.readMeshString(event.providerType),
           providerSessionId: this.readMeshString(event.providerSessionId),
-          finalSummary: this.readMeshString(event.finalSummary) || this.readMeshString(event.summary)
+          finalSummary: this.readMeshString(event.finalSummary) || this.readMeshString(event.summary),
+          ...relayTimestamp !== void 0 ? { timestamp: relayTimestamp } : {}
         };
         if (coordinatorDaemonId === localDaemonId) {
           try {
@@ -67560,6 +68809,22 @@ ${err?.stack || ""}`);
           await this.meshManager.sendCommand(coordinatorDaemonId, "mesh_forward_event", payload);
           LOG.info("MeshEvents", `Relayed ${payload.event} for mesh ${meshId} to coordinator daemon ${coordinatorDaemonId.slice(0, 12)}\u2026`);
         } catch (error48) {
+          queuePendingMeshCoordinatorEvent({
+            event: payload.event,
+            meshId,
+            nodeLabel: payload.nodeId ? `Node '${payload.nodeId}'` : payload.workspace ? `Agent at ${payload.workspace}` : "Remote agent",
+            nodeId: payload.nodeId || void 0,
+            workspace: payload.workspace || void 0,
+            metadataEvent: {
+              targetSessionId: payload.targetSessionId,
+              providerType: payload.providerType,
+              providerSessionId: payload.providerSessionId,
+              finalSummary: payload.finalSummary,
+              workspace: payload.workspace,
+              ...payload.timestamp !== void 0 ? { timestamp: payload.timestamp } : {}
+            },
+            queuedAt: Date.now()
+          });
           LOG.warn("MeshEvents", `Failed to relay ${payload.event} for mesh ${meshId}: ${error48?.message || error48}`);
         }
       }
@@ -82608,7 +83873,7 @@ var require_buffer_list = __commonJS({
         }
       }, {
         key: "join",
-        value: function join36(s) {
+        value: function join37(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -96667,13 +97932,13 @@ function splitStringBySpace(str2) {
   }
   return pieces;
 }
-var import_chardet, import_child_process14, import_fs12, import_node_path3, import_node_os3, import_node_crypto3, import_iconv_lite, ExternalEditor;
+var import_chardet, import_child_process14, import_fs13, import_node_path3, import_node_os3, import_node_crypto3, import_iconv_lite, ExternalEditor;
 var init_esm4 = __esm({
   "../../node_modules/@inquirer/external-editor/dist/esm/index.js"() {
     "use strict";
     import_chardet = __toESM(require_lib2(), 1);
     import_child_process14 = require("child_process");
-    import_fs12 = require("fs");
+    import_fs13 = require("fs");
     import_node_path3 = __toESM(require("path"), 1);
     import_node_os3 = __toESM(require("os"), 1);
     import_node_crypto3 = require("crypto");
@@ -96749,14 +98014,14 @@ var init_esm4 = __esm({
           if (Object.prototype.hasOwnProperty.call(this.fileOptions, "mode")) {
             opt.mode = this.fileOptions.mode;
           }
-          (0, import_fs12.writeFileSync)(this.tempFile, this.text, opt);
+          (0, import_fs13.writeFileSync)(this.tempFile, this.text, opt);
         } catch (createFileError) {
           throw new CreateFileError(createFileError);
         }
       }
       readTemporaryFile() {
         try {
-          const tempFileBuffer = (0, import_fs12.readFileSync)(this.tempFile);
+          const tempFileBuffer = (0, import_fs13.readFileSync)(this.tempFile);
           if (tempFileBuffer.length === 0) {
             this.text = "";
           } else {
@@ -96772,7 +98037,7 @@ var init_esm4 = __esm({
       }
       removeTemporaryFile() {
         try {
-          (0, import_fs12.unlinkSync)(this.tempFile);
+          (0, import_fs13.unlinkSync)(this.tempFile);
         } catch (removeFileError) {
           throw new RemoveFileError(removeFileError);
         }