@adhdev/daemon-standalone 1.0.28-rc.32 → 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 ? "9d291b6668878c1d0e3c210fad52ff57cf9ec1f8" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "9d291b66" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.28-rc.32" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-30T17:15:53.842Z" : 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);
@@ -39597,6 +39628,32 @@ Next step: ${nextStep}`;
         return false;
       }
     }
+    function requeueDrainedPendingMeshCoordinatorEvent(event) {
+      const fingerprint = buildPendingEventFingerprint(event);
+      if (!fingerprint.trim()) return false;
+      let requeued = false;
+      try {
+        requeued = MeshRuntimeStore.getInstance().requeueDrainedPendingEventByFingerprint(event.meshId, fingerprint);
+      } catch (e) {
+        LOG2.warn("MeshEvents", `SQLite re-queue of held ${event.event} failed for mesh ${event.meshId}: ${e?.message || e}`);
+      }
+      try {
+        const path50 = getPendingEventsPath(event.meshId, event.targetCoordinatorDaemonId);
+        const alreadyOnDisk = readPendingMeshCoordinatorEventsFromDisk(event.meshId, event.targetCoordinatorDaemonId).some((pending) => buildPendingEventFingerprint(pending) === fingerprint);
+        if (!alreadyOnDisk) {
+          trimPendingEventsIfNeeded(path50);
+          (0, import_fs5.appendFileSync)(path50, JSON.stringify(event) + "\n", "utf-8");
+          requeued = true;
+        }
+      } catch (e) {
+        if (!requeued) {
+          LOG2.warn("MeshEvents", `Failed to durably re-queue held ${event.event} for mesh ${event.meshId}: ${e?.message || e}`);
+          return false;
+        }
+        LOG2.warn("MeshEvents", `JSONL re-queue append failed for mesh ${event.meshId}; SQLite holds the event: ${e?.message || e}`);
+      }
+      return requeued;
+    }
     function atomicDrainFile(path50) {
       const tmpPath = `${path50}.draining`;
       try {
@@ -43395,6 +43452,49 @@ Next step: ${nextStep}`;
               `UPDATE mesh_pending_events SET drained = 1, drained_at = ? WHERE drained = 0 AND id IN (${idList.map(() => "?").join(",")})`
             ).run(now, ...idList).changes;
           }
