@adhdev/daemon-standalone 0.9.82-rc.367 → 0.9.82-rc.369

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "bb7e66dbc483232a27d1de42cf8ecba3eb0a818c" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "bb7e66db" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.367" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-24T04:45:42.045Z" : void 0);
+      const commit = readInjected(true ? "4464cd9f1effac841aa1fbef3b1691d2f06d64e4" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "4464cd9f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.369" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-24T08:22:41.172Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -40160,6 +40160,88 @@ Next step: ${nextStep}`;
         CAT = "EvtTrace";
       }
     });
+    function awaitWithWarmupDeadline(work, opts) {
+      const pollMs = Math.max(1, Math.min(opts.pollIntervalMs ?? 200, opts.connectTimeoutMs));
+      return new Promise((resolve24, reject) => {
+        let done = false;
+        let poll;
+        let responseTimer;
+        const startedAt = Date.now();
+        const cleanup = () => {
+          if (poll) {
+            clearInterval(poll);
+            poll = void 0;
+          }
+          if (responseTimer) {
+            clearTimeout(responseTimer);
+            responseTimer = void 0;
+          }
+        };
+        const settle = (fn) => {
+          if (done) return;
+          done = true;
+          cleanup();
+          fn();
+        };
+        const armResponse = () => {
+          if (responseTimer || done) return;
+          responseTimer = setTimeout(
+            () => settle(() => reject(new Error("timeout"))),
+            opts.responseTimeoutMs
+          );
+          if (typeof responseTimer.unref === "function") responseTimer.unref();
+        };
+        const onPoll = () => {
+          if (done) return;
+          if (opts.isConnected()) {
+            if (poll) {
+              clearInterval(poll);
+              poll = void 0;
+            }
+            armResponse();
+            return;
+          }
+          if (Date.now() - startedAt >= opts.connectTimeoutMs) {
+            settle(() => reject(new Error("timeout")));
+          }
+        };
+        if (opts.isConnected()) {
+          armResponse();
+        } else {
+          poll = setInterval(onPoll, pollMs);
+          if (typeof poll.unref === "function") poll.unref();
+        }
+        work.then(
+          (val) => settle(() => resolve24(val)),
+          (err) => settle(() => reject(err))
+        );
+      });
+    }
+    function readWarmupConnectionState(connection) {
+      const state = connection?.state;
+      return typeof state === "string" && state.length > 0 ? state : void 0;
+    }
+    function resolveWarmupDeadlineOpts(opts) {
+      const { getConnection, daemonId, connectTimeoutMs, responseTimeoutMs } = opts;
+      if (getConnection) {
+        return {
+          isConnected: () => readWarmupConnectionState(getConnection(daemonId)) === "connected",
+          connectTimeoutMs,
+          responseTimeoutMs
+        };
+      }
+      opts.onMissingGetter?.(daemonId);
+      return {
+        isConnected: () => false,
+        connectTimeoutMs: connectTimeoutMs + responseTimeoutMs,
+        responseTimeoutMs
+      };
+    }
+    var init_mesh_warmup_deadline = __esm2({
+      "src/mesh/mesh-warmup-deadline.ts"() {
+        "use strict";
+      }
+    });
     function isPlainObject22(value) {
       return !!value && typeof value === "object" && !Array.isArray(value);
     }
@@ -42603,7 +42685,12 @@ ${cleanBody}`;
         return void 0;
       }
     }
-    function deliverTaskToSession(dispatchThunk, ctx) {
+    function warnDispatchWarmupGetterMissingOnce(daemonId) {
+      if (dispatchWarmupGetterMissingWarned.has(daemonId)) return;
+      dispatchWarmupGetterMissingWarned.add(daemonId);
+      LOG2.warn("MeshQueue", `Mesh peer connection getter unavailable for ${String(daemonId).slice(0, 12)}; remote task-dispatch warmup deadline degraded to the combined connect+response window. Avoids a cold-open false-timeout but loses warm/cold precision \u2014 wire getMeshPeerConnectionStatus on this daemon.`);
+    }
+    function deliverTaskToSession(dispatchThunk, ctx, warmup) {
       const delivery = createSessionDelivery({
         meshId: ctx.meshId,
         nodeId: ctx.nodeId,
@@ -42623,16 +42710,27 @@ ${cleanBody}`;
         dispatchPromise = Promise.reject(e);
       }
       let timer;
-      const guarded = Promise.race([
-        dispatchPromise,
-        new Promise((_, reject) => {
-          timer = setTimeout(
-            () => reject(new Error(`dispatch_confirm_timeout after ${DISPATCH_CONFIRM_TIMEOUT_MS}ms`)),
-            DISPATCH_CONFIRM_TIMEOUT_MS
-          );
-          if (typeof timer?.unref === "function") timer.unref();
-        })
-      ]);
+      let guarded;
+      if (warmup) {
+        guarded = awaitWithWarmupDeadline(dispatchPromise, resolveWarmupDeadlineOpts({
+          getConnection: warmup.getConnection,
+          daemonId: warmup.daemonId,
+          connectTimeoutMs: DISPATCH_CONNECT_TIMEOUT_MS,
+          responseTimeoutMs: DISPATCH_CONFIRM_TIMEOUT_MS,
+          onMissingGetter: warnDispatchWarmupGetterMissingOnce
+        }));
+      } else {
+        guarded = Promise.race([
+          dispatchPromise,
+          new Promise((_, reject) => {
+            timer = setTimeout(
+              () => reject(new Error(`dispatch_confirm_timeout after ${DISPATCH_CONFIRM_TIMEOUT_MS}ms`)),
+              DISPATCH_CONFIRM_TIMEOUT_MS
+            );
+            if (typeof timer?.unref === "function") timer.unref();
+          })
+        ]);
+      }
       guarded.then(() => {
         if (timer) clearTimeout(timer);
         updateSessionDeliveryStatus(delivery.id, "delivered");
@@ -42656,13 +42754,25 @@ ${cleanBody}`;
       const mesh = getMeshWithCache(components, meshId);
       const node = mesh?.nodes.find((n) => readMeshNodeId(n) === nodeId);
       const localClaimAdapter = components.cliManager?.adapters?.get(sessionId);
-      if (localClaimAdapter) {
-        const sessionWorkspace = normalizeMeshWorkspaceForCompare(localClaimAdapter.workingDir);
-        const nodeWorkspace = normalizeMeshWorkspaceForCompare(readNonEmptyString2(node?.workspace));
-        if (sessionWorkspace && nodeWorkspace && sessionWorkspace !== nodeWorkspace) {
-          LOG2.info("MeshQueue", `WTCLAIM: refusing claim for node ${nodeId} (${sessionId}) \u2014 session workspace "${sessionWorkspace}" \u2260 node workspace "${nodeWorkspace}" (cross-workspace dispatch blocked)`);
+      let claimInstanceWorkspace = "";
+      let claimStampedNodeId = "";
+      try {
+        const claimState = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+        claimInstanceWorkspace = readNonEmptyString2(claimState?.workspace);
+        const claimSettings = claimState?.settings || {};
+        claimStampedNodeId = readNonEmptyString2(claimSettings.meshNodeId);
+      } catch {
+      }
+      const nodeWorkspaceRaw = readNonEmptyString2(node?.workspace);
+      const sessionWorkspaceRaw = readNonEmptyString2(localClaimAdapter?.workingDir) || claimInstanceWorkspace;
+      if (claimStampedNodeId && nodeId) {
+        if (!meshNodeIdMatches({ id: claimStampedNodeId }, nodeId)) {
+          LOG2.info("MeshQueue", `WTDISPATCH: refusing claim for node ${nodeId} (${sessionId}) \u2014 session is bound to node "${claimStampedNodeId}" (cross-node claim blocked)`);
           return false;
         }
+      } else if (sessionWorkspaceRaw && nodeWorkspaceRaw && !meshWorkspacesEquivalent(sessionWorkspaceRaw, nodeWorkspaceRaw)) {
+        LOG2.info("MeshQueue", `WTCLAIM: refusing claim for node ${nodeId} (${sessionId}) \u2014 session workspace "${normalizeMeshWorkspaceForCompare(sessionWorkspaceRaw)}" \u2260 node workspace "${normalizeMeshWorkspaceForCompare(nodeWorkspaceRaw)}" (cross-workspace dispatch blocked)`);
+        return false;
       }
       const capabilityTags = buildMeshNodeCapabilityTags(node, providerType);
       const providerMaxParallel = resolveProviderMaxParallel(node?.policy, providerType);
@@ -42704,7 +42814,11 @@ ${cleanBody}`;
               transport: "remote",
               ...sourceCoordinatorSessionId ? { sourceCoordinatorSessionId } : {},
               ...localDaemonIdForDispatch ? { sourceCoordinatorDaemonId: localDaemonIdForDispatch } : {}
-            }
+            },
+            // Warmup-aware deadline: this dispatch can be the FIRST command to a
+            // peer whose mesh DataChannel is still opening — charge the cold-open
+            // handshake to the connect budget, not the response budget.
+            { daemonId: remoteDaemonId, getConnection: components.getMeshPeerConnectionStatus }
           );
           return true;
         }
@@ -43940,6 +44054,25 @@ ${cleanBody}`;
         metadataEvent: buildRelayMetadataEvent(payload)
       });
     }
+    function enqueueCoordinatorForwardPush(coordinatorDaemonId, run) {
+      let lane = coordinatorForwardLanes.get(coordinatorDaemonId);
+      if (!lane) {
+        lane = { tail: Promise.resolve(), depth: 0 };
+        coordinatorForwardLanes.set(coordinatorDaemonId, lane);
+      }
+      const wasIdle = lane.depth === 0;
+      lane.depth += 1;
+      const dec = () => {
+        lane.depth -= 1;
+      };
+      if (wasIdle) {
+        lane.tail = Promise.resolve(run()).catch(() => {
+        }).then(dec, dec);
+      } else {
+        lane.tail = lane.tail.then(() => run()).catch(() => {
+        }).then(dec, dec);
+      }
+    }
     function forwardUnresolvedDelegateEvent(components, routing, event) {
       const coordinatorDaemonId = readNonEmptyString2(routing.coordinatorDaemonId);
       if (!coordinatorDaemonId) return false;
@@ -43971,7 +44104,8 @@ ${cleanBody}`;
       };
       traceMeshEventStage("outbox_enqueue", fwdTraceCtx, `coordinatorDaemon=${coordinatorDaemonId} meshId=absent`);
       traceMeshEventStage("forward_send", fwdTraceCtx, "immediate push");
-      Promise.resolve(components.dispatchMeshCommand(coordinatorDaemonId, "mesh_forward_event", payload)).then((result) => {
+      const dispatchMeshCommand = components.dispatchMeshCommand;
+      enqueueCoordinatorForwardPush(coordinatorDaemonId, () => Promise.resolve(dispatchMeshCommand(coordinatorDaemonId, "mesh_forward_event", payload)).then((result) => {
         if (result && result.success === false) {
           LOG2.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued for retry`);
           traceMeshEventDrop("immediate_forward_rejected", fwdTraceCtx, readNonEmptyString2(result.error) || "no reason");
@@ -43980,7 +44114,7 @@ ${cleanBody}`;
         if (persisted) ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventName, payload);
       }).catch((e) => {
         LOG2.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued for retry`);
-      });
+      }));
       LOG2.info("MeshEvents", `Durably forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId}`);
       return true;
     }
