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

package/dist/commands/chat-commands.d.ts

@@ -6,6 +6,33 @@ import type { CommandResult, CommandHelpers } from './handler.js';
 import { type InputEnvelope } from '../providers/contracts.js';
 export declare const READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25000;
 export declare function buildSendInputSignature(input: InputEnvelope): string;
+/**
+ * read_chat node scope verdict. One physical daemon hosts a base node plus several
+ * worktree nodes; mesh_read_chat always dispatches read_chat with the requested
+ * node's workspace (`args.workspace`). When the resolved target session actually
+ * lives in a DIFFERENT worktree, returning its transcript — or worse, letting the
+ * native-history-by-workspace fallback splice sibling worktree turns into the
+ * reply — makes the coordinator believe one session received every worktree's
+ * work. This guard refuses a CONFIRMED cross-workspace read instead of mixing.
+ *
+ * Conservative by design (mirrors the WTCLAIM fix-B "unknown → allow" rule): only
+ * a session id that resolves to a known workspace which is unequal to a known
+ * intended workspace blocks. When either side is unknown — no targetSessionId, no
+ * args.workspace, an unregistered session, the coordinator self-session, or a
+ * plain dashboard read that never passes a node workspace — the read proceeds
+ * untouched, so base-node and same-daemon coordinator reads never regress.
+ */
+export declare function evaluateReadChatNodeWorkspaceScope(args: {
+    targetSessionId?: string;
+    intendedWorkspace?: string;
+    sessionWorkspace?: string;
+}): {
+    scoped: false;
+} | {
+    scoped: true;
+    intended: string;
+    actual: string;
+};
 interface DebugSanitizeOptions {
     maxDepth?: number;
     maxArrayLength?: number;

package/dist/commands/router.d.ts

@@ -86,6 +86,7 @@ export declare function finalizeMeshNodeStatus(args: {
 }): void;
 export declare const MESH_DIRECT_PROBE_TIMEOUT_MS: number;
 export declare const MESH_DIRECT_PROBE_RETRY_TIMEOUT_MS: number;
+export declare const MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS: number;
 /**
  * De-duplicates and rate-limits per-peer git_status probes so a single mesh
  * refresh — or a burst of refreshes from the dashboard auto-retry loop — cannot
@@ -116,6 +117,37 @@ export declare class MeshGitProbeCache {
      */
     probe(daemonId: string, workspace: string, probe: () => Promise<Record<string, unknown> | null>): Promise<Record<string, unknown> | null>;
 }
+/**
+ * Await `work` under a warmup-aware deadline so a cold-open DataChannel handshake
+ * is NOT charged against the command response budget — the root cause of the
+ * "first mesh probe to a cold peer false-times-out, the warm retry succeeds"
+ * signature. Two budgets, switched by the live peer connection state:
+ *
+ *  - While `isConnected()` returns false the peer's channel is still opening; the
+ *    cold-open `connectTimeoutMs` budget applies. This phase is deliberately
+ *    generous because a TURN-relayed cross-machine handshake legitimately needs
+ *    many seconds — but a genuine connect *failure* is surfaced by `work`
+ *    rejecting on its own (the mesh manager fails the peer the instant its
+ *    PeerConnection state goes terminal), so a real failure is never masked for
+ *    the whole window.
+ *  - The first time `isConnected()` returns true the channel is warm; from that
+ *    instant the tight `responseTimeoutMs` governs how long the handler may take.
+ *    Warm-channel callers therefore see behavior identical to the old single
+ *    `Promise.race(work, responseTimeoutMs)`.
+ *
+ * Rejects with `Error('timeout')` when either budget is exhausted, mirroring the
+ * previous single-race contract. Pure except for timers + the injected
+ * `isConnected` probe, so it is unit-testable under fake timers without any real
+ * WebRTC. When no connection getter is wired `isConnected` should be `() => true`
+ * (the caller's choice) so the response deadline governs from t0 — the legacy
+ * single-budget behavior, never a combined connect+response window.
+ */
+export declare function awaitWithWarmupDeadline<T>(work: Promise<T>, opts: {
+    isConnected: () => boolean;
+    connectTimeoutMs: number;
+    responseTimeoutMs: number;
+    pollIntervalMs?: number;
+}): Promise<T>;
 /**
  * Probe a remote peer's git_status with a bounded retry budget, but only while
  * the peer is reported `connected`. A single slow (often TURN-relayed) peer can
@@ -136,6 +168,8 @@ export declare function probeRemoteMeshGitStatusWithRetry(args: {
     timeoutMs: number;
     /** Per-attempt timeout for retries (attempts > 0); defaults to timeoutMs. */
     retryTimeoutMs?: number;
+    /** Cold-open warmup budget per attempt; defaults to MESH_DIRECT_PROBE_CONNECT_TIMEOUT_MS. */
+    connectTimeoutMs?: number;
     getConnection?: (daemonId: string) => Record<string, unknown> | null;
     onConnection?: (connection: Record<string, unknown>) => void;
 }): Promise<Record<string, unknown> | null>;

package/dist/index.js

@@ -316,10 +316,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;
 }
@@ -2903,6 +2903,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;
@@ -12856,21 +12866,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);
@@ -13711,7 +13729,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);
@@ -14145,6 +14166,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;
@@ -14157,6 +14197,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,
@@ -14166,7 +14216,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");
@@ -14175,7 +14226,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;
 }
@@ -14258,7 +14309,7 @@ function setupMeshEventForwarding(components) {
     });
   });
 }
-var import_fs13, 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 import_fs13, 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";
@@ -14323,6 +14374,7 @@ var init_mesh_events_coordinator = __esm({
       "worktree_bootstrap_complete",
       "worktree_bootstrap_failed"
     ]);
+    coordinatorForwardLanes = /* @__PURE__ */ new Map();
   }
 });
 
@@ -14665,6 +14717,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,
@@ -14672,6 +14726,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}`);
@@ -28227,6 +28298,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;
@@ -28788,6 +28860,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;
@@ -29602,6 +29692,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() : "";
@@ -29990,10 +30098,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
@@ -41453,6 +41570,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 ──────────────────────────────
@@ -49493,6 +49622,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) {
@@ -49530,12 +49660,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);
@@ -49570,7 +49761,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 {
@@ -49653,6 +49846,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();
@@ -49704,13 +49898,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);