@adhdev/daemon-core 0.9.82-rc.371 → 0.9.82-rc.373

package/dist/commands/router.d.ts

@@ -112,6 +112,34 @@ export declare function buildMeshNodeDataFreshness(args: {
     directTruthUnavailable?: boolean;
     now?: () => number;
 }): Record<string, unknown>;
+/**
+ * Canonical live-probe → freshness adapter. The coordinator-facing mesh_status
+ * (mcp-server `meshStatus`) builds each node entry from a SINGLE fresh git_status
+ * probe that either returns (live truth) or throws (peer unreachable). It used to
+ * hand-reconstruct the freshness INPUT inline — a synthetic `{ git, connection }`
+ * status plus the directTruthUnavailable/liveTruthProbed wiring — which is exactly
+ * how a field added to `buildMeshNodeDataFreshness`'s input contract ends up "wired
+ * on the daemon surface, null on the coordinator surface" (the rc.371
+ * null-everywhere regression). Routing every live-probe surface through this one
+ * adapter keeps the marker derivation canonical: there is a SINGLE place that turns
+ * a probe outcome into freshness args, so the two mesh_status surfaces cannot drift.
+ *
+ * `liveTruthProbed` true → the probe returned (live/self truth); false → it threw,
+ * so a configured peer is unreachable while an unconfigured node (no daemonId) falls
+ * through to the classifier's `unconfigured` branch.
+ */
+export declare function buildMeshNodeProbeFreshness(args: {
+    /** The git snapshot this probe stamped on the node entry (entry.git). */
+    git: unknown;
+    /** True when the fresh git_status probe RETURNED (live truth); false when it threw. */
+    liveTruthProbed: boolean;
+    isSelfNode: boolean;
+    /** The node's resolved daemonId; absent → unconfigured node. */
+    daemonId?: string;
+    /** The mesh node record, for held-git fallback when the probe did not return live. */
+    node?: any;
+    now?: () => number;
+}): Record<string, unknown>;
 export declare function finalizeMeshNodeStatus(args: {
     status: Record<string, unknown>;
     node: any;

package/dist/index.d.ts

@@ -84,7 +84,7 @@ export { DaemonCdpInitializer } from './cdp/initializer.js';
 export type { CdpInitializerConfig } from './cdp/initializer.js';
 export { DaemonCommandHandler } from './commands/handler.js';
 export type { CommandResult, CommandContext } from './commands/handler.js';
-export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails, resolveMeshNodeAttribution, buildMeshNodeDataFreshness, MESH_NODE_LIVE_TRUTH_MARKER } from './commands/router.js';
+export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails, resolveMeshNodeAttribution, buildMeshNodeDataFreshness, buildMeshNodeProbeFreshness, MESH_NODE_LIVE_TRUTH_MARKER } from './commands/router.js';
 export type { CommandRouterDeps, CommandRouterResult } from './commands/router.js';
 export { maybeRunDaemonUpgradeHelperFromEnv, spawnDetachedDaemonUpgradeHelper, resolveCurrentGlobalInstallSurface, buildPinnedGlobalInstallCommand, execNpmCommandSync, getNpmExecOptions, } from './commands/upgrade-helper.js';
 export type { DaemonUpgradeHelperPayload, CurrentGlobalInstallSurface, PinnedGlobalInstallCommand, NpmExecOptions, } from './commands/upgrade-helper.js';

package/dist/index.js

@@ -316,10 +316,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "0e66043bc2858f114fbdd7b1edeb7774f33bfd2d" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "0e66043b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.371" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-24T12:30:13.850Z" : void 0);
+  const commit = readInjected(true ? "f16b5e6cdf653b4258f8f44cb11fb6ad8c13329f" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "f16b5e6c" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.373" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-24T16:28:52.547Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -5542,7 +5542,14 @@ var init_mesh_runtime_store = __esm({
             if (candidate.taskMode === "live_debug_readonly") return true;
             return !nodeBusy;
           };