+          /**
+           * STRICT-ROUTE-HOLD-DURABILITY: return an ALREADY-DRAINED row to the queue
+           * (drained=1 → drained=0), in place, by fingerprint.
+           *
+           * Why this exists (the rc.33 defect): a strict-routed completion whose originating
+           * coordinator session is not currently live is "held" by re-queuing it. That
+           * re-queue used to call the normal insert path, which CANNOT work for a held
+           * event — three independent suppressors reject it:
+           *
+           *   1. `idx_mesh_pending_events_fingerprint` is UNIQUE on (mesh_id, fingerprint)
+           *      with NO `drained` qualifier, and insertPendingEvent uses INSERT OR IGNORE.
+           *      The just-drained row still occupies that fingerprint, so the "fresh
+           *      undrained copy" is silently ignored — changes = 0, no row added.
+           *   2. hasPendingCoordinatorEventDuplicate → hasPendingEventFingerprint queries
+           *      `drained = 0`, so it does NOT see the drained original and reports no
+           *      duplicate — the caller believes the re-queue succeeded.
+           *   3. Even if a copy did land, the v2 eventId is already in
+           *      drainedEventIdsForMesh(), so routeV2EventsForDrainer would skip it as
+           *      already-delivered on the next drain.
+           *
+           * The pre-restart hold only ever worked because the in-memory reconcile loop
+           * re-read the event; nothing durable was written. A restart inside the 60s TTL
+           * therefore lost the completion permanently (observed: task ec6c901a — exactly
+           * one row, drained=1, and zero lines in the JSONL mirror).
+           *
+           * Flipping the EXISTING row back to drained=0 is the only correct move: it keeps
+           * the unique fingerprint (no duplicate row can ever be created), removes the
+           * eventId from the drained-baseline so the v2 idempotency filter stops swallowing
+           * it, and makes the hold survive a process restart. queued_at is deliberately
+           * PRESERVED so the strict TTL keeps measuring the event's true age across holds
+           * and cannot be refreshed into an immortal row.
+           *
+           * Returns true when a drained row was found and returned to the queue.
+           */
+          requeueDrainedPendingEventByFingerprint(meshId, fingerprint) {
+            if (!fingerprint) return false;
+            const changes = this.db.prepare(
+              `UPDATE mesh_pending_events SET drained = 0, drained_at = NULL
+             WHERE mesh_id = ? AND fingerprint = ? AND drained = 1`
+            ).run(meshId, fingerprint).changes;
+            if (changes > 0) this.maybeCheckpointWal();
+            return changes > 0;
+          }
           /**
            * Hard-delete pending-event rows by id (including the dedup fingerprint history).
            * Used to expire an unresolved-delegate outbox entry that has exhausted its retry
@@ -43586,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)
@@ -44810,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;
@@ -53910,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));
     }
@@ -54110,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);
@@ -55682,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;
@@ -60859,23 +61045,51 @@ ${cleanBody}`;
     async function pollAssignedTaskTerminalEvidence(components, mesh, row, opts) {
       const sessionId = readNonEmptyString(row.assignedSessionId);
       const nodeId = readNonEmptyString(row.assignedNodeId);
-      if (!sessionId || !nodeId) return null;
+      const traceCtx = {
+        taskId: row.id,
+        ...sessionId ? { sessionId } : {},
+        ...nodeId ? { nodeId } : {},
+        meshId: mesh.id,
+        event: "agent:generating_completed"
+      };
+      const declined = (reason, detail) => {
+        traceMeshEventDrop(`poll_terminal_evidence_${reason}`, traceCtx, detail);
+        return null;
+      };
+      if (!sessionId || !nodeId) {
+        return declined("no_assigned_worker", `sessionId=${sessionId ?? "none"} nodeId=${nodeId ?? "none"}`);
+      }
       const providerType = readNonEmptyString(row.assignedProviderType);
       const payload = await runSessionEvidenceCollection(sessionId, () => fetchAssignedTaskChatTail(components, mesh, row));
-      if (!payload) return null;
-      if (readChatPayloadStatus(payload) !== "idle") return null;
+      if (!payload) return declined("chat_tail_unreadable", "worker transcript read returned no payload (offline/unreachable?)");
+      const payloadStatus = readChatPayloadStatus(payload);
+      if (payloadStatus !== "idle") return declined("session_not_idle", `status=${payloadStatus ?? "unknown"} \u2014 mid-turn, not a turn-end`);
       const messages = Array.isArray(payload.messages) ? payload.messages : [];
       const evidence = extractFinalAssistantSummaryEvidence(messages);
-      if (!evidence.finalSummary) return null;
-      if (hasTrailingToolActivityAfterFinalAssistant(messages)) return null;
+      if (!evidence.finalSummary) return declined("no_final_assistant_summary", `idle with ${messages.length} message(s) but no assistant result`);
+      if (hasTrailingToolActivityAfterFinalAssistant(messages)) {
+        return declined("trailing_tool_activity", "tool/terminal bubble trails the final assistant \u2014 worker is mid-turn");
+      }
       const dispatchedAtMs = Date.parse(readNonEmptyString(row.dispatchTimestamp));
       const transcriptAtMs = Date.parse(evidence.transcriptMessageAt ?? "");
       if (!(Number.isFinite(dispatchedAtMs) && Number.isFinite(transcriptAtMs) && transcriptAtMs >= dispatchedAtMs)) {
-        return null;
+        const unusable = !Number.isFinite(dispatchedAtMs) || !Number.isFinite(transcriptAtMs);
+        return declined(
+          unusable ? "timestamp_unusable" : "summary_predates_dispatch",
+          `dispatchTimestamp=${row.dispatchTimestamp ?? "none"} transcriptMessageAt=${evidence.transcriptMessageAt ?? "none"}`
+        );
       }
       if (typeof opts?.minFinalAssistantAgeMs === "number" && opts.minFinalAssistantAgeMs > 0 && Date.now() - transcriptAtMs < opts.minFinalAssistantAgeMs) {
-        return null;
+        return declined(
+          "final_assistant_not_settled",
+          `age=${Date.now() - transcriptAtMs}ms < minFinalAssistantAgeMs=${opts.minFinalAssistantAgeMs} \u2014 treated as in-flight narration`
+        );
       }
+      traceMeshEventStage(
+        "poll_terminal_evidence_completed",
+        traceCtx,
+        `idle with final assistant after dispatch \u2014 task is completed, re-drive prevented`
+      );
       return {
         outcome: "completed",
         finalSummary: evidence.finalSummary,
@@ -61002,7 +61216,7 @@ ${cleanBody}`;
         ...force ? { force: true } : {}
       });
     }
-    function recordHeldTerminalEventsToLedger(meshId, drainDaemonIds, reason, heldForCoordinatorCount) {
+    function recordHeldTerminalEventsToLedger(meshId, drainDaemonIds, reason, heldForCoordinatorCount, strictRoutedFingerprints) {
       let pending;
       try {
         pending = getPendingMeshCoordinatorEvents(meshId, drainDaemonIds.length > 0 ? drainDaemonIds : void 0);
@@ -61010,6 +61224,7 @@ ${cleanBody}`;
         return;
       }
       for (const event of pending) {
+        if (strictRoutedFingerprints?.has(buildPendingEventFingerprint(event))) continue;
         if (!shouldForceInjectMeshEvent(event.event)) continue;
         const fingerprint = buildPendingEventFingerprint(event);
         const key2 = `${meshId}::${fingerprint || `${event.event}::${event.nodeId || ""}::${event.queuedAt}`}`;
@@ -62089,6 +62304,7 @@ ${cleanBody}`;
               meshCoordinators.map((c) => readNonEmptyString(c.sessionId)).filter(Boolean)
             );
             let orphanEscaped = 0;
+            const strictRoutedFingerprints = /* @__PURE__ */ new Set();
             const hasPendingForOrphanPeek = !store || (() => {
               try {
                 return store.pendingEventCount(meshId) > 0;
@@ -62123,10 +62339,11 @@ ${cleanBody}`;
                 for (const pending of drained) {
                   if (isOrphan(pending)) {
                     holdOrExpireStrictUnmatchedEvent(pending, readNonEmptyString(pending.targetCoordinatorSessionId), meshId);
+                    strictRoutedFingerprints.add(buildPendingEventFingerprint(pending));
                     orphanEscaped++;
                   } else {
                     try {
-                      queuePendingMeshCoordinatorEvent(pending);
+                      requeueDrainedPendingMeshCoordinatorEvent(pending);
                     } catch {
                     }
                   }
@@ -62149,7 +62366,8 @@ ${cleanBody}`;
                 meshId,
                 drainDaemonIds.length > 0 ? drainDaemonIds : localDaemonId ? [localDaemonId] : [],
                 "modal_parked",
-                modalParkedCoordinators.length
+                modalParkedCoordinators.length,
+                strictRoutedFingerprints
               );
             }
           } else if (generatingCoordinators.length > 0) {
@@ -62208,15 +62426,15 @@ ${cleanBody}`;
       const queuedAt = typeof pending.queuedAt === "number" ? pending.queuedAt : Date.now();
       if (Date.now() - queuedAt <= STRICT_SESSION_MATCH_TTL_MS) {
         try {
-          queuePendingMeshCoordinatorEvent(pending);
-          LOG2.info("MeshReconcile", `Strict route hold: coordinator session ${wantSession} not live on mesh ${meshId} \u2014 re-queued (${pending.event})`);
+          const requeued = requeueDrainedPendingMeshCoordinatorEvent(pending);
+          LOG2.info("MeshReconcile", `Strict route hold: coordinator session ${wantSession} not live on mesh ${meshId} \u2014 re-queued (${pending.event})${requeued ? "" : " [WARN: not durably re-queued]"}`);
           traceMeshEventDrop("strict_route_hold", {
             taskId: pending.metadataEvent?.taskId,
             sessionId: pending.metadataEvent?.targetSessionId ?? wantSession,
             nodeId: pending.nodeId,
             meshId,
             event: pending.event
-          }, `coordinatorSession=${wantSession} not live`);
+          }, `coordinatorSession=${wantSession} not live durable=${requeued}`);
         } catch (e) {
           LOG2.warn("MeshReconcile", `Strict route re-queue failed for ${pending.event} on mesh ${meshId}: ${e?.message || e}`);
         }
@@ -70820,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,
@@ -70829,6 +71048,7 @@ ${lastSnapshot}`;
       DaemonCommandRouter: () => DaemonCommandRouter,
       DaemonStatusReporter: () => DaemonStatusReporter,
       DevServer: () => DevServer,
+      DuplicateMeshDispatchError: () => DuplicateMeshDispatchError,
       FsmDriver: () => FsmDriver,
       GOAL_PREVIEW_MAX: () => GOAL_PREVIEW_MAX,
       GitCommandError: () => GitCommandError,
@@ -70938,6 +71158,7 @@ ${lastSnapshot}`;
       canonicalDaemonId: () => canonicalDaemonId,
       claimNextTask: () => claimNextTask,
       classifyChatMessageVisibility: () => classifyChatMessageVisibility,
+      classifyDuplicateMeshDispatch: () => classifyDuplicateMeshDispatch,
       classifyHotChatSessionsForSubscriptionFlush: () => classifyHotChatSessionsForSubscriptionFlush2,
       classifyP2pRelayFailure: () => classifyP2pRelayFailure,
       classifyShadowDivergence: () => classifyShadowDivergence,
@@ -70980,6 +71201,7 @@ ${lastSnapshot}`;
       detectIDEs: () => detectIDEs,
       detectNewlySettledCompletedSessions: () => detectNewlySettledCompletedSessions2,
       drainPendingMeshCoordinatorEvents: () => drainPendingMeshCoordinatorEvents,
+      encodeDuplicateMeshDispatchCode: () => encodeDuplicateMeshDispatchCode,
       enqueueTask: () => enqueueTask,
       ensureSessionHostReady: () => ensureSessionHostReady2,
       evaluateFsm: () => evaluateFsm,
@@ -73540,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");
@@ -85232,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"));
@@ -94745,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 {
@@ -110513,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") {
@@ -110524,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);