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

package/dist/index.mjs

@@ -384,10 +384,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "ae90493419784d563faac61e6caab2a6f05e0719" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "ae904934" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.421" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-06-29T03:34:21.633Z" : 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;
 }
@@ -3680,21 +3680,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
-});
 import * as fs4 from "fs";
 import * as path9 from "path";
 import * as os3 from "os";
@@ -3769,9 +3754,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);
 }
@@ -3851,10 +3833,7 @@ function installGlobalInterceptor() {
   writeToFile(`Log file: ${currentLogFile}`);
   writeToFile(`Log level: ${currentLevel}`);
 }
-function getLogPath() {
-  return currentLogFile;
-}
-var 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 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";
@@ -3913,7 +3892,6 @@ var init_logger = __esm({
     };
     interceptorInstalled = false;
     LOG_PATH = path9.join(LOG_DIR, `daemon-${getDateStr()}.log`);
-    LOG_DIR_PATH = LOG_DIR;
   }
 });
 
@@ -12524,6 +12502,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 || ""}`;
@@ -12709,6 +12704,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;
@@ -44595,8 +44594,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 } : {},
@@ -44604,6 +44604,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);
@@ -58211,25 +58214,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). */