-          const entry = candidates.find((candidate) => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags) && dependenciesSatisfied(candidate) && nodeConflictAllows(candidate));
+          const nodeIsWorktree = opts?.nodeIsWorktree === true;
+          const convergenceAllows = (candidate) => candidate.taskMode !== "convergence" || !nodeIsWorktree;
+          const targetMatches = (candidate) => {
+            if (candidate.targetSessionId && candidate.targetSessionId !== sessionId) return false;
+            if (candidate.targetNodeId && candidate.targetNodeId !== nodeId) return false;
+            return true;
+          };
+          const entry = candidates.find((candidate) => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags) && dependenciesSatisfied(candidate) && convergenceAllows(candidate) && targetMatches(candidate) && nodeConflictAllows(candidate));
           if (!entry) return null;
           const now = (/* @__PURE__ */ new Date()).toISOString();
           entry.status = "assigned";
@@ -12746,6 +12753,31 @@ function recoverMeshIdByNodeId(nodeId) {
   }
   return "";
 }
+function resolveForwardEventMeshId(components, payload) {
+  const direct = readNonEmptyString2(payload.meshId);
+  if (direct) return direct;
+  const workspace = readNonEmptyString2(payload.workspace);
+  const byWorkspace = workspace ? readNonEmptyString2(getCachedMeshByWorkspace(workspace)?.id) : "";
+  if (byWorkspace) return byWorkspace;
+  const byNode = recoverMeshIdByNodeId(readNonEmptyString2(payload.nodeId));
+  if (byNode) return byNode;
+  const sessionId = readNonEmptyString2(payload.targetSessionId) || readNonEmptyString2(payload.sessionId) || readNonEmptyString2(payload.instanceId);
+  if (sessionId) {
+    try {
+      const state = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+      const settings = state?.settings || {};
+      const meshNodeFor = readNonEmptyString2(settings.meshNodeFor);
+      if (meshNodeFor) return meshNodeFor;
+      const byStamp = recoverMeshIdByNodeId(readNonEmptyString2(settings.meshNodeId));
+      if (byStamp) return byStamp;
+      const sessionWorkspace = readNonEmptyString2(state?.workspace);
+      const bySessionWorkspace = sessionWorkspace ? readNonEmptyString2(getCachedMeshByWorkspace(sessionWorkspace)?.id) : "";
+      if (bySessionWorkspace) return bySessionWorkspace;
+    } catch {
+    }
+  }
+  return "";
+}
 function __resetIdleAutoFastForwardForTests() {
   idleAutoFastForwardLastAttempt.clear();
 }
@@ -12992,9 +13024,11 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
   }
   const capabilityTags = buildMeshNodeCapabilityTags(node, providerType);
   const providerMaxParallel = resolveProviderMaxParallel(node?.policy, providerType);