@@ -44072,6 +44206,8 @@ ${cleanBody}`;
     var INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS;
     var RECENT_COMPLETION_FINGERPRINT_TTL_MS;
     var DISPATCH_CONFIRM_TIMEOUT_MS;
+    var DISPATCH_CONNECT_TIMEOUT_MS;
+    var dispatchWarmupGetterMissingWarned;
     var autoLaunchInProgress;
     var autoLaunchCooldownUntil;
     var AUTO_LAUNCH_COOLDOWN_MS;
@@ -44081,6 +44217,7 @@ ${cleanBody}`;
     var MESH_COORDINATOR_EVENTS;
     var EVENT_TO_LEDGER_KIND;
     var MESH_FORCE_INJECT_EVENTS;
+    var coordinatorForwardLanes;
     var init_mesh_events_coordinator = __esm2({
       "src/mesh/mesh-events-coordinator.ts"() {
         "use strict";
@@ -44098,6 +44235,7 @@ ${cleanBody}`;
         init_mesh_routing();
         init_mesh_unresolved_forward_outbox();
         init_mesh_event_trace();
+        init_mesh_warmup_deadline();
         init_snapshot();
         init_repo_mesh_types();
         init_dist();
@@ -44111,6 +44249,8 @@ ${cleanBody}`;
         INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS = 30 * 60 * 1e3;
         RECENT_COMPLETION_FINGERPRINT_TTL_MS = 10 * 60 * 1e3;
         DISPATCH_CONFIRM_TIMEOUT_MS = 12e4;
+        DISPATCH_CONNECT_TIMEOUT_MS = 45e3;
+        dispatchWarmupGetterMissingWarned = /* @__PURE__ */ new Set();
         autoLaunchInProgress = /* @__PURE__ */ new Set();
         autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
         AUTO_LAUNCH_COOLDOWN_MS = 5e3;
@@ -44145,6 +44285,7 @@ ${cleanBody}`;
           "worktree_bootstrap_complete",
           "worktree_bootstrap_failed"
         ]);
+        coordinatorForwardLanes = /* @__PURE__ */ new Map();
       }
     });
     function resolveAutoPruneMinAgeMs() {
@@ -71144,6 +71285,18 @@ ${rawInput}` : rawInput;
           throw new Error(`Failed to start ${provider.displayName || provider.name || cliType}: ${spawnErr?.message}`);
         }
         this.adapters.set(key, cliInstance.getAdapter());
+        const launchMeshNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
+        const launchMeshNodeFor = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
+        if (launchMeshNodeId || launchMeshNodeFor) {
+          try {
+            cliInstance.getAdapter().updateRuntimeMeta?.({
+              ...launchMeshNodeId ? { meshNodeId: launchMeshNodeId } : {},
+              ...launchMeshNodeFor ? { meshNodeFor: launchMeshNodeFor } : {},
+              ...settings?.launchedByCoordinator === true ? { launchedByCoordinator: true } : {}
+            });
+          } catch {
+          }
+        }
         this.startCliExitMonitor(key, cliType);
       }
       // ─── Session start/management ──────────────────────────────
@@ -71411,6 +71564,14 @@ Run 'adhdev doctor' for detailed diagnostics.`
         let restored = 0;
         const restoredBindings = /* @__PURE__ */ new Set();
         const managerTag = this.deps.hostedRuntimeManagerTag;
+        const restoredRuntimeIds = /* @__PURE__ */ new Set();
+        const workspaceTypeCounts = /* @__PURE__ */ new Map();
+        for (const r of sessions) {
+          if (!r?.runtimeId || !r?.cliType || !r?.workspace) continue;
+          restoredRuntimeIds.add(r.runtimeId);
+          const key = `${r.workspace}::${r.cliType}`;
+          workspaceTypeCounts.set(key, (workspaceTypeCounts.get(key) || 0) + 1);
+        }
         for (const record2 of sessions) {
           if (!record2?.runtimeId || !record2?.cliType || !record2?.workspace) continue;
           if (!shouldRestoreHostedRuntime(record2, managerTag)) {
@@ -71448,11 +71609,21 @@ Run 'adhdev doctor' for detailed diagnostics.`
           if (!coordinatorEntry?.meshId && record2.workspace) {
             const workspaceCoordinators = listCoordinatorsForWorkspace(record2.workspace).filter((e) => e.meshId && (!e.cliType || e.cliType === record2.cliType));
             if (workspaceCoordinators.length === 1) {
-              coordinatorEntry = workspaceCoordinators[0];
-              LOG2.info(
-                "CLI",
-                `\u21BB Rebound coordinator mark by workspace for ${record2.runtimeKey || record2.runtimeId} (mesh ${coordinatorEntry.meshId} @ ${record2.workspace}); registry key did not match runtimeId`
-              );
+              const candidate = workspaceCoordinators[0];
+              const coordinatorPresentById = !!candidate.sessionId && restoredRuntimeIds.has(candidate.sessionId);
+              const siblingCount = workspaceTypeCounts.get(`${record2.workspace}::${record2.cliType}`) || 1;
+              if (!coordinatorPresentById && siblingCount === 1) {
+                coordinatorEntry = candidate;
+                LOG2.info(
+                  "CLI",
+                  `\u21BB Rebound coordinator mark by workspace for ${record2.runtimeKey || record2.runtimeId} (mesh ${candidate.meshId} @ ${record2.workspace}); registry key did not match runtimeId`
+                );
+              } else {
+                LOG2.info(
+                  "CLI",
+                  `\u21B7 Skipping workspace coordinator rebind for ${record2.runtimeKey || record2.runtimeId} (${record2.cliType} @ ${record2.workspace}): ${coordinatorPresentById ? "registered coordinator is restoring under its own id \u2014 this is a delegated worker" : `ambiguous (${siblingCount} sessions share this workspace+cliType)`}`
+                );
+              }
             }
           }
           if (coordinatorEntry?.meshId) {
@@ -77880,6 +78051,7 @@ ${ptyResult.output.slice(-2e3)}`);
                   const remoteGit = await meshGitProbeCache.probe(daemonId, workspace, runNodeProbe);
                   if (remoteGit) {
                     status.git = remoteGit;
+                    status[MESH_NODE_LIVE_TRUTH_MARKER] = true;
                     status.health = remoteGit.isGitRepo ? deriveMeshNodeHealthFromGit(remoteGit) : "degraded";
                     const connection = readObjectRecord(status.connection);
                     const connectionState = readStringValue(connection.state);
@@ -77905,13 +78077,13 @@ ${ptyResult.output.slice(-2e3)}`);
                     pendingPeerGitProbe ? { skipGit: true, skipError: true, skipHealth: true } : void 0
                   )) {
                     applyInlineMeshBranchConvergence(mesh, node, status);
-                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
+                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode, directTruthUnavailable: directTruthUnavailableNodeIds.has(nodeId) });
                     nodeStatuses.push(status);
                     continue;
                   }
                   if (meshRecord?.source === "inline_cache" && !isSelfNode) {
                     applyInlineMeshBranchConvergence(mesh, node, status);
-                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
+                    finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode, directTruthUnavailable: directTruthUnavailableNodeIds.has(nodeId) });
                     nodeStatuses.push(status);
                     continue;
                   }
