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

package/dist/index.mjs

@@ -311,10 +311,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;
 }
@@ -5535,7 +5535,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";
@@ -12742,6 +12749,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();
 }
@@ -12988,9 +13020,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;
@@ -13334,6 +13368,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];
@@ -14317,6 +14352,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 {
@@ -14838,7 +14875,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) {
@@ -14857,6 +14897,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");
@@ -14865,21 +14906,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}`);
   }
 }
@@ -15105,7 +15165,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";
@@ -15130,6 +15190,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;
   }
 });
 
@@ -34389,6 +34451,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) {
@@ -34403,47 +34486,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);
@@ -34451,30 +34584,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 } : {}
   };
 }
@@ -34591,6 +34720,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 } : {}
     };
   }
@@ -41723,7 +41858,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 };
@@ -47716,7 +47851,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;
@@ -47766,7 +47901,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");
@@ -47894,7 +48029,7 @@ import { hostname as osHostname } from "os";
 
 // src/mesh/preview-freshness.ts
 import { execFileSync as execFileSync5 } from "child_process";
-import { existsSync as existsSync39, readFileSync as readFileSync29 } from "fs";
+import { existsSync as existsSync39, readFileSync as readFileSync30 } from "fs";
 import { resolve as resolve19 } from "path";
 var PREVIEW_DEPLOY_RECORD = ".adhdev/preview-deploy.json";
 function runGit2(repoRoot, args) {
@@ -47913,7 +48048,7 @@ function readRecord5(repoRoot) {
   const path42 = resolve19(repoRoot, PREVIEW_DEPLOY_RECORD);
   if (!existsSync39(path42)) return null;
   try {
-    const parsed = JSON.parse(readFileSync29(path42, "utf8"));
+    const parsed = JSON.parse(readFileSync30(path42, "utf8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
   } catch {
     return null;
@@ -49486,6 +49621,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)) {
@@ -61463,11 +61615,11 @@ init_parse_session();
 
 // src/providers/sdk/v1/fixture-tooling/replay.ts
 init_provider_cli_shared();
-import { readFileSync as readFileSync37 } from "fs";
+import { readFileSync as readFileSync38 } from "fs";
 import { dirname as dirname15, resolve as resolve22 } from "path";
 
 // src/providers/sdk/v1/validators/taint.ts
-import { readFileSync as readFileSync38, existsSync as existsSync48 } from "fs";
+import { readFileSync as readFileSync39, existsSync as existsSync48 } from "fs";
 import { resolve as resolve23, dirname as dirname16, join as join47 } from "path";
 
 // src/providers/sdk/v1/validators/index.ts
@@ -61645,6 +61797,7 @@ export {
   buildMeshLedgerReplicaEvidence,
   buildMeshNodeCapabilityTags,
   buildMeshNodeDataFreshness,
+  buildMeshNodeProbeFreshness,
   buildMissionPromptSection,
   buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand,