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

package/dist/index.mjs

@@ -404,10 +404,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "37211cd9f2109403d5da1bf739407ae80c440a60" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "37211cd9" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.442" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-01T08:08:15.319Z" : void 0);
+  const commit = readInjected(true ? "fafdde138250b2edcbf2e42c643e3cabd1b8bda0" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "fafdde13" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.444" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-01T12:06:17.132Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3711,6 +3711,7 @@ var init_coordinator_prompt = __esm({
 | \`mesh_read_debug\` | Collect a daemon-side chat/parser debug bundle for a session |
 | \`mesh_task_history\` | Read the task ledger \u2014 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) \u2014 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 |
@@ -4096,6 +4097,10 @@ var init_load_better_sqlite3 = __esm({
 var mesh_ledger_exports = {};
 __export(mesh_ledger_exports, {
   MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
+  OPERATING_NOTE_DEDUPE_WINDOW: () => OPERATING_NOTE_DEDUPE_WINDOW,
+  OPERATING_NOTE_KEEP_LATEST: () => OPERATING_NOTE_KEEP_LATEST,
+  OPERATING_NOTE_KIND: () => OPERATING_NOTE_KIND,
+  OPERATING_NOTE_TOMBSTONE_KIND: () => OPERATING_NOTE_TOMBSTONE_KIND,
   __clearMeshLedgerForTests: () => __clearMeshLedgerForTests,
   appendLedgerEntry: () => appendLedgerEntry,
   appendRemoteLedgerEntries: () => appendRemoteLedgerEntries,
@@ -4106,11 +4111,15 @@ __export(mesh_ledger_exports, {
   getLedgerSummary: () => getLedgerSummary,
   getSessionRecoveryContext: () => getSessionRecoveryContext,
   isIntentionalCleanupStopEntry: () => isIntentionalCleanupStopEntry,
+  isOperatingNoteTombstoned: () => isOperatingNoteTombstoned,
   meshLedgerEvents: () => meshLedgerEvents,
   normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
+  pruneOperatingNotes: () => pruneOperatingNotes,
   readLedgerEntries: () => readLedgerEntries,
   readLedgerSlice: () => readLedgerSlice,
-  readLedgerSliceFromStore: () => readLedgerSliceFromStore
+  readLedgerSliceFromStore: () => readLedgerSliceFromStore,
+  readOperatingNotes: () => readOperatingNotes,
+  tombstoneOperatingNote: () => tombstoneOperatingNote
 });
 import { appendFileSync, existsSync as existsSync7, mkdirSync as mkdirSync4, readFileSync as readFileSync5, statSync as statSync4, renameSync as renameSync2, writeFileSync as writeFileSync3 } from "fs";
 import { join as join8 } from "path";
@@ -4384,6 +4393,17 @@ function buildTaskCompletionEvidence(opts) {
   };
 }
 function appendLedgerEntry(meshId, partial) {
+  if (partial.kind === OPERATING_NOTE_KIND) {
+    const text = operatingNoteText(partial.payload);
+    if (text) {
+      const recentNotes = readLedgerEntries(meshId, {
+        kind: [OPERATING_NOTE_KIND],
+        tail: OPERATING_NOTE_DEDUPE_WINDOW
+      });
+      const existing = recentNotes.find((e) => operatingNoteText(e.payload) === text);
+      if (existing) return existing;
+    }
+  }
   const entry = {
     id: randomUUID4(),
     meshId,
@@ -4421,11 +4441,101 @@ function appendLedgerEntry(meshId, partial) {
     appendFileSync(filePath, line, { encoding: "utf-8", mode: 384 });
     invalidateLedgerCache(meshId);
     meshLedgerEvents.emit("append", meshId, entry);
+    if (entry.kind === OPERATING_NOTE_KIND || entry.kind === OPERATING_NOTE_TOMBSTONE_KIND) {
+      try {
+        pruneOperatingNotes(meshId);
+      } catch {
+      }
+    }
     return entry;
   } catch (e) {
     throw new Error(`Failed to append to ledger for mesh ${meshId}: ${e.message}`);
   }
 }
+function operatingNoteText(payload) {
+  const text = payload && typeof payload.text === "string" ? payload.text.trim() : "";
+  return text || void 0;
+}
+function collectOperatingNoteTombstones(entries) {
+  const ids = /* @__PURE__ */ new Set();
+  const fingerprints = /* @__PURE__ */ new Set();
+  for (const e of entries) {
+    if (e.kind !== OPERATING_NOTE_TOMBSTONE_KIND) continue;
+    const p = e.payload || {};
+    const targetId = typeof p.targetNoteId === "string" ? p.targetNoteId.trim() : "";
+    const targetFp = typeof p.targetFingerprint === "string" ? p.targetFingerprint.trim() : "";
+    if (targetId) ids.add(targetId);
+    if (targetFp) fingerprints.add(targetFp);
+  }
+  return { ids, fingerprints };
+}
+function isOperatingNoteTombstoned(entry, tombstones) {
+  if (tombstones.ids.has(entry.id)) return true;
+  const text = operatingNoteText(entry.payload);
+  return text ? tombstones.fingerprints.has(text) : false;
+}
+function tombstoneOperatingNote(meshId, target) {
+  const noteId = typeof target.noteId === "string" ? target.noteId.trim() : "";
+  const fingerprint = typeof target.text === "string" ? target.text.trim() : "";
+  if (!noteId && !fingerprint) {
+    throw new Error("tombstoneOperatingNote requires a noteId or text target");
+  }
+  const notes = readOperatingNotes(meshId);
+  const matched = notes.filter(
+    (n) => noteId && n.id === noteId || fingerprint && operatingNoteText(n.payload) === fingerprint
+  ).length;
+  const tombstone = appendLedgerEntry(meshId, {
+    kind: OPERATING_NOTE_TOMBSTONE_KIND,
+    payload: {
+      ...noteId ? { targetNoteId: noteId } : {},
+      ...fingerprint ? { targetFingerprint: fingerprint } : {},
+      ...target.reason && target.reason.trim() ? { reason: target.reason.trim() } : {},
+      forgottenAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  });
+  return { tombstone, matched };
+}
+function readOperatingNotes(meshId, opts) {
+  const raw = getCachedRawEntries(meshId);
+  const tombstones = collectOperatingNoteTombstones(raw);
+  let notes = raw.filter((e) => e.kind === OPERATING_NOTE_KIND && !isOperatingNoteTombstoned(e, tombstones));
+  if (opts?.tail && opts.tail > 0 && notes.length > opts.tail) {
+    notes = notes.slice(-opts.tail);
+  }
+  return notes;
+}
+function pruneOperatingNotes(meshId, keepLatest = OPERATING_NOTE_KEEP_LATEST) {
+  const raw = getCachedRawEntries(meshId);
+  const tombstones = collectOperatingNoteTombstones(raw);
+  const removeIds = [];
+  const liveNotes = [];
+  for (const e of raw) {
+    if (e.kind !== OPERATING_NOTE_KIND) continue;
+    if (isOperatingNoteTombstoned(e, tombstones)) {
+      removeIds.push(e.id);
+    } else {
+      liveNotes.push(e);
+    }
+  }
+  const bound = Math.max(0, Math.floor(keepLatest));
+  if (liveNotes.length > bound) {
+    for (const e of liveNotes.slice(0, liveNotes.length - bound)) removeIds.push(e.id);
+  }
+  if (removeIds.length === 0) return 0;
+  try {
+    MeshRuntimeStore.getInstance().deleteLedgerEntries(meshId, removeIds);
+  } catch {
+  }
+  try {
+    const remaining = readLedgerFile(meshId).filter((e) => !removeIds.includes(e.id));
+    const filePath = getLedgerPath(meshId);
+    const lines = remaining.length ? remaining.map((e) => JSON.stringify(e)).join("\n") + "\n" : "";
+    writeFileSync3(filePath, lines, { encoding: "utf-8", mode: 384 });
+  } catch {
+  }
+  invalidateLedgerCache(meshId);
+  return removeIds.length;
+}
 function clampLedgerSliceLimit(limit) {
   if (typeof limit !== "number" || !Number.isFinite(limit)) return DEFAULT_LEDGER_SLICE_LIMIT;
   return Math.max(1, Math.min(MAX_LEDGER_SLICE_LIMIT, Math.floor(limit)));
@@ -4765,7 +4875,7 @@ function rotateLedgerFile(meshId, currentPath) {
 `);
   }
 }
