@adhdev/daemon-core 0.9.82-rc.368 → 0.9.82-rc.369

package/dist/boot/daemon-lifecycle.d.ts

@@ -81,6 +81,7 @@ export interface DaemonComponents {
     };
     refreshProviderAvailability: (providerType?: string) => Promise<void>;
     dispatchMeshCommand?: (daemonId: string, command: string, args: Record<string, unknown>) => Promise<any>;
+    getMeshPeerConnectionStatus?: (daemonId: string) => Record<string, unknown> | null;
     onMeshCoordinatorEventForwarded?: (payload: Record<string, unknown>) => void;
     meshReconcileLoop?: {
         stop(): void;

package/dist/commands/router.d.ts

@@ -14,6 +14,7 @@ import { DaemonCliManager } from './cli-manager.js';
 import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { SessionRegistry } from '../sessions/registry.js';
+import { awaitWithWarmupDeadline } from '../mesh/mesh-warmup-deadline.js';
 export declare function readProviderPriorityFromPolicy(policy: unknown): string[];
 /**
  * Normalize a providerRoles array (RepoMeshNodePolicy.providerRoles) from raw
@@ -78,11 +79,46 @@ export declare function resolveMeshNodeAttribution(node: unknown): {
     machineName?: string;
 };
 export declare function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>>;
+/**
+ * Transient per-node marker the mesh_status render loop stamps onto a node
+ * `status` at the two sites that obtain git truth from a FRESH probe this call
+ * (a successful local `getGitRepoStatus`, or a successful P2P `git_status`
+ * round-trip). finalizeMeshNodeStatus consumes and deletes it. Held/standing
+ * truth (node.lastGit / cachedStatus / inline transit) is deliberately NOT
+ * stamped — its absence is exactly how the freshness marker tells "live" apart
+ * from "cached". Internal only; never serialized in the response.
+ */
+export declare const MESH_NODE_LIVE_TRUTH_MARKER = "__liveTruthProbed";
+/**
+ * Build the additive per-node `dataFreshness` marker. This NEVER mutates any
+ * existing field — it only adds an explicit, machine-readable answer to the
+ * question the legacy fields blurred: is this node's data live (just probed),
+ * cached (held truth, maybe old), or absent because the peer was unreachable?
+ *
+ * The crucial separation: an UNREACHABLE peer (P2P probe failed / not connected)
+ * is no longer indistinguishable from an idle/EMPTY node. Both used to render as
+ * `health:'unknown'` with no sessions; now `dataFreshness.dataSource` and
+ * `reachable` tell them apart so a coordinator never reads a dead peer as "online
+ * but doing nothing".
+ */
+export declare function buildMeshNodeDataFreshness(args: {
+    status: Record<string, unknown>;
+    node?: any;
+    isSelfNode: boolean;
+    daemonId?: string;
+    /** True when this node was stamped with a fresh live git probe this call. */
+    liveTruthProbed: boolean;
+    /** True when direct-peer-truth accounting classified this node unavailable. */
+    directTruthUnavailable?: boolean;
+    now?: () => number;
+}): Record<string, unknown>;
 export declare function finalizeMeshNodeStatus(args: {
     status: Record<string, unknown>;
     node: any;
     daemonId?: string;
     isSelfNode: boolean;
+    /** True when direct-peer-truth accounting classified this node unavailable. */
+    directTruthUnavailable?: boolean;
 }): void;
 export declare const MESH_DIRECT_PROBE_TIMEOUT_MS: number;
 export declare const MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS: number;
@@ -117,37 +153,7 @@ export declare class MeshGitProbeCache {
      */
     probe(daemonId: string, workspace: string, probe: () => Promise<Record<string, unknown> | null>): Promise<Record<string, unknown> | null>;
 }
-/**
- * Await `work` under a warmup-aware deadline so a cold-open DataChannel handshake
- * is NOT charged against the command response budget — the root cause of the
- * "first mesh probe to a cold peer false-times-out, the warm retry succeeds"
- * signature. Two budgets, switched by the live peer connection state:
- *
- *  - While `isConnected()` returns false the peer's channel is still opening; the
- *    cold-open `connectTimeoutMs` budget applies. This phase is deliberately
- *    generous because a TURN-relayed cross-machine handshake legitimately needs
- *    many seconds — but a genuine connect *failure* is surfaced by `work`
- *    rejecting on its own (the mesh manager fails the peer the instant its
- *    PeerConnection state goes terminal), so a real failure is never masked for
- *    the whole window.
- *  - The first time `isConnected()` returns true the channel is warm; from that
- *    instant the tight `responseTimeoutMs` governs how long the handler may take.
- *    Warm-channel callers therefore see behavior identical to the old single
- *    `Promise.race(work, responseTimeoutMs)`.
- *
- * Rejects with `Error('timeout')` when either budget is exhausted, mirroring the
- * previous single-race contract. Pure except for timers + the injected
- * `isConnected` probe, so it is unit-testable under fake timers without any real
- * WebRTC. When no connection getter is wired `isConnected` should be `() => true`
- * (the caller's choice) so the response deadline governs from t0 — the legacy
- * single-budget behavior, never a combined connect+response window.
- */
-export declare function awaitWithWarmupDeadline<T>(work: Promise<T>, opts: {
-    isConnected: () => boolean;
-    connectTimeoutMs: number;
-    responseTimeoutMs: number;
-    pollIntervalMs?: number;
-}): Promise<T>;
+export { awaitWithWarmupDeadline };
 /**
  * Probe a remote peer's git_status with a bounded retry budget, but only while
  * the peer is reported `connected`. A single slow (often TURN-relayed) peer can
@@ -781,4 +787,3 @@ export declare class DaemonCommandRouter {
      */
     private stopIde;
 }
