@adhdev/daemon-standalone 1.0.28-rc.33 → 1.0.28-rc.34

package/dist/index.js

@@ -33311,10 +33311,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "5e05ac37dcef7e88d50d419fe2cf93bfbf77fc88" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "5e05ac37" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.28-rc.33" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-31T00:24:14.883Z" : void 0);
+      const commit = readInjected(true ? "fcccd1309a13173048d54bcfb1edbf698ee22ee3" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "fcccd130" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.28-rc.34" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-31T01:14:11.973Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -38307,6 +38307,37 @@ Next step: ${nextStep}`;
         nowMs: args.nowMs
       });
     }
+    function rebindAttemptToLiveHolder(args) {
+      const holder = typeof args.holderSessionId === "string" ? args.holderSessionId.trim() : "";
+      if (!holder) return { rebound: false, reason: "no_holder" };
+      const store = MeshRuntimeStore.getInstance();
+      const attempt = store.getCurrentTurnAttempt(args.meshId, args.taskId);
+      if (!attempt) return { rebound: false, reason: "no_attempt" };
+      if (attempt.terminalOutcome) return { rebound: false, reason: "attempt_terminal", attemptId: attempt.attemptId };
+      if (attempt.sessionId && sessionIdsEquivalent(attempt.sessionId, holder)) {
+        return { rebound: false, reason: "same_session", attemptId: attempt.attemptId };
+      }
+      const nowMs = args.nowMs ?? Date.now();
+      const nowIso = new Date(nowMs).toISOString();
+      const ok = store.rebindTurnAttemptSession(attempt.attemptId, holder, nowIso);
+      if (!ok) return { rebound: false, reason: "store_rejected", attemptId: attempt.attemptId };
+      try {
+        store.insertTurnEvent({
+          eventId: (0, import_crypto5.randomUUID)(),
+          meshId: args.meshId,
+          attemptId: attempt.attemptId,
+          taskId: args.taskId,
+          kind: "session_rebound",
+          dedupeKey: holder,
+          payload: safeEvidenceJson({ fromSessionId: attempt.sessionId ?? null, toSessionId: holder, reason: "duplicate_dispatch_refused" }),
+          occurredAtMs: nowMs,
+          recordedAt: nowIso
+        });
+      } catch {
+      }
+      LOG2.info("TurnLedger", `Rebound attempt ${attempt.attemptId} (task ${args.taskId}) from session ${attempt.sessionId ?? "none"} to live holder ${holder} after a duplicate-dispatch refusal`);
+      return { rebound: true, attemptId: attempt.attemptId, fromSessionId: attempt.sessionId ?? void 0, toSessionId: holder };
+    }
     function evaluateRedrive(meshId, taskId, nowMs = Date.now()) {
       const store = MeshRuntimeStore.getInstance();
       const attempt = store.getCurrentTurnAttempt(meshId, taskId);
@@ -43655,6 +43686,23 @@ Next step: ${nextStep}`;
         `).run(leaseDeadlineMs, updatedAt, attemptId);
             this.maybeCheckpointWal();
           }