@@ -77920,6 +78092,7 @@ ${ptyResult.output.slice(-2e3)}`);
                 try {
                   const gitStatus = await getGitRepoStatus(workspace, { timeoutMs: 1e4, refreshUpstream: true });
                   status.git = gitStatus;
+                  status[MESH_NODE_LIVE_TRUTH_MARKER] = true;
                   const reporter = recordInlineMeshDirectGitTruth(node, gitStatus, "selected_coordinator_local_git");
                   persistNodeReporterPlatform(meshRecord.source, mesh, nodeId, reporter);
                   if (gitStatus.isGitRepo) {
@@ -77938,7 +78111,7 @@ ${ptyResult.output.slice(-2e3)}`);
               applyCachedInlineMeshNodeStatus(status, node);
             }
             applyInlineMeshBranchConvergence(mesh, node, status);
-            finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode });
+            finalizeMeshNodeStatus({ status, node, daemonId, isSelfNode, directTruthUnavailable: directTruthUnavailableNodeIds.has(nodeId) });
             nodeStatuses.push(status);
           }
           const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : ctx.deps.statusInstanceId || void 0;
@@ -78340,6 +78513,7 @@ ${ptyResult.output.slice(-2e3)}`);
       return { order: ranked.map((a) => a.nodeId), changeAreas: areaById, rationale };
     }
     init_mesh_work_queue();
+    init_mesh_warmup_deadline();
     init_repo_mesh_types();
     var import_os4 = require("os");
     var import_path13 = require("path");
@@ -79081,14 +79255,92 @@ ${ptyResult.output.slice(-2e3)}`);
         status.updatedAt = gitCheckedAt ?? connectionFreshAt;
       }
     }
