@adhdev/daemon-standalone 1.0.56-rc.19 → 1.0.56-rc.20

package/dist/index.js

@@ -36622,10 +36622,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "6d9cfa28a604d36d2b29cf1cdd21499c13171ab4" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "6d9cfa28" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.56-rc.19" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-08-20T17:59:03.306Z" : void 0);
+      const commit = readInjected(true ? "cc85ef744099479d57036518cd809b2c0a2ea5dc" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "cc85ef74" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.56-rc.20" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-08-21T01:12:48.071Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -53591,6 +53591,58 @@ The instruction it carried was never delivered to anyone. If it still matters, r
         MAX_CLONE_CHAIN = 16;
       }
     });
+    function selectClaimCandidate(candidates, gates) {
+      let deepestIndex = -1;
+      let deepestReason;
+      let deepest;
+      for (const candidate of candidates) {
+        const failedAt = gates.findIndex((gate) => !gate.test(candidate));
+        if (failedAt === -1) return { entry: candidate };
+        if (failedAt > deepestIndex) {
+          deepestIndex = failedAt;
+          deepestReason = gates[failedAt].reason;
+          deepest = candidate;
+        }
+      }
+      return { reason: deepestReason ?? "no_pending_candidates", ...deepest !== void 0 ? { deepest } : {} };
+    }
+    function claimDeferralKey(meshId, nodeId) {
+      return `${meshId}::${nodeId}`;
+    }
+    function noteClaimDeferredForNode(meshId, nodeId) {
+      if (!nodeId) return;
+      const key2 = claimDeferralKey(meshId, nodeId);
+      claimDeferredByFastForward.set(key2, (claimDeferredByFastForward.get(key2) || 0) + 1);
+      if (claimDeferredByFastForward.size > CLAIM_DEFERRAL_MAX_ENTRIES) {
+        const oldest = claimDeferredByFastForward.keys().next().value;
+        if (oldest !== void 0) claimDeferredByFastForward.delete(oldest);
+      }
+    }
+    function claimDeferralOwedForNode(meshId, nodeId) {
+      if (!nodeId) return false;
+      const seen = claimDeferredByFastForward.get(claimDeferralKey(meshId, nodeId)) || 0;
+      return seen > 0 && seen <= MAX_FAST_FORWARD_CLAIM_REDRIVES;
+    }
+    function shouldRedriveDeferredClaim(meshId, nodeId, sessionId, leaseHeld) {
+      if (!nodeId || !sessionId) return false;
+      if (!claimDeferralOwedForNode(meshId, nodeId)) return false;
+      return !leaseHeld();
+    }
+    function clearClaimDeferralForNode(meshId, nodeId) {
+      if (!nodeId) return;
+      claimDeferredByFastForward.delete(claimDeferralKey(meshId, nodeId));
+    }
+    var claimDeferredByFastForward;
+    var MAX_FAST_FORWARD_CLAIM_REDRIVES;
+    var CLAIM_DEFERRAL_MAX_ENTRIES;
+    var init_mesh_claim_refusal = __esm2({
+      "src/mesh/mesh-claim-refusal.ts"() {
+        "use strict";
+        claimDeferredByFastForward = /* @__PURE__ */ new Map();
+        MAX_FAST_FORWARD_CLAIM_REDRIVES = 3;
+        CLAIM_DEFERRAL_MAX_ENTRIES = 2e3;
+      }
+    });
     function meshTurnAttemptFromRow(r) {
       return {
         attemptId: r.attempt_id,
@@ -53740,6 +53792,7 @@ The instruction it carried was never delivered to anyone. If it still matters, r
         init_slot_model_enforcement();
         init_mesh_daemon_slot_axis();
         init_dist();
+        init_mesh_claim_refusal();
         init_mesh_runtime_store_turn_rows();
         init_mesh_runtime_store_turn_rows();
         loggedMigrationFailure = false;
@@ -54647,7 +54700,14 @@ The instruction it carried was never delivered to anyone. If it still matters, r
           claimNextQueueTask(meshId, nodeId, sessionId, capabilityTags = [], opts) {
             return this.transaction(() => {
               this.ensureLegacyQueueMigrated(meshId);
-              if (this.hasActiveSessionAssignment(meshId, sessionId)) return null;
+              const refuse = (reason, detail) => {
+                if (opts?.outRefusal) {
+                  opts.outRefusal.reason = reason;
+                  if (detail) opts.outRefusal.detail = detail;
+                }
+                return null;
+              };
+              if (this.hasActiveSessionAssignment(meshId, sessionId)) return refuse("session_already_assigned");
               const nodeBusy = this.hasActiveNodeAssignment(meshId, nodeId);
               const providerType = typeof opts?.providerType === "string" ? opts.providerType.trim() : "";
               const providerMaxParallel = opts?.providerMaxParallel;
@@ -54720,8 +54780,22 @@ The instruction it carried was never delivered to anyone. If it still matters, r
               const allowedTaskDifficulties = opts?.allowedTaskDifficulties;
               const difficultyAllows = (candidate) => !allowedTaskDifficulties || candidate.difficulty === "freeform" || !candidate.difficulty || allowedTaskDifficulties.includes(candidate.difficulty);
               const notParked = (candidate) => !taskIsParked(candidate);
-              const entry = candidates.find((candidate) => nodeSatisfiesRequiredTags(candidate.requiredTags, capabilityTags) && dependenciesSatisfied(candidate) && notBeforeReady(candidate) && notParked(candidate) && convergenceAllows(candidate) && targetMatches(candidate) && difficultyAllows(candidate) && parallelCapsAllow(candidate) && nodeConflictAllows(candidate));
-              if (!entry) return null;
+              const selected = selectClaimCandidate(candidates, [
+                { reason: "required_tags_unsatisfied", test: (c) => nodeSatisfiesRequiredTags(c.requiredTags, capabilityTags) },
+                { reason: "dependencies_unsatisfied", test: dependenciesSatisfied },
+                { reason: "not_before_delayed", test: notBeforeReady },
+                { reason: "task_parked", test: notParked },
+                { reason: "convergence_target_is_worktree", test: convergenceAllows },
+                { reason: "target_pin_unmatched", test: targetMatches },
+                { reason: "difficulty_floor_unmet", test: difficultyAllows },
+                { reason: "parallel_cap_reached", test: parallelCapsAllow },
+                { reason: "node_busy_with_active_assignment", test: nodeConflictAllows }
+              ]);
+              if (!selected.entry) {
+                if (!candidates.length) return refuse("no_pending_candidates");
+                return refuse(selected.reason, selected.deepest ? `closest candidate ${selected.deepest.id} of ${candidates.length}` : void 0);
+              }
+              const entry = selected.entry;
               const now = (/* @__PURE__ */ new Date()).toISOString();
               entry.status = "assigned";
               entry.assignedNodeId = nodeId;
@@ -63557,6 +63631,16 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     function getLastQuotaRanking(nodeId) {
       return lastQuotaRankingByNode.get(nodeId);
     }
+    function recordLastQuotaRankingOutcome(nodeId, outcome, refusalReason) {
+      if (!nodeId) return;
+      const existing = lastQuotaRankingByNode.get(nodeId);
+      if (!existing) return;
+      lastQuotaRankingByNode.set(nodeId, {
+        ...existing,
+        claimOutcome: outcome,
+        ...outcome === "refused" && refusalReason ? { claimRefusalReason: refusalReason } : {}
+      });
+    }
     function quotaSpreadBonusByProvider(node, policy, now = Date.now(), context) {
       const resolved = resolveQuotaRoutingPolicy(policy);
       const out = {};
@@ -64642,6 +64726,19 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return 0;
     }
+    function trimInProgressTurnToolTail(messages) {
+      if (!Array.isArray(messages) || messages.length === 0) return Array.isArray(messages) ? messages : [];
+      const isTrailingToolBubble = (msg) => {
+        if (!msg) return false;
+        const classification = classifyChatMessageVisibility(msg);
+        if (classification.role !== "assistant" && classification.role !== "model") return false;
+        return classification.kind === "tool" || classification.kind === "terminal";
+      };
+      if (!isTrailingToolBubble(messages[messages.length - 1])) return messages;
+      let cut = messages.length - 1;
+      while (cut >= 0 && isTrailingToolBubble(messages[cut])) cut -= 1;
+      return messages.slice(0, cut + 1);
+    }
     function canonicalizeKindHint(value) {
       return value.trim().toLowerCase().replace(/[\s-]+/g, "_");
     }
@@ -67010,6 +67107,36 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     function clearAllQuotaClaimCandidatesBlockedState(meshId) {
       lastAllQuotaClaimBlockedLog.delete(meshId);
     }
+    function claimRefusalKey(meshId, nodeId, sessionId) {
+      return `${meshId}:${nodeId}:${sessionId}`;
+    }
+    function recordClaimRefusal(meshId, args) {
+      if (!args.reason || args.reason === "no_pending_candidates") {
+        clearClaimRefusalState(meshId, args.nodeId, args.sessionId);
+        return;
+      }
+      const key2 = claimRefusalKey(meshId, args.nodeId, args.sessionId);
+      const fingerprint = `${args.reason}|${args.detail || ""}`;
+      if (lastClaimRefusalLog.get(key2) === fingerprint) return;
+      rememberBounded(lastClaimRefusalLog, key2, fingerprint);
+      LOG2.info("MeshQueue", `CLAIM REFUSED on node ${args.nodeId} (${args.sessionId}${args.providerType ? `, ${args.providerType}` : ""}) for mesh ${meshId}: ${args.reason}${args.detail ? ` \u2014 ${args.detail}` : ""}`);
+      try {
+        appendLedgerEntry(meshId, {
+          kind: "claim_refused",
+          nodeId: args.nodeId,
+          sessionId: args.sessionId,
+          ...args.providerType ? { providerType: args.providerType } : {},
+          payload: {
+            reason: args.reason,
+            ...args.detail ? { detail: args.detail } : {}
+          }
+        });
+      } catch {
+      }
+    }
+    function clearClaimRefusalState(meshId, nodeId, sessionId) {
+      lastClaimRefusalLog.delete(claimRefusalKey(meshId, nodeId, sessionId));
+    }
     function logAutoLaunchQuotaFallbackSuccess(resolved, taskId, nodeId, sessionId) {
       if (!resolved.providerType || !resolved.quotaGated?.length) return;
       const detail = resolved.quotaGated.map((item) => quotaClaimBlockDescription(item.providerType, item.block)).join("; ");
@@ -67050,6 +67177,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     }
     var lastQuotaClaimBlockLog;
     var lastAllQuotaClaimBlockedLog;
+    var lastClaimRefusalLog;
     var lastAutoLaunchLedgerKey;
     var AUTO_LAUNCH_LEDGER_DEDUP_MAX;
     var init_mesh_queue_observability = __esm2({
@@ -67060,6 +67188,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_quota_routing();
         lastQuotaClaimBlockLog = /* @__PURE__ */ new Map();
         lastAllQuotaClaimBlockedLog = /* @__PURE__ */ new Map();
+        lastClaimRefusalLog = /* @__PURE__ */ new Map();
         lastAutoLaunchLedgerKey = /* @__PURE__ */ new Map();
         AUTO_LAUNCH_LEDGER_DEDUP_MAX = 2e3;
       }
@@ -67874,7 +68003,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         }
       }
     }
-    function autoLaunchWriteWouldClobberWinner(meshId, taskId, args, awaitClaimWindowMs2) {
+    function autoLaunchWriteWouldClobberWinner(meshId, taskId, args, awaitClaimWindowMs3) {
       if (args.status === "completed" && readNonEmptyString(args.sessionId)) return false;
       let existing;
       try {
@@ -67885,7 +68014,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const heldSessionId = existing ? readNonEmptyString(existing.sessionId) : "";
       if (!existing || existing.status !== "completed" || !heldSessionId) return false;
       const heldAtMs = Date.parse(existing.updatedAt);
-      if (!Number.isFinite(heldAtMs) || Date.now() - heldAtMs >= awaitClaimWindowMs2) return false;
+      if (!Number.isFinite(heldAtMs) || Date.now() - heldAtMs >= awaitClaimWindowMs3) return false;
       if (sessionIdsEquivalent(readNonEmptyString(args.sessionId), heldSessionId)) return false;
       LOG2.info("MeshQueue", `AUTOLAUNCH-WINNER-CLOBBER: suppressed a '${args.status}' autoLaunch write for task ${taskId} (mesh ${meshId}) that would have overwritten the in-window launch record for session ${heldSessionId}; the field keeps pointing at the actually-launched session.`);
       return true;
@@ -67916,6 +68045,43 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       return out;
     }
+    function driveExpiredAwaitClaim(components, meshId, task, ctx, assignQueueTask) {
+      const { sessionId, nodeId, providerType } = ctx;
+      const backoffKey = `${meshId}::${task.id}`;
+      const nowMs = Date.now();
+      const state = autoLaunchAwaitClaimBackoff.get(backoffKey) || { cycles: 0, nextAttemptAtMs: 0 };
+      if (state.nextAttemptAtMs && nowMs < state.nextAttemptAtMs) return "backoff";
+      const atCap = state.cycles >= AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
+      const live = remoteSessionAppearsLive(meshId, sessionId);
+      if ((live || atCap) && nodeId && providerType) {
+        try {
+          MeshRuntimeStore.getInstance().setRemoteIdleSession(meshId, nodeId, sessionId, providerType, nowMs + AUTO_LAUNCH_REMOTE_IDLE_TTL_MS);
+        } catch {
+        }
+        const assigned = assignQueueTask(components, meshId, nodeId, sessionId, providerType);
+        if (assigned) {
+          autoLaunchAwaitClaimBackoff.delete(backoffKey);
+          const isFallback = atCap && !live;
+          recordAutoLaunchEvent(meshId, {
+            phase: "completed",
+            taskId: task.id,
+            reason: isFallback ? "await_claim_direct_dispatch_fallback" : "await_claim_redriven",
+            nodeId,
+            sessionId
+          });
+          LOG2.info("MeshQueue", `Auto-launch await-claim ${isFallback ? "direct-dispatch fallback" : "re-drive"} claimed task ${task.id} into existing session ${sessionId} on node ${nodeId} (mesh ${meshId})`);
+          return isFallback ? "fallback" : "claimed";
+        }
+        if (atCap) {
+          autoLaunchAwaitClaimBackoff.delete(backoffKey);
+          return "respawn";
+        }
+      }
+      const cycles = Math.min(state.cycles + 1, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES);
+      autoLaunchAwaitClaimBackoff.set(backoffKey, { cycles, nextAttemptAtMs: nowMs + awaitClaimWindowMs(cycles) });
+      recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim_backoff", nodeId, sessionId });
+      return "backoff";
+    }
     var AUTO_LAUNCH_AWAIT_CLAIM_MS;
     var AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES;
     var AUTO_LAUNCH_REMOTE_IDLE_TTL_MS;
@@ -68372,6 +68538,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       }
       if (isWorkspaceAutoFastForwardInFlight(readNonEmptyString(node?.workspace))) {
         LOG2.info("MeshQueue", `Deferring queue claim for node ${nodeId} (${sessionId}): an auto fast-forward is mutating its workspace \u2014 task left pending, claim re-fires next tick`);
+        noteClaimDeferredForNode(meshId, nodeId);
         return false;
       }
       const quotaClaimBlock = evaluateProviderQuotaGate(node, providerType, mesh?.policy?.quotaRouting ?? null, Date.now(), quotaFactsContextForLiveRouting(mesh, isLocalAutoLaunchNode, components.providerLoader));
@@ -68433,6 +68600,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
       const nodeIsWorktree = node?.isLocalWorktree === true;
       const assignedTranscriptProfile = resolveClaimingSessionTranscriptProfile(components, sessionId);
       const daemonNodeIds = resolveDaemonSiblingNodeIds(nodeId, mesh?.nodes);
+      const claimRefusal = {};
       const task = claimNextTask(meshId, nodeId, sessionId, capabilityTags, {
         providerType,
         ...providerMaxParallel !== void 0 ? { providerMaxParallel } : {},
@@ -68441,11 +68609,24 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         daemonNodeIds,
         nodeIsWorktree,
         ...allowedTaskDifficulties ? { allowedTaskDifficulties } : {},
-        ...assignedTranscriptProfile ? { assignedTranscriptProfile } : {}
+        ...assignedTranscriptProfile ? { assignedTranscriptProfile } : {},
+        outRefusal: claimRefusal
       });
       if (!task) {
+        const refusalReason = claimRefusal.reason || "no_pending_candidates";
+        recordClaimRefusal(meshId, {
+          nodeId,
+          sessionId,
+          ...providerType ? { providerType } : {},
+          reason: refusalReason,
+          ...claimRefusal.detail ? { detail: claimRefusal.detail } : {}
+        });
+        recordLastQuotaRankingOutcome(nodeId, "refused", refusalReason);
         return false;
       }
+      clearClaimRefusalState(meshId, nodeId, sessionId);
+      clearClaimDeferralForNode(meshId, nodeId);
+      recordLastQuotaRankingOutcome(nodeId, "claimed");
       if (quotaClaimTrace?.blocked.length) {
         logQuotaClaimFallbackSuccess(quotaClaimTrace.blocked, task.id, { nodeId, sessionId, providerType });
         quotaClaimTrace.blocked = [];
@@ -68931,43 +69112,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     function readMeshNodeId(node) {
       return normalizeMeshNodeId(node) ?? "";
     }
-    function driveExpiredAwaitClaim(components, meshId, task, ctx) {
-      const { sessionId, nodeId, providerType } = ctx;
-      const backoffKey = `${meshId}::${task.id}`;
-      const nowMs = Date.now();
-      const state = autoLaunchAwaitClaimBackoff.get(backoffKey) || { cycles: 0, nextAttemptAtMs: 0 };
-      if (state.nextAttemptAtMs && nowMs < state.nextAttemptAtMs) return "backoff";
-      const atCap = state.cycles >= AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES2;
-      const live = remoteSessionAppearsLive(meshId, sessionId);
-      if ((live || atCap) && nodeId && providerType) {
-        try {
-          MeshRuntimeStore.getInstance().setRemoteIdleSession(meshId, nodeId, sessionId, providerType, nowMs + AUTO_LAUNCH_REMOTE_IDLE_TTL_MS);
-        } catch {
-        }
-        const assigned = tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType);
-        if (assigned) {
-          autoLaunchAwaitClaimBackoff.delete(backoffKey);
-          const isFallback = atCap && !live;
-          recordAutoLaunchEvent(meshId, {
-            phase: "completed",
-            taskId: task.id,
-            reason: isFallback ? "await_claim_direct_dispatch_fallback" : "await_claim_redriven",
-            nodeId,
-            sessionId
-          });
-          LOG2.info("MeshQueue", `Auto-launch await-claim ${isFallback ? "direct-dispatch fallback" : "re-drive"} claimed task ${task.id} into existing session ${sessionId} on node ${nodeId} (mesh ${meshId})`);
-          return isFallback ? "fallback" : "claimed";
-        }
-        if (atCap) {
-          autoLaunchAwaitClaimBackoff.delete(backoffKey);
-          return "respawn";
-        }
-      }
-      const cycles = Math.min(state.cycles + 1, AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES2);
-      autoLaunchAwaitClaimBackoff.set(backoffKey, { cycles, nextAttemptAtMs: nowMs + awaitClaimWindowMs(cycles) });
-      recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim_backoff", nodeId, sessionId });
-      return "backoff";
-    }
     async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       const queue = getQueue(meshId);
       const statusById = new Map(queue.map((task) => [task.id, task.status]));
@@ -69048,11 +69192,22 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
             const alNodeId = readNonEmptyString(task.autoLaunch.nodeId);
             const alProvider = readNonEmptyString(task.autoLaunch.providerType);
             if (Number.isFinite(launchedAtMs) && Date.now() - launchedAtMs < AUTO_LAUNCH_AWAIT_CLAIM_MS) {
+              if (shouldRedriveDeferredClaim(meshId, alNodeId, alSessionId, () => isWorkspaceAutoFastForwardInFlight(readNonEmptyString(
+                (Array.isArray(mesh?.nodes) ? mesh.nodes.find((n) => meshNodeIdMatches(n, alNodeId)) : void 0)?.workspace
+              )))) {
+                if (tryAssignQueueTask(components, meshId, alNodeId, alSessionId, alProvider)) {
+                  clearClaimDeferralForNode(meshId, alNodeId);
+                  recordAutoLaunchEvent(meshId, { phase: "completed", taskId: task.id, reason: "fast_forward_deferred_claim_redriven", nodeId: alNodeId, sessionId: alSessionId });
+                  LOG2.info("MeshQueue", `Auto-launch re-drove the auto-fast-forward-deferred claim for task ${task.id} into session ${alSessionId} on node ${alNodeId} (mesh ${meshId})`);
+                  return true;
+                }
+                noteClaimDeferredForNode(meshId, alNodeId);
+              }
               recordAutoLaunchEvent(meshId, { phase: "skipped", taskId: task.id, reason: "awaiting_launched_session_claim", nodeId: alNodeId, sessionId: alSessionId });
               continue;
             }
             if (Number.isFinite(launchedAtMs) && alSessionId && alNodeId) {
-              const outcome = driveExpiredAwaitClaim(components, meshId, task, { sessionId: alSessionId, nodeId: alNodeId, providerType: alProvider });
+              const outcome = driveExpiredAwaitClaim(components, meshId, task, { sessionId: alSessionId, nodeId: alNodeId, providerType: alProvider }, tryAssignQueueTask);
               if (outcome === "claimed" || outcome === "fallback") return true;
               if (outcome === "backoff") continue;
             }
@@ -69502,7 +69657,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
     var autoLaunchTaskInProgress;
     var autoLaunchCooldownUntil;
     var AUTO_LAUNCH_COOLDOWN_MS;
-    var AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES2;
     var init_mesh_queue_assignment = __esm2({
       "src/mesh/mesh-queue-assignment.ts"() {
         "use strict";
@@ -69516,6 +69670,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_transcript_evidence();
         init_mesh_delivery_policy();
         init_mesh_runtime_store();
+        init_mesh_claim_refusal();
         init_mesh_event_trace();
         init_mesh_warmup_deadline();
         init_repo_mesh_types();
@@ -69545,6 +69700,7 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         init_mesh_auto_fast_forward();
         init_mesh_skip_notify();
         init_mesh_scheduling_fitness();
+        init_mesh_claim_refusal();
         init_mesh_autolaunch_integrity();
         BOOTSTRAP_TERMINAL_STATUSES = /* @__PURE__ */ new Set(["complete", "failed"]);
         DISPATCH_CONFIRM_TIMEOUT_MS = 12e4;
@@ -69556,7 +69712,6 @@ The mesh has no work in flight. For each mission, decide its outcome: continue i
         autoLaunchTaskInProgress = /* @__PURE__ */ new Set();
         autoLaunchCooldownUntil = /* @__PURE__ */ new Map();
         AUTO_LAUNCH_COOLDOWN_MS = 5e3;
-        AUTO_LAUNCH_AWAIT_CLAIM_BACKOFF_CAP_CYCLES2 = 2;
       }
     });
     function readSettings(state) {
@@ -73956,6 +74111,9 @@ ${cleanBody}`;
     function resolveAckedTranscriptFastTrackGraceMs() {
       return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_TRANSCRIPT_FASTTRACK_GRACE_MS", 4e4, 0, 5 * 6e4);
     }
+    function resolveAckedHoldHardCeilingMs() {
+      return resolveTunedReconcileMs("MESH_INFLIGHT_ACKED_HOLD_HARD_CEILING_MS", 90 * 6e4, 0, 24 * 60 * 6e4);
+    }
     function inFlightSynthKey(meshId, taskId) {
       return `${meshId}::${taskId}`;
     }
@@ -73985,20 +74143,32 @@ ${cleanBody}`;
       const state = {
         liveConfirmedSinceAck: row.holdReason === "live",
         consecutiveReadFailures: row.readFailureCount ?? 0,
-        ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {}
+        ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {},
+        ...row.heldAt !== null && row.heldAt !== void 0 ? { heldSinceMs: row.heldAt } : {}
       };
       inFlightAckedHoldState.set(synthKey, state);
       return state;
     }
     function setHoldState(synthKey, meshId, state) {
-      inFlightAckedHoldState.set(synthKey, state);
       const store = holdStore();
+      let priorHeldSinceMs = state.heldSinceMs ?? inFlightAckedHoldState.get(synthKey)?.heldSinceMs;
+      if (priorHeldSinceMs === void 0 && store) {
+        try {
+          priorHeldSinceMs = store.getInflightHold(taskIdFromSynthKey(meshId, synthKey))?.heldAt ?? void 0;
+        } catch {
+        }
+      }
+      const heldSinceMs = priorHeldSinceMs ?? Date.now();
+      inFlightAckedHoldState.set(synthKey, { ...state, heldSinceMs });
       if (!store) return;
       try {
         store.upsertInflightHold({
           taskId: taskIdFromSynthKey(meshId, synthKey),
           meshId,
           holdReason: state.liveConfirmedSinceAck ? "live" : "unconfirmed",
+          // Only meaningful when the row is NEW — upsertInflightHold deliberately
+          // preserves held_at on conflict, so an existing row keeps its original anchor.
+          heldAt: heldSinceMs,
           firstIdleSinceAck: state.transcriptIdleSinceMs ?? null,
           readFailureCount: state.consecutiveReadFailures
         });
@@ -74031,7 +74201,8 @@ ${cleanBody}`;
         inFlightAckedHoldState.set(synthKey, {
           liveConfirmedSinceAck: row.holdReason === "live",
           consecutiveReadFailures: row.readFailureCount ?? 0,
-          ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {}
+          ...row.firstIdleSinceAck !== null && row.firstIdleSinceAck !== void 0 ? { transcriptIdleSinceMs: row.firstIdleSinceAck } : {},
+          ...row.heldAt !== null && row.heldAt !== void 0 ? { heldSinceMs: row.heldAt } : {}
         });
       }
       if (rows.length > 0) {
@@ -75516,6 +75687,29 @@ ${cleanBody}`;
       }
       return fp;
     }
+    function terminalizeAckedHold(args) {
+      const { meshId, taskId, sessionId, nodeId, providerType, synthKey, reason, detail } = args;
+      updateDirectDispatchStatus(meshId, sessionId, "stale", taskId);
+      deleteHoldState(synthKey, meshId);
+      try {
+        appendLedgerEntry(meshId, {
+          kind: "acked_hold_terminalized",
+          nodeId,
+          sessionId,
+          ...providerType ? { providerType } : {},
+          taskId,
+          payload: { taskId, reason, ...detail }
+        });
+      } catch {
+      }
+      traceMeshEventStage("acked_hold_terminalized", {
+        taskId,
+        sessionId,
+        nodeId,
+        meshId,
+        event: "agent:generating_completed"
+      }, `${reason} \u2014 dispatch row marked stale, synth hold deleted`);
+    }
     async function reconcileUnterminatedDirectDispatches(components, mesh, selfIds, localDaemonId) {
       const dispatches = getActiveDirectDispatches(mesh.id);
       rehydrateAckedHoldsForMesh(mesh.id);
@@ -75539,7 +75733,9 @@ ${cleanBody}`;
         if (!sessionId || !nodeId || !taskId) continue;
         const node = nodeById.get(nodeId);
         const nodeDaemonId = readNonEmptyString(node?.daemonId);
-        const isLocalNode = !nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || !!components.instanceManager.getInstance(sessionId);
+        const sessionLiveHere = !!components.instanceManager.getInstance(sessionId);
+        const nodeIsGone = !node && !sessionLiveHere;
+        const isLocalNode = !nodeIsGone && (!nodeDaemonId || daemonIdListIncludes(selfIds, nodeDaemonId) || daemonIdsEquivalent(nodeDaemonId, localDaemonId) || sessionLiveHere);
         const providerType = readNonEmptyString(dispatch.providerType);
         const readArgs = {
           sessionId,
@@ -75550,10 +75746,41 @@ ${cleanBody}`;
         };
         const synthKey = inFlightSynthKey(mesh.id, taskId);
         const isAcked = dispatch.status === "acked";
+        if (isAcked) {
+          const ceilingMs = resolveAckedHoldHardCeilingMs();
+          const heldSinceMs = getHoldState(synthKey, mesh.id)?.heldSinceMs;
+          if (heldSinceMs !== void 0) {
+            const heldMs = Date.now() - heldSinceMs;
+            if (Number.isFinite(heldMs) && heldMs >= ceilingMs) {
+              LOG2.warn("MeshReconcile", `Acked-hold HARD CEILING exceeded: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) has held its synth for ${Math.round(heldMs / 6e4)}min (> ${Math.round(ceilingMs / 6e4)}min ceiling) without ever reaching a release condition \u2014 marking the dispatch row STALE and deleting the synth hold (no completion is asserted). A hold this old is presumed wedged, not slow.`);
+              terminalizeAckedHold({
+                meshId: mesh.id,
+                taskId,
+                sessionId,
+                nodeId,
+                ...providerType ? { providerType } : {},
+                synthKey,
+                reason: "acked_hold_time_ceiling",
+                detail: { heldMs, ceilingMs }
+              });
+              continue;
+            }
+          }
+        }
         let backstopKind;
         let payload = null;
         let readFailed = false;
         try {
+          if (nodeIsGone) {
+            traceMeshEventDrop("reconcile_synth_node_gone_no_transport", {
+              taskId,
+              sessionId,
+              nodeId,
+              meshId: mesh.id,
+              event: "agent:generating_completed"
+            }, `nodeId not present in mesh.nodes and no live local session \u2014 orphan-prune owns this row`);
+            continue;
+          }
           if (isLocalNode) {
             const result = await components.commandHandler.handle("read_chat", readArgs);
             if (result && result.success === false) {
@@ -75582,7 +75809,17 @@ ${cleanBody}`;
             const liveConfirmedSinceAck = prior?.liveConfirmedSinceAck ?? false;
             setHoldState(synthKey, mesh.id, { liveConfirmedSinceAck, consecutiveReadFailures: failures });
             if (liveConfirmedSinceAck && failures >= ACKED_DEATH_CONSECUTIVE_READ_FAILURES) {
-              LOG2.warn("MeshReconcile", `Acked-hold death signal: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read_chat failed ${failures}x consecutively after a live-confirmed ack \u2014 worker session presumed gone mid-turn; releasing the indefinite synth hold to the stranded-reclaim / orphan-prune nets`);
+              LOG2.warn("MeshReconcile", `Acked-hold death signal: task ${taskId} on node ${nodeId} (mesh ${mesh.id}) read_chat failed ${failures}x consecutively after a live-confirmed ack \u2014 worker session presumed gone mid-turn; marking the dispatch row STALE and deleting the synth hold (no completion is asserted \u2014 the transcript never showed one). Orphan-prune reaps the record on its own schedule.`);
+              terminalizeAckedHold({
+                meshId: mesh.id,
+                taskId,
+                sessionId,
+                nodeId,
+                ...providerType ? { providerType } : {},
+                synthKey,
+                reason: "acked_read_failure_death",
+                detail: { consecutiveReadFailures: failures, threshold: ACKED_DEATH_CONSECUTIVE_READ_FAILURES }
+              });
             }
           }
           continue;
@@ -106928,8 +107165,15 @@ ${buttons.join("\n")}`;
         // turn's half-written tail is hidden from the user. The completion gate needs the
         // exact opposite — it exists to judge the turn that JUST finished, so excluding the
         // in-progress turn would hide the very evidence it is looking for and would make
-        // missing_final_assistant strictly more common. Codex's manifest sets
-        // excludeInProgressTurn:true for its own read path; that must not leak here.
+        // missing_final_assistant strictly more common.
+        //
+        // Codex's provider.v1.json carries `nativeHistory.excludeInProgressTurn: true`,
+        // but that declaration is NOT what drives the read path and never reaches this
+        // call: the manifest field has no reader anywhere in daemon-core. The live
+        // behaviour comes from the per-call flag read_chat computes, which the loader's
+        // readNativeHistory wrapper applies (provider-loader.ts). The distinction matters
+        // — omitting the flag here is what keeps the in-progress turn visible to the gate,
+        // and no manifest declaration can override that.
       });
       host.lastNativeTurnTerminalMarkers = Array.isArray(restoredHistory.turnTerminalMarkers) ? restoredHistory.turnTerminalMarkers : null;
       if (restoredHistory.source !== "provider-native") {
@@ -113982,6 +114226,7 @@ Run 'adhdev doctor' for detailed diagnostics.`
     }
     init_external_sources();
     init_config();
+    init_chat_message_normalization();
     var fs41 = __toESM2(require("fs"));
     var os28 = __toESM2(require("os"));
     var path46 = __toESM2(require("path"));
@@ -118204,7 +118449,13 @@ Run 'adhdev doctor' for detailed diagnostics.`
               }
               if (reader) {
                 resolved.scripts = { ...resolved.scripts || {} };
-                resolved.scripts.readNativeHistory = reader;
+                resolved.scripts.readNativeHistory = (input) => {
+                  const result = reader(input);
+                  const wantsTrim = input?.excludeInProgressTurn === true || input?.args?.excludeInProgressTurn === true;
+                  if (!wantsTrim || !result || !Array.isArray(result.messages)) return result;
+                  const trimmed = trimInProgressTurnToolTail(result.messages);
+                  return trimmed === result.messages ? result : { ...result, messages: trimmed };
+                };
                 const scriptsMarker = { readSession: "readNativeHistory" };
                 if (lister) {
                   resolved.scripts.listNativeHistory = lister;