@adhdev/daemon-core 0.9.82-rc.441 → 0.9.82-rc.443

package/dist/commands/high-family/types.d.ts

@@ -34,6 +34,7 @@ export interface HighFamilyContext {
     /** Bound `DaemonCommandRouter.getCachedAggregateMeshStatus`. */
     getCachedAggregateMeshStatus: (meshId: string, mesh?: any, options?: {
         requireDirectPeerTruth?: boolean;
+        allowStalePending?: boolean;
     }) => any | null;
     /** Bound `DaemonCommandRouter.rememberAggregateMeshStatus`. */
     rememberAggregateMeshStatus: (meshId: string, snapshot: any, refreshReason: string) => any;
@@ -49,6 +50,9 @@ export interface HighFamilyContext {
         snapshot: any;
         queueRevision: string;
     }>;
+    /** Meshes with a background SWR freshen already in flight — coalesces the
+     *  async refresh a stale-serve interactive open kicks off. */
+    swrRefreshInFlight: Set<string>;
     /** Router's running-refine-job table (surfaced as activeRefineJobs in mesh_status). */
     runningRefineJobs: Map<string, MeshRefineJobHandle>;
     /** Router's inline-mesh cache (launch_mesh_coordinator caches cloud inline mesh). */

package/dist/commands/router.d.ts

@@ -116,6 +116,10 @@ export declare class DaemonCommandRouter {
      *  Spans separate mesh_status/get_mesh calls so the dashboard auto-retry
      *  loop cannot storm a slow peer with back-to-back refreshUpstream probes. */
     private meshGitProbeCache;
+    /** Meshes with a background SWR freshen (async mesh_status refresh) already in
+     *  flight — so a burst of interactive detail-opens serves the cached snapshot
+     *  and coalesces onto ONE background refresh instead of storming the peers. */
+    private swrRefreshInFlight;
     /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests. */
     private runningRefineJobs;
     /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */

package/dist/index.js

@@ -409,10 +409,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "88526551632362f9601e9ebc31340627700a82fd" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "88526551" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.441" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-01T06:40:04.206Z" : void 0);
+  const commit = readInjected(true ? "21c6fe269d621db0b4841be14c111d4d656d6996" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "21c6fe26" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.443" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-01T10:41:15.424Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -17200,7 +17200,7 @@ function resolveCoordinatorDrainDeliverability(components, meshId) {
     holdForReconcile: !hasIdle
   };
 }
-function shouldHoldPendingDrainForBusyLocalCoordinator(components, meshId, requestedCoordinatorDaemonId) {
+function shouldHoldPendingDrainForBusyLocalCoordinator(components, meshId, requestedCoordinatorDaemonId, callerIsSelfCoordinatorInboxRead) {
   if (!meshId) return false;
   const deliverability = resolveCoordinatorDrainDeliverability(components, meshId);
   if (!deliverability.holdForReconcile) return false;
@@ -17210,7 +17210,10 @@ function shouldHoldPendingDrainForBusyLocalCoordinator(components, meshId, reque
     readNonEmptyString2(components.statusInstanceId),
     readNonEmptyString2(loadConfig().machineId)
   ]);
-  return localIds.some((id) => daemonIdsEquivalent(id, requested));
+  const targetsLocalCoordinator = localIds.some((id) => daemonIdsEquivalent(id, requested));
+  if (!targetsLocalCoordinator) return false;
+  if (callerIsSelfCoordinatorInboxRead) return false;
+  return true;
 }
 function injectPendingIntoCoordinator(coordinator, pending) {
   if (!coordinator) return;
@@ -32442,6 +32445,26 @@ async function handleReadChat(h, args) {
         ptyStatusApprovalOnly: false
       });
       if (supportsNative && !decision.nativeSelected) {
+        if (safeMapping && historyMessages.length > 0) {
+          LOG.debug("Command", `[read_chat] native-only content preserved despite pty-parser selection target=${String(args?.targetSessionId || "")} provider=${agentStr} rows=${historyMessages.length} cause=${decision.decision.transition.cause}`);
+          return buildReadChatCommandResult({
+            messages: historyMessages,
+            status: "idle",
+            messageSource: {
+              ...decision.messageSource,
+              nativeOnlyContentPreserved: true,
+              returnedMessageCount: historyMessages.length
+            },
+            transcriptProvenance: {
+              ...decision.messageSource,
+              nativeOnlyContentPreserved: true
+            },
+            ...typeof history?.title === "string" ? { title: history.title } : {},
+            ...historyProviderSessionId ? { providerSessionId: historyProviderSessionId } : {},
+            ...provider?.historyBehavior?.transcriptAuthority === "provider" || provider?.historyBehavior?.transcriptAuthority === "daemon" ? { transcriptAuthority: (provider?.historyBehavior).transcriptAuthority } : {},
+            coverage: "tail"
+          }, args, h);
+        }
         LOG.debug("Command", `[read_chat] soft pending: no live adapter and native history not safely mappable target=${String(args?.targetSessionId || "")} provider=${agentStr} reason=native_history_not_safely_available`);
         return {
           success: true,
@@ -39135,10 +39158,17 @@ function executeSqlite(src, input) {
   }
   try {
     const requested = input.providerSessionId || "";
-    let sessionId;
-    if (requested) {
-      sessionId = requested;
-    } else {
+    const resolveMessagesFor = (sessionId2) => {
+      if (!sessionId2) return null;
+      let rows;
+      try {
+        rows = db.prepare(src.message_query).all(sessionId2);
+      } catch {
+        return null;
+      }
+      return rows && rows.length > 0 ? rows : null;
+    };
+    const resolveNewestSessionId = () => {
       let sessionRow;
       try {
         const sessionFloorSeconds = typeof input.sessionStartedAtMs === "number" ? Math.floor(input.sessionStartedAtMs / 1e3) : 0;
@@ -39149,14 +39179,27 @@ function executeSqlite(src, input) {
           sessionRow = stmt.get();
         }
       } catch {
-        return null;
+        return "";
       }
-      if (!sessionRow) return null;
+      if (!sessionRow) return "";
       const sessionIdRaw = Object.values(sessionRow)[0];
-      sessionId = sessionIdRaw == null ? "" : String(sessionIdRaw);
+      return sessionIdRaw == null ? "" : String(sessionIdRaw);
+    };
+    let sessionId;
+    let messageRows;
+    if (requested) {
+      messageRows = resolveMessagesFor(requested);
+      if (messageRows) {
+        sessionId = requested;
+      } else {
+        sessionId = resolveNewestSessionId();
+        messageRows = resolveMessagesFor(sessionId);
+      }
+    } else {
+      sessionId = resolveNewestSessionId();
+      messageRows = resolveMessagesFor(sessionId);
     }
     if (!sessionId) return null;
-    const messageRows = db.prepare(src.message_query).all(sessionId);
     if (!messageRows || messageRows.length === 0) return null;
     const mtime = safeMtimeMs(resolved);
     const messages = [];
@@ -41023,6 +41066,15 @@ var CliProviderInstance = class _CliProviderInstance {
   // first sets it; the other becomes a no-op.
   agentReadyEmitted = false;
   generatingStartedAt = 0;
+  // FALSE-IDLE continuity epoch: monotonically bumped on EVERY entry into a busy
+  // phase (→generating or →waiting_approval). The completedDebouncePending snapshots
+  // this value at arm time (busyEpochAtArm); the flush guard requires it UNCHANGED
+  // — proving the session did not re-enter a busy phase (a momentary busy→idle blip
+  // in an inter-approval valley) between arming the debounce and flushing it. A
+  // single point-sample of status at flush time cannot see a generating phase that
+  // opened AND closed within the settle window; the epoch can. See
+  // flushCompletedDebounceIfFinalized.
+  busyEpoch = 0;
   // GENERATING-BOUNDARY (R4b): the per-turn taskId for which a startup-grace
   // started+completed pair was already synthesized. Both fast-collapse callers
   // (starting→idle transition AND the idle-stayed no-status-change poll) route
@@ -41689,13 +41741,17 @@ var CliProviderInstance = class _CliProviderInstance {
     }
     this.applyProviderResponse(parsed.payload, { phase: "immediate" });
   }
-  completionHasFinalAssistantMessage(messages) {
+  completionHasFinalAssistantMessage(messages, turnStartedAt) {
     const visibleMessages = (Array.isArray(messages) ? messages : []).filter((message) => isUserFacingChatMessage(message));
     const lastVisible = visibleMessages[visibleMessages.length - 1];
     const role = typeof lastVisible?.role === "string" ? lastVisible.role.trim().toLowerCase() : "";
     const content = lastVisible ? flattenContent(lastVisible.content).trim() : "";
     if (role !== "assistant" || !content) return false;
     if (looksLikeActiveApprovalPromptText(content)) return false;
+    if (typeof turnStartedAt === "number" && Number.isFinite(turnStartedAt) && turnStartedAt > 0) {
+      const ts2 = readChatMessageTimestampMs(lastVisible);
+      if (typeof ts2 === "number" && ts2 < turnStartedAt) return false;
+    }
     return true;
   }
   buildExternalTranscriptProbe(messages, sourcePath, sourceMtimeMs) {
@@ -41758,8 +41814,8 @@ var CliProviderInstance = class _CliProviderInstance {
     );
     return restoredHistory.messages;
   }
-  completionFinalAssistantEvidence(parsedMessages) {
-    if (this.completionHasFinalAssistantMessage(parsedMessages)) {
+  completionFinalAssistantEvidence(parsedMessages, turnStartedAt) {
+    if (this.completionHasFinalAssistantMessage(parsedMessages, turnStartedAt)) {
       return {
         present: true,
         messages: Array.isArray(parsedMessages) ? parsedMessages : [],
@@ -41769,7 +41825,7 @@ var CliProviderInstance = class _CliProviderInstance {
     const externalMessages = this.readExternalCompletionMessages();
     if (externalMessages) {
       return {
-        present: this.completionHasFinalAssistantMessage(externalMessages),
+        present: this.completionHasFinalAssistantMessage(externalMessages, turnStartedAt),
         messages: externalMessages,
         source: "external-native"
       };
@@ -41782,8 +41838,9 @@ var CliProviderInstance = class _CliProviderInstance {
   }
   completionFinalSummary(parsedMessages, turnStartedAt) {
     const adapterOwnsMessagesElsewhere = this.adapter?.chatMessagesOwnedExternally === true;
-    const parsedSummary = extractFinalSummaryFromMessages(
-      this.completionHasFinalAssistantMessage(parsedMessages) ? Array.isArray(parsedMessages) ? parsedMessages : [] : []
+    const parsedSummary = extractFinalSummaryFromMessagesAfter(
+      this.completionHasFinalAssistantMessage(parsedMessages, turnStartedAt) ? Array.isArray(parsedMessages) ? parsedMessages : [] : [],
+      turnStartedAt
     );
     if (adapterOwnsMessagesElsewhere) {
       const externalMessages = this.readExternalCompletionMessages();
@@ -41888,7 +41945,7 @@ var CliProviderInstance = class _CliProviderInstance {
     }
     if (parsed?.activeModal || parsed?.modal) return { reason: "parsed_modal_active", terminal: true };
     const adapterOwnsMessagesElsewhere = this.adapter?.chatMessagesOwnedExternally === true;
-    const finalAssistantEvidence = this.completionFinalAssistantEvidence(parsed?.messages);
+    const finalAssistantEvidence = this.completionFinalAssistantEvidence(parsed?.messages, pending.turnStartedAt);
     const allowMissingAssistantTimeout = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
     LOG.debug("CLI", `[${this.type}] finalAssistantEvidence: present=${finalAssistantEvidence.present} source=${finalAssistantEvidence.source} adapterOwnsMessagesElsewhere=${adapterOwnsMessagesElsewhere} parsedStatus=${parsedStatus}`);
     if (!finalAssistantEvidence.present) {
@@ -42029,6 +42086,19 @@ var CliProviderInstance = class _CliProviderInstance {
       this.completedDebounceTimer = null;
       return;
     }
+    if (typeof pending.busyEpochAtArm === "number" && this.busyEpoch !== pending.busyEpochAtArm) {
+      LOG.info("CLI", `[${this.type}] cancelled pending completed (busy re-entry during settle: epoch ${pending.busyEpochAtArm}\u2192${this.busyEpoch})`);
+      this.completedDebouncePending = null;
+      this.completedDebounceTimer = null;
+      return;
+    }
+    const latestOutputAt = typeof latestStatus?.lastOutputAt === "number" ? latestStatus.lastOutputAt : void 0;
+    if (typeof pending.lastOutputAtArm === "number" && typeof latestOutputAt === "number" && latestOutputAt > pending.lastOutputAtArm) {
+      LOG.info("CLI", `[${this.type}] cancelled pending completed (new PTY output during settle: ${pending.lastOutputAtArm}\u2192${latestOutputAt})`);
+      this.completedDebouncePending = null;
+      this.completedDebounceTimer = null;
+      return;
+    }
     const block2 = this.getCompletedFinalizationBlock(latestVisibleStatus, pending);
     if (block2) {
       const blockReason = block2.reason;
@@ -42331,6 +42401,7 @@ var CliProviderInstance = class _CliProviderInstance {
           this.completedDebouncePending = null;
         }
         if (!this.generatingStartedAt) this.generatingStartedAt = now;
+        this.busyEpoch++;
         if (this.generatingDebounceTimer) clearTimeout(this.generatingDebounceTimer);
         this.generatingDebouncePending = { chatTitle, timestamp: now };
         this.generatingDebounceTimer = setTimeout(() => {
@@ -42356,6 +42427,7 @@ var CliProviderInstance = class _CliProviderInstance {
         }
         this.completedDebouncePending = null;
         if (!this.generatingStartedAt) this.generatingStartedAt = now;
+        this.busyEpoch++;
         const modal = adapterStatus.activeModal;
         LOG.info("CLI", `[${this.type}] approval modal: "${modal?.message?.slice(0, 80) ?? "none"}"`);
         const approvalEntrySeq = typeof adapterStatus?.approvalEntrySeq === "number" ? adapterStatus.approvalEntrySeq : 0;
@@ -42454,7 +42526,13 @@ var CliProviderInstance = class _CliProviderInstance {
               const engineTurnStart = typeof this.adapter?.currentTurnStartedAt === "number" && Number.isFinite(this.adapter.currentTurnStartedAt) ? this.adapter.currentTurnStartedAt : 0;
               const turnStartedAt = engineTurnStart || this.generatingStartedAt || 0;
               return turnStartedAt ? { turnStartedAt } : {};
-            })()
+            })(),
+            // FALSE-IDLE continuity: snapshot the busy epoch + raw PTY output
+            // clock at arm time so the flush guard can prove the session stayed
+            // continuously idle (no busy re-entry, no new PTY output) through the
+            // settle window rather than merely reading 'idle' once at flush.
+            busyEpochAtArm: this.busyEpoch,
+            ...typeof adapterStatus?.lastOutputAt === "number" && Number.isFinite(adapterStatus.lastOutputAt) ? { lastOutputAtArm: adapterStatus.lastOutputAt } : {}
           };
           const ownsExternalHistory = !!this.adapter?.chatMessagesOwnedExternally;
           const meshWorkerSession = this.isMeshWorkerSession();
@@ -51262,12 +51340,13 @@ var meshEventsHandlers = {
   get_pending_mesh_events: async (ctx, args) => {
     const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
     const coordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : void 0;
+    const selfCoordinatorInboxRead = args?.selfCoordinatorInboxRead === true;
     const hasLiveCliCoordinator = meshId ? resolveCoordinatorDrainDeliverability(ctx.deps, meshId).hasLiveCliCoordinator : false;
-    if (meshId && shouldHoldPendingDrainForBusyLocalCoordinator(ctx.deps, meshId, coordinatorDaemonId)) {
+    if (meshId && shouldHoldPendingDrainForBusyLocalCoordinator(ctx.deps, meshId, coordinatorDaemonId, selfCoordinatorInboxRead)) {
       return { success: true, events: [], heldForBusyLocalCoordinator: true, hasLiveCliCoordinator };
     }
     const events = drainPendingMeshCoordinatorEvents(meshId || void 0, coordinatorDaemonId);
-    return { success: true, events, hasLiveCliCoordinator };
+    return { success: true, events, hasLiveCliCoordinator, ...selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {} };
   },
   interactive_prompt_response: async (ctx, args) => {
     const sessionId = typeof args?.targetSessionId === "string" && args.targetSessionId.trim() ? args.targetSessionId.trim() : typeof args?.sessionId === "string" && args.sessionId.trim() ? args.sessionId.trim() : "";
@@ -51905,6 +51984,7 @@ var meshStatusHandlers = {
   mesh_status: async (ctx, args) => {
     const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
     if (!meshId) return { success: false, error: "meshId required" };
+    const startedAtMs = Date.now();
     try {
       const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
       const mesh = meshRecord?.mesh;
@@ -51922,10 +52002,38 @@ var meshStatusHandlers = {
             meshId,
             command: "mesh_status",
             refreshRequested,
+            durationMs: Date.now() - startedAtMs,
             summary: summarizeRepoMeshStatusDebug(cachedStatus)
           });
           return cachedStatus;
         }
+        const staleStatus = ctx.getCachedAggregateMeshStatus(meshId, mesh, {
+          requireDirectPeerTruth: args?.requireDirectPeerTruth === true,
+          allowStalePending: true
+        });
+        if (staleStatus) {
+          if (!ctx.swrRefreshInFlight.has(meshId)) {
+            ctx.swrRefreshInFlight.add(meshId);
+            void Promise.resolve().then(() => ctx.execute("mesh_status", {
+              meshId,
+              inlineMesh: args?.inlineMesh,
+              coordinatorDaemonId: args?.coordinatorDaemonId,
+              requireDirectPeerTruth: args?.requireDirectPeerTruth === true,
+              refresh: true
+            }, "mesh_status_swr_freshen")).catch(() => {
+            }).finally(() => {
+              ctx.swrRefreshInFlight.delete(meshId);
+            });
+          }
+          logRepoMeshStatusDebug("return_stale_swr", {
+            meshId,
+            command: "mesh_status",
+            refreshRequested,
+            durationMs: Date.now() - startedAtMs,
+            summary: summarizeRepoMeshStatusDebug(staleStatus)
+          });
+          return staleStatus;
+        }
       }
       const refreshReason = refreshRequested ? "explicit_refresh" : pendingCoordinatorEventCount > 0 ? "pending_coordinator_events" : hadAggregateCache ? "stale_pending_cache_refresh" : "cold_cache_miss";
       const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
@@ -52006,8 +52114,7 @@ var meshStatusHandlers = {
       );
       const inlineCoordinatorNodeId = meshRecord?.inline && Array.isArray(mesh.nodes) ? selectedCoordinatorNodeId : void 0;
       const refreshedAt = (/* @__PURE__ */ new Date()).toISOString();
-      const nodeStatuses = [];
-      for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
+      const renderMeshNode = async (nodeIndex, node) => {
         const nodeId = normalizeMeshNodeId(node) ?? "";
         const daemonId = readStringValue(node.daemonId);
         const nodeMachineId = readMeshNodeMachineId(node);
@@ -52162,19 +52269,19 @@ var meshStatusHandlers = {
               )) {
                 applyInlineMeshBranchConvergence(mesh, node, status);
                 finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode, directTruthUnavailable: directTruthUnavailableNodeIds.has(nodeId) });
-                nodeStatuses.push(status);
-                continue;
+                return status;
               }
               if (meshRecord?.source === "inline_cache" && !isSelfNode) {
                 applyInlineMeshBranchConvergence(mesh, node, status);
                 finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode, directTruthUnavailable: directTruthUnavailableNodeIds.has(nodeId) });
-                nodeStatuses.push(status);
-                continue;
+                return status;
               }
             }
           } else {
             try {
-              const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+              const runLocalProbe = () => getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+              const gitStatus = await meshGitProbeCache.probeLocal(workspace, runLocalProbe);
+              if (!gitStatus) throw new Error("local_git_probe_unavailable");
               status.git = gitStatus;
               status[MESH_NODE_LIVE_TRUTH_MARKER] = true;
               const reporter = recordInlineMeshDirectGitTruth(node, gitStatus, "selected_coordinator_local_git");
@@ -52196,8 +52303,38 @@ var meshStatusHandlers = {
         }
         applyInlineMeshBranchConvergence(mesh, node, status);
         finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode, directTruthUnavailable: directTruthUnavailableNodeIds.has(nodeId) });
-        nodeStatuses.push(status);
-      }
+        return status;
+      };
+      const meshNodeEntries = [...(mesh.nodes || []).entries()];
+      const settledNodeStatuses = await Promise.allSettled(
+        meshNodeEntries.map(([nodeIndex, node]) => renderMeshNode(nodeIndex, node))
+      );
+      const nodeStatuses = settledNodeStatuses.map((settled, i) => {
+        if (settled.status === "fulfilled") return settled.value;
+        const [nodeIndex, node] = meshNodeEntries[i];
+        const nodeId = normalizeMeshNodeId(node) ?? "";
+        const daemonId = readStringValue(node.daemonId);
+        const fallback = {
+          nodeId,
+          machineLabel: buildMeshNodeDisplayLabel(node, nodeId, readProviderPriorityFromPolicy(node.policy)),
+          workspace: node.workspace,
+          repoRoot: node.repoRoot,
+          isLocalWorktree: node.isLocalWorktree,
+          worktreeBranch: node.worktreeBranch,
+          daemonId,
+          machineId: readMeshNodeMachineId(node) || node.machineId,
+          health: "unknown",
+          providers: node.providers || [],
+          activeSessions: [],
+          activeSessionDetails: [],
+          launchReady: false,
+          error: settled.reason instanceof Error ? settled.reason.message : "node render failed"
+        };
+        applyCachedInlineMeshNodeStatus(fallback, node);
+        applyInlineMeshBranchConvergence(mesh, node, fallback);
+        finalizeMeshNodeStatus({ status: fallback, node, daemonId, isSelfNode: false, directTruthUnavailable: directTruthUnavailableNodeIds.has(nodeId) });
+        return fallback;
+      });
       const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : ctx.deps.statusInstanceId || void 0;
       const pendingCoordinatorEvents = getPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
       const unroutableDeliveries = getRecentUnroutableDeliveries();
@@ -52313,6 +52450,7 @@ var meshStatusHandlers = {
         refreshReason,
         meshSource: meshRecord.source,
         directTruth,
+        durationMs: Date.now() - startedAtMs,
         summary: summarizeRepoMeshStatusDebug(returnedStatus)
       });
       return returnedStatus;
@@ -53513,7 +53651,7 @@ var MESH_DIRECT_PROBE_TIMEOUT_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_TIMEO
 var MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS", 25e3);
 var MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS = MESH_CONNECT_TIMEOUT_MS;
 var MESH_DIRECT_PROBE_REUSE_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_REUSE_MS", 12e3);
-var MeshGitProbeCache = class {
+var MeshGitProbeCache = class _MeshGitProbeCache {
   constructor(reuseMs, now = Date.now) {
     this.reuseMs = reuseMs;
     this.now = now;
@@ -53523,6 +53661,23 @@ var MeshGitProbeCache = class {
   key(daemonId, workspace) {
     return `${daemonId}::${workspace}`;
   }
+  /**
+   * Local (same-machine) git_status dedup. The bootstrap direct-truth hydrate
+   * and the per-node render loop both call getGitRepoStatus(refreshUpstream:true)
+   * for the same local workspace within one mesh_status call. Each such probe
+   * fans out ~13-15 git subprocesses, and because the two passes are separated by
+   * the render/hydrate work of every OTHER node they routinely straddle the
+   * getGitRepoStatus 1.5s TTL, so the second pass re-shells the whole ~14-process
+   * collection. Routing both through this cache (namespaced under a reserved
+   * daemon id so it never collides with a remote-peer key) collapses them to one
+   * collection per workspace per request, and reuses it across the reuse window
+   * so the dashboard auto-retry loop can't restart a fresh local probe seconds
+   * apart either.
+   */
+  static LOCAL_PROBE_DAEMON_ID = "__local_git__";
+  async probeLocal(workspace, probe) {
+    return this.probe(_MeshGitProbeCache.LOCAL_PROBE_DAEMON_ID, workspace, probe);
+  }
   /**
    * Run `probe` for this peer, but reuse a fresh recent result or an in-flight
    * probe for the same key when one is available. `probe` is only invoked when
@@ -53633,7 +53788,7 @@ async function hydrateInlineMeshDirectTruth(args) {
   let standingEvidenceCount = 0;
   const unavailableNodeIds = [];
   const deadNodeIds = [];
-  for (const [nodeIndex, node] of nodes.entries()) {
+  const classifyNode = async (nodeIndex, node) => {
     const nodeId = normalizeMeshNodeId(node) || `node_${nodeIndex}`;
     const workspace = readStringValue(node?.workspace);
     const daemonId = readStringValue(node?.daemonId);
@@ -53646,38 +53801,33 @@ async function hydrateInlineMeshDirectTruth(args) {
       daemonId && (daemonIdsEquivalent(daemonId, args.localMachineId) || daemonIdsEquivalent(daemonId, args.statusInstanceId))
     );
     if ((isSelfNode || isSelfDaemonNode) && isDeadLocalWorktreeNode(node)) {
-      deadNodeIds.push(nodeId);
-      continue;
+      return { kind: "dead", nodeId };
     }
     if (!workspace) {
-      if (!isSelfNode && daemonId) unavailableNodeIds.push(nodeId);
-      continue;
+      return !isSelfNode && daemonId ? { kind: "unavailable", nodeId } : { kind: "skip" };
     }
     if (fs29.existsSync(workspace)) {
       try {
-        const localGit = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+        const runLocalProbe = () => getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
+        const localGit = args.probeCache ? await args.probeCache.probeLocal(workspace, runLocalProbe) : await runLocalProbe();
         if (localGit?.isGitRepo) {
           const reporter = recordInlineMeshDirectGitTruth(node, localGit, "selected_coordinator_local_git");
           persistNodeReporterPlatform(args.meshSource, args.mesh, nodeId, reporter);
-          localConfirmedCount += 1;
-          continue;
+          return { kind: "local" };
         }
       } catch {
       }
     }
     const standingGit = buildInlineMeshTransitGitStatus(node);
     if (standingGit) {
-      standingEvidenceCount += 1;
-      continue;
+      return { kind: "standing" };
     }
     if (!args.probeRemotePeers) {
-      continue;
+      return { kind: "skip" };
     }
     if (!daemonId || !args.dispatchMeshCommand) {
-      if (!isSelfNode) unavailableNodeIds.push(nodeId);
-      continue;
+      return !isSelfNode ? { kind: "unavailable", nodeId } : { kind: "skip" };
     }
-    peerAttemptedCount += 1;
     const runProbe = () => probeRemoteMeshGitStatusWithRetry({
       dispatchMeshCommand: args.dispatchMeshCommand,
       daemonId,
@@ -53691,11 +53841,52 @@ async function hydrateInlineMeshDirectTruth(args) {
     if (remoteGit) {
       const reporter = recordInlineMeshDirectGitTruth(node, remoteGit, "selected_coordinator_mesh_p2p_git");
       persistNodeReporterPlatform(args.meshSource, args.mesh, nodeId, reporter);
-      peerConfirmedCount += 1;
-      continue;
+      return { kind: "peerConfirmed" };
     }
-    unavailableNodeIds.push(nodeId);
-  }
+    return { kind: "peerUnavailable", nodeId };
+  };
+  const nodeEntries = [...nodes.entries()];
+  const settledResults = await Promise.allSettled(
+    nodeEntries.map(([nodeIndex, node]) => classifyNode(nodeIndex, node))
+  );
+  settledResults.forEach((settled, i) => {
+    const [nodeIndex, node] = nodeEntries[i];
+    const result = settled.status === "fulfilled" ? settled.value : (() => {
+      const nodeId = normalizeMeshNodeId(node) || `node_${nodeIndex}`;
+      const daemonId = readStringValue(node?.daemonId);
+      const isSelfNode = Boolean(
+        nodeId && selectedCoordinatorNodeId && nodeId === selectedCoordinatorNodeId
+      ) || Boolean(
+        daemonId && (daemonIdsEquivalent(daemonId, args.localMachineId) || daemonIdsEquivalent(daemonId, args.statusInstanceId))
+      );
+      return !isSelfNode && daemonId ? { kind: "unavailable", nodeId } : { kind: "skip" };
+    })();
+    switch (result.kind) {
+      case "dead":
+        deadNodeIds.push(result.nodeId);
+        break;
+      case "unavailable":
+        unavailableNodeIds.push(result.nodeId);
+        break;
+      case "local":
+        localConfirmedCount += 1;
+        break;
+      case "standing":
+        standingEvidenceCount += 1;
+        break;
+      case "peerConfirmed":
+        peerAttemptedCount += 1;
+        peerConfirmedCount += 1;
+        break;
+      case "peerUnavailable":
+        peerAttemptedCount += 1;
+        unavailableNodeIds.push(result.nodeId);
+        break;
+      case "skip":
+      default:
+        break;
+    }
+  });
   return {
     directEvidenceCount: localConfirmedCount + peerConfirmedCount + standingEvidenceCount,
     localConfirmedCount,
@@ -55066,6 +55257,10 @@ var DaemonCommandRouter = class {
    *  Spans separate mesh_status/get_mesh calls so the dashboard auto-retry
    *  loop cannot storm a slow peer with back-to-back refreshUpstream probes. */
   meshGitProbeCache = new MeshGitProbeCache(MESH_DIRECT_PROBE_REUSE_MS);
+  /** Meshes with a background SWR freshen (async mesh_status refresh) already in
+   *  flight — so a burst of interactive detail-opens serves the cached snapshot
+   *  and coalesces onto ONE background refresh instead of storming the peers. */
+  swrRefreshInFlight = /* @__PURE__ */ new Set();
   /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests. */
   runningRefineJobs = /* @__PURE__ */ new Map();
   /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
@@ -55169,7 +55364,7 @@ var DaemonCommandRouter = class {
     if (cached3.queueRevision !== getMeshQueueRevision(meshId)) return null;
     let snapshot = this.cloneJsonValue(cached3.snapshot);
     snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
-    if (shouldRefreshStalePendingAggregate(snapshot, options)) return null;
+    if (!options?.allowStalePending && shouldRefreshStalePendingAggregate(snapshot, options)) return null;
     const ageMs = Math.max(0, Date.now() - cached3.builtAt);
     const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === "object" ? snapshot.sourceOfTruth : {};
     snapshot.sourceOfTruth = {
@@ -55399,6 +55594,7 @@ var DaemonCommandRouter = class {
       rememberAggregateMeshStatus: this.rememberAggregateMeshStatus.bind(this),
       execute: this.execute.bind(this),
       aggregateMeshStatusCache: this.aggregateMeshStatusCache,
+      swrRefreshInFlight: this.swrRefreshInFlight,
       runningRefineJobs: this.runningRefineJobs,
       inlineMeshCache: this.inlineMeshCache,
       meshGitProbeCache: this.meshGitProbeCache