@adhdev/daemon-core 0.9.82-rc.420 → 0.9.82-rc.422

package/dist/index.d.ts

@@ -68,7 +68,7 @@ export type { MeshSchedulingRuntime, MeshNodeSchedulingRuntime, MeshNodeProvider
 export { buildMeshHostRequiredFailure, createDefaultMeshHostMetadata, isMeshHostOwner, normalizeMeshDaemonRole, requireMeshHostQueueOwner, resolveMeshHostStatus } from './mesh/mesh-host-ownership.js';
 export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, reconcileDirectDispatchCompletionFromTranscript } from './mesh/mesh-events.js';
 export type { PendingMeshCoordinatorEvent } from './mesh/mesh-events.js';
-export { resolveMeshSurfacedSessionPreview, readMeshCompletionSummary } from './mesh/mesh-events-utils.js';
+export { resolveMeshSurfacedSessionPreview, readMeshCompletionSummary, isWeakCompletionEvidence } from './mesh/mesh-events-utils.js';
 export { resolveDeliveryDecision, createSessionDelivery, updateSessionDeliveryStatus, getActiveSessionDeliveries, markSessionDeliveriesTerminal, recordCompletionConflict, getRecentCompletionConflicts } from './mesh/mesh-delivery-policy.js';
 export type { MeshSessionDeliveryStatus, MeshSessionDeliveryKind, MeshDeliveryDecision, MeshDeliveryPolicyResult, SessionDeliveryRecord } from './mesh/mesh-delivery-policy.js';
 export { P2pRelayFailureError, buildP2pRelayFailurePayload, classifyP2pRelayFailure, isP2pRelayTransportFailure, } from './mesh/p2p-relay-failure.js';

package/dist/index.js

@@ -389,10 +389,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "bd19cb0fbe1e16db1d8d2fcd8c2c871aae3ce33b" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "bd19cb0f" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.420" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-28T19:41:31.696Z" : void 0);
+  const commit = readInjected(true ? "308e099c65d2de2491f3db46913f9ced6aa3992c" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "308e099c" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.422" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-06-29T05:26:31.350Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3686,21 +3686,6 @@ var init_async_batch_writer = __esm({
 });
 
 // src/logging/logger.ts
-var logger_exports = {};
-__export(logger_exports, {
-  LOG: () => LOG,
-  LOG_DIR_PATH: () => LOG_DIR_PATH,
-  LOG_PATH: () => LOG_PATH,
-  daemonLog: () => daemonLog,
-  getCurrentDaemonLogPath: () => getCurrentDaemonLogPath,
-  getDaemonLogDir: () => getDaemonLogDir,
-  getLogBufferSize: () => getLogBufferSize,
-  getLogLevel: () => getLogLevel,
-  getLogPath: () => getLogPath,
-  getRecentLogs: () => getRecentLogs,
-  installGlobalInterceptor: () => installGlobalInterceptor,
-  setLogLevel: () => setLogLevel
-});
 function setLogLevel(level) {
   currentLevel = level;
   daemonLog("Logger", `Log level set to: ${level}`, "info");
@@ -3772,9 +3757,6 @@ function getRecentLogs(count = 50, minLevel = "info") {
   const filtered = ringBuffer.filter((e) => LEVEL_NUM[e.level] >= minNum);
   return filtered.slice(-count);
 }
-function getLogBufferSize() {
-  return ringBuffer.length;
-}
 function ts() {
   return (/* @__PURE__ */ new Date()).toISOString().slice(11, 23);
 }
@@ -3854,10 +3836,7 @@ function installGlobalInterceptor() {
   writeToFile(`Log file: ${currentLogFile}`);
   writeToFile(`Log level: ${currentLevel}`);
 }
-function getLogPath() {
-  return currentLogFile;
-}
-var fs4, path9, os3, LEVEL_NUM, LEVEL_LABEL, currentLevel, ADHDEV_HOME, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH, LOG_DIR_PATH;
+var fs4, path9, os3, LEVEL_NUM, LEVEL_LABEL, currentLevel, ADHDEV_HOME, LOG_DIR, MAX_LOG_SIZE, MAX_LOG_DAYS, currentDate, currentLogFile, writeCount, RING_BUFFER_SIZE, ringBuffer, origConsoleLog, origConsoleError, origConsoleWarn, LOG, interceptorInstalled, LOG_PATH;
 var init_logger = __esm({
   "src/logging/logger.ts"() {
     "use strict";
@@ -3919,7 +3898,6 @@ var init_logger = __esm({
     };
     interceptorInstalled = false;
     LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
-    LOG_DIR_PATH = LOG_DIR;
   }
 });
 
@@ -12528,6 +12506,23 @@ function liveSessionCountForNode(components, meshId, nodeId) {
     return !isTerminalSessionStatus(status);
   }).length;
 }
