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

package/dist/commands/med-family/mesh-restart.d.ts

@@ -0,0 +1,2 @@
+import type { MedFamilyHandler } from './types.js';
+export declare const meshRestartHandlers: Record<string, MedFamilyHandler>;

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 } from './commands/router.js';
+export { DaemonCommandRouter, readCachedInlineMeshActiveSessionDetails, resolveMeshNodeAttribution, buildMeshNodeDataFreshness, 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 ? "84d52e533859a9dd3c3bc8bc11a2541911f7bd0c" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "84d52e53" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:07:48.772Z" : void 0);
+  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);
   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;
   }
 });
 
@@ -20712,6 +20774,7 @@ __export(index_exports, {
   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,
@@ -20758,6 +20821,7 @@ __export(index_exports, {
   buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
   buildMeshNodeCapabilityTags: () => buildMeshNodeCapabilityTags,
+  buildMeshNodeDataFreshness: () => buildMeshNodeDataFreshness,
   buildMissionPromptSection: () => buildMissionPromptSection,
   buildP2pRelayFailurePayload: () => buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand: () => buildPinnedGlobalInstallCommand,
@@ -42089,7 +42153,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 };
@@ -47696,6 +47760,52 @@ var fastForwardHandlers = {
   }
 };
 
+// src/commands/med-family/mesh-restart.ts
+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 };
+  }
+};
+
 // src/commands/med-family/index.ts
 var medFamilyRegistry = new Map(
   Object.entries({
@@ -47704,7 +47814,8 @@ var medFamilyRegistry = new Map(
     ...meshCrudHandlers,
     ...meshHostPairingHandlers,
     ...meshQueueHandlers,
-    ...fastForwardHandlers
+    ...fastForwardHandlers,
+    ...meshRestartHandlers
   })
 );
 
@@ -61910,6 +62021,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   MESH_CONVERGE_FAST_FORWARD_TAG,
   MESH_CONVERGE_REFINE_TAG,
   MESH_MISSION_STATUSES,
+  MESH_NODE_LIVE_TRUTH_MARKER,
   MESH_REFINE_CONFIG_LOCATIONS,
   MESH_REFINE_CONFIG_SCHEMA,
   MESH_SCHEDULING_STRATEGIES,
@@ -61956,6 +62068,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence,
   buildMeshNodeCapabilityTags,
+  buildMeshNodeDataFreshness,
   buildMissionPromptSection,
   buildP2pRelayFailurePayload,
   buildPinnedGlobalInstallCommand,