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

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 ? "bb7e66dbc483232a27d1de42cf8ecba3eb0a818c" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "bb7e66db" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.367" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-24T04:45:13.384Z" : 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,10 +12862,6 @@ 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);
@@ -13707,7 +13713,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);
@@ -14153,6 +14162,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,
@@ -14660,6 +14679,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 +14688,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 +27896,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 +28458,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 +29290,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 +29696,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
@@ -49129,6 +49213,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 +49251,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 +49352,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 +49437,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 +49489,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);