@adhdev/daemon-standalone 0.9.82-rc.381 → 0.9.82-rc.383

package/dist/index.js

@@ -30108,10 +30108,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "18afac213951f79c502feb6b25b7399fe4d709b3" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "18afac21" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.381" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-25T11:45:12.459Z" : void 0);
+      const commit = readInjected(true ? "6cca365bcea9757dd350c6bac460ca5a169a9280" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "6cca365b" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.383" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-25T15:16:13.636Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -38363,6 +38363,107 @@ ${rendered}`, "utf-8");
         ]);
       }
     });
+    var mesh_scheduling_runtime_exports = {};
+    __export2(mesh_scheduling_runtime_exports, {
+      buildMeshSchedulingRuntime: () => buildMeshSchedulingRuntime
+    });
+    function isReadonly(task) {
+      return task.taskMode === "live_debug_readonly";
+    }
+    function isAssigned(task) {
+      return task.status === "assigned";
+    }
+    function buildMeshSchedulingRuntime(mesh, queue) {
+      const strategy = normalizeMeshSchedulingStrategy(mesh?.policy?.schedulingStrategy);
+      const maxParallelTasks = resolveMaxParallelTasks(mesh?.policy?.maxParallelTasks);
+      const maxReadonlyParallelTasks = Math.max(2, maxParallelTasks * 2);
+      const assignedTasks = (Array.isArray(queue) ? queue : []).filter(isAssigned);
+      const activeWriteAssigned = assignedTasks.filter((t) => !isReadonly(t)).length;
+      const activeReadonlyAssigned = assignedTasks.filter(isReadonly).length;
+      const globalWriteCapReached = activeWriteAssigned >= maxParallelTasks;
+      const globalReadonlyCapReached = activeReadonlyAssigned >= maxReadonlyParallelTasks;
+      const writeAssignedByNode = /* @__PURE__ */ new Map();
+      const assignedByNode = /* @__PURE__ */ new Map();
+      const providerCountByNode = /* @__PURE__ */ new Map();
+      for (const task of assignedTasks) {
+        const nodeId = typeof task.assignedNodeId === "string" ? task.assignedNodeId.trim() : "";
+        if (!nodeId) continue;
+        assignedByNode.set(nodeId, (assignedByNode.get(nodeId) ?? 0) + 1);
+        if (!isReadonly(task)) {
+          writeAssignedByNode.set(nodeId, (writeAssignedByNode.get(nodeId) ?? 0) + 1);
+        }
+        const provider = typeof task.assignedProviderType === "string" ? task.assignedProviderType : "";
+        if (provider) {
+          let byProvider = providerCountByNode.get(nodeId);
+          if (!byProvider) {
+            byProvider = /* @__PURE__ */ new Map();
+            providerCountByNode.set(nodeId, byProvider);
+          }
+          byProvider.set(provider, (byProvider.get(provider) ?? 0) + 1);
+        }
+      }
+      const nodes = [];
+      for (const rawNode of Array.isArray(mesh?.nodes) ? mesh.nodes : []) {
+        const nodeId = normalizeMeshNodeId(rawNode);
+        if (!nodeId) continue;
+        const policy = rawNode?.policy || void 0;
+        const load4 = assignedByNode.get(nodeId) ?? 0;
+        const schedulingPriority = resolveNodeSchedulingPriority(policy);
+        const capReasons = [];
+        if (globalWriteCapReached) capReasons.push("global_max_parallel_tasks_reached");
+        if ((writeAssignedByNode.get(nodeId) ?? 0) > 0) capReasons.push("node_has_active_assignment");
+        let providerRoles;
+        const declaredRoles = Array.isArray(policy?.providerRoles) ? policy.providerRoles : [];
+        if (declaredRoles.length) {
+          const byProvider = providerCountByNode.get(nodeId);
+          providerRoles = [];
+          for (const role of declaredRoles) {
+            if (!role || typeof role !== "object") continue;
+            const providerType = typeof role.providerType === "string" ? role.providerType.trim() : "";
+            if (!providerType) continue;
+            const maxParallel = resolveProviderMaxParallel(policy, providerType);
+            const activeAssigned = byProvider?.get(providerType) ?? 0;
+            const capReached = maxParallel !== void 0 && activeAssigned >= maxParallel;
+            providerRoles.push({
+              providerType,
+              ...maxParallel !== void 0 ? { maxParallel } : {},
+              activeAssigned,
+              capReached
+            });
+            if (capReached) capReasons.push(`max_provider_parallel_reached:${providerType}`);
+          }
+          if (!providerRoles.length) providerRoles = void 0;
+        }
+        const maxConcurrentSessions = Number(policy?.maxConcurrentSessions);
+        const hasSessionCap = Number.isFinite(maxConcurrentSessions) && maxConcurrentSessions >= 0;
+        nodes.push({
+          nodeId,
+          load: load4,
+          schedulingPriority,
+          ...hasSessionCap ? { maxConcurrentSessions: Math.floor(maxConcurrentSessions) } : {},
+          ...providerRoles ? { providerRoles } : {},
+          capReached: capReasons.length > 0,
+          capReasons
+        });
+      }
+      return {
+        strategy,
+        maxParallelTasks,
+        maxReadonlyParallelTasks,
+        activeWriteAssigned,
+        activeReadonlyAssigned,
+        globalWriteCapReached,
+        globalReadonlyCapReached,
+        nodes
+      };
+    }
+    var init_mesh_scheduling_runtime = __esm2({
+      "src/mesh/mesh-scheduling-runtime.ts"() {
+        "use strict";
+        init_repo_mesh_types();
+        init_dist();
+      }
+    });
     function readNonEmptyString2(value) {
       return typeof value === "string" && value.trim() ? value.trim() : "";
     }
@@ -43619,6 +43720,20 @@ ${cleanBody}`;
       }
       return "";
     }
+    function recoverMeshIdByCoordinatorAndNode(coordinatorDaemonId, nodeId) {
+      if (!coordinatorDaemonId) return "";
+      const hosted = listMeshes().filter((mesh) => {
+        const host = resolveMeshHostStatus(mesh);
+        return host.role === "host" && (!host.hostDaemonId || daemonIdsEquivalent(host.hostDaemonId, coordinatorDaemonId));
+      });
+      if (hosted.length === 0) return "";
+      if (nodeId) {
+        const byNode = hosted.find((mesh) => Array.isArray(mesh.nodes) && mesh.nodes.some((n) => meshNodeIdMatches(n, nodeId)));
+        if (byNode) return readNonEmptyString2(byNode.id);
+        return "";
+      }
+      return hosted.length === 1 ? readNonEmptyString2(hosted[0].id) : "";
+    }
     function resolveForwardEventMeshId(components, payload) {
       const direct = readNonEmptyString2(payload.meshId);
       if (direct) return direct;
@@ -44365,7 +44480,10 @@ ${cleanBody}`;
       }
       const nodeId = readNonEmptyString2(payload.nodeId);
       const workspace = readNonEmptyString2(payload.workspace);