+    var MESH_NODE_LIVE_TRUTH_MARKER = "__liveTruthProbed";
+    var MESH_FRESHNESS_FRESH_MS = 3e4;
+    var MESH_FRESHNESS_RECENT_MS = 3e5;
+    function classifyMeshNodeStaleness(dataSource, ageMs) {
+      if (dataSource === "self" || dataSource === "live") return "fresh";
+      if (ageMs === null) return "unknown";
+      if (ageMs < MESH_FRESHNESS_FRESH_MS) return "fresh";
+      if (ageMs < MESH_FRESHNESS_RECENT_MS) return "recent";
+      return "stale";
+    }
+    function buildMeshNodeDataFreshness(args) {
+      const { status, node, isSelfNode, daemonId, liveTruthProbed, directTruthUnavailable } = args;
+      const now = args.now ?? Date.now;
+      const connection = readObjectRecord(status.connection);
+      const connectionState = readStringValue(connection.state);
+      const git = readObjectRecord(status.git);
+      const hasGit = readBooleanValue(git.isGitRepo) === true || !!readStringValue(git.branch, git.headCommit, git.head, git.upstream);
+      const connectionFreshAt = toIsoTimestamp(connection.lastCommandAt ?? connection.lastConnectedAt ?? connection.lastStateChangeAt);
+      const liveGitCheckedAt = liveTruthProbed ? toIsoTimestamp(git.lastCheckedAt) : null;
+      const heldGit = readObjectRecord(node?.lastGit ?? node?.last_git);
+      const heldCheckedAt = toIsoTimestamp(heldGit.checkedAt ?? heldGit.checked_at);
+      const cachedStatus = readObjectRecord(node?.cachedStatus);
+      const cachedGitCheckedAt = toIsoTimestamp(readObjectRecord(cachedStatus.git).lastCheckedAt);
+      const lastProbeAt = liveGitCheckedAt ?? heldCheckedAt ?? cachedGitCheckedAt ?? toIsoTimestamp(git.lastCheckedAt) ?? connectionFreshAt ?? toIsoTimestamp(status.updatedAt) ?? toIsoTimestamp(status.lastSeenAt);
+      const connectionReachable = connectionState === "connected" ? true : !connectionState || connectionState === "unknown" || connectionState === "connecting" ? connectionState === "connecting" ? true : null : false;
+      let dataSource;
+      let reachable;
+      if (isSelfNode) {
+        dataSource = "self";
+        reachable = true;
+      } else if (liveTruthProbed) {
+        dataSource = "live";
+        reachable = true;
+      } else if (readBooleanValue(status.gitProbePending) === true) {
+        dataSource = "pending";
+        reachable = connectionReachable;
+      } else if (directTruthUnavailable) {
+        dataSource = "unreachable";
+        reachable = false;
+      } else if (hasGit) {
+        dataSource = "cached";
+        reachable = connectionReachable;
+      } else if (!daemonId) {
+        dataSource = "unconfigured";
+        reachable = null;
+      } else if (connectionState === "connected") {
+        dataSource = "empty";
+        reachable = true;
+      } else {
+        dataSource = "unreachable";
+        reachable = false;
+      }
+      const probeOk = dataSource === "live" || dataSource === "self";
+      let ageMs = null;
+      if (lastProbeAt) {
+        const parsed = Date.parse(lastProbeAt);
+        if (Number.isFinite(parsed)) ageMs = Math.max(0, now() - parsed);
+      }
+      const staleness = classifyMeshNodeStaleness(dataSource, ageMs);
+      return {
+        dataSource,
+        probeOk,
+        reachable,
+        lastProbeAt: lastProbeAt ?? null,
+        ageMs,
+        staleness
+      };
+    }
     function finalizeMeshNodeStatus(args) {
-      const { status, node, daemonId, isSelfNode } = args;
+      const { status, node, daemonId, isSelfNode, directTruthUnavailable } = args;
       if (!readStringValue(status.machineStatus)) {
         const cachedStatus = readObjectRecord(node?.cachedStatus);
         const machineStatus = readStringValue(cachedStatus.machineStatus, cachedStatus.machine_status, node?.machineStatus);
         if (machineStatus) status.machineStatus = machineStatus;
       }
       synthesizeMeshNodeFreshnessFromConnection(status);
+      const liveTruthProbed = readBooleanValue(status[MESH_NODE_LIVE_TRUTH_MARKER]) === true;
+      delete status[MESH_NODE_LIVE_TRUTH_MARKER];
+      status.dataFreshness = buildMeshNodeDataFreshness({
+        status,
+        node,
+        isSelfNode,
+        daemonId,
+        liveTruthProbed,
+        directTruthUnavailable
+      });
       const bootstrap = readObjectRecord(node?.worktreeBootstrap);
       if (node?.isLocalWorktree && readStringValue(bootstrap.status)) {
         status.worktreeBootstrap = bootstrap;
@@ -79156,73 +79408,16 @@ ${ptyResult.output.slice(-2e3)}`);
         }
       }
     };
-    function awaitWithWarmupDeadline(work, opts) {
-      const pollMs = Math.max(1, Math.min(opts.pollIntervalMs ?? 200, opts.connectTimeoutMs));
-      return new Promise((resolve24, reject) => {
-        let done = false;
-        let poll;
-        let responseTimer;
-        const startedAt = Date.now();
-        const cleanup = () => {
-          if (poll) {
-            clearInterval(poll);
-            poll = void 0;
-          }
-          if (responseTimer) {
-            clearTimeout(responseTimer);
-            responseTimer = void 0;
-          }
-        };
-        const settle = (fn) => {
-          if (done) return;
-          done = true;
-          cleanup();
-          fn();
-        };
-        const armResponse = () => {
-          if (responseTimer || done) return;
-          responseTimer = setTimeout(
-            () => settle(() => reject(new Error("timeout"))),
-            opts.responseTimeoutMs
-          );
-          if (typeof responseTimer.unref === "function") responseTimer.unref();
-        };
-        const onPoll = () => {
-          if (done) return;
-          if (opts.isConnected()) {
-            if (poll) {
-              clearInterval(poll);
-              poll = void 0;
-            }
-            armResponse();
-            return;
-          }
-          if (Date.now() - startedAt >= opts.connectTimeoutMs) {
-            settle(() => reject(new Error("timeout")));
-          }
-        };
-        if (opts.isConnected()) {
-          armResponse();
-        } else {
-          poll = setInterval(onPoll, pollMs);
-          if (typeof poll.unref === "function") poll.unref();
-        }
-        work.then(
-          (val) => settle(() => resolve24(val)),
-          (err) => settle(() => reject(err))
-        );
-      });
-    }
     async function probeRemoteMeshGitStatus(args) {
       if (!args.dispatchMeshCommand) return null;
       const dispatch = args.dispatchMeshCommand(args.daemonId, "git_status", { workspace: args.workspace, refreshUpstream: true });
-      const getConnection = args.getConnection;
-      const isConnected = getConnection ? () => readMeshConnectionState(getConnection(args.daemonId)) === "connected" : () => true;
-      const remoteResult = await awaitWithWarmupDeadline(dispatch, {
-        isConnected,
+      const remoteResult = await awaitWithWarmupDeadline(dispatch, resolveWarmupDeadlineOpts({
+        getConnection: args.getConnection,
+        daemonId: args.daemonId,
         connectTimeoutMs: args.connectTimeoutMs,
-        responseTimeoutMs: args.responseTimeoutMs
-      });
+        responseTimeoutMs: args.responseTimeoutMs,
+        onMissingGetter: warnMeshWarmupGetterMissingOnce
+      }));
       const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
       if (!remoteGit || typeof remoteGit !== "object" || typeof remoteGit.isGitRepo !== "boolean") return null;
       const reporterPlatform = readStringValue(remoteResult?.reporterPlatform);
@@ -79236,6 +79431,12 @@ ${ptyResult.output.slice(-2e3)}`);
     function readMeshConnectionState(connection) {
       return readStringValue(connection?.state);
     }
+    var meshWarmupGetterMissingWarned = /* @__PURE__ */ new Set();
+    function warnMeshWarmupGetterMissingOnce(daemonId) {
+      if (meshWarmupGetterMissingWarned.has(daemonId)) return;
+      meshWarmupGetterMissingWarned.add(daemonId);
+      LOG2.warn("Mesh", `Mesh peer connection getter unavailable for ${String(daemonId).slice(0, 12)}; warmup deadline degraded to the combined connect+response window (cannot observe DataChannel open). This avoids a cold-open false-timeout but loses warm/cold precision \u2014 wire getMeshPeerConnectionStatus on this daemon.`);
+    }
     function isMeshConnectionDefinitivelyDown(connection) {
       if (!connection) return true;
       const state = readMeshConnectionState(connection);
@@ -91250,6 +91451,7 @@ data: ${JSON.stringify(msg.data)}
         detectedIdes: detectedIdesRef,
         refreshProviderAvailability,
         dispatchMeshCommand: config2.dispatchMeshCommand,
+        getMeshPeerConnectionStatus: config2.getMeshPeerConnectionStatus,
         onMeshCoordinatorEventForwarded: config2.onMeshCoordinatorEventForwarded,
         statusInstanceId: config2.statusInstanceId
       };