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

package/dist/index.mjs

@@ -311,10 +311,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "c2224ab0c9d05e85b4cbf88e4fc696f3733ec397" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "c2224ab0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = 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:22:36.214Z" : 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 version = 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:14:32.255Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -2897,6 +2897,16 @@ function meshNodeIdMatches(node, candidateId) {
   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;
@@ -12852,21 +12862,29 @@ function deliverTaskToSession(dispatchThunk, ctx) {
     }
   });
 }
-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) {
-      LOG.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)) {
+      LOG.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)) {
+    LOG.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);
@@ -13707,7 +13725,10 @@ function injectMeshSystemMessage(components, args) {
     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);
@@ -14141,6 +14162,25 @@ function handleMeshForwardEvent(components, payload) {
     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;
@@ -14153,6 +14193,16 @@ function forwardUnresolvedDelegateEvent(components, routing, event) {
     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);
+      LOG.info("MeshEvents", `Self-addressed unresolved-delegate ${eventName} routed via local router (coordinator ${coordinatorDaemonId} is self) \u2014 outbox skipped`);
+    } catch (e) {
+      LOG.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,
@@ -14162,7 +14212,8 @@ function forwardUnresolvedDelegateEvent(components, routing, event) {
   };
   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) {
       LOG.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");
@@ -14171,7 +14222,7 @@ function forwardUnresolvedDelegateEvent(components, routing, event) {
     if (persisted) ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventName, payload);
   }).catch((e) => {
     LOG.warn("MeshEvents", `Immediate forward of ${eventName} to coordinator ${coordinatorDaemonId} failed: ${e?.message || e} \u2014 left queued for retry`);
-  });
+  }));
   LOG.info("MeshEvents", `Durably forwarded ${eventName} for unresolved-mesh worker at ${routing.workspace || "(no workspace)"} to coordinator daemon ${coordinatorDaemonId}`);
   return true;
 }
@@ -14254,7 +14305,7 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, DISPATCH_CONFIRM_TIMEOUT_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, MESH_FORCE_INJECT_EVENTS;
+var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, IDLE_AUTO_FAST_FORWARD_THROTTLE_MS, idleAutoFastForwardLastAttempt, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, DISPATCH_CONFIRM_TIMEOUT_MS, autoLaunchInProgress, autoLaunchCooldownUntil, AUTO_LAUNCH_COOLDOWN_MS, AUTO_LAUNCH_AWAIT_CLAIM_MS, lastAutoLaunchLedgerKey, AUTO_LAUNCH_LEDGER_DEDUP_MAX, MESH_COORDINATOR_EVENTS, EVENT_TO_LEDGER_KIND, MESH_FORCE_INJECT_EVENTS, coordinatorForwardLanes;
 var init_mesh_events_coordinator = __esm({
   "src/mesh/mesh-events-coordinator.ts"() {
     "use strict";
@@ -14318,6 +14369,7 @@ var init_mesh_events_coordinator = __esm({
       "worktree_bootstrap_complete",
       "worktree_bootstrap_failed"
     ]);
+    coordinatorForwardLanes = /* @__PURE__ */ new Map();
   }
 });
 
@@ -14660,6 +14712,8 @@ async function retryUnresolvedDelegateForwards(components) {
   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,
@@ -14667,6 +14721,23 @@ async function retryUnresolvedDelegateForwards(components) {
       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) {
+        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);
+      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");
+      } else {
+        LOG.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}`);
@@ -27858,6 +27929,7 @@ var CHAT_SOURCE_REGISTRY = new ChatSourceRegistry();
 
 // src/commands/chat-commands.ts
 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;
@@ -28419,6 +28491,24 @@ function normalizeComparableWorkspace(value) {
   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;
@@ -29233,6 +29323,24 @@ async function handleChatHistory(h, args) {
   }
 }
 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) {
+        LOG.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() : "";
@@ -29621,10 +29729,19 @@ async function handleReadChat(h, args) {
         ptyStatusApprovalOnly: false
       });
       if (supportsNative && !decision.nativeSelected) {
+        LOG.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
@@ -41089,6 +41206,18 @@ var DaemonCliManager = class {
       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 ──────────────────────────────
@@ -49129,6 +49258,7 @@ function readMeshTimeoutEnvMs(name, defaultMs) {
 }
 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) {
@@ -49166,12 +49296,73 @@ var MeshGitProbeCache = class {
     }
   }
 };
+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);
@@ -49206,7 +49397,9 @@ async function probeRemoteMeshGitStatusWithRetry(args) {
         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 {
@@ -49289,6 +49482,7 @@ async function hydrateInlineMeshDirectTruth(args) {
       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();
@@ -49340,13 +49534,13 @@ function liveSessionRecordMatchesMeshNode(record, meshId, nodeId, nodeWorkspace
   if (!recordNodeId || recordNodeId !== nodeId) return false;
   if (nodeIsMissingLocalWorktree) return false;
   const recordWorkspace = readStringValue(record?.workspace);
-  if (nodeWorkspace && recordWorkspace && recordWorkspace !== nodeWorkspace) return false;
+  if (nodeWorkspace && recordWorkspace && !meshWorkspacesEquivalent(recordWorkspace, nodeWorkspace)) return false;
   const recordMeshId = readStringValue(record?.meta?.meshNodeFor);
   return !recordMeshId || recordMeshId === meshId;
 }
 function liveSessionRecordMatchesMeshWorkspace(record, meshId, workspace) {
   const recordWorkspace = readStringValue(record?.workspace);
-  if (!recordWorkspace || !workspace || recordWorkspace !== workspace) return false;
+  if (!recordWorkspace || !workspace || !meshWorkspacesEquivalent(recordWorkspace, workspace)) return false;
   const recordMeshId = readStringValue(record?.meta?.meshNodeFor);
   if (recordMeshId) return recordMeshId === meshId;
   return record?.meta?.launchedByCoordinator === true || !!readStringValue(record?.meta?.meshNodeId);