@adhdev/daemon-core 0.9.82-rc.372 → 0.9.82-rc.374

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 ? "376a56400a2a60c210b7d8a2476b5d2a15604c7e" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "376a5640" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.372" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-24T13:46:48.450Z" : void 0);
+  const commit = readInjected(true ? "47e042dcb10c9ca07c30ac4bf8e0d5a4153a63c6" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "47e042dc" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.374" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-25T00:33:05.038Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -8749,7 +8749,7 @@ var init_mesh_events_utils = __esm({
   "src/mesh/mesh-events-utils.ts"() {
     "use strict";
     MESH_SURFACED_PREVIEW_MAX_CHARS = 512;
-    MESH_COMPLETION_SURFACE_MAX_CHARS = 4e3;
+    MESH_COMPLETION_SURFACE_MAX_CHARS = 16e3;
   }
 });
 
@@ -9389,6 +9389,22 @@ function isWeakCompletionLedgerPayload(payload) {
   const diag = readRecord4(payload.completionDiagnostic);
   return diag?.finalAssistantPresent === false || diag?.blockReason === "missing_final_assistant";
 }
+function findTerminalLedgerEvidenceForTask(args) {
+  const taskId = readNonEmptyString2(args.taskId);
+  if (!taskId) return null;
+  const entries = readLedgerEntries(args.meshId, { tail: args.tail ?? 500 });
+  for (let i = entries.length - 1; i >= 0; i--) {
+    const entry = entries[i];
+    if (entry.kind !== "task_completed" && entry.kind !== "task_failed" && entry.kind !== "task_stalled") continue;
+    const terminalTaskId = readNonEmptyString2(entry.payload?.taskId);
+    if (terminalTaskId !== taskId) continue;
+    if (entry.kind === "task_completed" && isWeakCompletionLedgerPayload(entry.payload)) continue;
+    if (args.sessionId && entry.sessionId && entry.sessionId !== args.sessionId) continue;
+    if (!args.sessionId && args.nodeId && entry.nodeId && !meshNodeIdMatches(entry, args.nodeId)) continue;
+    return { id: entry.id, kind: entry.kind, payload: entry.payload || {}, timestamp: entry.timestamp };
+  }
+  return null;
+}
 function findDirectDispatchLedgerEntry(args) {
   const entries = readLedgerEntries(args.meshId, { tail: 500 });
   for (let i = entries.length - 1; i >= 0; i--) {
@@ -11517,7 +11533,7 @@ var init_chat_message_normalization = __esm({
   "src/providers/chat-message-normalization.ts"() {
     "use strict";
     init_contracts();
-    DEFAULT_FINAL_SUMMARY_MAX_CHARS = 4e3;
+    DEFAULT_FINAL_SUMMARY_MAX_CHARS = 16e3;
     BUILTIN_CHAT_MESSAGE_KINDS = ["standard", "thought", "tool", "terminal", "system"];
     CHAT_MESSAGE_VISIBILITIES = ["user", "debug", "internal", "hidden"];
     CHAT_MESSAGE_TRANSCRIPT_VISIBILITIES = ["visible", "chat", "user", "debug", "internal", "hidden"];
@@ -13033,6 +13049,23 @@ function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType)
   if (!task) {
     return false;
   }
+  const terminal = findTerminalLedgerEvidenceForTask({
+    meshId,
+    taskId: task.id
+  });
+  if (terminal) {
+    const status = terminal.kind === "task_completed" ? "completed" : "failed";
+    updateTaskStatus(meshId, task.id, status);
+    LOG.info("MeshQueue", `Skipped dispatch for terminal task ${task.id} on mesh ${meshId}; ${terminal.kind} ledger evidence already exists`);
+    traceMeshEventDrop("dispatch_terminal_ledger", {
+      taskId: task.id,
+      sessionId,
+      nodeId,
+      meshId,
+      event: "agent_command"
+    }, terminal.kind);
+    return false;
+  }
   LOG.info("MeshQueue", `Node ${nodeId} (${sessionId}) pulled task ${task.id}`);
   if (node?.daemonId && components.dispatchMeshCommand) {
     const isLocalNode = components.cliManager.adapters.has(sessionId);
@@ -14570,20 +14603,24 @@ function daemonHostsMesh(mesh, daemonIds) {
   if (host.role && host.role !== "host") return false;
   const hostDaemonId = readNonEmptyString2(host.hostDaemonId);
   if (!hostDaemonId) return true;
-  return daemonIds.includes(hostDaemonId);
+  return daemonIdListIncludes(daemonIds, hostDaemonId);
+}
+function daemonIdListIncludes(ids, id) {
+  if (!id) return false;
+  return ids.some((candidate) => candidate === id || daemonIdsEquivalent(candidate, id));
 }
 function resolveCoordinatorSelfIds(mesh, drainDaemonIds) {
   const ids = new Set(drainDaemonIds);
   for (const node of mesh.nodes) {
     const nodeDaemonId = readNonEmptyString2(node.daemonId);
     const nodeMachineId = readNonEmptyString2(node.machineId);
-    const isSelf = nodeDaemonId && drainDaemonIds.includes(nodeDaemonId) || nodeMachineId && drainDaemonIds.includes(nodeMachineId);
+    const isSelf = nodeDaemonId && daemonIdListIncludes(drainDaemonIds, nodeDaemonId) || nodeMachineId && daemonIdListIncludes(drainDaemonIds, nodeMachineId);
     if (!isSelf) continue;
     if (nodeDaemonId) ids.add(nodeDaemonId);
     if (nodeMachineId) ids.add(nodeMachineId);
   }
   const hostDaemonId = readNonEmptyString2(mesh.meshHost?.hostDaemonId);
-  if (hostDaemonId && ids.has(hostDaemonId)) ids.add(hostDaemonId);
+  if (hostDaemonId && daemonIdListIncludes([...ids], hostDaemonId)) ids.add(hostDaemonId);
   return [...ids];
 }
 function findLiveCoordinators(components) {
@@ -14661,6 +14698,23 @@ function recoverStrandedAssignedDispatches(meshId, store) {
     const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? "");
     if (!Number.isFinite(dispatchedAtMs)) continue;
     if (nowMs - dispatchedAtMs < ASSIGNED_STRANDED_DEADLINE_MS) continue;
+    const terminal = findTerminalLedgerEvidenceForTask({
+      meshId,
+      taskId: row.id
+    });
+    if (terminal) {
+      const status = terminal.kind === "task_completed" ? "completed" : "failed";
+      updateTaskStatus(meshId, row.id, status);
+      LOG.warn("MeshReconcile", `Skipped stranded reclaim redispatch for terminal task ${row.id} on mesh ${meshId}; ${terminal.kind} ledger evidence already exists`);
+      traceMeshEventDrop("assigned_stranded_terminal_ledger", {
+        taskId: row.id,
+        sessionId: row.assignedSessionId,
+        nodeId: row.assignedNodeId,
+        meshId,
+        event: "agent:generating_completed"
+      }, terminal.kind);
+      continue;
+    }
     if (store.taskHasConfirmedDelivery(meshId, row.id)) continue;
     const reclaimed = reclaimStrandedAssignedTask(meshId, row.id, {
       reason: "assigned_stranded_dispatch_unconfirmed",
@@ -14957,7 +15011,7 @@ async function pullRemoteNodeQueues(components, mesh, localDaemonId, candidateDa
     const nodeDaemonId = readNonEmptyString2(node.daemonId);
     if (!nodeDaemonId) continue;
     if (daemonIdsEquivalent(nodeDaemonId, localDaemonId)) continue;
-    if (candidateDaemonIds.includes(nodeDaemonId)) continue;
+    if (daemonIdListIncludes(candidateDaemonIds, nodeDaemonId)) continue;
     for (const pendingEventArgs of pulls) {
       let events;
       try {
@@ -15013,7 +15067,7 @@ async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds,
     if (!sessionId || !nodeId || !taskId) continue;
     const node = nodeById.get(nodeId);
     const nodeDaemonId = readNonEmptyString2(node?.daemonId);
-    const isLocalNode = !nodeDaemonId || selfIds.includes(nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || !!components.instanceManager.getInstance(sessionId);
+    const isLocalNode = !nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || !!components.instanceManager.getInstance(sessionId);
     const providerType = readNonEmptyString2(dispatch.providerType);
     const readArgs = {
       sessionId,
@@ -15088,7 +15142,7 @@ async function collectLiveNodesWithSessions(components, mesh, selfIds, localDaem
   const dispatchMeshCommand = components.dispatchMeshCommand;
   return Promise.all(mesh.nodes.map(async (node) => {
     const nodeDaemonId = readNonEmptyString2(node.daemonId);
-    const isLocalNode = !nodeDaemonId || selfIds.includes(nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
+    const isLocalNode = !nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId);
     let statusResult;
     try {
       if (isLocalNode) {
@@ -20822,6 +20876,7 @@ __export(index_exports, {
   buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
   buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
   buildMeshNodeDataFreshness: () => buildMeshNodeDataFreshness,
+  buildMeshNodeProbeFreshness: () => buildMeshNodeProbeFreshness,
   buildMissionPromptSection: () => buildMissionPromptSection,
   buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
@@ -34824,6 +34879,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) {
@@ -34838,47 +34914,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);
@@ -34886,30 +35012,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 } : {}
   };
 }
@@ -35026,6 +35148,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 } : {}
     };
   }
@@ -46797,7 +46925,7 @@ var meshCrudHandlers = {
             return "";
           }
         })();
-        const isCoordinatorBaseNode = !!selfDaemonId && (nodeDaemonId === selfDaemonId || nodeMachineId === selfDaemonId) || !!selfMachineId && (nodeDaemonId === selfMachineId || nodeMachineId === selfMachineId);
+        const isCoordinatorBaseNode = !!selfDaemonId && (daemonIdsEquivalent(nodeDaemonId, selfDaemonId) || daemonIdsEquivalent(nodeMachineId, selfDaemonId)) || !!selfMachineId && (daemonIdsEquivalent(nodeDaemonId, selfMachineId) || daemonIdsEquivalent(nodeMachineId, selfMachineId));
         if (isCoordinatorBaseNode) {
           return {
             success: false,
@@ -48146,7 +48274,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;
@@ -48196,7 +48324,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");
@@ -49916,6 +50044,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)) {
@@ -62069,6 +62214,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   buildMeshLedgerReplicaEvidence,
   buildMeshNodeCapabilityTags,
   buildMeshNodeDataFreshness,
+  buildMeshNodeProbeFreshness,
   buildMissionPromptSection,
   buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand,