@adhdev/daemon-standalone 0.9.82-rc.370 → 0.9.82-rc.373

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "84d52e533859a9dd3c3bc8bc11a2541911f7bd0c" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "84d52e53" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.370" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-24T10:08:19.248Z" : 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 version2 = 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:29:42.060Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -35318,7 +35318,14 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
                 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";
@@ -42530,6 +42537,31 @@ ${cleanBody}`;
       }
       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();
     }
@@ -42776,9 +42808,11 @@ ${cleanBody}`;
       }
       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;
@@ -43122,6 +43156,7 @@ ${cleanBody}`;
         }
         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];
@@ -44105,6 +44140,8 @@ ${cleanBody}`;
         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 {
@@ -44645,7 +44682,10 @@ ${cleanBody}`;
       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) {
@@ -44664,6 +44704,7 @@ ${cleanBody}`;
             LOG2.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) {
             LOG2.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");
@@ -44672,21 +44713,40 @@ ${cleanBody}`;
           }
           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) {
           LOG2.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) {
-          LOG2.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);
+            LOG2.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 {
+            LOG2.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);
         LOG2.info("MeshReconcile", `Retried+delivered unresolved-delegate ${readNonEmptyString2(entry.payload.event)} to coordinator ${entry.coordinatorDaemonId}`);
       }
     }
@@ -44917,6 +44977,8 @@ ${cleanBody}`;
     var heldEventLedgerRecorded;
     var ASSIGNED_STRANDED_DEADLINE_MS;
     var STRICT_SESSION_MATCH_TTL_MS;
+    var unresolvedForwardRejectionCounts;
+    var MAX_FORWARD_REJECTIONS;
     var init_mesh_reconcile_loop = __esm2({
       "src/mesh/mesh-reconcile-loop.ts"() {
         "use strict";
@@ -44941,6 +45003,8 @@ ${cleanBody}`;
         heldEventLedgerRecorded = /* @__PURE__ */ new Set();
         ASSIGNED_STRANDED_DEADLINE_MS = 5 * 6e4;
         STRICT_SESSION_MATCH_TTL_MS = 6e4;
+        unresolvedForwardRejectionCounts = /* @__PURE__ */ new Map();
+        MAX_FORWARD_REJECTIONS = 5;
       }
     });
     var mesh_events_exports = {};
@@ -50518,6 +50582,7 @@ ${lastSnapshot}`;
       MESH_CONVERGE_FAST_FORWARD_TAG: () => MESH_CONVERGE_FAST_FORWARD_TAG,
       MESH_CONVERGE_REFINE_TAG: () => MESH_CONVERGE_REFINE_TAG,
       MESH_MISSION_STATUSES: () => MESH_MISSION_STATUSES,
+      MESH_NODE_LIVE_TRUTH_MARKER: () => MESH_NODE_LIVE_TRUTH_MARKER,
       MESH_REFINE_CONFIG_LOCATIONS: () => MESH_REFINE_CONFIG_LOCATIONS,
       MESH_REFINE_CONFIG_SCHEMA: () => MESH_REFINE_CONFIG_SCHEMA,
       MESH_SCHEDULING_STRATEGIES: () => MESH_SCHEDULING_STRATEGIES,
@@ -50564,6 +50629,8 @@ ${lastSnapshot}`;
       buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
       buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
       buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
+      buildMeshNodeDataFreshness: () => buildMeshNodeDataFreshness,
+      buildMeshNodeProbeFreshness: () => buildMeshNodeProbeFreshness,
       buildMissionPromptSection: () => buildMissionPromptSection,
       buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
       buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
@@ -64416,6 +64483,27 @@ ${body}
         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) {
@@ -64430,47 +64518,97 @@ ${body}
       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(date5) {
+      if (date5 instanceof Date) return date5;
+      if (typeof date5 === "string" && date5.trim()) return /* @__PURE__ */ new Date(`${date5.trim()}T00:00:00.000Z`);
+      return /* @__PURE__ */ new Date();
+    }
+    function errorResult(error48, logPath, platform10) {
+      return {
+        success: false,
+        error: error48,
+        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);
@@ -64478,30 +64616,26 @@ ${body}
         });
       }
       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 } : {}
       };
     }
@@ -64614,6 +64748,12 @@ ${body}
           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 } : {}
         };
       }
@@ -71695,7 +71835,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 };
@@ -77259,6 +77399,50 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         return ctx.startMeshRefineBatchJob(meshId, requestedNodeIds, args);
       }
     };
+    init_dist();
+    var RESTART_BLOCKING_STATES = /* @__PURE__ */ new Set(["generating", "waiting_approval", "starting"]);
+    function hasBlockingSessions(ctx) {
+      const states = ctx.deps.instanceManager.collectAllStates();
+      for (const state of states) {
+        if (RESTART_BLOCKING_STATES.has(String(state.status || ""))) return true;
+        const childStates = "extensions" in state && Array.isArray(state.extensions) ? state.extensions : [];
+        for (const child of childStates) {
+          if (RESTART_BLOCKING_STATES.has(String(child?.status || ""))) return true;
+        }
+      }
+      return false;
+    }
+    var meshRestartHandlers = {
+      restart_daemon_node: async (ctx, args) => {
+        const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
+        const nodeId = typeof args?.nodeId === "string" ? args.nodeId.trim() : "";
+        let nodeDaemonId;
+        if (meshId && nodeId) {
+          const meshRecord = await ctx.getMeshForCommand(meshId, args?.inlineMesh, { preferInline: true });
+          const node = meshRecord?.mesh?.nodes?.find((n) => meshNodeIdMatches(n, nodeId));
+          nodeDaemonId = typeof node?.daemonId === "string" ? node.daemonId.trim() : void 0;
+        }
+        const selfDaemonId = ctx.deps.statusInstanceId;
+        const isRemote = nodeDaemonId && selfDaemonId && !daemonIdsEquivalent(nodeDaemonId, selfDaemonId);
+        if (isRemote && ctx.deps.dispatchMeshCommand && !args?._meshDirectDispatch) {
+          const forwarded = await ctx.deps.dispatchMeshCommand(nodeDaemonId, "restart_daemon_node", {
+            ...typeof args === "object" && args !== null ? args : {},
+            _meshDirectDispatch: true
+          });
+          return forwarded ?? { success: false, error: "no response from remote node" };
+        }
+        if (hasBlockingSessions(ctx)) {
+          return {
+            success: false,
+            restarted: false,
+            code: "blocking_sessions",
+            reason: "Daemon has an active session (generating / waiting_approval / starting); restart refused to avoid interrupting in-flight work. Retry when the node is idle."
+          };
+        }
+        const result = await daemonLifecycleHandlers.daemon_upgrade({ deps: ctx.deps }, args);
+        return { ...result, restarted: result?.restarting === true };
+      }
+    };
     var medFamilyRegistry = new Map(
       Object.entries({
         ...cliAgentHandlers,
@@ -77266,7 +77450,8 @@ ${formatManifestValidationIssues2(validation2.issues)}`);
         ...meshCrudHandlers,
         ...meshHostPairingHandlers,
         ...meshQueueHandlers,
-        ...fastForwardHandlers
+        ...fastForwardHandlers,
+        ...meshRestartHandlers
       })
     );
     init_mesh_events();
@@ -77593,7 +77778,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;
@@ -77643,7 +77828,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");
@@ -79345,6 +79530,23 @@ ${ptyResult.output.slice(-2e3)}`);
         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)) {