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

package/dist/mesh/mesh-node-identity.d.ts

@@ -199,6 +199,21 @@ export declare class MeshGitProbeCache {
     private recent;
     constructor(reuseMs: number, now?: () => number);
     private key;
+    /**
+     * 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.
+     */
+    private static readonly LOCAL_PROBE_DAEMON_ID;
+    probeLocal(workspace: string, probe: () => Promise<Record<string, unknown> | null>): Promise<Record<string, unknown> | null>;
     /**
      * 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

package/dist/mesh/mesh-reconcile-loop.d.ts

@@ -52,10 +52,24 @@ export declare function resolveCoordinatorDrainDeliverability(components: Pick<D
  * remote pull is never blocked by our local coordinator's busy state. A pure
  * stdio MCP coordinator (no live CLI session) never satisfies (1), so its tool
  * result remains the surface and the drain proceeds. No regression to either.
+ *
+ * SELF-COORDINATOR INBOX LEVEL-DRAIN (Defect 2): the hold above assumes the ONLY
+ * surface for a busy local coordinator's events is a future PTY inject on its idle
+ * edge, so it defers to the reconcile loop. But when the drain caller IS the local
+ * coordinator reading its OWN inbox (the `get_pending_mesh_events` call whose events
+ * are returned in the caller's tool RESULT — a data queue the self-coordinating LLM
+ * consumes directly), the events ARE surfaced losslessly the moment the tool returns,
+ * with NO PTY write. A busy self-coordinating LLM that calls a mesh tool mid-turn would
+ * otherwise get an empty inbox (held) and only see the completion on its NEXT busy→idle
+ * edge — the measured ~59s strand. `callerIsSelfCoordinatorInboxRead` marks that safe
+ * caller: the hold is relaxed for it (return the events), while every OTHER drain (a
+ * backfill relay, a broadcast poll, a DIFFERENT coordinator that genuinely needs its PTY)
+ * still defers to the reconcile loop. This relaxes delivery INTO the coordinator's own
+ * inbox only — it never changes how events are injected into a live PTY prompt.
  */
 export declare function shouldHoldPendingDrainForBusyLocalCoordinator(components: Pick<DaemonComponents, 'instanceManager'> & {
     statusInstanceId?: string;
-}, meshId: string, requestedCoordinatorDaemonId?: string | null): boolean;
+}, meshId: string, requestedCoordinatorDaemonId?: string | null, callerIsSelfCoordinatorInboxRead?: boolean): boolean;
 export declare function runMeshReconcileTick(components: DaemonComponents): Promise<void>;
 export declare function __resetUnresolvedForwardRejectionCountsForTests(): void;
 interface ReconcileLoopHandle {

package/dist/providers/chat-message-normalization.d.ts

@@ -1,6 +1,7 @@
 import type { ChatMessage } from '../types.js';
 export declare const DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16000;
 export declare function extractFinalSummaryFromMessages(messages: ChatMessage[] | null | undefined, maxChars?: number): string;
+export declare function readChatMessageTimestampMs(message: ChatMessage | null | undefined): number | undefined;
 /**
  * Turn-scoped variant of extractFinalSummaryFromMessages. Selects the last
  * user-facing assistant/model bubble whose own timestamp is at/after the

package/dist/providers/cli-provider-instance.d.ts

@@ -99,6 +99,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private lastStatus;
     private agentReadyEmitted;
     private generatingStartedAt;
+    private busyEpoch;
     private fastCollapseSynthesizedTaskId;
     private startupGraceCollapseAt;
     private settings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.441",
+  "version": "0.9.82-rc.443",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.441",
+    "@adhdev/mesh-shared": "0.9.82-rc.443",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/chat-commands-read.ts

@@ -2210,6 +2210,47 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
             });
 
             if (supportsNative && !decision.nativeSelected) {
+                // Native-only content preservation (hermes chat_tail gap).
+                // The history-only path has NO PTY transcript (native-only
+                // providers suppress PTY bodies), so args.ptyMessages is empty
+                // and the machine's pty-parser selection returns NOTHING. But a
+                // post-turn / cold read routinely lands here with a REAL,
+                // safely-mapped native slice that the source FSM declined only
+                // because coverage came back 'partial' (missing sessionStartedAtMs
+                // → Booting→Recovering→pty-parser) or a transient shrink looked
+                // like a regression. Dropping those rows deletes the assistant
+                // answer from chat_tail / read_chat entirely. When the native
+                // read actually resolved rows for THIS session identity
+                // (safeMapping proves ownership: matching historySessionId /
+                // providerSessionId + workspace), return them instead of an empty
+                // array. This never loosens identity safety — it is gated on the
+                // same hasSafeNativeHistoryMapping used everywhere else — and it
+                // is scoped to the native-only history path (no PTY to prefer).
+                // Truly-empty native reads (historyMessages.length === 0) and
+                // unsafe/workspace-aliasing reads (safeMapping === false) still
+                // fall through to the soft-pending dead-end below.
+                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 as any)?.title === 'string' ? { title: (history as any).title } : {}),
+                        ...(historyProviderSessionId ? { providerSessionId: historyProviderSessionId } : {}),
+                        ...(((provider?.historyBehavior as any)?.transcriptAuthority === 'provider' || (provider?.historyBehavior as any)?.transcriptAuthority === 'daemon')
+                            ? { transcriptAuthority: (provider?.historyBehavior as any).transcriptAuthority }
+                            : {}),
+                        coverage: 'tail',
+                    }, args, h);
+                }
                 // Dead-end: we are in the history-only path (no live PTY/ACP
                 // adapter was found for this target session) AND provider-native
                 // history is not safely mappable to the requested session

package/src/commands/high-family/mesh-events.ts

@@ -29,6 +29,11 @@ export const meshEventsHandlers: Record<string, HighFamilyHandler> = {
         const coordinatorDaemonId = typeof args?.coordinatorDaemonId === 'string' && args.coordinatorDaemonId.trim()
             ? args.coordinatorDaemonId.trim()
             : undefined;
+        // SELF-COORDINATOR INBOX LEVEL-DRAIN (Defect 2): the MCP self-coordinator inbox read
+        // (drainCoordinatorPendingEvents) sets this so its own drain is not held while its CLI
+        // is busy — the events return in ITS tool result (a lossless data-queue surface), never
+        // a PTY inject. Every other drain leaves it unset and keeps the busy-coordinator hold.
+        const selfCoordinatorInboxRead = args?.selfCoordinatorInboxRead === true;
         // DRAIN-WITHOUT-INJECT guard: when a LOCAL live CLI coordinator for this mesh is
         // busy (generating / modal-parked), the reconcile loop is HOLDING its terminal
         // events (drained=0) for the coordinator's next idle tick. Draining here would
@@ -57,11 +62,15 @@ export const meshEventsHandlers: Record<string, HighFamilyHandler> = {
         // loop: return nothing, leaving the rows undrained for its idle-tick delivery. A
         // remote pull (foreign coordinatorDaemonId) or a pure stdio MCP coordinator (no live
         // CLI session) is NOT held — see shouldHoldPendingDrainForBusyLocalCoordinator.
-        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 || undefined, coordinatorDaemonId);
-        return { success: true, events, hasLiveCliCoordinator };
+        // SELF-COORDINATOR INBOX LEVEL-DRAIN: when the busy local coordinator drained its OWN
+        // inbox (selfCoordinatorInboxRead), tell the puller these events were surfaced through
+        // the caller's tool result — it must NOT re-forward them into the (busy) PTY (that is the
+        // lossy path). Absent the flag, delivery is unchanged (reconcile-owned PTY / remote pull).
+        return { success: true, events, hasLiveCliCoordinator, ...(selfCoordinatorInboxRead ? { surfacedForSelfCoordinator: true } : {}) };
     },
 
     interactive_prompt_response: async (ctx: HighFamilyContext, args: any) => {

package/src/commands/high-family/mesh-status.ts

@@ -61,6 +61,11 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
     mesh_status: async (ctx: HighFamilyContext, args: any) => {
                 const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
                 if (!meshId) return { success: false, error: 'meshId required' };
+                // Latency telemetry: stamp handler entry so every return path can
+                // report durationMs. Makes the detail-open cost measurable in the
+                // repo-mesh-status debug log (cache hit ≈ single-digit ms; a full
+                // live rebuild is the ~seconds path this change is reducing).
+                const startedAtMs = Date.now();
                 try {
                     const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
                     const mesh = meshRecord?.mesh;
@@ -94,10 +99,51 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                                 meshId,
                                 command: 'mesh_status',
                                 refreshRequested,
+                                durationMs: Date.now() - startedAtMs,
                                 summary: summarizeRepoMeshStatusDebug(cachedStatus),
                             });
                             return cachedStatus;
                         }
+                        // SWR stale-serve: the strict serve above missed only because
+                        // some node still has a pending peer-git probe (the
+                        // shouldRefreshStalePendingAggregate gate). Rather than block
+                        // this interactive detail-open on a full synchronous live
+                        // rebuild, serve the held (slightly stale) snapshot instantly
+                        // and kick ONE coalesced background freshen whose result
+                        // repopulates the cache for the next poll/subscription push.
+                        // allowStalePending relaxes ONLY the pending-git freshness gate;
+                        // getCachedAggregateMeshStatus still enforces the queueRevision
+                        // guard, so a genuine queue/identity mutation is never stale-served.
+                        const staleStatus = ctx.getCachedAggregateMeshStatus(meshId, mesh, {
+                            requireDirectPeerTruth: args?.requireDirectPeerTruth === true,
+                            allowStalePending: true,
+                        });
+                        if (staleStatus) {
+                            if (!ctx.swrRefreshInFlight.has(meshId)) {
+                                ctx.swrRefreshInFlight.add(meshId);
+                                // Fire-and-forget: a full refresh (peer fan-out) that
+                                // rewrites the aggregate cache. Errors are swallowed —
+                                // the stale snapshot was already returned to the caller.
+                                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'
@@ -229,8 +275,15 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                         ? selectedCoordinatorNodeId
                         : undefined;
                     const refreshedAt = new Date().toISOString();
-                    const nodeStatuses = [];
-                    for (const [nodeIndex, node] of (mesh.nodes || []).entries()) {
+                    // Per-node render is parallelized (Promise.allSettled below):
+                    // each node's git probe (local getGitRepoStatus or the remote
+                    // P2P fan-out) is independent, so serializing them stacked one
+                    // slow node's latency onto every other node. Each node has its
+                    // own bounded timeout; a rejected/timed-out node degrades to a
+                    // partial/last-known status for THAT node only and never rejects
+                    // the whole aggregate. Order is preserved by mapping over the
+                    // original entries() index and re-assembling in order.
+                    const renderMeshNode = async (nodeIndex: number, node: any): Promise<Record<string, unknown>> => {
                         const nodeId = normalizeMeshNodeId(node) ?? '';
                         const daemonId = readStringValue(node.daemonId);
                         const nodeMachineId = readMeshNodeMachineId(node as Record<string, unknown>);
@@ -425,19 +478,23 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                                     )) {
                                         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: 10_000, refreshUpstream: true });
+                                    // Route through the shared per-request cache so this
+                                    // local probe reuses the bootstrap hydrate's probe for
+                                    // the same workspace (and vice versa) instead of
+                                    // re-shelling ~14 git processes across the 1.5s TTL.
+                                    const runLocalProbe = () => getGitRepoStatus(workspace, { timeoutMs: 10_000, refreshUpstream: true }) as unknown as Promise<Record<string, unknown> | null>;
+                                    const gitStatus = (await meshGitProbeCache.probeLocal(workspace, runLocalProbe)) as any;
+                                    if (!gitStatus) throw new Error('local_git_probe_unavailable');
                                     status.git = gitStatus;
                                     status[MESH_NODE_LIVE_TRUTH_MARKER] = true;
                                     const reporter = recordInlineMeshDirectGitTruth(node, gitStatus as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
@@ -459,8 +516,43 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                         }
                         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;
+                        // A per-node render should never reject (every git path is
+                        // caught internally), but if one does, degrade to a minimal
+                        // last-known/unknown entry for THAT node so a single failure
+                        // can't drop the whole aggregate. Best-effort recovery of the
+                        // node's cached inline truth, else an unknown-health stub.
+                        const [nodeIndex, node] = meshNodeEntries[i];
+                        const nodeId = normalizeMeshNodeId(node) ?? '';
+                        const daemonId = readStringValue(node.daemonId);
+                        const fallback: Record<string, unknown> = {
+                            nodeId,
+                            machineLabel: buildMeshNodeDisplayLabel(node as Record<string, unknown>, nodeId, readProviderPriorityFromPolicy(node.policy)),
+                            workspace: node.workspace,
+                            repoRoot: node.repoRoot,
+                            isLocalWorktree: node.isLocalWorktree,
+                            worktreeBranch: node.worktreeBranch,
+                            daemonId,
+                            machineId: readMeshNodeMachineId(node as Record<string, unknown>) || 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;
+                    });
 
                     // (B3) Resolve the coordinator daemon scope for the peek.
                     // mesh_status is a read-only status query — it must not consume
@@ -620,6 +712,7 @@ export const meshStatusHandlers: Record<string, HighFamilyHandler> = {
                         refreshReason,
                         meshSource: meshRecord.source,
                         directTruth,
+                        durationMs: Date.now() - startedAtMs,
                         summary: summarizeRepoMeshStatusDebug(returnedStatus),
                     });
                     return returnedStatus;

package/src/commands/high-family/types.ts

@@ -45,7 +45,7 @@ export interface HighFamilyContext {
     getCachedAggregateMeshStatus: (
         meshId: string,
         mesh?: any,
-        options?: { requireDirectPeerTruth?: boolean },
+        options?: { requireDirectPeerTruth?: boolean; allowStalePending?: boolean },
     ) => any | null;
 
     /** Bound `DaemonCommandRouter.rememberAggregateMeshStatus`. */
@@ -61,6 +61,10 @@ export interface HighFamilyContext {
     /** Router's aggregate-status memory cache (`.has()` probe in mesh_status). */
     aggregateMeshStatusCache: Map<string, { builtAt: number; 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>;
 

package/src/commands/router.ts

@@ -286,6 +286,10 @@ export 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 = 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. */
+    private swrRefreshInFlight = new Set<string>();
     /** In-memory async Refinery jobs keyed by meshId:nodeId to reject/return duplicate in-flight requests. */
     private runningRefineJobs = new Map<string, MeshRefineJobHandle>();
     /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
@@ -403,13 +407,25 @@ export class DaemonCommandRouter {
         };
     }
 
-    private getCachedAggregateMeshStatus(meshId: string, mesh?: any, options?: { requireDirectPeerTruth?: boolean }): any | null {
+    private getCachedAggregateMeshStatus(
+        meshId: string,
+        mesh?: any,
+        options?: { requireDirectPeerTruth?: boolean; allowStalePending?: boolean },
+    ): any | null {
         const cached = this.aggregateMeshStatusCache.get(meshId);
         if (!cached?.snapshot || cached.snapshot.success !== true || !Array.isArray(cached.snapshot.nodes)) return null;
+        // Genuine invalidation still forces truth: a queue mutation bumps the
+        // revision, so a stale-revision snapshot is never served (even under the
+        // SWR allowStalePending path below).
         if (cached.queueRevision !== getMeshQueueRevision(meshId)) return null;
         let snapshot = this.cloneJsonValue(cached.snapshot);
         snapshot = this.hydrateCachedAggregateMeshStatusFromInline(snapshot, mesh, options);
-        if (shouldRefreshStalePendingAggregate(snapshot, options)) return null;
+        // SWR: allowStalePending lets the interactive detail-open serve a snapshot
+        // that still has pending peer-git nodes (would otherwise miss here) so the
+        // graph paints instantly; the caller fires a background freshen. The
+        // queueRevision guard above is NOT relaxed — only the pending-git freshness
+        // gate is, so a genuine queue/identity mutation still forces a live rebuild.
+        if (!options?.allowStalePending && shouldRefreshStalePendingAggregate(snapshot, options)) return null;
         const ageMs = Math.max(0, Date.now() - cached.builtAt);
         const sourceOfTruth = snapshot.sourceOfTruth && typeof snapshot.sourceOfTruth === 'object'
             ? snapshot.sourceOfTruth
@@ -677,6 +693,7 @@ export class DaemonCommandRouter {
             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,

package/src/mesh/mesh-node-identity.ts

@@ -1308,6 +1308,28 @@ export class MeshGitProbeCache {
         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.
+     */
+    private static readonly LOCAL_PROBE_DAEMON_ID = '__local_git__';
+
+    async probeLocal(
+        workspace: string,
+        probe: () => Promise<Record<string, unknown> | null>,
+    ): Promise<Record<string, unknown> | null> {
+        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
@@ -1551,7 +1573,25 @@ export async function hydrateInlineMeshDirectTruth(args: {
     const unavailableNodeIds: string[] = [];
     const deadNodeIds: string[] = [];
 
-    for (const [nodeIndex, node] of nodes.entries()) {
+    // Each node's classification (local git probe, standing truth, or the remote
+    // P2P fan-out) is independent, so probing them serially stacked one slow
+    // (often TURN-relayed) peer's latency onto every other node — the 3×25s serial
+    // stall. Classify all nodes concurrently via Promise.allSettled; each node has
+    // its own bounded per-peer timeout + definitively-down fast-fail inside
+    // probeRemoteMeshGitStatusWithRetry, so a hung peer degrades to `unavailable`
+    // for THAT node only and never blocks the aggregate. The counters and
+    // unavailable/dead node lists are folded from the settled results afterward so
+    // no shared mutable state is touched concurrently.
+    type NodeTruthResult =
+        | { kind: 'dead'; nodeId: string }
+        | { kind: 'unavailable'; nodeId: string; attempted?: boolean }
+        | { kind: 'local' }
+        | { kind: 'standing' }
+        | { kind: 'peerConfirmed' }
+        | { kind: 'peerUnavailable'; nodeId: string }
+        | { kind: 'skip' };
+
+    const classifyNode = async (nodeIndex: number, node: any): Promise<NodeTruthResult> => {
         const nodeId = normalizeMeshNodeId(node) || `node_${nodeIndex}`;
         const workspace = readStringValue(node?.workspace);
         const daemonId = readStringValue(node?.daemonId);
@@ -1573,23 +1613,27 @@ export 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 (fs.existsSync(workspace)) {
             try {
-                const localGit = await getGitRepoStatus(workspace, { timeoutMs: 10_000, refreshUpstream: true });
+                // Route the local probe through the shared cache so the per-node
+                // render loop's getGitRepoStatus for the same workspace reuses this
+                // exact result instead of re-shelling ~14 git processes when the two
+                // passes straddle the getGitRepoStatus 1.5s TTL.
+                const runLocalProbe = () => getGitRepoStatus(workspace, { timeoutMs: 10_000, refreshUpstream: true }) as unknown as Promise<Record<string, unknown> | null>;
+                const localGit = args.probeCache
+                    ? await args.probeCache.probeLocal(workspace, runLocalProbe)
+                    : await runLocalProbe();
                 if (localGit?.isGitRepo) {
                     const reporter = recordInlineMeshDirectGitTruth(node, localGit as unknown as Record<string, unknown>, 'selected_coordinator_local_git');
                     persistNodeReporterPlatform(args.meshSource, args.mesh, nodeId, reporter);
-                    localConfirmedCount += 1;
-                    continue;
+                    return { kind: 'local' };
                 }
             } catch {
                 // Fall through to remote classification.
@@ -1603,8 +1647,7 @@ export async function hydrateInlineMeshDirectTruth(args: {
         // block the bootstrap.
         const standingGit = buildInlineMeshTransitGitStatus(node);
         if (standingGit) {
-            standingEvidenceCount += 1;
-            continue;
+            return { kind: 'standing' };
         }
 
         if (!args.probeRemotePeers) {
@@ -1612,15 +1655,13 @@ export async function hydrateInlineMeshDirectTruth(args: {
             // pending (the per-node loop marks it gitProbePending and the graph
             // shows setup inventory for it). It is NOT unavailable — the graph
             // must still render. An explicit refresh will fan out and freshen it.
-            continue;
+            return { kind: 'skip' };
         }
 
         if (!daemonId || !args.dispatchMeshCommand) {
-            if (!isSelfNode) unavailableNodeIds.push(nodeId);
-            continue;
+            return !isSelfNode ? { kind: 'unavailable', nodeId } : { kind: 'skip' };
         }
 
-        peerAttemptedCount += 1;
         // Bounded retry, gated on the peer staying `connected`: a slow
         // (TURN-relayed) peer that just exceeds one probe window is recovered
         // instead of being hard-failed. The connection is re-checked before each
@@ -1642,8 +1683,7 @@ export 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' };
         }
 
         // Invariant: a connected peer that still holds standing git truth is
@@ -1652,8 +1692,56 @@ export async function hydrateInlineMeshDirectTruth(args: {
         // not currently connected, or it is connected but every bounded probe
         // failed — that is the genuine "connected, no truth, retries exhausted"
         // case that drives the explicit-refresh hard-fail.
-        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];
+        // A classifier should never reject (every probe is caught internally), but
+        // if one does, degrade that node to `unavailable` when it is a remote peer —
+        // never silently drop it, never fail the whole aggregate.
+        const result: NodeTruthResult = 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 } as NodeTruthResult : { kind: 'skip' } as NodeTruthResult;
+            })();
+        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,

package/src/mesh/mesh-reconcile-loop.ts

@@ -523,11 +523,26 @@ export function resolveCoordinatorDrainDeliverability(
  * remote pull is never blocked by our local coordinator's busy state. A pure
  * stdio MCP coordinator (no live CLI session) never satisfies (1), so its tool
  * result remains the surface and the drain proceeds. No regression to either.
+ *
+ * SELF-COORDINATOR INBOX LEVEL-DRAIN (Defect 2): the hold above assumes the ONLY
+ * surface for a busy local coordinator's events is a future PTY inject on its idle
+ * edge, so it defers to the reconcile loop. But when the drain caller IS the local
+ * coordinator reading its OWN inbox (the `get_pending_mesh_events` call whose events
+ * are returned in the caller's tool RESULT — a data queue the self-coordinating LLM
+ * consumes directly), the events ARE surfaced losslessly the moment the tool returns,
+ * with NO PTY write. A busy self-coordinating LLM that calls a mesh tool mid-turn would
+ * otherwise get an empty inbox (held) and only see the completion on its NEXT busy→idle
+ * edge — the measured ~59s strand. `callerIsSelfCoordinatorInboxRead` marks that safe
+ * caller: the hold is relaxed for it (return the events), while every OTHER drain (a
+ * backfill relay, a broadcast poll, a DIFFERENT coordinator that genuinely needs its PTY)
+ * still defers to the reconcile loop. This relaxes delivery INTO the coordinator's own
+ * inbox only — it never changes how events are injected into a live PTY prompt.
  */
 export function shouldHoldPendingDrainForBusyLocalCoordinator(
     components: Pick<DaemonComponents, 'instanceManager'> & { statusInstanceId?: string },
     meshId: string,
     requestedCoordinatorDaemonId?: string | null,
+    callerIsSelfCoordinatorInboxRead?: boolean,
 ): boolean {
     if (!meshId) return false;
     const deliverability = resolveCoordinatorDrainDeliverability(components, meshId);
@@ -539,7 +554,13 @@ export function shouldHoldPendingDrainForBusyLocalCoordinator(
         readNonEmptyString((components as { statusInstanceId?: string }).statusInstanceId),
         readNonEmptyString(loadConfig().machineId),
     ]);
-    return localIds.some(id => daemonIdsEquivalent(id, requested));
+    const targetsLocalCoordinator = localIds.some(id => daemonIdsEquivalent(id, requested));
+    if (!targetsLocalCoordinator) return false;
+    // SELF-COORDINATOR INBOX LEVEL-DRAIN: the busy local coordinator is itself the caller,
+    // reading its own inbox — the drained events return in ITS tool result (lossless data-queue
+    // surface, no PTY inject). Do NOT hold; let the self-coordinator see its completions now.
+    if (callerIsSelfCoordinatorInboxRead) return false;
+    return true;
 }
 
 // Inject a drained pending event into a live coordinator session. Force-inject

package/src/providers/chat-message-normalization.ts

@@ -27,7 +27,7 @@ export function extractFinalSummaryFromMessages(
   return '';
 }
 
-function readChatMessageTimestampMs(message: ChatMessage | null | undefined): number | undefined {
+export function readChatMessageTimestampMs(message: ChatMessage | null | undefined): number | undefined {
   if (!message) return undefined;
   const record = message as ChatMessage & Record<string, unknown>;
   for (const value of [record.timestamp, record.createdAt, record.created_at, record.updatedAt, record.time, record.receivedAt]) {