-export {};

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "8cb6cfc5399f55c6b625095bacc9a27e1741df17" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "8cb6cfc5" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.368" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-24T06:14:32.255Z" : 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 version = 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:14.501Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -10382,6 +10382,90 @@ var init_mesh_event_trace = __esm({
   }
 });
 
+// src/mesh/mesh-warmup-deadline.ts
+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 = __esm({
+  "src/mesh/mesh-warmup-deadline.ts"() {
+    "use strict";
+  }
+});
+
 // src/config/state-store.ts
 function isPlainObject2(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -12817,7 +12901,12 @@ function resolveActiveDirectDispatchTaskId(meshId, sessionId) {
     return void 0;
   }
 }
-function deliverTaskToSession(dispatchThunk, ctx) {
+function warnDispatchWarmupGetterMissingOnce(daemonId) {
+  if (dispatchWarmupGetterMissingWarned.has(daemonId)) return;
+  dispatchWarmupGetterMissingWarned.add(daemonId);
+  LOG.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,
@@ -12837,16 +12926,27 @@ function deliverTaskToSession(dispatchThunk, ctx) {
     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");
@@ -12930,7 +13030,11 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
           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;
     }
@@ -14309,7 +14413,7 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var import_fs13, REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, DISPATCH_CONFIRM_TIMEOUT_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, MESH_FORCE_INJECT_EVENTS, coordinatorForwardLanes;
+var import_fs13, REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, DISPATCH_CONFIRM_TIMEOUT_MS, DISPATCH_CONNECT_TIMEOUT_MS, dispatchWarmupGetterMissingWarned, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, MESH_FORCE_INJECT_EVENTS, coordinatorForwardLanes;
 var init_mesh_events_coordinator = __esm({
   "src/mesh/mesh-events-coordinator.ts"() {
     "use strict";
@@ -14327,6 +14431,7 @@ var init_mesh_events_coordinator = __esm({
     init_mesh_routing();
     init_mesh_unresolved_forward_outbox();
     init_mesh_event_trace();
+    init_mesh_warmup_deadline();
     init_snapshot();
     init_repo_mesh_types();
     init_dist();
@@ -14340,6 +14445,8 @@ var init_mesh_events_coordinator = __esm({
     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;
@@ -41849,6 +41956,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 record of sessions) {
       if (!record?.runtimeId || !record?.cliType || !record?.workspace) continue;
       if (!shouldRestoreHostedRuntime(record, managerTag)) {
@@ -41886,11 +42001,21 @@ Run 'adhdev doctor' for detailed diagnostics.`
       if (!coordinatorEntry?.meshId && record.workspace) {
         const workspaceCoordinators = listCoordinatorsForWorkspace(record.workspace).filter((e) => e.meshId && (!e.cliType || e.cliType === record.cliType));
         if (workspaceCoordinators.length === 1) {
-          coordinatorEntry = workspaceCoordinators[0];
-          LOG.info(
-            "CLI",
-            `\u21BB Rebound coordinator mark by workspace for ${record.runtimeKey || record.runtimeId} (mesh ${coordinatorEntry.meshId} @ ${record.workspace}); registry key did not match runtimeId`
-          );
+          const candidate = workspaceCoordinators[0];
+          const coordinatorPresentById = !!candidate.sessionId && restoredRuntimeIds.has(candidate.sessionId);
+          const siblingCount = workspaceTypeCounts.get(`${record.workspace}::${record.cliType}`) || 1;
+          if (!coordinatorPresentById && siblingCount === 1) {
+            coordinatorEntry = candidate;
+            LOG.info(
+              "CLI",
+              `\u21BB Rebound coordinator mark by workspace for ${record.runtimeKey || record.runtimeId} (mesh ${candidate.meshId} @ ${record.workspace}); registry key did not match runtimeId`
+            );
+          } else {
+            LOG.info(
+              "CLI",
+              `\u21B7 Skipping workspace coordinator rebind for ${record.runtimeKey || record.runtimeId} (${record.cliType} @ ${record.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) {
@@ -48372,6 +48497,7 @@ var meshStatusHandlers = {
               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);
@@ -48397,13 +48523,13 @@ var meshStatusHandlers = {
                 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;
               }
@@ -48412,6 +48538,7 @@ var meshStatusHandlers = {
             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) {
@@ -48430,7 +48557,7 @@ var meshStatusHandlers = {
           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;
@@ -48844,6 +48971,7 @@ function orderMeshRefineBatchNodes(changeAreas) {
 
 // src/commands/router.ts
 init_mesh_work_queue();
+init_mesh_warmup_deadline();
 init_repo_mesh_types();
 var import_os4 = require("os");
 var import_path13 = require("path");
@@ -49585,14 +49713,92 @@ function synthesizeMeshNodeFreshnessFromConnection(status) {
     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;
@@ -49660,73 +49866,16 @@ var MeshGitProbeCache = class {
     }
   }
 };
-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);
@@ -49740,6 +49889,12 @@ var MESH_DIRECT_PROBE_MAX_RETRIES = 2;
 function readMeshConnectionState(connection) {
   return readStringValue(connection?.state);
 }
+var meshWarmupGetterMissingWarned = /* @__PURE__ */ new Set();
+function warnMeshWarmupGetterMissingOnce(daemonId) {
+  if (meshWarmupGetterMissingWarned.has(daemonId)) return;
+  meshWarmupGetterMissingWarned.add(daemonId);
+  LOG.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);
@@ -61816,6 +61971,7 @@ async function initDaemonComponents(config) {
     detectedIdes: detectedIdesRef,
     refreshProviderAvailability,
     dispatchMeshCommand: config.dispatchMeshCommand,
+    getMeshPeerConnectionStatus: config.getMeshPeerConnectionStatus,
     onMeshCoordinatorEventForwarded: config.onMeshCoordinatorEventForwarded,
     statusInstanceId: config.statusInstanceId
   };