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

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 ? "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;
   }
 });
 
@@ -42091,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 };