@adhdev/daemon-core 0.9.82-rc.442 → 0.9.82-rc.444

package/dist/mesh/mesh-ledger.d.ts

@@ -14,7 +14,7 @@
  */
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed' | 'coordinator_operating_note' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated' | 'magi_dispatched' | 'magi_synthesis';
+export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned' | 'event_held' | 'task_reclaimed' | 'coordinator_operating_note' | 'coordinator_operating_note_tombstone' | 'mission_created' | 'mission_status_changed' | 'mission_goal_updated' | 'magi_dispatched' | 'magi_synthesis';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;
@@ -151,6 +151,10 @@ export interface AppendRemoteLedgerResult {
     entries: MeshLedgerEntry[];
 }
 export declare const MAX_LEDGER_SLICE_LIMIT = 500;
+export declare const OPERATING_NOTE_KIND: MeshLedgerKind;
+export declare const OPERATING_NOTE_TOMBSTONE_KIND: MeshLedgerKind;
+export declare const OPERATING_NOTE_DEDUPE_WINDOW = 40;
+export declare const OPERATING_NOTE_KEEP_LATEST = 100;
 export declare function getLedgerDir(): string;
 /**
  * Footer to append to worker task messages so workers output structured results
@@ -180,6 +184,40 @@ export declare function buildTaskCompletionEvidence(opts: BuildTaskCompletionEvi
  */
 export declare const meshLedgerEvents: EventEmitter<[never]>;
 export declare function appendLedgerEntry(meshId: string, partial: Omit<MeshLedgerEntry, 'id' | 'meshId' | 'timestamp'>): MeshLedgerEntry;
+/** True if the operating note is retracted by any tombstone in `tombstones`. */
+export declare function isOperatingNoteTombstoned(entry: Pick<MeshLedgerEntry, 'id' | 'payload'>, tombstones: {
+    ids: Set<string>;
+    fingerprints: Set<string>;
+}): boolean;
+/**
+ * Fix (2) supersede/remove: append a tombstone that retracts a coordinator
+ * operating note. Targets by note id and/or by exact trimmed text (a text target
+ * retracts every note with that text). History is preserved — the notes stay in
+ * the ledger but readers filter them out. Returns how many currently-live notes
+ * the tombstone will hide.
+ */
+export declare function tombstoneOperatingNote(meshId: string, target: {
+    noteId?: string;
+    text?: string;
+    reason?: string;
+}): {
+    tombstone: MeshLedgerEntry;
+    matched: number;
+};
+/**
+ * Read live operating notes (tombstoned notes filtered out), oldest→newest.
+ * `tail` bounds the number of live notes returned (the freshest N).
+ */
+export declare function readOperatingNotes(meshId: string, opts?: {
+    tail?: number;
+}): MeshLedgerEntry[];
+/**
+ * Fix (3) keep-latest-N prune for coordinator_operating_note. Removes, from the
+ * store, (a) every note retracted by a tombstone, and (b) the oldest live notes
+ * beyond `keepLatest`. Tombstone entries themselves are retained as an audit trail
+ * of what was forgotten. Returns the number of note entries removed.
+ */
+export declare function pruneOperatingNotes(meshId: string, keepLatest?: number): number;
 /**
  * Append entries received over local-first/P2P ledger replication to the local ledger.
  * This skips deduplicated entries and rejects malformed/cross-mesh entries.

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;
@@ -285,6 +286,7 @@ export declare class CliProviderInstance implements ProviderInstance {
     private approvalResolutionFinalizationBlock;
     private scheduleCompletedDebounceFlush;
     private isMeshWorkerSession;
+    private isAutonomousMeshSession;
     /**
      * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.
      * Prefers the per-turn binding (engine.currentTurnTaskId, set when the turn was

package/dist/providers/native-history/antigravity-cli-transcript.d.ts

@@ -12,11 +12,35 @@
  *        { source: 'USER_EXPLICIT'|'MODEL', type: string, content: string, status: 'DONE'|..., created_at: number }
  *
  *   3. ~/.gemini/antigravity-cli/conversations/<uuid>.pb
- *      Protobuf binary — schema not publicly documented. Adapter extracts
+ *      Legacy protobuf binary — schema not publicly documented. Adapter extracts
  *      printable UTF-8 text runs as best-effort content (no proto library needed).
  *
+ *   4. ~/.gemini/antigravity-cli/conversations/<uuid>.db  ← current format
+ *      Per-session SQLite database. Recent antigravity migrated conversation
+ *      storage from .pb (+ brain/*.jsonl) to a per-session SQLite db. The
+ *      schema is a trajectory of `steps`, NOT a simple messages(role,content)
+ *      table:
+ *        steps(idx INTEGER PK, step_type INTEGER, status INTEGER,
+ *              step_payload BLOB [protobuf], ...)
+ *      Each `step_payload` is a protobuf message. Empirically (introspected
+ *      from real stores):
+ *        - step_type 14 → a USER turn. The prompt text is the largest
+ *          contiguous UTF-8 run inside the payload (field 19 subtree).
+ *        - step_type 15 → a MODEL/assistant turn. The assistant's final
+ *          natural-language answer lives at payload field 20 → field 1
+ *          (identical to field 8). Field 20 → field 3 is the internal
+ *          reasoning summary and is intentionally NOT surfaced.
+ *        - other step types are tool calls / ephemeral system context.
+ *      We read the blobs with a tiny dependency-free protobuf field walker
+ *      (no proto schema / codegen needed) and map the two message step types.
+ *      Because the daemon does NOT read this db, native history previously
+ *      returned 0 rows for these sessions and read_chat fell back to the
+ *      pty parser (which only echoes the user's own input) — assistant
+ *      answers appeared lost even though they were on disk.
+ *
  * This adapter provides:
- *   - Full coverage when a brain transcript exists (authoritative source).
+ *   - Full coverage from a per-session .db (current format) — preferred.
+ *   - Full coverage when a brain transcript exists (legacy authoritative source).
  *   - Partial coverage (user prompts only) from history.jsonl as fallback.
  *   - Best-effort raw-string extraction from .pb files when no other source exists.
  *
@@ -24,6 +48,7 @@
  *   ~/.gemini/antigravity-cli/history.jsonl
  *   ~/.gemini/antigravity-cli/brain/{uuid}/.system_generated/logs/transcript*.jsonl
  *   ~/.gemini/antigravity-cli/conversations/{uuid}.pb
+ *   ~/.gemini/antigravity-cli/conversations/{uuid}.db
  *
  * OSS code (AGPL-3.0). Must not import from packages/ (proprietary).
  */
@@ -79,6 +104,7 @@ export interface NativeHistorySessionMeta {
  * `sessionPath` is the absolute path to one of:
  *   - A brain transcript JSONL: ~/.gemini/antigravity-cli/brain/<uuid>/.system_generated/logs/transcript*.jsonl
  *   - The shared history.jsonl: ~/.gemini/antigravity-cli/history.jsonl
+ *   - A conversation SQLite db: ~/.gemini/antigravity-cli/conversations/<uuid>.db
  *   - A conversation protobuf: ~/.gemini/antigravity-cli/conversations/<uuid>.pb
  *
  * The session UUID is inferred from the directory name (brain), filename (pb), or

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.442",
+  "version": "0.9.82-rc.444",
   "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.442",
+    "@adhdev/mesh-shared": "0.9.82-rc.444",
     "@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-coordinator-launch.ts

@@ -101,8 +101,10 @@ export const meshCoordinatorLaunchHandlers: Record<string, HighFamilyHandler> =
                     // Best-effort: a read failure just omits the section.
                     const buildOperatingNotesBestEffort = async (id: string) => {
                         try {
-                            const { readLedgerEntries } = await import('../../mesh/mesh-ledger.js');
-                            const noteEntries = readLedgerEntries(id, { kind: ['coordinator_operating_note'], tail: 20 });
+                            const { readOperatingNotes } = await import('../../mesh/mesh-ledger.js');
+                            // readOperatingNotes filters out tombstoned (forgotten) notes so a
+                            // retracted lesson never rides into the prompt. Newest last; tail 20.
+                            const noteEntries = readOperatingNotes(id, { tail: 20 });
                             const notes = noteEntries
                                 .map((e) => {
                                     const p = (e.payload || {}) as Record<string, unknown>;

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/index.ts

@@ -262,7 +262,7 @@ export { loadRepoSettings } from './config/repo-settings.js';
 export type { RepoSettings, LoadRepoSettingsOptions } from './config/repo-settings.js';
 
 // ── Mesh Task Ledger ──
-export { appendLedgerEntry, appendRemoteLedgerEntries, buildTaskCompletionEvidence, normalizeMeshWorkerResult, readLedgerEntries, readLedgerSlice, readLedgerSliceFromStore, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, MAX_LEDGER_SLICE_LIMIT } from './mesh/mesh-ledger.js';
+export { appendLedgerEntry, appendRemoteLedgerEntries, buildTaskCompletionEvidence, normalizeMeshWorkerResult, readLedgerEntries, readLedgerSlice, readLedgerSliceFromStore, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, MAX_LEDGER_SLICE_LIMIT, tombstoneOperatingNote, readOperatingNotes, pruneOperatingNotes, isOperatingNoteTombstoned, OPERATING_NOTE_KIND, OPERATING_NOTE_TOMBSTONE_KIND, OPERATING_NOTE_DEDUPE_WINDOW, OPERATING_NOTE_KEEP_LATEST } from './mesh/mesh-ledger.js';
 export type { AppendRemoteLedgerResult, MeshLedgerEntry, MeshLedgerKind, MeshLedgerSlice, MeshLedgerSummary, ReadLedgerOptions, ReadLedgerSliceOptions, SessionRecoveryContext, MeshTaskCompletionEvidence, MeshWorkerResultArtifact, MeshProcessArtifact, MeshValidationResultArtifact } from './mesh/mesh-ledger.js';
 export { fastForwardMeshNode } from './mesh/mesh-fast-forward.js';
 export type { MeshFastForwardNodeArgs, MeshFastForwardPlannedStep, MeshFastForwardResult } from './mesh/mesh-fast-forward.js';

package/src/mesh/coordinator-prompt.ts

@@ -490,6 +490,7 @@ const TOOLS_SECTION = `## Available Tools
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger — dispatches, completions, failures. Use to understand what has been done before deciding next steps |
 | \`mesh_record_note\` | Record a durable, provider-neutral operating note (provider quirk / pattern to avoid / recovery lesson). Future coordinators see it under "## Operating Notes" at launch |
+| \`mesh_forget_note\` | Retract a stale/wrong operating note by note_id or exact text so it stops riding into future coordinators' prompts (append-only tombstone; history preserved) |
 | \`mesh_git_status\` | Check git status on a specific node |
 | \`mesh_read_node_logs\` | Fetch a remote node's daemon log tail directly over P2P (grep/since/byte-bounded, secrets redacted) — no session/PowerShell needed to debug a node's daemon |
 | \`mesh_fast_forward_node\` | Safely dry-run or explicitly execute an obvious clean fast-forward without launching an agent session |