+          /**
+           * DUP-CLAIM-REBIND: point a still-open attempt at the session that is ACTUALLY
+           * working it. Used when a node refuses a duplicate dispatch and names the live
+           * holder — the attempt was opened against the session we tried to dispatch to,
+           * but the work is running on the holder, so the binding (not the attempt) is what
+           * is wrong. Conditional on `terminal_outcome IS NULL` so a settled attempt is
+           * never rewritten; returns whether the rebind landed.
+           */
+          rebindTurnAttemptSession(attemptId, sessionId, updatedAt) {
+            const res = this.db.prepare(`
+            UPDATE mesh_turn_attempts
+            SET session_id = ?, updated_at = ?
+            WHERE attempt_id = ? AND terminal_outcome IS NULL
+        `).run(sessionId, updatedAt, attemptId);
+            this.maybeCheckpointWal();
+            return res.changes > 0;
+          }
           // ── TURN-LEDGER (Stage 5): idempotency-keyed causal events ───────────────
           /**
            * Append a causal event. INSERT OR IGNORE on UNIQUE(attempt_id, kind, dedupe_key)
@@ -44879,7 +44927,8 @@ Valid status values: \`completed\` | \`failed\` | \`blocked\` | \`partial\`.`;
           "task_reclaimed",
           "task_approval_needed",
           "task_question_pending",
-          "p2p_dispatch_failed"
+          "p2p_dispatch_failed",
+          "dispatch_duplicate_rebound"
         ]);
         LEDGER_DIR_NAME = "mesh-ledger";
         MAX_FILE_SIZE_BYTES = 10 * 1024 * 1024;
@@ -53979,6 +54028,42 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         ]);
       }
     });
+    function encodeDuplicateMeshDispatchCode(holderSessionId) {
+      const holder = typeof holderSessionId === "string" ? holderSessionId.trim() : "";
+      return holder ? `${DUPLICATE_MESH_DISPATCH_CODE}:${holder}` : DUPLICATE_MESH_DISPATCH_CODE;
+    }
+    function classifyDuplicateMeshDispatch(err) {
+      if (!err || typeof err !== "object") return null;
+      const e = err;
+      if (e.code === DUPLICATE_MESH_DISPATCH_CODE) {
+        const holder = typeof e.holderSessionId === "string" ? e.holderSessionId.trim() : "";
+        return holder ? { holderSessionId: holder } : {};
+      }
+      for (const raw of [e.meshCode, e.code]) {
+        if (typeof raw !== "string") continue;
+        if (raw !== DUPLICATE_MESH_DISPATCH_CODE && !raw.startsWith(`${DUPLICATE_MESH_DISPATCH_CODE}:`)) continue;
+        const holder = raw.slice(DUPLICATE_MESH_DISPATCH_CODE.length + 1).trim();
+        return holder ? { holderSessionId: holder } : {};
+      }
+      return null;
+    }
+    var DUPLICATE_MESH_DISPATCH_CODE;
+    var DuplicateMeshDispatchError;
+    var init_mesh_duplicate_dispatch = __esm2({
+      "src/mesh/mesh-duplicate-dispatch.ts"() {
+        "use strict";
+        DUPLICATE_MESH_DISPATCH_CODE = "DUPLICATE_MESH_DISPATCH";
+        DuplicateMeshDispatchError = class extends Error {
+          code = DUPLICATE_MESH_DISPATCH_CODE;
+          holderSessionId;
+          constructor(message, info = {}) {
+            super(message);
+            this.name = "DuplicateMeshDispatchError";
+            this.holderSessionId = info.holderSessionId;
+          }
+        };
+      }
+    });
     function localCoordinatorDaemonId() {
       return canonicalDaemonId(readNonEmptyString(loadConfig2().machineId));
     }
@@ -54179,6 +54264,37 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         }
       }).catch((e) => {
         if (timer) clearTimeout(timer);
+        const duplicate = classifyDuplicateMeshDispatch(e);
+        if (duplicate?.holderSessionId) {
+          const rebind = rebindAttemptToLiveHolder({
+            meshId: ctx.meshId,
+            taskId: ctx.task.id,
+            holderSessionId: duplicate.holderSessionId
+          });
+          if (rebind.rebound || rebind.reason === "same_session") {
+            LOG2.info("MeshQueue", `Duplicate dispatch of task ${ctx.task.id} refused by node ${ctx.nodeId}: it is already being worked by live session ${duplicate.holderSessionId}. Task stays assigned; turn attempt ${rebind.attemptId ?? "n/a"} ${rebind.rebound ? "rebound to that session" : "was already bound to it"}.`);
+            updateSessionDeliveryStatus(delivery.id, "delivered");
+            try {
+              appendLedgerEntry(ctx.meshId, {
+                kind: "dispatch_duplicate_rebound",
+                nodeId: ctx.nodeId,
+                sessionId: duplicate.holderSessionId,
+                payload: {
+                  taskId: ctx.task.id,
+                  deliveryId: delivery.id,
+                  transport: ctx.transport,
+                  attemptedSessionId: ctx.sessionId,
+                  holderSessionId: duplicate.holderSessionId,
+                  ...rebind.attemptId ? { attemptId: rebind.attemptId } : {},
+                  rebound: rebind.rebound
+                }
+              });
+            } catch {
+            }
+            return;
+          }
+          LOG2.warn("MeshQueue", `Duplicate dispatch of task ${ctx.task.id} refused by node ${ctx.nodeId} (holder ${duplicate.holderSessionId}), but the turn attempt could not be rebound (${rebind.reason}) \u2014 falling back to the requeue path.`);
+        }
         LOG2.error("MeshQueue", `Failed to dispatch task via ${ctx.transport} to node ${ctx.nodeId}: ${e?.message}`);
         updateSessionDeliveryStatus(delivery.id, "failed", { lastError: e?.message, incrementAttempt: true });
         endTaskDispatchInFlight(ctx.meshId, ctx.task.id);
@@ -55751,6 +55867,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_task_inflight();
         init_model_provider_compat();
         init_mesh_turn_ledger();
+        init_mesh_duplicate_dispatch();
         IDLE_AUTO_FAST_FORWARD_THROTTLE_MS = 30 * 60 * 1e3;
         idleAutoFastForwardLastAttempt = /* @__PURE__ */ new Map();
         CONTINUOUS_AUTO_FAST_FORWARD_SCAN_COOLDOWN_MS = 45 * 1e3;
@@ -70921,6 +71038,7 @@ ${lastSnapshot}`;
       DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS: () => DEFAULT_STATUS_P2P_REPORT_INTERVAL_MS,
       DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS: () => DEFAULT_STATUS_SERVER_REPORT_INTERVAL_MS,
       DEV_SERVER_PORT: () => DEV_SERVER_PORT,
+      DUPLICATE_MESH_DISPATCH_CODE: () => DUPLICATE_MESH_DISPATCH_CODE,
       DaemonAgentStreamManager: () => DaemonAgentStreamManager,
       DaemonCdpInitializer: () => DaemonCdpInitializer,
       DaemonCdpManager: () => DaemonCdpManager,
@@ -70930,6 +71048,7 @@ ${lastSnapshot}`;
       DaemonCommandRouter: () => DaemonCommandRouter,
       DaemonStatusReporter: () => DaemonStatusReporter,
       DevServer: () => DevServer,
+      DuplicateMeshDispatchError: () => DuplicateMeshDispatchError,
       FsmDriver: () => FsmDriver,
       GOAL_PREVIEW_MAX: () => GOAL_PREVIEW_MAX,
       GitCommandError: () => GitCommandError,
@@ -71039,6 +71158,7 @@ ${lastSnapshot}`;
       canonicalDaemonId: () => canonicalDaemonId,
       claimNextTask: () => claimNextTask,
       classifyChatMessageVisibility: () => classifyChatMessageVisibility,
+      classifyDuplicateMeshDispatch: () => classifyDuplicateMeshDispatch,
       classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush2,
       classifyP2pRelayFailure: () => classifyP2pRelayFailure,
       classifyShadowDivergence: () => classifyShadowDivergence,
@@ -71081,6 +71201,7 @@ ${lastSnapshot}`;
       detectIDEs: () => detectIDEs,
       detectNewlySettledCompletedSessions: () => detectNewlySettledCompletedSessions2,
       drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
+      encodeDuplicateMeshDispatchCode: () => encodeDuplicateMeshDispatchCode,
       enqueueTask: () => enqueueTask,
       ensureSessionHostReady: () => ensureSessionHostReady2,
       evaluateFsm: () => evaluateFsm,
@@ -73641,6 +73762,7 @@ ${lastSnapshot}`;
         this.authEpoch = context.authEpoch;
       }
     };
+    init_mesh_duplicate_dispatch();
     init_state_store();
     var import_child_process5 = require("child_process");
     var import_util22 = require("util");
@@ -85333,6 +85455,7 @@ ${body}
     init_recent_activity();
     init_hash();
     init_coordinator_registry();
+    init_mesh_duplicate_dispatch();
     init_summary_metadata();
     var os19 = __toESM2(require("os"));
     var crypto5 = __toESM2(require("crypto"));
@@ -94846,7 +94969,10 @@ 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`);
+                  throw new DuplicateMeshDispatchError(
+                    `Refusing duplicate mesh dispatch: task ${meshContext.taskId} is already being worked by a live session on this daemon`,
+                    { holderSessionId: stampResult.holderSessionId }
+                  );
                 }
                 if (meshContext.silentIdlePush === true) {
                   try {
@@ -110614,7 +110740,13 @@ ${e?.stderr || ""}`;
        *  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). */
+       *  fired (the same task is already running on another live session here).
+       *
+       *  DUP-CLAIM-REBIND: when the guard fires, the id of the live session that already
+       *  holds the task is returned as `holderSessionId`. The coordinator needs it to
+       *  REBIND its turn-ledger attempt onto the real worker instead of cancelling the
+       *  attempt — the guard already resolved that instance, so surfacing it here keeps
+       *  the caller from having to parse it back out of an error string. */
       attachMeshAssignmentToInstance(instanceId, assignment) {
         const inst = this.instances.get(instanceId);
         if (!inst || typeof inst.attachMeshAssignment !== "function") {
@@ -110625,7 +110757,7 @@ ${e?.stderr || ""}`;
           const conflict = this.findLiveWorkingTaskHolder(assignment.meshId, assignment.taskId, instanceId);
           if (conflict) {
             LOG2.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 { stamped: false, reason: "task_already_stamped_on_live_instance", holderSessionId: conflict };
           }
         }
         inst.attachMeshAssignment(assignment);