-var LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS, ledgerImportStoreRef, ledgerImportDone;
+var LEDGER_DIR_NAME, MAX_FILE_SIZE_BYTES, COMPACT_THRESHOLD_BYTES, ARCHIVE_TERMINAL_OLDER_THAN_MS, RECENT_FAILURE_WINDOW_MS, ARCHIVABLE_KINDS, DEFAULT_LEDGER_SLICE_LIMIT, MAX_LEDGER_SLICE_LIMIT, OPERATING_NOTE_KIND, OPERATING_NOTE_TOMBSTONE_KIND, OPERATING_NOTE_DEDUPE_WINDOW, OPERATING_NOTE_KEEP_LATEST, meshLedgerEvents, ledgerReadCache, LEDGER_CACHE_TTL_MS, ledgerImportStoreRef, ledgerImportDone;
 var init_mesh_ledger = __esm({
   "src/mesh/mesh-ledger.ts"() {
     "use strict";
@@ -4784,6 +4894,10 @@ var init_mesh_ledger = __esm({
     ]);
     DEFAULT_LEDGER_SLICE_LIMIT = 100;
     MAX_LEDGER_SLICE_LIMIT = 500;
+    OPERATING_NOTE_KIND = "coordinator_operating_note";
+    OPERATING_NOTE_TOMBSTONE_KIND = "coordinator_operating_note_tombstone";
+    OPERATING_NOTE_DEDUPE_WINDOW = 40;
+    OPERATING_NOTE_KEEP_LATEST = 100;
     meshLedgerEvents = new EventEmitter();
     ledgerReadCache = /* @__PURE__ */ new Map();
     LEDGER_CACHE_TTL_MS = 100;
@@ -17195,7 +17309,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;
@@ -17205,7 +17319,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;
@@ -32038,6 +32155,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,
@@ -40639,6 +40776,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
@@ -41122,8 +41268,7 @@ var CliProviderInstance = class _CliProviderInstance {
    * to the genuine-modal classification.
    */
   isTransientToolConsent(now = Date.now()) {
-    const isAutonomousMeshSession = this.isMeshWorkerSession() || !!this.settings.meshCoordinatorFor;
-    return isAutonomousMeshSession && this.hasAdapterPendingResponse() && !this.manualAttendance.isAttended(now);
+    return this.isAutonomousMeshSession() && this.hasAdapterPendingResponse() && !this.manualAttendance.isAttended(now);
   }
   /** True when this session is parked on a modal awaiting a human answer. */
   isModalParked() {
@@ -41305,13 +41450,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) {
@@ -41374,8 +41523,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 : [],
@@ -41385,7 +41534,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"
       };
@@ -41398,8 +41547,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();
@@ -41504,7 +41654,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) {
@@ -41601,6 +41751,19 @@ var CliProviderInstance = class _CliProviderInstance {
   isMeshWorkerSession() {
     return !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.meshNodeId || this.settings.launchedByCoordinator);
   }
+  // FALSE-IDLE (self-coordinator settle): an autonomously-progressing mesh session
+  // is either a delegated worker (isMeshWorkerSession) OR the coordinator's OWN
+  // claude-cli session (meshCoordinatorFor). Both run auto-approved tool turns whose
+  // inter-approval valley (busy→idle blip→generating re-entry ~0.5s later) must be
+  // absorbed by the completedDebounce settle window, not flushed on the first idle
+  // sample. The worker branch already gets NATIVE_HISTORY_MESH_IDLE_SETTLE_MS; the
+  // self-coordinator session (worker markers absent, meshCoordinatorFor present) was
+  // taking flushDelay=0 — no settle window — so its busyEpoch/lastOutputAt continuity
+  // guard had no window to observe the valley and fired mid-turn "next-step" previews
+  // as a finalSummary. Mirrors the isAutonomousMeshSession notion in isTransientToolConsent.
+  isAutonomousMeshSession() {
+    return this.isMeshWorkerSession() || !!this.settings.meshCoordinatorFor;
+  }
   /**
    * ARCH-REFACTOR R1: the taskId to attribute the CURRENTLY-completing turn to.
    * Prefers the per-turn binding (engine.currentTurnTaskId, set when the turn was
@@ -41645,6 +41808,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;
@@ -41947,6 +42123,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(() => {
@@ -41972,6 +42149,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;
@@ -42070,12 +42248,18 @@ 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();
-          const flushDelay = ownsExternalHistory ? meshWorkerSession ? NATIVE_HISTORY_MESH_IDLE_SETTLE_MS : 0 : 3e3;
-          LOG.debug("CLI", `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} meshWorker=${meshWorkerSession} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
+          const meshSettleSession = this.isAutonomousMeshSession();
+          const flushDelay = ownsExternalHistory ? meshSettleSession ? NATIVE_HISTORY_MESH_IDLE_SETTLE_MS : 0 : 3e3;
+          LOG.debug("CLI", `[${this.type}] set completedDebouncePending duration=${duration}s ownsExternalHistory=${ownsExternalHistory} meshSettle=${meshSettleSession} flushDelay=${flushDelay}ms generatingStartedAt=${this.generatingStartedAt}`);
           this.scheduleCompletedDebounceFlush(flushDelay);
         }
       } else if (newStatus === "idle" && this.lastStatus === "starting") {
@@ -46135,6 +46319,7 @@ function readSession2(sessionPath) {
 }
 
 // src/providers/native-history/antigravity-cli-transcript.ts
+init_load_better_sqlite3();
 import * as fs22 from "fs";
 import * as path31 from "path";
 import * as os22 from "os";
@@ -46311,6 +46496,151 @@ function parsePbFile(filePath, sessionId) {
     }
   ];
 }
+var AGY_STEP_TYPE_USER = 14;
+var AGY_STEP_TYPE_MODEL = 15;
+function readVarint(buf, offset) {
+  let result = 0;
+  let shift = 0;
+  let i = offset;
+  while (i < buf.length) {
+    const byte = buf[i];
+    i += 1;
+    result += (byte & 127) * Math.pow(2, shift);
+    if ((byte & 128) === 0) return [result, i];
+    shift += 7;
+    if (shift > 63) break;
+  }
+  return [result, i];
+}
+function decodeProtoFields(buf) {
+  const fields = [];
+  let i = 0;
+  while (i < buf.length) {
+    const [key2, afterKey] = readVarint(buf, i);
+    if (afterKey === i) break;
+    i = afterKey;
+    const field = Math.floor(key2 / 8);
+    const wireType = key2 & 7;
+    if (field <= 0) break;
+    if (wireType === 0) {
+      const [value, next] = readVarint(buf, i);
+      if (next === i) break;
+      i = next;
+      fields.push({ field, wireType, varint: value });
+    } else if (wireType === 2) {
+      const [len, afterLen] = readVarint(buf, i);
+      i = afterLen;
+      if (len < 0 || i + len > buf.length) break;
+      fields.push({ field, wireType, bytes: buf.subarray(i, i + len) });
+      i += len;
+    } else if (wireType === 5) {
+      i += 4;
+    } else if (wireType === 1) {
+      i += 8;
+    } else {
+      break;
+    }
+  }
+  return fields;
+}
+function firstLenField(buf, field) {
+  for (const f of decodeProtoFields(buf)) {
+    if (f.field === field && f.wireType === 2 && f.bytes) return f.bytes;
+  }
+  return null;
+}
+function looksLikeText(buf) {
+  if (buf.length === 0) return false;
+  let printable = 0;
+  for (let i = 0; i < buf.length; i++) {
+    const b = buf[i];
+    if (b >= 32 && b <= 126 || b === 9 || b === 10 || b === 13 || b >= 128) printable += 1;
+  }
+  return printable / buf.length >= 0.9;
+}
+function stripAnswerMarker(text) {
+  return text.replace(/^\s*MARKER_V1\s*/, "");
+}
+function extractModelAnswer(payload) {
+  const inner = firstLenField(payload, 20);
+  if (!inner) return "";
+  const answer = firstLenField(inner, 1) ?? firstLenField(inner, 8);
+  if (!answer || !looksLikeText(answer)) return "";
+  return stripAnswerMarker(answer.toString("utf-8")).trim();
+}
+function extractUserPrompt(payload) {
+  const inner = firstLenField(payload, 19);
+  if (!inner) return "";
+  const raw = firstLenField(inner, 2) ?? firstLenField(inner, 3);
+  if (!raw || !looksLikeText(raw)) return "";
+  const text = raw.toString("utf-8").trim();
+  if (!text) return "";
+  return extractUserRequestContent(text);
+}
+function parseConversationDb(filePath, sessionId, workspace) {
+  let db;
+  try {
+    const Database = loadBetterSqlite3();
+    db = new Database(filePath, { readonly: true, fileMustExist: true });
+  } catch {
+    return null;
+  }
+  let rows;
+  try {
+    rows = db.prepare(
+      `SELECT idx, step_type, step_payload
+           FROM steps
+          WHERE step_type IN (${AGY_STEP_TYPE_USER}, ${AGY_STEP_TYPE_MODEL})
+          ORDER BY idx ASC`
+    ).all();
+  } catch {
+    return null;
+  } finally {
+    try {
+      db.close();
+    } catch {
+    }
+  }
+  if (!Array.isArray(rows) || rows.length === 0) return null;
+  const normalizedWorkspace = typeof workspace === "string" ? workspace.trim() : "";
+  const baseTs = statMtimeMs3(filePath) || Date.now();
+  const messages = [];
+  for (const row of rows) {
+    const payload = row.step_payload;
+    if (!payload || !Buffer.isBuffer(payload) || payload.length === 0) continue;
+    const receivedAt = baseTs + messages.length;
+    if (row.step_type === AGY_STEP_TYPE_USER) {
+      const content = extractUserPrompt(payload);
+      if (!content) continue;
+      const msg = {
+        ts: new Date(receivedAt).toISOString(),
+        receivedAt,
+        role: "user",
+        content,
+        kind: "standard",
+        agent: "antigravity-cli",
+        historySessionId: sessionId
+      };
+      if (normalizedWorkspace) msg.workspace = normalizedWorkspace;
+      messages.push(msg);
+    } else if (row.step_type === AGY_STEP_TYPE_MODEL) {
+      const content = extractModelAnswer(payload);
+      if (!content) continue;
+      const msg = {
+        ts: new Date(receivedAt).toISOString(),
+        receivedAt,
+        role: "assistant",
+        content,
+        kind: "standard",
+        agent: "antigravity-cli",
+        historySessionId: sessionId
+      };
+      if (normalizedWorkspace) msg.workspace = normalizedWorkspace;
+      messages.push(msg);
+    }
+  }
+  return messages.length > 0 ? messages : null;
+}
 function readSession3(sessionPath, sessionId, workspace) {
   if (!sessionPath || !path31.isAbsolute(sessionPath)) return null;
   if (!fs22.existsSync(sessionPath)) return null;
@@ -46333,6 +46663,21 @@ function readSession3(sessionPath, sessionId, workspace) {
       workspace
     };
   }
+  if (sessionPath.endsWith(".db")) {
+    const dbSessionId = sessionId || path31.basename(sessionPath, ".db");
+    if (!isUuidLike(dbSessionId)) return null;
+    const messages = parseConversationDb(sessionPath, dbSessionId, workspace);
+    if (!messages || messages.length === 0) return null;
+    return {
+      messages,
+      providerSessionId: dbSessionId,
+      source: "provider-native",
+      sourcePath: sessionPath,
+      sourceMtimeMs,
+      nativeHistoryCoverage: "full",
+      workspace
+    };
+  }
   if (sessionPath.endsWith(".pb")) {
     const pbSessionId = sessionId || path31.basename(sessionPath, ".pb");
     if (!isUuidLike(pbSessionId)) return null;
@@ -46561,7 +46906,7 @@ function resolveSourcePath(reader, workspace, sessionId, sessionStartedAtMs) {
     case "codex-cli":
       return resolveCodexPath(workspace, sessionId, sessionStartedAtMs);
     case "antigravity-cli":
-      return resolveAntigravityPath(workspace);
+      return resolveAntigravityPath(workspace, sessionId);
     case "hermes-cli":
       return resolveHermesPath(workspace, sessionId);
   }
@@ -46676,16 +47021,25 @@ function resolveRealPath(value) {
     return value;
   }
 }
-function resolveAntigravityPath(workspace) {
+function resolveAntigravityPath(workspace, sessionId) {
   void workspace;
-  const brainRoot2 = path33.join(os24.homedir(), ".gemini", "antigravity-cli", "brain");
-  if (!fs24.existsSync(brainRoot2)) return null;
-  const cutoff = Date.now() - RECENT_WINDOW_MS;
-  const entries = fs24.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => ({ p: path33.join(brainRoot2, e.name), mtime: safeMtime(path33.join(brainRoot2, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
-  for (const e of entries) {
-    const t = path33.join(e.p, ".system_generated", "logs", "transcript.jsonl");
-    if (fs24.existsSync(t)) return t;
+  const agyRoot = path33.join(os24.homedir(), ".gemini", "antigravity-cli");
+  if (sessionId && isUuidLikeSessionId2(sessionId)) {
+    const dbPath = path33.join(agyRoot, "conversations", `${sessionId}.db`);
+    if (fs24.existsSync(dbPath)) return dbPath;
   }
+  const brainRoot2 = path33.join(agyRoot, "brain");
+  if (fs24.existsSync(brainRoot2)) {
+    const cutoff = Date.now() - RECENT_WINDOW_MS;
+    const entries = fs24.readdirSync(brainRoot2, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => ({ p: path33.join(brainRoot2, e.name), mtime: safeMtime(path33.join(brainRoot2, e.name)) })).filter((e) => e.mtime >= cutoff).sort((a, b) => b.mtime - a.mtime);
+    for (const e of entries) {
+      const t = path33.join(e.p, ".system_generated", "logs", "transcript.jsonl");
+      if (fs24.existsSync(t)) return t;
+    }
+  }
+  const convRoot = path33.join(agyRoot, "conversations");
+  const newestDb = newestRecentFile2(convRoot, /^[0-9a-f-]+\.db$/i);
+  if (newestDb) return newestDb;
   return null;
 }
 function resolveHermesPath(workspace, sessionId) {
@@ -50883,12 +51237,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() : "";
@@ -50956,8 +51311,8 @@ var meshCoordinatorLaunchHandlers = {
       };
       const buildOperatingNotesBestEffort = async (id) => {
         try {
-          const { readLedgerEntries: readLedgerEntries2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
-          const noteEntries = readLedgerEntries2(id, { kind: ["coordinator_operating_note"], tail: 20 });
+          const { readOperatingNotes: readOperatingNotes2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
+          const noteEntries = readOperatingNotes2(id, { tail: 20 });
           const notes = noteEntries.map((e) => {
             const p = e.payload || {};
             const text = typeof p.text === "string" ? p.text.trim() : "";
@@ -51526,6 +51881,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;
@@ -51543,10 +51899,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));
@@ -51627,8 +52011,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);
@@ -51783,19 +52166,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");
@@ -51817,8 +52200,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();
@@ -51934,6 +52347,7 @@ var meshStatusHandlers = {
         refreshReason,
         meshSource: meshRecord.source,
         directTruth,
+        durationMs: Date.now() - startedAtMs,
         summary: summarizeRepoMeshStatusDebug(returnedStatus)
       });
       return returnedStatus;
@@ -53134,7 +53548,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;
@@ -53144,6 +53558,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
@@ -53254,7 +53685,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);
@@ -53267,38 +53698,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,
@@ -53312,11 +53738,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,
@@ -54687,6 +55154,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. */
@@ -54790,7 +55261,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 = {
@@ -55020,6 +55491,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
@@ -65541,6 +66013,10 @@ export {
   MIN_MACHINE_RUNTIME_SUBSCRIPTION_INTERVAL_MS,
   MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS,
   NodePtyTransportFactory,
+  OPERATING_NOTE_DEDUPE_WINDOW,
+  OPERATING_NOTE_KEEP_LATEST,
+  OPERATING_NOTE_KIND,
+  OPERATING_NOTE_TOMBSTONE_KIND,
   P2pRelayFailureError,
   PRUNABLE_ORPHAN_STALE_REASONS,
   ProviderCliAdapter,
@@ -65710,6 +66186,7 @@ export {
   isManagedStatusWaiting,
   isManagedStatusWorking,
   isMeshHostOwner,
+  isOperatingNoteTombstoned,
   isP2pRelayTransportFailure,
   isPathInside,
   isSessionHostLiveRuntime,
@@ -65778,6 +66255,7 @@ export {
   prepareSessionChatTailUpdate,
   prepareSessionModalUpdate,
   probeCdpPort,
+  pruneOperatingNotes,
   pruneStaleDirectDispatches,
   queuePendingMeshCoordinatorEvent,
   readSession3 as readAntigravityCliSession,
@@ -65790,6 +66268,7 @@ export {
   readLedgerSlice,
   readLedgerSliceFromStore,
   readMeshCompletionSummary,
+  readOperatingNotes,
   reconcileDirectDispatchCompletionFromTranscript,
   recordCompletionConflict,
   recordDebugTrace,
@@ -65847,6 +66326,7 @@ export {
   summarizeMeshMagiActivity,
   summarizeMeshMission,
   summarizeMissionTasks,
+  tombstoneOperatingNote,
   triggerMeshQueue,
   unregisterMeshCoordinator,
   updateConfig,