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

package/dist/commands/router.d.ts

@@ -156,8 +156,18 @@ export declare class DaemonCommandRouter {
      * 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: string): string | undefined;
+    resolveRemoteMeshSessionOwnerDaemonId(sessionId: string, ownerNodeIdHint?: string): string | undefined;
     /**
      * Candidate nodes for remote-session owner resolution: the cached inline-mesh nodes (which
      * carry each node's primary session) plus the nodes from every cached aggregate mesh-status

package/dist/index.js

@@ -383,10 +383,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "18afac213951f79c502feb6b25b7399fe4d709b3" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "18afac21" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:44:40.598Z" : 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 version = 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:14:41.579Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -8581,6 +8581,109 @@ var init_mesh_active_work = __esm({
   }
 });
 
+// src/mesh/mesh-scheduling-runtime.ts
+var mesh_scheduling_runtime_exports = {};
+__export(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 = __esm({
+  "src/mesh/mesh-scheduling-runtime.ts"() {
+    "use strict";
+    init_repo_mesh_types();
+    init_dist();
+  }
+});
+
 // src/mesh/mesh-events-utils.ts
 function readNonEmptyString2(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
@@ -13810,6 +13913,20 @@ function recoverMeshIdByNodeId(nodeId) {
   }
   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;
@@ -14556,7 +14673,10 @@ function handleMeshForwardEvent(components, payload) {
   }
   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,
@@ -14611,7 +14731,12 @@ function forwardUnresolvedDelegateEvent(components, routing, event) {
     ...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;
@@ -14740,6 +14865,7 @@ var init_mesh_event_forwarding = __esm({
     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();
@@ -15031,8 +15157,7 @@ async function runMeshReconcileTick(components) {
     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(
@@ -15099,6 +15224,23 @@ async function runMeshReconcileTick(components) {
             modalParkedCoordinators.length
           );
         }
+      } else if (generatingCoordinators.length > 0) {
+        let hasPending = true;
+        if (store) {
+          try {
+            hasPending = store.pendingEventCount(meshId) > 0;
+          } catch {
+          }
+        }
+        if (hasPending) {
+          LOG.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;
     }
@@ -15112,16 +15254,14 @@ async function runMeshReconcileTick(components) {
     try {
       pendingEvents = drainPendingMeshCoordinatorEvents(
         meshId,
-        drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId,
-        forceOnly ? { onlyEvents: MESH_FORCE_INJECT_EVENTS } : void 0
+        drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId
       );
     } catch (e) {
       LOG.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";
-    LOG.info("MeshReconcile", `Reconcile ${mode}: ${pendingEvents.length} pending event(s) \u2192 ${targetCoordinators.length} coordinator(s) for mesh ${meshId}`);
+    LOG.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) {
@@ -23355,102 +23495,7 @@ function buildMeshLedgerReconciliationEvidence(meshId, replicas) {
 init_mesh_work_queue();
 init_mesh_active_work();
 init_mesh_refine_status();
-
-// src/mesh/mesh-scheduling-runtime.ts
-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
-  };
-}
-
-// src/index.ts
+init_mesh_scheduling_runtime();
 init_mesh_host_ownership();
 init_mesh_events();
 init_mesh_events_utils();
@@ -39233,9 +39278,35 @@ var CliProviderInstance = class _CliProviderInstance {
    * 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;
@@ -49104,6 +49175,9 @@ var meshStatusHandlers = {
       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 });
@@ -49218,6 +49292,11 @@ var meshStatusHandlers = {
           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",
@@ -49418,6 +49497,19 @@ var meshStatusHandlers = {
         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 } : {},
@@ -52362,17 +52454,40 @@ var DaemonCommandRouter = class {
    * 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;
   }
@@ -54506,7 +54621,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) {
             LOG.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, {