+function nodeHasLiveSessionPendingClaim(components, meshId, nodeId) {
+  const busySessionIds = new Set(
+    getQueue(meshId, { status: ["assigned"] }).filter((task) => daemonIdsEquivalent(task.assignedNodeId, nodeId)).map((task) => readNonEmptyString2(task.assignedSessionId)).filter(Boolean)
+  );
+  return components.instanceManager.getByCategory("cli").some((inst) => {
+    const state = inst.getState();
+    const settings = state.settings || {};
+    if (readNonEmptyString2(settings.meshNodeFor) !== meshId) return false;
+    const instNodeId = readNonEmptyString2(settings.meshNodeId) || readNonEmptyString2(settings.nodeId);
+    if (!daemonIdsEquivalent(instNodeId, nodeId)) return false;
+    const status = readNonEmptyString2(state.status).toLowerCase();
+    if (isTerminalSessionStatus(status)) return false;
+    const sessionId = readNonEmptyString2(state.instanceId);
+    if (sessionId && busySessionIds.has(sessionId)) return false;
+    return true;
+  });
+}
 function recordAutoLaunchEvent(meshId, args) {
   const dedupKey = `${meshId}:${args.taskId}`;
   const currentSig = `${args.phase}|${args.reason || ""}`;
@@ -12713,6 +12708,10 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
         sweepExpiredCooldowns();
         continue;
       }
+      if (nodeHasLiveSessionPendingClaim(components, meshId, nodeId)) {
+        markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_has_live_session_pending_claim", nodeId });
+        continue;
+      }
       if (!isTaskReadonly(task) && nodeHasActiveAssignment(meshId, nodeId)) {
         markAutoLaunch(meshId, task.id, { status: "skipped", reason: "node_has_active_assignment", nodeId });
         continue;
@@ -16558,6 +16557,62 @@ function ackUnresolvedDelegateForwardByFingerprint(coordinatorDaemonId, eventNam
   );
   if (match) ackUnresolvedDelegateForward(match.id);
 }
+function flushPendingForMeshIdleCoordinators(components, meshId) {
+  try {
+    const store = MeshRuntimeStore.getInstance();
+    if (store.pendingEventCount(meshId) === 0) return;
+  } catch {
+  }
+  const idleCoordinators = [];
+  try {
+    for (const inst of components.instanceManager.getByCategory("cli")) {
+      const state = inst.getState();
+      const settings = state.settings && typeof state.settings === "object" ? state.settings : {};
+      if (readNonEmptyString2(settings.meshCoordinatorFor) !== meshId) continue;
+      const status = readNonEmptyString2(state.status).toLowerCase();
+      const modalParked = typeof inst.isModalParked === "function" ? inst.isModalParked() === true : status === "waiting_choice" || status === "waiting_approval";
+      if (status === "idle" && !modalParked) {
+        idleCoordinators.push({ instance: inst, sessionId: readNonEmptyString2(state.instanceId) });
+      }
+    }
+  } catch {
+    return;
+  }
+  if (idleCoordinators.length === 0) return;
+  const drainDaemonIds = resolveCoordinatorDrainDaemonIds(components);
+  let pendingEvents;
+  try {
+    pendingEvents = drainPendingMeshCoordinatorEvents(meshId, drainDaemonIds.length > 0 ? drainDaemonIds : void 0);
+  } catch (e) {
+    LOG.warn("MeshEvents", `Event-driven coordinator drain failed for mesh ${meshId}: ${e?.message || e}`);
+    return;
+  }
+  if (pendingEvents.length === 0) return;
+  let delivered = 0;
+  for (const pending of pendingEvents) {
+    const wantSession = readNonEmptyString2(pending.targetCoordinatorSessionId);
+    const targets = wantSession ? idleCoordinators.filter((c) => c.sessionId === wantSession) : idleCoordinators;
+    if (targets.length === 0 || !pending.coordinatorMessage) {
+      try {
+        queuePendingMeshCoordinatorEvent(pending);
+      } catch {
+      }
+      continue;
+    }
+    const message = pending.coordinatorMessage;
+    const force = shouldForceInjectMeshEvent(pending.event);
+    for (const c of targets) {
+      c.instance.onEvent("send_message", {
+        input: { text: message, textFallback: message },
+        ...force ? { force: true } : {}
+      });
+      delivered++;
+    }
+  }
+  if (delivered > 0) {
+    LOG.info("MeshEvents", `Event-driven drain delivered ${delivered} pending event(s) to ${idleCoordinators.length} idle coordinator(s) for mesh ${meshId}`);
+  }
+}
 function setupMeshEventForwarding(components) {
   components.instanceManager.onEvent((event) => {
     if (event.event === "agent:ready" || event.event === "agent:generating_completed") {
@@ -16629,6 +16684,7 @@ function setupMeshEventForwarding(components) {
       event: event.event,
       metadataEvent: event
     });
+    flushPendingForMeshIdleCoordinators(components, routing.meshId);
   });
 }
 var REMOTE_IDLE_SESSION_TTL_MS, meshByWorkspaceCache, MESH_WORKSPACE_CACHE_TTL_MS, INTENTIONAL_CLEANUP_STOP_SUPPRESSION_MS, RECENT_COMPLETION_FINGERPRINT_TTL_MS, RECONCILED_COMPLETION_SOURCES, coordinatorForwardLanes;