-      const meshId = readNonEmptyString2(payload.meshId) || (workspace ? readNonEmptyString2(getCachedMeshByWorkspace(workspace)?.id) : "") || recoverMeshIdByNodeId(nodeId);
+      const meshId = readNonEmptyString2(payload.meshId) || (workspace ? readNonEmptyString2(getCachedMeshByWorkspace(workspace)?.id) : "") || recoverMeshIdByNodeId(nodeId) || recoverMeshIdByCoordinatorAndNode(
+        readNonEmptyString2(payload.meshCoordinatorDaemonId) || readNonEmptyString2(payload.coordinatorDaemonId),
+        nodeId
+      );
       if (!meshId) {
         traceMeshEventDrop("meshId_required", {
           taskId: payload.taskId,
@@ -44420,7 +44538,12 @@ ${cleanBody}`;
         ...event,
         event: eventName,
         nodeId: readNonEmptyString2(routing.nodeId) || readNonEmptyString2(event.meshNodeId) || void 0,
-        workspace: readNonEmptyString2(routing.workspace) || readNonEmptyString2(event.workspace) || void 0
+        workspace: readNonEmptyString2(routing.workspace) || readNonEmptyString2(event.workspace) || void 0,
+        // Fix B: carry the resolved coordinator anchor so the coordinator's receive-side
+        // recovery (recoverMeshIdByCoordinatorAndNode) can match this forward to one of the
+        // meshes it hosts when workspace + nodeId both miss. routing.coordinatorDaemonId is
+        // the same anchor this forward is addressed to (coordinatorDaemonId below).
+        meshCoordinatorDaemonId: coordinatorDaemonId
       };
       const resolvedMeshId = resolveForwardEventMeshId(components, payload);
       if (resolvedMeshId) payload.meshId = resolvedMeshId;
@@ -44555,6 +44678,7 @@ ${cleanBody}`;
         init_mesh_runtime_store();
         init_mesh_events_pending();
         init_mesh_routing();
+        init_mesh_host_ownership();
         init_mesh_unresolved_forward_outbox();
         init_mesh_event_trace();
         init_snapshot();
@@ -44842,8 +44966,7 @@ ${cleanBody}`;
         const idleCoordinators = meshCoordinators.filter((c) => c.idle);
         const generatingCoordinators = meshCoordinators.filter((c) => !c.idle && !c.modalParked);
         const modalParkedCoordinators = meshCoordinators.filter((c) => !c.idle && c.modalParked);
-        const targetCoordinators = idleCoordinators.length > 0 ? idleCoordinators : generatingCoordinators;
-        const forceOnly = idleCoordinators.length === 0;
+        const targetCoordinators = idleCoordinators;
         if (targetCoordinators.length === 0) {
           if (modalParkedCoordinators.length > 0) {
             const liveSessionIds = new Set(
@@ -44910,6 +45033,23 @@ ${cleanBody}`;
                 modalParkedCoordinators.length
               );
             }
+          } else if (generatingCoordinators.length > 0) {
+            let hasPending = true;
+            if (store) {
+              try {
+                hasPending = store.pendingEventCount(meshId) > 0;
+              } catch {
+              }
+            }
+            if (hasPending) {
+              LOG2.info("MeshReconcile", `Reconcile skip \u2192 generating: holding pending event(s) for mesh ${meshId} (${generatingCoordinators.length} coordinator(s) busy; events left queued for the next idle tick)`);
+              recordHeldTerminalEventsToLedger(
+                meshId,
+                drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId ? [localDaemonId] : [],
+                "generating_no_idle_coordinator",
+                generatingCoordinators.length
+              );
+            }
           }
           continue;
         }
@@ -44923,16 +45063,14 @@ ${cleanBody}`;
         try {
           pendingEvents = drainPendingMeshCoordinatorEvents(
             meshId,
-            drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId,
-            forceOnly ? { onlyEvents: MESH_FORCE_INJECT_EVENTS } : void 0
+            drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId
           );
         } catch (e) {
           LOG2.warn("MeshReconcile", `Drain failed for mesh ${meshId}: ${e?.message || e}`);
           continue;
         }
         if (pendingEvents.length === 0) continue;
-        const mode = forceOnly ? "force-drain \u2192 generating" : "inject \u2192 idle";
-        LOG2.info("MeshReconcile", `Reconcile ${mode}: ${pendingEvents.length} pending event(s) \u2192 ${targetCoordinators.length} coordinator(s) for mesh ${meshId}`);
+        LOG2.info("MeshReconcile", `Reconcile inject \u2192 idle: ${pendingEvents.length} pending event(s) \u2192 ${targetCoordinators.length} coordinator(s) for mesh ${meshId}`);
         for (const pending of pendingEvents) {
           const wantSession = readNonEmptyString2(pending.targetCoordinatorSessionId);
           if (wantSession) {
@@ -53138,98 +53276,7 @@ ${lastSnapshot}`;
     init_mesh_work_queue();
     init_mesh_active_work();
     init_mesh_refine_status();
-    init_repo_mesh_types();
-    init_dist();
-    function isReadonly(task) {
-      return task.taskMode === "live_debug_readonly";
-    }
-    function isAssigned(task) {
-      return task.status === "assigned";
-    }
-    function buildMeshSchedulingRuntime(mesh, queue) {
-      const strategy = normalizeMeshSchedulingStrategy(mesh?.policy?.schedulingStrategy);
-      const maxParallelTasks = resolveMaxParallelTasks(mesh?.policy?.maxParallelTasks);
-      const maxReadonlyParallelTasks = Math.max(2, maxParallelTasks * 2);
-      const assignedTasks = (Array.isArray(queue) ? queue : []).filter(isAssigned);
-      const activeWriteAssigned = assignedTasks.filter((t) => !isReadonly(t)).length;
-      const activeReadonlyAssigned = assignedTasks.filter(isReadonly).length;
-      const globalWriteCapReached = activeWriteAssigned >= maxParallelTasks;
-      const globalReadonlyCapReached = activeReadonlyAssigned >= maxReadonlyParallelTasks;
-      const writeAssignedByNode = /* @__PURE__ */ new Map();
-      const assignedByNode = /* @__PURE__ */ new Map();
-      const providerCountByNode = /* @__PURE__ */ new Map();
-      for (const task of assignedTasks) {
-        const nodeId = typeof task.assignedNodeId === "string" ? task.assignedNodeId.trim() : "";
-        if (!nodeId) continue;
-        assignedByNode.set(nodeId, (assignedByNode.get(nodeId) ?? 0) + 1);
-        if (!isReadonly(task)) {
-          writeAssignedByNode.set(nodeId, (writeAssignedByNode.get(nodeId) ?? 0) + 1);
-        }
-        const provider = typeof task.assignedProviderType === "string" ? task.assignedProviderType : "";
-        if (provider) {
-          let byProvider = providerCountByNode.get(nodeId);
-          if (!byProvider) {
-            byProvider = /* @__PURE__ */ new Map();
-            providerCountByNode.set(nodeId, byProvider);
-          }
-          byProvider.set(provider, (byProvider.get(provider) ?? 0) + 1);
-        }
-      }
-      const nodes = [];
-      for (const rawNode of Array.isArray(mesh?.nodes) ? mesh.nodes : []) {
-        const nodeId = normalizeMeshNodeId(rawNode);
-        if (!nodeId) continue;
-        const policy = rawNode?.policy || void 0;
-        const load4 = assignedByNode.get(nodeId) ?? 0;
-        const schedulingPriority = resolveNodeSchedulingPriority(policy);
-        const capReasons = [];
-        if (globalWriteCapReached) capReasons.push("global_max_parallel_tasks_reached");
-        if ((writeAssignedByNode.get(nodeId) ?? 0) > 0) capReasons.push("node_has_active_assignment");
-        let providerRoles;
-        const declaredRoles = Array.isArray(policy?.providerRoles) ? policy.providerRoles : [];
-        if (declaredRoles.length) {
-          const byProvider = providerCountByNode.get(nodeId);
-          providerRoles = [];
-          for (const role of declaredRoles) {
-            if (!role || typeof role !== "object") continue;
-            const providerType = typeof role.providerType === "string" ? role.providerType.trim() : "";
-            if (!providerType) continue;
-            const maxParallel = resolveProviderMaxParallel(policy, providerType);
-            const activeAssigned = byProvider?.get(providerType) ?? 0;
-            const capReached = maxParallel !== void 0 && activeAssigned >= maxParallel;
-            providerRoles.push({
-              providerType,
-              ...maxParallel !== void 0 ? { maxParallel } : {},
-              activeAssigned,
-              capReached
-            });
-            if (capReached) capReasons.push(`max_provider_parallel_reached:${providerType}`);
-          }
-          if (!providerRoles.length) providerRoles = void 0;
-        }
-        const maxConcurrentSessions = Number(policy?.maxConcurrentSessions);
-        const hasSessionCap = Number.isFinite(maxConcurrentSessions) && maxConcurrentSessions >= 0;
-        nodes.push({
-          nodeId,
-          load: load4,
-          schedulingPriority,
-          ...hasSessionCap ? { maxConcurrentSessions: Math.floor(maxConcurrentSessions) } : {},
-          ...providerRoles ? { providerRoles } : {},
-          capReached: capReasons.length > 0,
-          capReasons
-        });
-      }
-      return {
-        strategy,
-        maxParallelTasks,
-        maxReadonlyParallelTasks,
-        activeWriteAssigned,
-        activeReadonlyAssigned,
-        globalWriteCapReached,
-        globalReadonlyCapReached,
-        nodes
-      };
-    }
+    init_mesh_scheduling_runtime();
     init_mesh_host_ownership();
     init_mesh_events();
     init_mesh_events_utils();
@@ -68844,9 +68891,35 @@ ${body}
        * terminal state. Leaving meshNodeFor pinned would route this session's
        * subsequent unrelated turns (e.g. ad-hoc dashboard chats) to the
        * coordinator as if they were task completions.
+       *
+       * MESHID-DROP-ON-DETACH (Fix C): a coordinator-LAUNCHED worker session
+       * (launchedByCoordinator) holds its mesh membership (meshNodeFor / meshNodeId /
+       * meshCoordinatorDaemonId) at the SESSION level — set once at launch
+       * (mesh_launch_session / queue auto-launch), independent of any single task.
+       * The original detach wiped meshNodeFor + meshNodeId together with the
+       * task-level meshActiveTaskId, so the FIRST task completion stripped the
+       * membership and EVERY subsequent completion forwarded with meshId absent —
+       * resolveWorkerDelegateRouting fell to mesh_unresolved and the coordinator
+       * rejected the forward "meshId required". For a launched member we therefore
+       * clear ONLY the task-level marker (meshActiveTaskId) and preserve the
+       * session-level membership so its next task's completion still resolves.
+       * A task-less ad-hoc turn on a preserved-membership session is NOT misrouted:
+       * its completion carries no taskId and the session holds no active assignment,
+       * so the forwarder's WARMUPGAP guard skips the dispatch-row flip (it only
+       * injects a benign task-less notification). A NON-launched session (a plain CLI
+       * session adopted by mesh_send_task --direct, launchedByCoordinator falsy)
+       * keeps the original full clear so an ad-hoc session is never left pinned.
        */
       detachMeshAssignment() {
         if (!this.settings.meshNodeFor && !this.settings.meshActiveTaskId && !this.settings.meshNodeId) return;
+        if (this.settings.launchedByCoordinator === true) {
+          if (!this.settings.meshActiveTaskId) return;
+          const { meshActiveTaskId: meshActiveTaskId2, ...rest2 } = this.settings;
+          void meshActiveTaskId2;
+          this.settings = rest2;
+          this.adapter.updateRuntimeSettings?.(this.settings);
+          return;
+        }
         const { meshNodeFor, meshNodeId, meshActiveTaskId, ...rest } = this.settings;
         void meshNodeFor;
         void meshActiveTaskId;
@@ -78651,6 +78724,9 @@ ${ptyResult.output.slice(-2e3)}`);
           const { getMeshQueueStats: getMeshQueueStats2, getQueue: getQueue2 } = await Promise.resolve().then(() => (init_mesh_work_queue(), mesh_work_queue_exports));
           const queue = getQueue2(meshId);
           const queueSummary = getMeshQueueStats2(meshId);
+          const { buildMeshSchedulingRuntime: buildMeshSchedulingRuntime2 } = await Promise.resolve().then(() => (init_mesh_scheduling_runtime(), mesh_scheduling_runtime_exports));
+          const schedulingRuntime = buildMeshSchedulingRuntime2(mesh, queue);
+          const schedulingByNode = new Map(schedulingRuntime.nodes.map((n) => [n.nodeId, n]));
           const { readLedgerEntries: readLedgerEntries2, getLedgerSummary: getLedgerSummary2 } = await Promise.resolve().then(() => (init_mesh_ledger(), mesh_ledger_exports));
           const ledgerEntries = readLedgerEntries2(meshId, { tail: 20 });
           const asyncRefineLedgerEntries = readLedgerEntries2(meshId, { tail: 100 });
@@ -78765,6 +78841,11 @@ ${ptyResult.output.slice(-2e3)}`);
               activeSessionDetails: [],
               launchReady: false
             };
+            const nodeScheduling = schedulingByNode.get(nodeId);
+            if (nodeScheduling) {
+              const { nodeId: _omitNodeId, ...nodeSchedulingRest } = nodeScheduling;
+              status.scheduling = nodeSchedulingRest;
+            }
             if (isSelfNode) {
               status.connection = {
                 perspective: "selected_coordinator",
@@ -78965,6 +79046,19 @@ ${ptyResult.output.slice(-2e3)}`);
             branchConvergenceSummary: summarizeInlineMeshBranchConvergence(nodeStatuses),
             ...previewFreshness ? { previewFreshness, deployFreshness: previewFreshness } : {},
             nodes: nodeStatuses,
+            // Mesh-level scheduling rollup (strategy + global cap consumption). Mirrors
+            // the MCP `mesh_status` tool's `scheduling` block field-for-field so both
+            // surfaces read the same runtime; per-node detail lives on each
+            // nodes[].scheduling above.
+            scheduling: {
+              strategy: schedulingRuntime.strategy,
+              maxParallelTasks: schedulingRuntime.maxParallelTasks,
+              maxReadonlyParallelTasks: schedulingRuntime.maxReadonlyParallelTasks,
+              activeWriteAssigned: schedulingRuntime.activeWriteAssigned,
+              activeReadonlyAssigned: schedulingRuntime.activeReadonlyAssigned,
+              globalWriteCapReached: schedulingRuntime.globalWriteCapReached,
+              globalReadonlyCapReached: schedulingRuntime.globalReadonlyCapReached
+            },
             queue: { tasks: queue, summary: queueSummary },
             ledger: { entries: ledgerEntries, summary: ledgerSummary },
             ...missions.length > 0 ? { missions } : {},
@@ -81889,17 +81983,40 @@ ${mergeTreeErr?.stderr || ""}`;
        * the wider plural-shape scan so a controlbar/modal command targeting a non-primary remote
        * session still resolves its owner — the singular readCachedInlineMeshActiveSessions semantics
        * other consumers depend on stay untouched.
+       *
+       * CANCEL-STOP-RELAY: the session-id cache scan above only matches when the coordinator's
+       * cached status snapshot already lists the worker's session id in a recognized active-sessions
+       * shape. A worktree-clone worker session whose id form/timing differs from the cached snapshot
+       * (or is simply not yet reflected) misses the scan, so a stop that carries the authoritative
+       * owning nodeId (mesh_queue_cancel knows assignedNodeId) used to silently fail to forward.
+       * `ownerNodeIdHint` adds a deterministic fallback: when the session-id scan misses, resolve the
+       * owner daemonId by matching the node by id (meshNodeIdMatches — same form-tolerant compare the
+       * rest of the router uses, no new raw compare). The same self-loopback guard applies to both
+       * paths, so a coordinator-hosted node is still never force-forwarded to a remote form of itself.
        */
-      resolveRemoteMeshSessionOwnerDaemonId(sessionId) {
+      resolveRemoteMeshSessionOwnerDaemonId(sessionId, ownerNodeIdHint) {
         const trimmed = typeof sessionId === "string" ? sessionId.trim() : "";
-        if (!trimmed) return void 0;
+        const nodeHint = typeof ownerNodeIdHint === "string" ? ownerNodeIdHint.trim() : "";
+        if (!trimmed && !nodeHint) return void 0;
         const selfDaemonId = this.deps.statusInstanceId;
-        for (const node of this.collectMeshSessionOwnerCandidateNodes()) {
-          if (!collectMeshNodeHostedSessionIds(node).has(trimmed)) continue;
-          const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
-          if (!nodeDaemonId) continue;
-          if (selfDaemonId && daemonIdsEquivalent(nodeDaemonId, selfDaemonId)) return void 0;
-          return nodeDaemonId;
+        const candidates = this.collectMeshSessionOwnerCandidateNodes();
+        if (trimmed) {
+          for (const node of candidates) {
+            if (!collectMeshNodeHostedSessionIds(node).has(trimmed)) continue;
+            const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
+            if (!nodeDaemonId) continue;
+            if (selfDaemonId && daemonIdsEquivalent(nodeDaemonId, selfDaemonId)) return void 0;
+            return nodeDaemonId;
+          }
+        }
+        if (nodeHint) {
+          for (const node of candidates) {
+            if (!meshNodeIdMatches(node, nodeHint)) continue;
+            const nodeDaemonId = readMeshNodeDaemonId(readObjectRecord(node));
+            if (!nodeDaemonId) continue;
+            if (selfDaemonId && daemonIdsEquivalent(nodeDaemonId, selfDaemonId)) return void 0;
+            return nodeDaemonId;
+          }
         }
         return void 0;
       }
@@ -84033,7 +84150,9 @@ ${hintLines.join("\n")}` : "",
             const localInstance = this.deps.instanceManager?.getInstance(targetSessionId);
             const localRegistry = this.deps.sessionRegistry?.get?.(targetSessionId);
             if (!localInstance && !localRegistry) {
-              const ownerDaemonId = this.resolveRemoteMeshSessionOwnerDaemonId(targetSessionId);
+              const meshContext = readObjectRecord(args?.meshContext);
+              const ownerNodeIdHint = readStringValue(meshContext.nodeId);
+              const ownerDaemonId = this.resolveRemoteMeshSessionOwnerDaemonId(targetSessionId, ownerNodeIdHint);
               if (ownerDaemonId) {
                 LOG2.info("Mesh", `[Mesh] Forwarding session-scoped '${cmd}' for remote worker session ${targetSessionId.split("_")[0]} \u2192 daemon ${ownerDaemonId.slice(0, 12)}`);
                 const forwarded = await this.deps.dispatchMeshCommand(ownerDaemonId, cmd, {