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

package/dist/index.mjs

@@ -311,10 +311,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "bb7e66dbc483232a27d1de42cf8ecba3eb0a818c" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "bb7e66db" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:13.384Z" : 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;
 }
@@ -10377,6 +10377,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
 import { existsSync as existsSync16, readFileSync as readFileSync12, writeFileSync as writeFileSync7 } from "fs";
 import { join as join18 } from "path";
@@ -12813,7 +12897,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,
@@ -12833,16 +12922,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");
@@ -12866,13 +12966,25 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
   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) {
-      LOG.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)) {
+      LOG.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)) {
+    LOG.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);
@@ -12914,7 +13026,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;
     }
@@ -14150,6 +14266,25 @@ function handleMeshForwardEvent(components, payload) {
     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;
@@ -14181,7 +14316,8 @@ function forwardUnresolvedDelegateEvent(components, routing, event) {
   };
   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) {
       LOG.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");
@@ -14190,7 +14326,7 @@ function forwardUnresolvedDelegateEvent(components, routing, event) {
     if (persisted) ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventName, payload);
   }).catch((e) => {
     LOG.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued for retry`);
-  });
+  }));
   LOG.info("MeshEvents", `Durably forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId}`);
   return true;
 }
@@ -14273,7 +14409,7 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var 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;
+var 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";
@@ -14290,6 +14426,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();
@@ -14303,6 +14440,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;
@@ -14337,6 +14476,7 @@ var init_mesh_events_coordinator = __esm({
       "worktree_bootstrap_complete",
       "worktree_bootstrap_failed"
     ]);
+    coordinatorForwardLanes = /* @__PURE__ */ new Map();
   }
 });
 
@@ -41173,6 +41313,18 @@ var DaemonCliManager = class {
       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 ──────────────────────────────
@@ -41440,6 +41592,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)) {
@@ -41477,11 +41637,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) {
@@ -47963,6 +48133,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);
@@ -47988,13 +48159,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;
               }
@@ -48003,6 +48174,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) {
@@ -48021,7 +48193,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;
@@ -48435,6 +48607,7 @@ function orderMeshRefineBatchNodes(changeAreas) {
 
 // src/commands/router.ts
 init_mesh_work_queue();
+init_mesh_warmup_deadline();
 init_repo_mesh_types();
 import { homedir as homedir26 } from "os";
 import { basename as pathBasename, join as pathJoin2, resolve as pathResolve2 } from "path";
@@ -49176,14 +49349,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;
@@ -49251,73 +49502,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);
@@ -49331,6 +49525,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);
@@ -61414,6 +61614,7 @@ async function initDaemonComponents(config) {
     detectedIdes: detectedIdesRef,
     refreshProviderAvailability,
     dispatchMeshCommand: config.dispatchMeshCommand,
+    getMeshPeerConnectionStatus: config.getMeshPeerConnectionStatus,
     onMeshCoordinatorEventForwarded: config.onMeshCoordinatorEventForwarded,
     statusInstanceId: config.statusInstanceId
   };