@@ -16749,7 +16805,7 @@ function findLiveCoordinators(components) {
     const meshId = readNonEmptyString2(settings.meshCoordinatorFor);
     if (!meshId) continue;
     const status = readNonEmptyString2(state.status).toLowerCase();
-    const modalParked = status === "waiting_choice" || status === "waiting_approval";
+    const modalParked = typeof inst.isModalParked === "function" ? inst.isModalParked() === true : status === "waiting_choice" || status === "waiting_approval";
     const sessionId = readNonEmptyString2(state.instanceId);
     const stateKey = `${meshId}::${sessionId || "?"}`;
     const prevParked = coordinatorModalParkState.get(stateKey);
@@ -23482,6 +23538,7 @@ __export(index_exports, {
   isSetupComplete: () => isSetupComplete,
   isTaskReadonly: () => isTaskReadonly,
   isUserFacingChatMessage: () => isUserFacingChatMessage,
+  isWeakCompletionEvidence: () => isWeakCompletionEvidence,
   killIdeProcess: () => killIdeProcess,
   launchIDE: () => launchIDE,
   launchWithCdp: () => launchWithCdp,
@@ -41032,10 +41089,27 @@ var CliProviderInstance = class _CliProviderInstance {
       return null;
     }
     if (adapterStatus.status === "waiting_approval" && (!this.autoApproveEffectivelyActive(adapterStatus.status) || this.autoApproveMaskStalled())) {
+      if (this.isTransientToolConsent()) {
+        return null;
+      }
       return "waiting_approval";
     }
     return null;
   }
+  /**
+   * NOTIF-HELD-DRAIN: true when this `waiting_approval` is a routine, transient tool-consent
+   * of an autonomously-progressing mesh session rather than a genuine human-await modal —
+   * i.e. it is a mesh coordinator/worker session, a turn is actively in flight
+   * (hasAdapterPendingResponse), and no human is attending it by hand. Such a consent is
+   * driven to resolution by the harness/operator as part of the in-flight turn, so holding
+   * the mesh's completion events behind it (modal_parked) is the false-positive that stalls
+   * delivery. Narrow by design: manual attendance or a non-progressing session falls through
+   * to the genuine-modal classification.
+   */
+  isTransientToolConsent(now = Date.now()) {
+    const isAutonomousMeshSession = this.isMeshWorkerSession() || !!this.settings.meshCoordinatorFor;
+    return isAutonomousMeshSession && this.hasAdapterPendingResponse() && !this.manualAttendance.isAttended(now);
+  }
   /** True when this session is parked on a modal awaiting a human answer. */
   isModalParked() {
     return this.resolveModalParkStatus() !== null;
@@ -44911,8 +44985,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
           const meshContext = args?.meshContext;
           if (meshContext && typeof meshContext === "object" && typeof meshContext.meshId === "string" && meshContext.meshId) {
             const targetInstanceId = key2;
+            let stampResult;
             try {
-              this.deps.getInstanceManager()?.attachMeshAssignmentToInstance(targetInstanceId, {
+              stampResult = this.deps.getInstanceManager()?.attachMeshAssignmentToInstance(targetInstanceId, {
                 meshId: meshContext.meshId,
                 ...typeof meshContext.nodeId === "string" && meshContext.nodeId ? { nodeId: meshContext.nodeId } : {},
                 ...typeof meshContext.taskId === "string" && meshContext.taskId ? { taskId: meshContext.taskId } : {},
@@ -44920,6 +44995,9 @@ Run 'adhdev doctor' for detailed diagnostics.`
               });
             } catch {
             }
+            if (stampResult && stampResult.stamped === false && stampResult.reason === "task_already_stamped_on_live_instance") {
+              throw new Error(`Refusing duplicate mesh dispatch: task ${meshContext.taskId} is already being worked by a live session on this daemon`);
+            }
           }
           const input = normalizeInputEnvelope(args?.input ? { input: args.input } : args);
           const provider = this.providerLoader.resolve(agentType) || this.providerLoader.getMeta(agentType);
@@ -58527,25 +58605,54 @@ var ProviderInstanceManager = class {
   }
   /** Stamp a mesh assignment on a single instance (used by mesh_send_task
    *  --direct so the worker's completion event has a coordinator routing
-   *  marker in state.settings). Returns true if the instance existed and
-   *  the stamp was applied. */
+   *  marker in state.settings). Returns `{ stamped: true }` when the stamp was
+   *  applied, or `{ stamped: false, reason }` when it was refused — the instance
+   *  was missing / has no attach method, or the DOUBLE-DISPATCH idempotence guard
+   *  fired (the same task is already running on another live session here). */
   attachMeshAssignmentToInstance(instanceId, assignment) {
     const inst = this.instances.get(instanceId);
     if (!inst || typeof inst.attachMeshAssignment !== "function") {
-      try {
-        const { LOG: LOG2 } = (init_logger(), __toCommonJS(logger_exports));
-        LOG2.warn?.("MeshDispatch", `attachMeshAssignment skipped: instance ${instanceId} ${inst ? "has no attach method" : "not found"}`);
-      } catch {
+      LOG.warn("MeshDispatch", `attachMeshAssignment skipped: instance ${instanceId} ${inst ? "has no attach method" : "not found"}`);
+      return { stamped: false, reason: inst ? "instance_has_no_attach_method" : "instance_not_found" };
+    }
+    if (assignment.taskId) {
+      const conflict = this.findLiveWorkingTaskHolder(assignment.meshId, assignment.taskId, instanceId);
+      if (conflict) {
+        LOG.warn("MeshDispatch", `attachMeshAssignment refused: task ${assignment.taskId} (mesh ${assignment.meshId}) is already being worked by live session ${conflict} \u2014 skipping duplicate stamp on ${instanceId}`);
+        return { stamped: false, reason: "task_already_stamped_on_live_instance" };
       }
-      return false;
     }
     inst.attachMeshAssignment(assignment);
-    try {
-      const { LOG: LOG2 } = (init_logger(), __toCommonJS(logger_exports));
-      LOG2.info?.("MeshDispatch", `stamped mesh assignment on ${instanceId}: mesh=${assignment.meshId} node=${assignment.nodeId || ""} task=${assignment.taskId || ""} coordinator=${assignment.coordinatorDaemonId || ""}`);
-    } catch {
+    LOG.info("MeshDispatch", `stamped mesh assignment on ${instanceId}: mesh=${assignment.meshId} node=${assignment.nodeId || ""} task=${assignment.taskId || ""} coordinator=${assignment.coordinatorDaemonId || ""}`);
+    return { stamped: true };
+  }
+  /**
+   * DOUBLE-DISPATCH support: the id of another LIVE, actively-working instance that already
+   * holds (meshId, taskId), or null. "Live working" = stamped with this exact mesh+task AND
+   * currently mid-turn / booting toward it (generating / waiting on approval-or-choice /
+   * starting) — NOT idle, stopped, or errored. A stale/dead/idle holder is deliberately
+   * ignored so a legitimate re-dispatch (e.g. after a dispatch failure) is never blocked.
+   * The instance being stamped (excludeInstanceId) is skipped so re-stamping the same
+   * session stays idempotent. O(n) over instances — the count is small.
+   */
+  findLiveWorkingTaskHolder(meshId, taskId, excludeInstanceId) {
+    const working = /* @__PURE__ */ new Set(["generating", "waiting_approval", "waiting_choice", "starting", "streaming", "working", "no_progress", "long_generating"]);
+    for (const [id, inst] of this.instances) {
+      if (id === excludeInstanceId) continue;
+      let state;
+      try {
+        state = inst.getState();
+      } catch {
+        continue;
+      }
+      const settings = state.settings || {};
+      if (settings.meshNodeFor !== meshId) continue;
+      if (settings.meshActiveTaskId !== taskId) continue;
+      const status = (typeof state.status === "string" ? state.status : "").toLowerCase();
+      const chatStatus = (typeof state.activeChat?.status === "string" ? state.activeChat.status : "").toLowerCase();
+      if (working.has(status) || working.has(chatStatus)) return id;
     }
-    return true;
+    return null;
   }
   /** Clear a mesh assignment after the dispatched task reaches a terminal
    *  state (generating_completed / stopped / failed). */
@@ -65244,6 +65351,7 @@ var V1_CONTRACT_VERSION = "1.0.0";
   isSetupComplete,
   isTaskReadonly,
   isUserFacingChatMessage,
+  isWeakCompletionEvidence,
   killIdeProcess,
   launchIDE,
   launchWithCdp,