+  const nodeIsWorktree = node?.isLocalWorktree === true;
   const task = claimNextTask(meshId, nodeId, sessionId, capabilityTags, {
     providerType,
-    ...providerMaxParallel !== void 0 ? { providerMaxParallel } : {}
+    ...providerMaxParallel !== void 0 ? { providerMaxParallel } : {},
+    nodeIsWorktree
   });
   if (!task) {
     return false;
@@ -13338,6 +13372,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
     }
     const candidateNodes = Array.isArray(mesh?.nodes) ? mesh.nodes.filter((node) => {
       if (task.targetNodeId && !meshNodeIdMatches(node, task.targetNodeId)) return false;
+      if (task.taskMode === "convergence" && node?.isLocalWorktree === true) return false;
       if (task.requiredTags?.length) {
         const priorities = normalizeProviderPriority(node?.policy);
         const providerCandidates = priorities.length ? priorities : [void 0];
@@ -14321,6 +14356,8 @@ function forwardUnresolvedDelegateEvent(components, routing, event) {
     nodeId: readNonEmptyString2(routing.nodeId) || readNonEmptyString2(event.meshNodeId) || void 0,
     workspace: readNonEmptyString2(routing.workspace) || readNonEmptyString2(event.workspace) || void 0
   };
+  const resolvedMeshId = resolveForwardEventMeshId(components, payload);
+  if (resolvedMeshId) payload.meshId = resolvedMeshId;
   const selfDaemonIds = resolveCoordinatorDrainDaemonIds(components);
   if (selfDaemonIds.some((self) => daemonIdsEquivalent(self, coordinatorDaemonId))) {
     try {
@@ -14843,7 +14880,10 @@ async function retryUnresolvedDelegateForwards(components) {
   if (!dispatchMeshCommand) return;
   expireStaleUnresolvedDelegateForwards();
   const entries = peekUnresolvedDelegateForwards();
-  if (entries.length === 0) return;
+  if (entries.length === 0) {
+    if (unresolvedForwardRejectionCounts.size > 0) unresolvedForwardRejectionCounts.clear();
+    return;
+  }
   const selfIds = resolveCoordinatorDaemonIds(components);
   const isSelfCoordinatorId = (id) => selfIds.some((self) => daemonIdsEquivalent(self, id));
   for (const entry of entries) {
@@ -14862,6 +14902,7 @@ async function retryUnresolvedDelegateForwards(components) {
         LOG.warn("MeshReconcile", `Local route of self-addressed forward to ${entry.coordinatorDaemonId} threw: ${e?.message || e} \u2014 draining anyway to break the retry loop`);
       }
       ackUnresolvedDelegateForward(entry.id);
+      unresolvedForwardRejectionCounts.delete(entry.id);
       if (localResult && localResult.success === false) {
         LOG.warn("MeshReconcile", `Self-addressed unresolved-delegate ${readNonEmptyString2(entry.payload.event)} rejected by local router (${readNonEmptyString2(localResult.error) || "no reason"}) \u2014 drained to break the self-forward retry loop`);
         traceMeshEventDrop("self_forward_local_rejected", entryTraceCtx, readNonEmptyString2(localResult.error) || "no reason");
@@ -14870,21 +14911,40 @@ async function retryUnresolvedDelegateForwards(components) {
       }
       continue;
     }
+    let pushPayload = entry.payload;
+    if (!readNonEmptyString2(pushPayload.meshId)) {
+      const recoveredMeshId = resolveForwardEventMeshId(components, pushPayload);
+      if (recoveredMeshId) {
+        pushPayload = { ...pushPayload, meshId: recoveredMeshId };
+        traceMeshEventStage("forward_meshid_recovered", entryTraceCtx, `meshId=${recoveredMeshId}`);
+      }
+    }
     let result;
     try {
       traceMeshEventStage("forward_send", entryTraceCtx, `retry \u2192 ${entry.coordinatorDaemonId}`);
-      result = await dispatchMeshCommand(entry.coordinatorDaemonId, "mesh_forward_event", entry.payload);
+      result = await dispatchMeshCommand(entry.coordinatorDaemonId, "mesh_forward_event", pushPayload);
     } catch (e) {
       LOG.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued`);
       traceMeshEventDrop("retry_forward_failed", entryTraceCtx, e?.message || String(e));
       continue;
     }
     if (result && result.success === false) {
-      LOG.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued`);
-      traceMeshEventDrop("retry_forward_rejected", entryTraceCtx, readNonEmptyString2(result.error) || "no reason");
+      const rejections = (unresolvedForwardRejectionCounts.get(entry.id) || 0) + 1;
+      unresolvedForwardRejectionCounts.set(entry.id, rejections);
+      const reason = readNonEmptyString2(result.error) || "no reason";
+      if (rejections >= MAX_FORWARD_REJECTIONS) {
+        ackUnresolvedDelegateForward(entry.id);
+        unresolvedForwardRejectionCounts.delete(entry.id);
+        LOG.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected ${rejections}x (${reason}) \u2014 dropping unresolved-delegate ${readNonEmptyString2(entry.payload.event)} (sess=${readNonEmptyString2(entry.payload.targetSessionId) || readNonEmptyString2(entry.payload.sessionId) || "-"}) to stop the retry loop`);
+        traceMeshEventDrop("retry_forward_exhausted", entryTraceCtx, `${reason} (${rejections} rejections)`);
+      } else {
+        LOG.warn("MeshReconcile", `Retry forward to coordinator ${entry.coordinatorDaemonId} rejected (${reason}) \u2014 left queued (attempt ${rejections}/${MAX_FORWARD_REJECTIONS})`);
+        traceMeshEventDrop("retry_forward_rejected", entryTraceCtx, reason);
+      }
       continue;
     }
     ackUnresolvedDelegateForward(entry.id);
+    unresolvedForwardRejectionCounts.delete(entry.id);
     LOG.info("MeshReconcile", `Retried+delivered unresolved-delegate ${readNonEmptyString2(entry.payload.event)} to coordinator ${entry.coordinatorDaemonId}`);
   }
 }
@@ -15110,7 +15170,7 @@ function setupMeshReconcileLoop(components) {
     }
   };
 }
-var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, STRICT_SESSION_MATCH_TTL_MS;
+var DEFAULT_RECONCILE_INTERVAL_MS, DEFAULT_AUTO_PRUNE_MIN_AGE_MS, heldEventLedgerRecorded, ASSIGNED_STRANDED_DEADLINE_MS, STRICT_SESSION_MATCH_TTL_MS, unresolvedForwardRejectionCounts, MAX_FORWARD_REJECTIONS;
 var init_mesh_reconcile_loop = __esm({
   "src/mesh/mesh-reconcile-loop.ts"() {
     "use strict";
@@ -15135,6 +15195,8 @@ var init_mesh_reconcile_loop = __esm({
     heldEventLedgerRecorded = /* @__PURE__ */ new Set();
     ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
     STRICT_SESSION_MATCH_TTL_MS = 6e4;
+    unresolvedForwardRejectionCounts = /* @__PURE__ */ new Map();
+    MAX_FORWARD_REJECTIONS = 5;
   }
 });
 
@@ -20760,6 +20822,7 @@ __export(index_exports, {
   buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
   buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
   buildMeshNodeDataFreshness: () => buildMeshNodeDataFreshness,
+  buildMeshNodeProbeFreshness: () => buildMeshNodeProbeFreshness,
   buildMissionPromptSection: () => buildMissionPromptSection,
   buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
@@ -34762,6 +34825,27 @@ function readByteBoundedTail(filePath, limitBytes) {
     fs13.closeSync(fd);
   }
 }
+function splitLogLines(text) {
+  const lines = text.split("\n");
+  if (lines.length && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function takeLastLinesWithinBytes(lines, limitBytes) {
+  if (lines.length === 0) return { kept: [], truncated: false, bytesReturned: 0 };
+  let total = 0;
+  let firstKept = lines.length;
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const lineBytes = Buffer.byteLength(lines[i], "utf-8") + 1;
+    if (firstKept !== lines.length && total + lineBytes > limitBytes) break;
+    total += lineBytes;
+    firstKept = i;
+  }
+  return {
+    kept: lines.slice(firstKept),
+    truncated: firstKept > 0,
+    bytesReturned: total
+  };
+}
 function parseLineEpochMs(line, fileDate) {
   const m = line.match(/^\[(\d{2}):(\d{2}):(\d{2})(?:\.(\d{1,3}))?\]/);
   if (!m) {
@@ -34776,47 +34860,97 @@ function parseLineEpochMs(line, fileDate) {
   d.setHours(Number(m[1]), Number(m[2]), Number(m[3]), m[4] ? Number(m[4].padEnd(3, "0")) : 0);
   return d.getTime();
 }
+function buildGrepPredicate(grepSource) {
+  let re = null;
+  try {
+    re = new RegExp(grepSource, "i");
+  } catch {
+    re = null;
+  }
+  if (re) {
+    const compiled = re;
+    return (line) => compiled.test(line);
+  }
+  const needle = grepSource.toLowerCase();
+  return (line) => line.toLowerCase().includes(needle);
+}
+function fileDateFor(date) {
+  if (date instanceof Date) return date;
+  if (typeof date === "string" && date.trim()) return /* @__PURE__ */ new Date(`${date.trim()}T00:00:00.000Z`);
+  return /* @__PURE__ */ new Date();
+}
+function errorResult(error, logPath, platform10) {
+  return {
+    success: false,
+    error,
+    lines: [],
+    truncated: false,
+    logPath,
+    platform: platform10,
+    bytesReturned: 0,
+    filtered: false,
+    fullScan: false,
+    scannedBytes: 0,
+    matchedLineCount: 0,
+    excludedByFilter: 0
+  };
+}
 function readDaemonLogTail(args = {}) {
   const platform10 = process.platform;
   const limitBytes = clampTailBytes(args.tailBytes);
-  let logPath = resolveLogPath(args.date);
-  if (!fs13.existsSync(logPath)) {
-    const backup = logPath.replace(/\.log$/, ".1.log");
-    if (fs13.existsSync(backup)) {
-      logPath = backup;
-    } else {
-      return {
-        success: false,
-        error: `No daemon log file at ${logPath} (dir: ${getDaemonLogDir()})`,
-        lines: [],
-        truncated: false,
-        logPath,
-        platform: platform10,
-        bytesReturned: 0,
-        filtered: false
-      };
-    }
+  const primaryPath = resolveLogPath(args.date);
+  const backupPath = primaryPath.replace(/\.log$/, ".1.log");
+  const primaryExists = fs13.existsSync(primaryPath);
+  const backupExists = fs13.existsSync(backupPath);
+  if (!primaryExists && !backupExists) {
+    return errorResult(
+      `No daemon log file at ${primaryPath} (dir: ${getDaemonLogDir()})`,
+      primaryPath,
+      platform10
+    );
   }
-  let raw;
-  try {
-    raw = readByteBoundedTail(logPath, limitBytes);
-  } catch (e) {
+  const logPath = primaryExists ? primaryPath : backupPath;
+  const hasGrep = typeof args.grep === "string" && args.grep.trim().length > 0;
+  const hasSince = Number.isFinite(args.sinceMs);
+  const filterMode = hasGrep || hasSince;
+  if (!filterMode) {
+    let raw;
+    try {
+      raw = readByteBoundedTail(logPath, limitBytes);
+    } catch (e) {
+      return errorResult(`Failed to read ${logPath}: ${e?.message ?? String(e)}`, logPath, platform10);
+    }
+    const lines2 = splitLogLines(raw.text);
     return {
-      success: false,
-      error: `Failed to read ${logPath}: ${e?.message ?? String(e)}`,
-      lines: [],
-      truncated: false,
+      success: true,
+      lines: lines2,
+      truncated: raw.truncated,
       logPath,
       platform: platform10,
-      bytesReturned: 0,
-      filtered: false
+      bytesReturned: raw.bytesReturned,
+      filtered: false,
+      fullScan: false,
+      scannedBytes: raw.bytesReturned,
+      matchedLineCount: lines2.length,
+      excludedByFilter: 0
     };
   }
-  let lines = raw.text.split("\n");
-  if (lines.length && lines[lines.length - 1] === "") lines.pop();
-  const rawCount = lines.length;
-  if (Number.isFinite(args.sinceMs)) {
-    const fileDate = args.date instanceof Date ? args.date : typeof args.date === "string" && args.date.trim() ? /* @__PURE__ */ new Date(`${args.date.trim()}T00:00:00.000Z`) : /* @__PURE__ */ new Date();
+  let scannedBytes = 0;
+  let allLines = [];
+  try {
+    for (const p of [backupExists ? backupPath : null, primaryExists ? primaryPath : null]) {
+      if (!p) continue;
+      const buf = fs13.readFileSync(p);
+      scannedBytes += buf.length;
+      allLines = allLines.concat(splitLogLines(buf.toString("utf-8")));
+    }
+  } catch (e) {
+    return errorResult(`Failed to read ${logPath}: ${e?.message ?? String(e)}`, logPath, platform10);
+  }
+  const scannedLineCount = allLines.length;
+  let lines = allLines;
+  if (hasSince) {
+    const fileDate = fileDateFor(args.date);
     const floor = args.sinceMs;
     lines = lines.filter((line) => {
       const ts2 = parseLineEpochMs(line, fileDate);
@@ -34824,30 +34958,26 @@ function readDaemonLogTail(args = {}) {
     });
   }
   let appliedGrep;
-  if (typeof args.grep === "string" && args.grep.trim()) {
+  if (hasGrep) {
     appliedGrep = args.grep.trim();
-    let re = null;
-    try {
-      re = new RegExp(appliedGrep, "i");
-    } catch {
-      re = null;
-    }
-    if (re) {
-      const compiled = re;
-      lines = lines.filter((line) => compiled.test(line));
-    } else {
-      const needle = appliedGrep.toLowerCase();
-      lines = lines.filter((line) => line.toLowerCase().includes(needle));
-    }
+    const matches = buildGrepPredicate(appliedGrep);
+    lines = lines.filter(matches);
   }
+  const matchedLineCount = lines.length;
+  const excludedByFilter = scannedLineCount - matchedLineCount;
+  const capped = takeLastLinesWithinBytes(lines, limitBytes);
   return {
     success: true,
-    lines,
-    truncated: raw.truncated,
+    lines: capped.kept,
+    truncated: capped.truncated,
     logPath,
     platform: platform10,
-    bytesReturned: raw.bytesReturned,
-    filtered: lines.length !== rawCount,
+    bytesReturned: capped.bytesReturned,
+    filtered: excludedByFilter > 0,
+    fullScan: true,
+    scannedBytes,
+    matchedLineCount,
+    excludedByFilter,
     ...appliedGrep ? { grep: appliedGrep } : {}
   };
 }
@@ -34964,6 +35094,12 @@ var meshNodeLogsHandlers = {
       truncated: tail.truncated,
       filtered: tail.filtered,
       bytesReturned: tail.bytesReturned,
+      // Transparency meta — lets the coordinator see that a full-file grep
+      // ran past the recent tail window, and how much was scanned/excluded.
+      fullScan: tail.fullScan,
+      scannedBytes: tail.scannedBytes,
+      matchedLineCount: tail.matchedLineCount,
+      excludedByFilter: tail.excludedByFilter,
       ...tail.grep ? { grep: tail.grep } : {}
     };
   }
@@ -42091,7 +42227,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
       const adapter = this.adapters.get(ik);
       if (adapter) return { adapter, key: ik };
     }
-    if (opts?.dir) {
+    if (opts?.dir && !opts?.instanceKey) {
       for (const [k, a] of this.adapters) {
         if (a.cliType === agentType && a.workingDir === opts.dir) {
           return { adapter: a, key: k };
@@ -48084,7 +48220,7 @@ ${ptyResult.output.slice(-2e3)}`);
           workspace
         };
       }
-      const { existsSync: existsSync49, readFileSync: readFileSync39, writeFileSync: writeFileSync24, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
+      const { existsSync: existsSync49, readFileSync: readFileSync40, writeFileSync: writeFileSync24, copyFileSync: copyFileSync4, mkdirSync: mkdirSync21 } = await import("fs");
       const { dirname: dirname17 } = await import("path");
       const mcpConfigPath = coordinatorSetup.configPath;
       const hermesManualFallback = cliType === "hermes-cli" && configFormat === "hermes_config_yaml" ? createHermesManualMeshCoordinatorSetup(meshId, workspace) : null;
@@ -48134,7 +48270,7 @@ ${ptyResult.output.slice(-2e3)}`);
       }
       if (hadExistingMcpConfig) {
         try {
-          const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync39(mcpConfigPath, "utf-8"), configFormat);
+          const parsedExistingMcpConfig = parseMeshCoordinatorMcpConfig(readFileSync40(mcpConfigPath, "utf-8"), configFormat);
           const existingCoordinatorConfig = hermesManualFallback ? stripHermesCoordinatorTempModelProviderOverrides(parsedExistingMcpConfig) : parsedExistingMcpConfig;
           existingMcpConfig = { ...existingMcpConfig, ...existingCoordinatorConfig };
           copyFileSync4(mcpConfigPath, mcpConfigPath + ".backup");
@@ -49854,6 +49990,23 @@ function buildMeshNodeDataFreshness(args) {
     staleness
   };
 }
+function buildMeshNodeProbeFreshness(args) {
+  const { git, liveTruthProbed, isSelfNode, daemonId, node, now } = args;
+  const status = {
+    git,
+    connection: { state: liveTruthProbed ? "connected" : "disconnected" }
+  };
+  if (liveTruthProbed) status[MESH_NODE_LIVE_TRUTH_MARKER] = true;
+  return buildMeshNodeDataFreshness({
+    status,
+    node,
+    isSelfNode,
+    daemonId,
+    liveTruthProbed,
+    directTruthUnavailable: !liveTruthProbed && !!daemonId,
+    now
+  });
+}
 function finalizeMeshNodeStatus(args) {
   const { status, node, daemonId, isSelfNode, directTruthUnavailable } = args;
   if (!readStringValue(status.machineStatus)) {
@@ -62007,6 +62160,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   buildMeshLedgerReplicaEvidence,
   buildMeshNodeCapabilityTags,
   buildMeshNodeDataFreshness,
+  buildMeshNodeProbeFreshness,
   buildMissionPromptSection,
   buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand,