@adhdev/daemon-standalone 0.9.82-rc.366 → 0.9.82-rc.368

package/dist/index.js

@@ -30036,10 +30036,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "c2224ab0c9d05e85b4cbf88e4fc696f3733ec397" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "c2224ab0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "0.9.82-rc.366" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-06-24T02:23:02.144Z" : void 0);
+      const commit = readInjected(true ? "8cb6cfc5399f55c6b625095bacc9a27e1741df17" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "8cb6cfc5" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "0.9.82-rc.368" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-06-24T06:15:00.243Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -32634,6 +32634,16 @@ ${error48.message || ""}`;
       if (!trimmed) return false;
       return normalizeMeshNodeId(node) === trimmed;
     }
+    function normalizeMeshWorkspaceForCompare(dir) {
+      if (typeof dir !== "string") return "";
+      return dir.trim().replace(/[\\/]+/g, "/").replace(/\/+$/, "").toLowerCase();
+    }
+    function meshWorkspacesEquivalent(a, b) {
+      const left = normalizeMeshWorkspaceForCompare(a);
+      const right = normalizeMeshWorkspaceForCompare(b);
+      if (!left || !right) return false;
+      return left === right;
+    }
     function machineCoreFromDaemonId(id) {
       const trimmed = readString3(id);
       if (!trimmed) return void 0;
@@ -42642,21 +42652,29 @@ ${cleanBody}`;
         }
       });
     }
-    function normalizeMeshWorkspaceForCompare(dir) {
-      if (typeof dir !== "string") return "";
-      return dir.trim().replace(/[\\/]+/g, "/").replace(/\/+$/, "").toLowerCase();
-    }
     function tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType) {
       const mesh = getMeshWithCache(components, meshId);
       const node = mesh?.nodes.find((n) => readMeshNodeId(n) === nodeId);
       const localClaimAdapter = components.cliManager?.adapters?.get(sessionId);
-      if (localClaimAdapter) {
-        const sessionWorkspace = normalizeMeshWorkspaceForCompare(localClaimAdapter.workingDir);
-        const nodeWorkspace = normalizeMeshWorkspaceForCompare(readNonEmptyString2(node?.workspace));
-        if (sessionWorkspace && nodeWorkspace && sessionWorkspace !== nodeWorkspace) {
-          LOG2.info("MeshQueue", `WTCLAIM: refusing claim for node ${nodeId} (${sessionId}) \u2014 session workspace "${sessionWorkspace}" \u2260 node workspace "${nodeWorkspace}" (cross-workspace dispatch blocked)`);
+      let claimInstanceWorkspace = "";
+      let claimStampedNodeId = "";
+      try {
+        const claimState = components.instanceManager?.getInstance?.(sessionId)?.getState?.();
+        claimInstanceWorkspace = readNonEmptyString2(claimState?.workspace);
+        const claimSettings = claimState?.settings || {};
+        claimStampedNodeId = readNonEmptyString2(claimSettings.meshNodeId);
+      } catch {
+      }
+      const nodeWorkspaceRaw = readNonEmptyString2(node?.workspace);
+      const sessionWorkspaceRaw = readNonEmptyString2(localClaimAdapter?.workingDir) || claimInstanceWorkspace;
+      if (claimStampedNodeId && nodeId) {
+        if (!meshNodeIdMatches({ id: claimStampedNodeId }, nodeId)) {
+          LOG2.info("MeshQueue", `WTDISPATCH: refusing claim for node ${nodeId} (${sessionId}) \u2014 session is bound to node "${claimStampedNodeId}" (cross-node claim blocked)`);
           return false;
         }
+      } else if (sessionWorkspaceRaw && nodeWorkspaceRaw && !meshWorkspacesEquivalent(sessionWorkspaceRaw, nodeWorkspaceRaw)) {
+        LOG2.info("MeshQueue", `WTCLAIM: refusing claim for node ${nodeId} (${sessionId}) \u2014 session workspace "${normalizeMeshWorkspaceForCompare(sessionWorkspaceRaw)}" \u2260 node workspace "${normalizeMeshWorkspaceForCompare(nodeWorkspaceRaw)}" (cross-workspace dispatch blocked)`);
+        return false;
       }
       const capabilityTags = buildMeshNodeCapabilityTags(node, providerType);
       const providerMaxParallel = resolveProviderMaxParallel(node?.policy, providerType);
@@ -43497,7 +43515,10 @@ ${cleanBody}`;
         if (terminal?.kind === "task_completed" && !sessionHasActiveAssignment(args.meshId, eventSessionId)) {
           const newDispatchAfterTerminal = hasDispatchAfterTerminal(args.meshId, eventSessionId, terminal.id);
           const supersedesWeakTerminal = isWeakTerminalLedgerPayload(terminal.payload) && isGenuineCompletionEvidence(args.metadataEvent);
-          if (!newDispatchAfterTerminal && !supersedesWeakTerminal) {
+          const terminalTaskId = readNonEmptyString2(terminal.payload.taskId);
+          const eventTaskId = readNonEmptyString2(args.metadataEvent.taskId);
+          const distinctTaskCompletion = !!eventTaskId && !!terminalTaskId && eventTaskId !== terminalTaskId;
+          if (!newDispatchAfterTerminal && !supersedesWeakTerminal && !distinctTaskCompletion) {
             const terminalProviderSessionId = readNonEmptyString2(terminal.payload.providerSessionId);
             const terminalFinalSummary = readNonEmptyString2(terminal.payload.finalSummary);
             const eventProviderSessionId = readNonEmptyString2(args.metadataEvent.providerSessionId);
@@ -43931,6 +43952,25 @@ ${cleanBody}`;
         metadataEvent: buildRelayMetadataEvent(payload)
       });
     }
+    function enqueueCoordinatorForwardPush(coordinatorDaemonId, run) {
+      let lane = coordinatorForwardLanes.get(coordinatorDaemonId);
+      if (!lane) {
+        lane = { tail: Promise.resolve(), depth: 0 };
+        coordinatorForwardLanes.set(coordinatorDaemonId, lane);
+      }
+      const wasIdle = lane.depth === 0;
+      lane.depth += 1;
+      const dec = () => {
+        lane.depth -= 1;
+      };
+      if (wasIdle) {
+        lane.tail = Promise.resolve(run()).catch(() => {
+        }).then(dec, dec);
+      } else {
+        lane.tail = lane.tail.then(() => run()).catch(() => {
+        }).then(dec, dec);
+      }
+    }
     function forwardUnresolvedDelegateEvent(components, routing, event) {
       const coordinatorDaemonId = readNonEmptyString2(routing.coordinatorDaemonId);
       if (!coordinatorDaemonId) return false;
@@ -43943,6 +43983,16 @@ ${cleanBody}`;
         nodeId: readNonEmptyString2(routing.nodeId) || readNonEmptyString2(event.meshNodeId) || void 0,
         workspace: readNonEmptyString2(routing.workspace) || readNonEmptyString2(event.workspace) || void 0
       };
+      const selfDaemonIds = resolveCoordinatorDrainDaemonIds(components);
+      if (selfDaemonIds.some((self) => daemonIdsEquivalent(self, coordinatorDaemonId))) {
+        try {
+          handleMeshForwardEvent(components, payload);
+          LOG2.info("MeshEvents", `Self-addressed unresolved-delegate ${eventName} routed via local router (coordinator ${coordinatorDaemonId} is self) \u2014 outbox skipped`);
+        } catch (e) {
+          LOG2.warn("MeshEvents", `Local route of self-addressed unresolved-delegate ${eventName} failed: ${e?.message || e}`);
+        }
+        return true;
+      }
       const persisted = enqueueUnresolvedDelegateForward(coordinatorDaemonId, eventName, payload);
       const fwdTraceCtx = {
         taskId: payload.taskId,
@@ -43952,7 +44002,8 @@ ${cleanBody}`;
       };
       traceMeshEventStage("outbox_enqueue", fwdTraceCtx, `coordinatorDaemon=${coordinatorDaemonId} meshId=absent`);
       traceMeshEventStage("forward_send", fwdTraceCtx, "immediate push");
-      Promise.resolve(components.dispatchMeshCommand(coordinatorDaemonId, "mesh_forward_event", payload)).then((result) => {
+      const dispatchMeshCommand = components.dispatchMeshCommand;
+      enqueueCoordinatorForwardPush(coordinatorDaemonId, () => Promise.resolve(dispatchMeshCommand(coordinatorDaemonId, "mesh_forward_event", payload)).then((result) => {
         if (result && result.success === false) {
           LOG2.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} rejected (${readNonEmptyString2(result.error) || "no reason"}) \u2014 left queued for retry`);
           traceMeshEventDrop("immediate_forward_rejected", fwdTraceCtx, readNonEmptyString2(result.error) || "no reason");
@@ -43961,7 +44012,7 @@ ${cleanBody}`;
         if (persisted) ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventName, payload);
       }).catch((e) => {
         LOG2.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued for retry`);
-      });
+      }));
       LOG2.info("MeshEvents", `Durably forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId}`);
       return true;
     }
@@ -44062,6 +44113,7 @@ ${cleanBody}`;
     var MESH_COORDINATOR_EVENTS;
     var EVENT_TO_LEDGER_KIND;
     var MESH_FORCE_INJECT_EVENTS;
+    var coordinatorForwardLanes;
     var init_mesh_events_coordinator = __esm2({
       "src/mesh/mesh-events-coordinator.ts"() {
         "use strict";
@@ -44126,6 +44178,7 @@ ${cleanBody}`;
           "worktree_bootstrap_complete",
           "worktree_bootstrap_failed"
         ]);
+        coordinatorForwardLanes = /* @__PURE__ */ new Map();
       }
     });
     function resolveAutoPruneMinAgeMs() {
@@ -44466,6 +44519,8 @@ ${cleanBody}`;
       expireStaleUnresolvedDelegateForwards();
       const entries = peekUnresolvedDelegateForwards();
       if (entries.length === 0) return;
+      const selfIds = resolveCoordinatorDaemonIds(components);
+      const isSelfCoordinatorId = (id) => selfIds.some((self) => daemonIdsEquivalent(self, id));
       for (const entry of entries) {
         const entryTraceCtx = {
           taskId: entry.payload.taskId,
@@ -44473,6 +44528,23 @@ ${cleanBody}`;
           nodeId: readNonEmptyString2(entry.payload.nodeId),
           event: readNonEmptyString2(entry.payload.event)
         };
+        if (isSelfCoordinatorId(entry.coordinatorDaemonId)) {
+          let localResult;
+          try {
+            traceMeshEventStage("forward_send", entryTraceCtx, `self \u2192 local router (${entry.coordinatorDaemonId})`);
+            localResult = handleMeshForwardEvent(components, entry.payload);
+          } catch (e) {
+            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);
+          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");
+          } else {
+            LOG2.info("MeshReconcile", `Self-addressed unresolved-delegate ${readNonEmptyString2(entry.payload.event)} routed via local router (coordinator ${entry.coordinatorDaemonId} is self) \u2014 drained`);
+          }
+          continue;
+        }
         let result;
         try {
           traceMeshEventStage("forward_send", entryTraceCtx, `retry \u2192 ${entry.coordinatorDaemonId}`);
@@ -57924,6 +57996,7 @@ ${effect.notification.body || ""}`.trim();
     }
     var CHAT_SOURCE_REGISTRY = new ChatSourceRegistry();
     init_chat_message_normalization();
+    init_dist();
     var RECENT_SEND_WINDOW_MS = 1200;
     var READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25e3;
     var HOT_TAIL_MIN_LIMIT = 60;
@@ -58485,6 +58558,24 @@ ${effect.notification.body || ""}`.trim();
       if (!text) return "";
       return path16.resolve(text);
     }
+    function evaluateReadChatNodeWorkspaceScope(args) {
+      const targetSessionId = typeof args.targetSessionId === "string" ? args.targetSessionId.trim() : "";
+      if (!targetSessionId) return { scoped: false };
+      const intended = normalizeMeshWorkspaceForCompare(args.intendedWorkspace);
+      const actual = normalizeMeshWorkspaceForCompare(args.sessionWorkspace);
+      if (!intended || !actual) return { scoped: false };
+      if (intended === actual) return { scoped: false };
+      return { scoped: true, intended, actual };
+    }
+    function resolveTargetSessionActualWorkspace(h, targetSessionId) {
+      const registryWorkspace = h.ctx?.sessionRegistry?.get?.(targetSessionId)?.workspace;
+      if (typeof registryWorkspace === "string" && registryWorkspace.trim()) return registryWorkspace;
+      const adapter = h.getCliAdapter?.(targetSessionId);
+      if (adapter && typeof adapter.workingDir === "string" && adapter.workingDir.trim()) return adapter.workingDir;
+      const instanceWorkspace = getTargetInstance(h, { targetSessionId })?.getState?.()?.workspace;
+      if (typeof instanceWorkspace === "string" && instanceWorkspace.trim()) return instanceWorkspace;
+      return "";
+    }
     function isCurrentRuntimePtySafelyAttributed(args) {
       if (args.adapter.cliType !== "codex-cli") return false;
       if (!Array.isArray(args.ptyMessages) || args.ptyMessages.length === 0) return false;
@@ -59299,6 +59390,24 @@ ${effect.notification.body || ""}`.trim();
       }
     }
     async function handleReadChat(h, args) {
+      {
+        const guardSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
+        if (guardSessionId && typeof args?.workspace === "string" && args.workspace.trim()) {
+          const verdict = evaluateReadChatNodeWorkspaceScope({
+            targetSessionId: guardSessionId,
+            intendedWorkspace: args.workspace,
+            sessionWorkspace: resolveTargetSessionActualWorkspace(h, guardSessionId)
+          });
+          if (verdict.scoped) {
+            LOG2.info("Command", `[read_chat] node scope mismatch: session ${guardSessionId} workspace "${verdict.actual}" \u2260 requested node workspace "${verdict.intended}" \u2014 refusing cross-worktree transcript`);
+            return {
+              success: false,
+              code: "read_chat_session_node_scope_mismatch",
+              error: `Session ${guardSessionId} belongs to a different worktree (workspace "${verdict.actual}") than the requested node (workspace "${verdict.intended}"). Refusing to return a cross-worktree transcript \u2014 target the node that owns this session.`
+            };
+          }
+        }
+      }
       let providerHint = args?.agentType || args?.providerType;
       if (!providerHint) {
         const targetSessionId = typeof args?.targetSessionId === "string" ? args.targetSessionId.trim() : "";
@@ -59687,10 +59796,19 @@ ${effect.notification.body || ""}`.trim();
             ptyStatusApprovalOnly: false
           });
           if (supportsNative && !decision.nativeSelected) {
+            LOG2.debug("Command", `[read_chat] soft pending: no live adapter and native history not safely mappable target=${String(args?.targetSessionId || "")} provider=${agentStr} reason=native_history_not_safely_available`);
             return {
-              success: false,
+              success: true,
+              pending: true,
+              // Both signals are true here: we reached the history-only path
+              // because no live adapter was found (`live_adapter_not_found`),
+              // and native history is not safely mappable
+              // (`native_history_not_safely_available`).
+              reason: "native_history_not_safely_available",
+              reasons: ["live_adapter_not_found", "native_history_not_safely_available"],
               code: "native_history_not_safely_available",
-              error: "Provider-native history was not safely available for the requested CLI session.",
+              messages: [],
+              status: "idle",
               providerSessionId: historyProviderSessionId,
               messageSource: decision.messageSource,
               transcriptProvenance: decision.messageSource
@@ -71060,6 +71178,18 @@ ${rawInput}` : rawInput;
           throw new Error(`Failed to start ${provider.displayName || provider.name || cliType}: ${spawnErr?.message}`);
         }
         this.adapters.set(key, cliInstance.getAdapter());
+        const launchMeshNodeId = typeof settings?.meshNodeId === "string" ? settings.meshNodeId.trim() : "";
+        const launchMeshNodeFor = typeof settings?.meshNodeFor === "string" ? settings.meshNodeFor.trim() : "";
+        if (launchMeshNodeId || launchMeshNodeFor) {
+          try {
+            cliInstance.getAdapter().updateRuntimeMeta?.({
+              ...launchMeshNodeId ? { meshNodeId: launchMeshNodeId } : {},
+              ...launchMeshNodeFor ? { meshNodeFor: launchMeshNodeFor } : {},
+              ...settings?.launchedByCoordinator === true ? { launchedByCoordinator: true } : {}
+            });
+          } catch {
+          }
+        }
         this.startCliExitMonitor(key, cliType);
       }
       // ─── Session start/management ──────────────────────────────
@@ -79034,6 +79164,7 @@ ${ptyResult.output.slice(-2e3)}`);
     }
     var MESH_DIRECT_PROBE_TIMEOUT_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_TIMEOUT_MS", 25e3);
     var MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS", 25e3);
+    var MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS", 45e3);
     var MESH_DIRECT_PROBE_REUSE_MS = readMeshTimeoutEnvMs("MESH_DIRECT_PROBE_REUSE_MS", 12e3);
     var MeshGitProbeCache = class {
       constructor(reuseMs, now = Date.now) {
@@ -79071,12 +79202,73 @@ ${ptyResult.output.slice(-2e3)}`);
         }
       }
     };
+    function awaitWithWarmupDeadline(work, opts) {
+      const pollMs = Math.max(1, Math.min(opts.pollIntervalMs ?? 200, opts.connectTimeoutMs));
+      return new Promise((resolve24, reject) => {
+        let done = false;
+        let poll;
+        let responseTimer;
+        const startedAt = Date.now();
+        const cleanup = () => {
+          if (poll) {
+            clearInterval(poll);
+            poll = void 0;
+          }
+          if (responseTimer) {
+            clearTimeout(responseTimer);
+            responseTimer = void 0;
+          }
+        };
+        const settle = (fn) => {
+          if (done) return;
+          done = true;
+          cleanup();
+          fn();
+        };
+        const armResponse = () => {
+          if (responseTimer || done) return;
+          responseTimer = setTimeout(
+            () => settle(() => reject(new Error("timeout"))),
+            opts.responseTimeoutMs
+          );
+          if (typeof responseTimer.unref === "function") responseTimer.unref();
+        };
+        const onPoll = () => {
+          if (done) return;
+          if (opts.isConnected()) {
+            if (poll) {
+              clearInterval(poll);
+              poll = void 0;
+            }
+            armResponse();
+            return;
+          }
+          if (Date.now() - startedAt >= opts.connectTimeoutMs) {
+            settle(() => reject(new Error("timeout")));
+          }
+        };
+        if (opts.isConnected()) {
+          armResponse();
+        } else {
+          poll = setInterval(onPoll, pollMs);
+          if (typeof poll.unref === "function") poll.unref();
+        }
+        work.then(
+          (val) => settle(() => resolve24(val)),
+          (err) => settle(() => reject(err))
+        );
+      });
+    }
     async function probeRemoteMeshGitStatus(args) {
       if (!args.dispatchMeshCommand) return null;
-      const remoteResult = await Promise.race([
-        args.dispatchMeshCommand(args.daemonId, "git_status", { workspace: args.workspace, refreshUpstream: true }),
-        new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), args.timeoutMs))
-      ]);
+      const dispatch = args.dispatchMeshCommand(args.daemonId, "git_status", { workspace: args.workspace, refreshUpstream: true });
+      const getConnection = args.getConnection;
+      const isConnected = getConnection ? () => readMeshConnectionState(getConnection(args.daemonId)) === "connected" : () => true;
+      const remoteResult = await awaitWithWarmupDeadline(dispatch, {
+        isConnected,
+        connectTimeoutMs: args.connectTimeoutMs,
+        responseTimeoutMs: args.responseTimeoutMs
+      });
       const remoteGit = remoteResult?.status ?? remoteResult?.git ?? remoteResult;
       if (!remoteGit || typeof remoteGit !== "object" || typeof remoteGit.isGitRepo !== "boolean") return null;
       const reporterPlatform = readStringValue(remoteResult?.reporterPlatform);
@@ -79111,7 +79303,9 @@ ${ptyResult.output.slice(-2e3)}`);
             dispatchMeshCommand: args.dispatchMeshCommand,
             daemonId: args.daemonId,
             workspace: args.workspace,
-            timeoutMs: attempt === 0 ? args.timeoutMs : args.retryTimeoutMs ?? args.timeoutMs
+            responseTimeoutMs: attempt === 0 ? args.timeoutMs : args.retryTimeoutMs ?? args.timeoutMs,
+            connectTimeoutMs: args.connectTimeoutMs ?? MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS,
+            getConnection: args.getConnection
           });
           if (remoteGit) return remoteGit;
         } catch {
@@ -79194,6 +79388,7 @@ ${ptyResult.output.slice(-2e3)}`);
           workspace,
           timeoutMs: MESH_DIRECT_PROBE_TIMEOUT_MS,
           retryTimeoutMs: MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS,
+          connectTimeoutMs: MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS,
           getConnection: args.getMeshPeerConnectionStatus
         });
         const remoteGit = args.probeCache ? await args.probeCache.probe(daemonId, workspace, runProbe) : await runProbe();
@@ -79245,13 +79440,13 @@ ${ptyResult.output.slice(-2e3)}`);
       if (!recordNodeId || recordNodeId !== nodeId) return false;
       if (nodeIsMissingLocalWorktree) return false;
       const recordWorkspace = readStringValue(record2?.workspace);
-      if (nodeWorkspace && recordWorkspace && recordWorkspace !== nodeWorkspace) return false;
+      if (nodeWorkspace && recordWorkspace && !meshWorkspacesEquivalent(recordWorkspace, nodeWorkspace)) return false;
       const recordMeshId = readStringValue(record2?.meta?.meshNodeFor);
       return !recordMeshId || recordMeshId === meshId;
     }
     function liveSessionRecordMatchesMeshWorkspace(record2, meshId, workspace) {
       const recordWorkspace = readStringValue(record2?.workspace);
-      if (!recordWorkspace || !workspace || recordWorkspace !== workspace) return false;
+      if (!recordWorkspace || !workspace || !meshWorkspacesEquivalent(recordWorkspace, workspace)) return false;
       const recordMeshId = readStringValue(record2?.meta?.meshNodeFor);
       if (recordMeshId) return recordMeshId === meshId;
       return record2?.meta?.launchedByCoordinator === true || !!readStringValue(record2?.meta?.meshNodeId);