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

package/dist/index.js

@@ -33311,10 +33311,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "73deced0f13f811d8474de1a99d1b2133dda1d4f" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "73deced0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.28-rc.19" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-27T17:36:58.024Z" : void 0);
+      const commit = readInjected(true ? "284a88d08b7bb93b250385f4da9c523fb4d8fd68" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "284a88d0" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.28-rc.20" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-28T17:20:58.778Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -37340,6 +37340,14 @@ ${error48.message || ""}`;
     function noteRejectedProposal(reason) {
       metrics.completionProposalsRejected[reason] = (metrics.completionProposalsRejected[reason] ?? 0) + 1;
     }
+    function noteDroppedSuspension(reason) {
+      metrics.suspensionsDropped[reason] = (metrics.suspensionsDropped[reason] ?? 0) + 1;
+    }
+    function logSuspensionOnce(level, key2, message) {
+      if (suspensionLogKeys.has(key2)) return;
+      if (suspensionLogKeys.size < MAX_SUSPENSION_LOG_KEYS) suspensionLogKeys.add(key2);
+      LOG2[level]("TurnLedger", message);
+    }
     function noteAckLatency(fromIso, nowMs) {
       if (!fromIso) return;
       const parsed = Date.parse(fromIso);
@@ -37481,10 +37489,16 @@ ${error48.message || ""}`;
       if (args.kind === "accepted") {
         return { attemptId: attempt.attemptId, stage: attempt.stage, applied: false, staleAttempt: false };
       }
-      const stageAfter = store.advanceTurnAttemptStage(attempt.attemptId, args.kind, allowedFromStages(args.kind).join(","), {
+      const stageAfter = args.kind === "consumed" ? store.transaction(() => {
+        const after = store.advanceTurnAttemptStage(attempt.attemptId, args.kind, allowedFromStages(args.kind).join(","), {
+          updatedAt: nowIso,
+          consumedAt: nowIso
+        });
+        drainHeldSuspensionsForAttempt(store, attempt.attemptId, nowMs, nowIso);
+        return after;
+      }) : store.advanceTurnAttemptStage(attempt.attemptId, args.kind, allowedFromStages(args.kind).join(","), {
         updatedAt: nowIso,
-        deliveredAt: args.kind === "delivered" ? nowIso : void 0,
-        consumedAt: args.kind === "consumed" ? nowIso : void 0
+        deliveredAt: args.kind === "delivered" ? nowIso : void 0
       });
       const applied = stageAfter === args.kind && attempt.stage !== args.kind;
       if (applied) noteAckLatency(fromIso, nowMs);
@@ -37525,9 +37539,15 @@ ${error48.message || ""}`;
           occurredAtMs: args.occurredAtMs ?? nowMs,
           recordedAt: nowIso
         });
+        if (SUSPENDED_STAGES.has(args.stage)) {
+          dropHeldSuspensionsForAttempt(store, attempt.attemptId, "stale_attempt", nowIso);
+        }
         return { attemptId: attempt.attemptId, stage: attempt.stage, applied: false, staleAttempt: true };
       }
       if (isTerminalTurnStage(attempt.stage)) {
+        if (SUSPENDED_STAGES.has(args.stage)) {
+          dropHeldSuspensionsForAttempt(store, attempt.attemptId, "attempt_terminal", nowIso);
+        }
         return { attemptId: attempt.attemptId, stage: attempt.stage, applied: false, staleAttempt: false };
       }
       const inserted = store.insertTurnEvent({
@@ -37542,9 +37562,45 @@ ${error48.message || ""}`;
         recordedAt: nowIso
       });
       if (!inserted) metrics.duplicateTurnEvents += 1;
+      if (args.stage === "generating" && SUSPENDED_STAGES.has(attempt.stage) && typeof args.occurredAtMs === "number") {
+        const appliedHold = store.getHeldTurnSuspension(attempt.attemptId, attempt.stage);
+        if (appliedHold && appliedHold.status === "applied" && typeof appliedHold.occurredAtMs === "number" && args.occurredAtMs < appliedHold.occurredAtMs) {
+          metrics.reorderedGeneratingSuppressed += 1;
+          logSuspensionOnce(
+            "info",
+            `reordered:${attempt.attemptId}`,
+            `Suppressed reordered generating for task ${args.taskId} attempt ${attempt.attemptId}: event occurred ${args.occurredAtMs} < applied ${attempt.stage} suspension at ${appliedHold.occurredAtMs} \u2014 the suspension stage stands`
+          );
+          return { attemptId: attempt.attemptId, stage: attempt.stage, applied: false, staleAttempt: false };
+        }
+      }
       const stageAfter = store.advanceTurnAttemptStage(attempt.attemptId, args.stage, allowedFromStages(args.stage).join(","), {
         updatedAt: nowIso
       });
+      if (SUSPENDED_STAGES.has(args.stage) && stageAfter !== null && stageAfter !== args.stage && STAGE_RANK[stageAfter] < STAGE_RANK.consumed) {
+        const held = store.insertHeldTurnSuspension({
+          holdId: `${attempt.attemptId}:${args.stage}`,
+          meshId: args.meshId,
+          attemptId: attempt.attemptId,
+          taskId: args.taskId,
+          stage: args.stage,
+          sessionId: args.sessionId,
+          dispatchNonce: attempt.dispatchNonce,
+          occurredAtMs: args.occurredAtMs ?? nowMs,
+          recordedAt: nowIso
+        });
+        if (held) {
+          metrics.suspensionsHeld += 1;
+          logSuspensionOnce(
+            "info",
+            `held:${attempt.attemptId}:${args.stage}`,
+            `Held ${args.stage} suspension for task ${args.taskId} attempt ${attempt.attemptId} (stage ${stageAfter} \u2014 consumed not yet durable); applying after the consumed ACK`
+          );
+        } else {
+          metrics.duplicateTurnEvents += 1;
+        }
+        return { attemptId: attempt.attemptId, stage: stageAfter, applied: false, staleAttempt: false, deferred: true };
+      }
       return {
         attemptId: attempt.attemptId,
         stage: stageAfter ?? attempt.stage,
@@ -37552,6 +37608,188 @@ ${error48.message || ""}`;
         staleAttempt: false
       };
     }
+    function dropHeldSuspensionsForAttempt(store, attemptId, reason, nowIso) {
+      const held = store.listHeldTurnSuspensionsForAttempt(attemptId, "held");
+      let dropped = 0;
+      for (const hold of held) {
+        if (store.resolveHeldTurnSuspension(hold.holdId, "dropped", reason, nowIso)) {
+          noteDroppedSuspension(reason);
+          logSuspensionOnce(
+            "info",
+            `dropped:${reason}:${attemptId}:${hold.stage}`,
+            `Dropped held ${hold.stage} suspension for task ${hold.taskId} attempt ${attemptId}: ${reason}`
+          );
+          dropped += 1;
+        }
+      }
+      return dropped;
+    }
+    function drainHeldSuspensionsForAttempt(store, attemptId, nowMs, nowIso) {
+      const held = store.listHeldTurnSuspensionsForAttempt(attemptId, "held");
+      if (held.length === 0) return { applied: 0, dropped: 0 };
+      let attempt = store.getTurnAttempt(attemptId);
+      let applied = 0;
+      let dropped = 0;
+      for (const hold of held) {
+        if (!attempt) {
+          if (store.resolveHeldTurnSuspension(hold.holdId, "dropped", "attempt_missing", nowIso)) {
+            noteDroppedSuspension("attempt_missing");
+            dropped += 1;
+          }
+          continue;
+        }
+        if (attempt.terminalOutcome || isTerminalTurnStage(attempt.stage)) {
+          if (store.resolveHeldTurnSuspension(hold.holdId, "dropped", "attempt_terminal", nowIso)) {
+            noteDroppedSuspension("attempt_terminal");
+            logSuspensionOnce(
+              "info",
+              `dropped:attempt_terminal:${attemptId}:${hold.stage}`,
+              `Dropped held ${hold.stage} suspension for task ${hold.taskId} attempt ${attemptId}: attempt terminal (${attempt.terminalOutcome ?? attempt.stage})`
+            );
+            dropped += 1;
+          }
+          continue;
+        }
+        if (attempt.stage === "finalizing") {
+          if (store.resolveHeldTurnSuspension(hold.holdId, "dropped", "finalizing", nowIso)) {
+            noteDroppedSuspension("finalizing");
+            dropped += 1;
+          }
+          continue;
+        }
+        if (STAGE_RANK[attempt.stage] < STAGE_RANK.consumed) {
+          continue;
+        }
+        const stageAfter = store.advanceTurnAttemptStage(attemptId, hold.stage, allowedFromStages(hold.stage).join(","), {
+          updatedAt: nowIso
+        });
+        if (stageAfter === hold.stage) {
+          if (store.resolveHeldTurnSuspension(hold.holdId, "applied", "applied", nowIso)) {
+            store.insertTurnEvent({
+              eventId: (0, import_crypto5.randomUUID)(),
+              meshId: hold.meshId,
+              attemptId,
+              taskId: hold.taskId,
+              kind: `held_${hold.stage}_applied`,
+              dedupeKey: hold.holdId,
+              occurredAtMs: hold.occurredAtMs ?? nowMs,
+              recordedAt: nowIso
+            });
+            metrics.suspensionsApplied += 1;
+            logSuspensionOnce(
+              "info",
+              `applied:${attemptId}:${hold.stage}`,
+              `Applied held ${hold.stage} suspension for task ${hold.taskId} attempt ${attemptId} after consumed became durable`
+            );
+            applied += 1;
+          }
+          attempt = { ...attempt, stage: stageAfter };
+        } else {
+          const reason = stageAfter === "finalizing" ? "finalizing" : "stage_advanced";
+          if (store.resolveHeldTurnSuspension(hold.holdId, "dropped", reason, nowIso)) {
+            noteDroppedSuspension(reason);
+            logSuspensionOnce(
+              "warn",
+              `dropped:${reason}:${attemptId}:${hold.stage}`,
+              `Held ${hold.stage} suspension for task ${hold.taskId} attempt ${attemptId} could not apply (stage now ${stageAfter ?? "missing"}) \u2014 dropped:${reason}`
+            );
+            dropped += 1;
+          }
+        }
+      }
+      return { applied, dropped };
+    }
+    function drainHeldTurnSuspensionsForMesh(meshId, nowMs = Date.now()) {
+      try {
+        const store = MeshRuntimeStore.getInstance();
+        const nowIso = new Date(nowMs).toISOString();
+        const held = store.listHeldTurnSuspensionsForMesh(meshId, "held");
+        let applied = 0;
+        let dropped = 0;
+        for (const attemptId of new Set(held.map((h) => h.attemptId))) {
+          const res = drainHeldSuspensionsForAttempt(store, attemptId, nowMs, nowIso);
+          applied += res.applied;
+          dropped += res.dropped;
+        }
+        const stillHeld = store.listHeldTurnSuspensionsForMesh(meshId, "held").length;
+        if (applied + dropped > 0 || held.length > 0) {
+          LOG2.info("TurnLedger", `Held-suspension drain for mesh ${meshId}: applied=${applied} dropped=${dropped} stillHeld=${stillHeld}`);
+        }
+        return { applied, dropped, stillHeld };
+      } catch (e) {
+        LOG2.warn("TurnLedger", `Held-suspension drain failed for mesh ${meshId} (rows stay held; retried on next boot/consumed): ${e?.message || e}`);
+        return { applied: 0, dropped: 0, stillHeld: 0 };
+      }
+    }
+    function heldSuspensionBlocksAttempt(hold, attempt) {
+      if (hold.attemptId !== attempt.attemptId) return false;
+      if (attempt.terminalOutcome || isTerminalTurnStage(attempt.stage)) return false;
+      if (STAGE_RANK[attempt.stage] >= STAGE_RANK.consumed) return false;
+      if (!hold.sessionId || !attempt.sessionId || !sessionIdsEquivalent(hold.sessionId, attempt.sessionId)) return false;
+      if (typeof hold.dispatchNonce !== "number" || typeof attempt.dispatchNonce !== "number" || hold.dispatchNonce !== attempt.dispatchNonce) return false;
+      return true;
+    }
+    function gateRedriveForHeldSuspension(args) {
+      const store = MeshRuntimeStore.getInstance();
+      const nowMs = args.nowMs ?? Date.now();
+      const nowIso = new Date(nowMs).toISOString();
+      const attempt = store.getCurrentTurnAttempt(args.meshId, args.taskId);
+      if (!attempt) return { kind: "none" };
+      const holds = store.listHeldTurnSuspensionsForAttempt(attempt.attemptId, "held").filter((h) => heldSuspensionBlocksAttempt(h, attempt));
+      if (holds.length === 0) return { kind: "none" };
+      if (args.sessionLiveness === "alive") {
+        let promoted = false;
+        store.transaction(() => {
+          if (STAGE_RANK[attempt.stage] < STAGE_RANK.consumed) {
+            store.insertTurnEvent({
+              eventId: (0, import_crypto5.randomUUID)(),
+              meshId: args.meshId,
+              attemptId: attempt.attemptId,
+              taskId: args.taskId,
+              kind: "consumed",
+              dedupeKey: "",
+              payload: safeEvidenceJson({ source: "held_suspension_recovery" }),
+              occurredAtMs: holds[0].occurredAtMs ?? nowMs,
+              recordedAt: nowIso
+            });
+            store.advanceTurnAttemptStage(attempt.attemptId, "consumed", allowedFromStages("consumed").join(","), {
+              updatedAt: nowIso,
+              consumedAt: nowIso
+            });
+            promoted = true;
+          }
+          drainHeldSuspensionsForAttempt(store, attempt.attemptId, nowMs, nowIso);
+        });
+        const stage = store.getTurnAttempt(attempt.attemptId)?.stage ?? attempt.stage;
+        if (promoted) {
+          metrics.suspensionConsumedRecovered += 1;
+          logSuspensionOnce(
+            "info",
+            `recovered:${attempt.attemptId}`,
+            `Recovered consumed evidence for task ${args.taskId} attempt ${attempt.attemptId} from held ${holds.map((h) => h.stage).join("/")} suspension(s): surviving session confirmed rebound (audit source held_suspension_recovery) \u2014 the SAME attempt continues`
+          );
+        }
+        return { kind: "recovered", attemptId: attempt.attemptId, stage };
+      }
+      if (args.sessionProvenDead) {
+        const dropped = dropHeldSuspensionsForAttempt(store, attempt.attemptId, "session_dead", nowIso);
+        if (dropped > 0) {
+          logSuspensionOnce(
+            "info",
+            `released:${attempt.attemptId}`,
+            `Released ${dropped} held suspension(s) for task ${args.taskId} attempt ${attempt.attemptId}: worker session demonstrably dead \u2014 redrive/reassign may proceed to a NEW attempt`
+          );
+        }
+        return { kind: "released", attemptId: attempt.attemptId, dropped };
+      }
+      metrics.redriveBlockedBySuspension += 1;
+      logSuspensionOnce(
+        "info",
+        `blocked:${attempt.attemptId}`,
+        `Redrive blocked by unresolved held ${holds.map((h) => h.stage).join("/")} suspension(s) for task ${args.taskId} attempt ${attempt.attemptId}: the prompt reached the worker (session liveness unconfirmed \u2014 awaiting rebind or the dead-detection grace)`
+      );
+      return { kind: "blocked", attemptId: attempt.attemptId, stages: holds.map((h) => h.stage) };
+    }
     function proposeTurnCompletion(proposal) {
       const store = MeshRuntimeStore.getInstance();
       const nowMs = proposal.nowMs ?? Date.now();
@@ -37585,6 +37823,7 @@ ${error48.message || ""}`;
         return { committed: false, reason: "epoch_mismatch", attemptId: attempt.attemptId };
       }
       if (attempt.terminalOutcome) {
+        dropHeldSuspensionsForAttempt(store, attempt.attemptId, "attempt_terminal", nowIso);
         if (attempt.terminalOutcome === proposal.outcome) {
           metrics.duplicateTurnEvents += 1;
           return { committed: true, attemptId: attempt.attemptId, outcome: proposal.outcome, duplicate: true };
@@ -37611,6 +37850,7 @@ ${error48.message || ""}`;
         return { committed: false, reason: "already_terminal", attemptId: attempt.attemptId, existingOutcome: winner };
       }
       metrics.completionProposalsCommitted += 1;
+      dropHeldSuspensionsForAttempt(store, attempt.attemptId, "attempt_terminal", nowIso);
       LOG2.info("TurnLedger", `Committed terminal ${proposal.outcome} for task ${proposal.taskId} attempt ${attempt.attemptId} (source=${proposal.source}, stage was ${attempt.stage})`);
       return { committed: true, attemptId: attempt.attemptId, outcome: proposal.outcome, duplicate: false };
     }
@@ -37788,7 +38028,10 @@ ${error48.message || ""}`;
     var import_crypto5;
     var TURN_TERMINAL_OUTCOMES;
     var STAGE_RANK;
+    var SUSPENDED_STAGES;
     var metrics;
+    var MAX_SUSPENSION_LOG_KEYS;
+    var suspensionLogKeys;
     var MAX_REDRIVES_PER_ATTEMPT;
     var sessionOrderChains;
     var init_mesh_turn_ledger = __esm2({
@@ -37811,6 +38054,7 @@ ${error48.message || ""}`;
           failed: 60,
           cancelled: 60
         };
+        SUSPENDED_STAGES = /* @__PURE__ */ new Set(["waiting_approval", "waiting_choice"]);
         metrics = {
           duplicatePromptPrevented: 0,
           ackLatencyCount: 0,
@@ -37820,8 +38064,16 @@ ${error48.message || ""}`;
           staleAttemptEvents: 0,
           transactionConflicts: 0,
           sameSessionStaleNonceCompatAccepted: 0,
-          duplicateTurnEvents: 0
+          duplicateTurnEvents: 0,
+          suspensionsHeld: 0,
+          suspensionsApplied: 0,
+          suspensionsDropped: {},
+          reorderedGeneratingSuppressed: 0,
+          redriveBlockedBySuspension: 0,
+          suspensionConsumedRecovered: 0
         };
+        MAX_SUSPENSION_LOG_KEYS = 200;
+        suspensionLogKeys = /* @__PURE__ */ new Set();
         MAX_REDRIVES_PER_ATTEMPT = 1;
         sessionOrderChains = /* @__PURE__ */ new Map();
       }
@@ -41011,6 +41263,22 @@ Next step: ${nextStep}`;
         updatedAt: r.updated_at
       };
     }
+    function meshTurnHeldSuspensionFromRow(r) {
+      return {
+        holdId: r.hold_id,
+        meshId: r.mesh_id,
+        attemptId: r.attempt_id,
+        taskId: r.task_id,
+        stage: r.stage,
+        sessionId: r.session_id,
+        dispatchNonce: r.dispatch_nonce,
+        occurredAtMs: r.occurred_at_ms,
+        recordedAt: r.recorded_at,
+        status: r.status,
+        resolution: r.resolution,
+        resolvedAt: r.resolved_at
+      };
+    }
     function pruneMeshRuntimeRetention() {
       try {
         const store = MeshRuntimeStore.getInstance();
@@ -41450,6 +41718,37 @@ Next step: ${nextStep}`;
                 ON mesh_turn_outbox(status, next_attempt_at_ms);
             CREATE INDEX IF NOT EXISTS idx_mesh_turn_outbox_mesh
                 ON mesh_turn_outbox(mesh_id, status);
+
+            -- TURN-LEDGER (Stage 5): durable HELD SUSPENSIONS. A waiting_approval /
+            -- waiting_choice edge can legitimately arrive BEFORE the consumed ACK
+            -- (a fast picker fires ahead of the generating_started processing, whose
+            -- attempt-resolution preamble defers the consumed write). The causal FSM
+            -- rightly refuses accepted/delivered \u2192 waiting_*; instead of dropping the
+            -- edge, the reducer holds it here \u2014 attempt/session/epoch-scoped and
+            -- content-free \u2014 insert-once via hold_id (<attempt_id>:<stage>). The
+            -- consumed commit applies the hold through the SAME FSM in the same
+            -- transaction; the restart reconcile drain covers a crash between hold
+            -- and consumed; terminal commits resolve held rows as dropped so a held
+            -- picker can never resurrect a finished/reassigned attempt.
+            CREATE TABLE IF NOT EXISTS mesh_turn_held_suspensions (
+                hold_id TEXT PRIMARY KEY,
+                mesh_id TEXT NOT NULL,
+                attempt_id TEXT NOT NULL,
+                task_id TEXT NOT NULL,
+                stage TEXT NOT NULL,
+                session_id TEXT,
+                dispatch_nonce INTEGER,
+                occurred_at_ms INTEGER,
+                recorded_at TEXT NOT NULL,
+                status TEXT NOT NULL DEFAULT 'held',
+                resolution TEXT,
+                resolved_at TEXT
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_mesh_turn_held_suspensions_mesh
+                ON mesh_turn_held_suspensions(mesh_id, status);
+            CREATE INDEX IF NOT EXISTS idx_mesh_turn_held_suspensions_attempt
+                ON mesh_turn_held_suspensions(attempt_id, status);
         `);
             this.migrateMeshIsolationColumns();
           }
@@ -43234,6 +43533,74 @@ Next step: ${nextStep}`;
             for (const r of rows) out[r.status] = r.n;
             return out;
           }
+          // ── TURN-LEDGER (Stage 5): held suspensions (pre-consumed waiting_*) ─────
+          /**
+           * Hold a pre-consumed suspension edge. INSERT OR IGNORE on the hold id
+           * (`<attemptId>:<stage>`) makes duplicate/reordered suspension arrivals
+           * insert-once. Returns true when this call inserted (first hold).
+           */
+          insertHeldTurnSuspension(row) {
+            const res = this.db.prepare(`
+            INSERT OR IGNORE INTO mesh_turn_held_suspensions (
+                hold_id, mesh_id, attempt_id, task_id, stage, session_id, dispatch_nonce, occurred_at_ms, recorded_at, status
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, 'held')
+        `).run(
+              row.holdId,
+              row.meshId,
+              row.attemptId,
+              row.taskId,
+              row.stage,
+              row.sessionId ?? null,
+              row.dispatchNonce ?? null,
+              row.occurredAtMs ?? null,
+              row.recordedAt
+            );
+            this.maybeCheckpointWal();
+            return res.changes > 0;
+          }
+          /** The hold row for one (attempt, stage) pair, any status (held/applied/dropped). */
+          getHeldTurnSuspension(attemptId, stage) {
+            const row = this.db.prepare(
+              "SELECT * FROM mesh_turn_held_suspensions WHERE hold_id = ? LIMIT 1"
+            ).get(`${attemptId}:${stage}`);
+            return row ? meshTurnHeldSuspensionFromRow(row) : null;
+          }
+          /** Hold rows for an attempt, oldest occurrence first (drain order). */
+          listHeldTurnSuspensionsForAttempt(attemptId, status) {
+            const rows = status ? this.db.prepare(`
+                SELECT * FROM mesh_turn_held_suspensions
+                WHERE attempt_id = ? AND status = ?
+                ORDER BY occurred_at_ms ASC, hold_id ASC
+            `).all(attemptId, status) : this.db.prepare(`
+                SELECT * FROM mesh_turn_held_suspensions
+                WHERE attempt_id = ?
+                ORDER BY occurred_at_ms ASC, hold_id ASC
+            `).all(attemptId);
+            return rows.map(meshTurnHeldSuspensionFromRow);
+          }
+          /** Hold rows for a mesh by status (the restart-reconcile drain set). */
+          listHeldTurnSuspensionsForMesh(meshId, status) {
+            const rows = this.db.prepare(`
+            SELECT * FROM mesh_turn_held_suspensions
+            WHERE mesh_id = ? AND status = ?
+            ORDER BY occurred_at_ms ASC, hold_id ASC
+        `).all(meshId, status);
+            return rows.map(meshTurnHeldSuspensionFromRow);
+          }
+          /**
+           * Resolve a hold exactly once: the status='held' guard makes a concurrent
+           * drain/terminal resolution converge on a single winner. Returns true when
+           * this call flipped the row.
+           */
+          resolveHeldTurnSuspension(holdId, status, resolution, resolvedAt) {
+            const res = this.db.prepare(`
+            UPDATE mesh_turn_held_suspensions
+            SET status = ?, resolution = ?, resolved_at = ?
+            WHERE hold_id = ? AND status = 'held'
+        `).run(status, resolution, resolvedAt, holdId);
+            this.maybeCheckpointWal();
+            return res.changes > 0;
+          }
         };
         MESH_EVENT_LEDGER_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
         MESH_TOOL_CALL_LOG_RETENTION_MS = 14 * 24 * 60 * 60 * 1e3;
@@ -49679,8 +50046,17 @@ ${rendered}`, "utf-8");
           waitingMs: record2.elapsedMs
         });
       }
-      approvals.sort((a, b) => b.waitingMs - a.waitingMs);
-      return approvals;
+      const bySession = /* @__PURE__ */ new Map();
+      for (const approval of approvals) {
+        const key2 = `${approval.nodeId}::${approval.sessionId}`;
+        const existing = bySession.get(key2);
+        if (!existing || approval.waitingMs > existing.waitingMs) {
+          bySession.set(key2, approval);
+        }
+      }
+      const deduped = [...bySession.values()];
+      deduped.sort((a, b) => b.waitingMs - a.waitingMs);
+      return deduped;
     }
     function buildMeshActiveWorkSummary(activeWork) {
       const statusCounts = {
@@ -57418,7 +57794,7 @@ ${cleanBody}`;
         const suspendedTaskId = readNonEmptyString(args.metadataEvent.taskId);
         if (suspendedTaskId) {
           try {
-            recordTurnStage({
+            const recorded = recordTurnStage({
               meshId: args.meshId,
               taskId: suspendedTaskId,
               stage: args.event === "agent:waiting_approval" ? "waiting_approval" : "waiting_choice",
@@ -57426,7 +57802,12 @@ ${cleanBody}`;
               sessionId: eventSessionId,
               occurredAtMs: eventTimestamp ?? void 0
             });
-          } catch {
+            if (recorded?.deferred) {
+              traceMeshEventStage("turn_suspension_held", traceCtx, `${args.event} preceded the consumed ACK \u2014 held for post-consumed drain`);
+            }
+          } catch (e) {
+            LOG2.warn("TurnLedger", `Failed to record ${args.event} suspension for task ${suspendedTaskId} (session ${eventSessionId}): ${e?.message || e}`);
+            traceMeshEventDrop("turn_suspension_record_error", traceCtx, e?.message ? String(e.message) : void 0);
           }
         }
       }
@@ -59649,6 +60030,51 @@ ${cleanBody}`;
       }
       return true;
     }
+    function restampReboundMeshWorkerAssignment(components, store, meshId, row) {
+      const sessionId = readNonEmptyString(row.assignedSessionId);
+      if (!sessionId) return false;
+      const inst = components.instanceManager?.getInstance?.(sessionId);
+      if (!inst || typeof inst.attachMeshAssignment !== "function") return false;
+      let settings = {};
+      try {
+        settings = inst.getState?.()?.settings || {};
+      } catch {
+        return false;
+      }
+      if (readNonEmptyString(settings.meshActiveTaskId)) return false;
+      const attempt = (() => {
+        try {
+          return store.getCurrentTurnAttempt(meshId, row.id);
+        } catch {
+          return null;
+        }
+      })();
+      if (attempt) {
+        if (attempt.terminalOutcome) return false;
+        const attemptSessionId = readNonEmptyString(attempt.sessionId);
+        if (attemptSessionId && !sessionIdsEquivalent(attemptSessionId, sessionId)) return false;
+      }
+      const nodeId = readNonEmptyString(row.assignedNodeId);
+      const coordinatorDaemonId = readNonEmptyString(attempt?.coordinatorDaemonId);
+      const coordinatorSessionId = readNonEmptyString(attempt?.coordinatorSessionId);
+      try {
+        const result = components.instanceManager?.attachMeshAssignmentToInstance?.(sessionId, {
+          meshId,
+          ...nodeId ? { nodeId } : {},
+          taskId: row.id,
+          ...typeof attempt?.dispatchNonce === "number" ? { dispatchNonce: attempt.dispatchNonce } : typeof row.dispatchNonce === "number" ? { dispatchNonce: row.dispatchNonce } : {},
+          ...attempt?.attemptId ? { attemptId: attempt.attemptId } : {},
+          ...coordinatorDaemonId ? { coordinatorDaemonId } : {},
+          ...coordinatorSessionId ? { coordinatorSessionId } : {}
+        });
+        if (result?.stamped) {
+          LOG2.info("MeshReconcile", `Re-stamped rebound mesh worker ${sessionId} from the durable ledger: task ${row.id} on mesh ${meshId} (attempt=${attempt?.attemptId ?? "n/a"} nonce=${attempt?.dispatchNonce ?? row.dispatchNonce ?? "n/a"}) \u2014 in-memory envelope lost (daemon restart)`);
+          return true;
+        }
+      } catch {
+      }
+      return false;
+    }
     async function recoverStrandedAssignedDispatches(components, mesh, store, localDaemonId, selfIds = []) {
       const meshId = mesh.id;
       const assigned = getQueue(meshId, { status: ["assigned"] });
@@ -59666,6 +60092,7 @@ ${cleanBody}`;
         if (key2.startsWith(meshKeyPrefix) && !assignedKeys.has(key2)) assignedIdleFinalAssistantSince.delete(key2);
       }
       for (const row of assigned) {
+        restampReboundMeshWorkerAssignment(components, store, meshId, row);
         const dispatchedAtMs = Date.parse(row.dispatchTimestamp ?? "");
         if (!Number.isFinite(dispatchedAtMs)) continue;
         const ageMs2 = nowMs - dispatchedAtMs;
@@ -59764,6 +60191,16 @@ ${cleanBody}`;
           const verdict = row.assignedSessionId ? resolveSessionBusyVerdict(components, row.assignedSessionId) : "IDLE_CONFIRMED";
           if (verdict === "GENERATING") {
             deliveredUnconsumedUnknownStreak.delete(shortStreakKey);
+            const gate = gateRedriveForHeldSuspension({ meshId, taskId: row.id, sessionLiveness: "alive", nowMs });
+            if (gate.kind === "recovered") {
+              traceMeshEventDrop("suspension_consumed_recovered", {
+                taskId: row.id,
+                sessionId: row.assignedSessionId,
+                nodeId: row.assignedNodeId,
+                meshId,
+                event: "agent:generating_started"
+              }, `held suspension recovered \u2192 ${gate.stage} (verdict GENERATING)`);
+            }
           } else {
             const redriveProfile = row.assignedSessionId ? resolveAssignedTranscriptProfile(components, row) : void 0;
             if (redriveProfile?.emitsPtyTurnEvents === false && await pollAssignedTaskInTurnProgress(components, { id: meshId, nodes: mesh.nodes }, row)) {
@@ -59792,16 +60229,39 @@ ${cleanBody}`;
               const streak = (deliveredUnconsumedUnknownStreak.get(shortStreakKey) ?? 0) + 1;
               deliveredUnconsumedUnknownStreak.set(shortStreakKey, streak);
               if (streak < RECLAIM_UNKNOWN_GRACE_TICKS) {
-                traceMeshEventDrop("short_redrive_deferred_unknown_verdict", {
+                const gate = gateRedriveForHeldSuspension({ meshId, taskId: row.id, sessionLiveness: "unknown", sessionProvenDead: false, nowMs });
+                traceMeshEventDrop(gate.kind === "blocked" ? "redrive_blocked_by_suspension" : "short_redrive_deferred_unknown_verdict", {
                   taskId: row.id,
                   sessionId: row.assignedSessionId,
                   nodeId: row.assignedNodeId,
                   meshId,
                   event: "agent:generating_started"
-                }, `unknown ${streak}/${RECLAIM_UNKNOWN_GRACE_TICKS}`);
+                }, gate.kind === "blocked" ? `held ${gate.stages.join("/")} unresolved; unknown ${streak}/${RECLAIM_UNKNOWN_GRACE_TICKS}` : `unknown ${streak}/${RECLAIM_UNKNOWN_GRACE_TICKS}`);
                 continue;
               }
             }
+            const suspensionGate = gateRedriveForHeldSuspension({
+              meshId,
+              taskId: row.id,
+              sessionLiveness: verdict === "UNKNOWN" ? "unknown" : "alive",
+              sessionProvenDead: verdict === "UNKNOWN",
+              // the bounded UNKNOWN grace just exhausted above
+              nowMs
+            });
+            if (suspensionGate.kind === "recovered" || suspensionGate.kind === "blocked") {
+              deliveredUnconsumedUnknownStreak.delete(shortStreakKey);
+              traceMeshEventDrop(suspensionGate.kind === "recovered" ? "suspension_consumed_recovered" : "redrive_blocked_by_suspension", {
+                taskId: row.id,
+                sessionId: row.assignedSessionId,
+                nodeId: row.assignedNodeId,
+                meshId,
+                event: "agent:generating_started"
+              }, suspensionGate.kind === "recovered" ? `consumed recovered from held suspension \u2192 ${suspensionGate.stage}; same attempt continues` : "held suspension unresolved \u2014 redrive suppressed");
+              continue;
+            }
+            if (suspensionGate.kind === "released" && suspensionGate.dropped > 0) {
+              LOG2.info("MeshReconcile", `Dropped ${suspensionGate.dropped} held suspension(s) for task ${row.id} on mesh ${meshId}: worker session ${row.assignedSessionId ?? "?"} demonstrably dead \u2014 delivered_not_consumed_redrive proceeds to a new attempt`);
+            }
             const redriveEval = (() => {
               try {
                 return evaluateRedrive(meshId, row.id, nowMs);
@@ -59868,6 +60328,16 @@ ${cleanBody}`;
           const verdict = row.assignedSessionId ? resolveSessionBusyVerdict(components, row.assignedSessionId) : "IDLE_CONFIRMED";
           if (verdict === "GENERATING") {
             deliveredNoTurnUnknownStreak.delete(streakKey);
+            const gate = gateRedriveForHeldSuspension({ meshId, taskId: row.id, sessionLiveness: "alive", nowMs });
+            if (gate.kind === "recovered") {
+              traceMeshEventDrop("suspension_consumed_recovered", {
+                taskId: row.id,
+                sessionId: row.assignedSessionId,
+                nodeId: row.assignedNodeId,
+                meshId,
+                event: "agent:generating_completed"
+              }, `held suspension recovered \u2192 ${gate.stage} (verdict GENERATING)`);
+            }
             continue;
           }
           let reclaimReason;
@@ -59887,17 +60357,40 @@ ${cleanBody}`;
             const streak = (deliveredNoTurnUnknownStreak.get(streakKey) ?? 0) + 1;
             deliveredNoTurnUnknownStreak.set(streakKey, streak);
             if (streak < RECLAIM_UNKNOWN_GRACE_TICKS) {
-              traceMeshEventDrop("reclaim_deferred_unknown_verdict", {
+              const gate = gateRedriveForHeldSuspension({ meshId, taskId: row.id, sessionLiveness: "unknown", sessionProvenDead: false, nowMs });
+              traceMeshEventDrop(gate.kind === "blocked" ? "redrive_blocked_by_suspension" : "reclaim_deferred_unknown_verdict", {
                 taskId: row.id,
                 sessionId: row.assignedSessionId,
                 nodeId: row.assignedNodeId,
                 meshId,
                 event: "agent:generating_completed"
-              }, `unknown ${streak}/${RECLAIM_UNKNOWN_GRACE_TICKS}`);
+              }, gate.kind === "blocked" ? `held ${gate.stages.join("/")} unresolved; unknown ${streak}/${RECLAIM_UNKNOWN_GRACE_TICKS}` : `unknown ${streak}/${RECLAIM_UNKNOWN_GRACE_TICKS}`);
               continue;
             }
             reclaimReason = "reclaim_after_unknown_grace";
           }
+          const suspensionGate = gateRedriveForHeldSuspension({
+            meshId,
+            taskId: row.id,
+            sessionLiveness: verdict === "UNKNOWN" ? "unknown" : "alive",
+            sessionProvenDead: verdict === "UNKNOWN",
+            // the bounded UNKNOWN grace just exhausted above
+            nowMs
+          });
+          if (suspensionGate.kind === "recovered" || suspensionGate.kind === "blocked") {
+            deliveredNoTurnUnknownStreak.delete(streakKey);
+            traceMeshEventDrop(suspensionGate.kind === "recovered" ? "suspension_consumed_recovered" : "redrive_blocked_by_suspension", {
+              taskId: row.id,
+              sessionId: row.assignedSessionId,
+              nodeId: row.assignedNodeId,
+              meshId,
+              event: "agent:generating_completed"
+            }, suspensionGate.kind === "recovered" ? `consumed recovered from held suspension \u2192 ${suspensionGate.stage}; same attempt continues` : "held suspension unresolved \u2014 reclaim suppressed");
+            continue;
+          }
+          if (suspensionGate.kind === "released" && suspensionGate.dropped > 0) {
+            LOG2.info("MeshReconcile", `Dropped ${suspensionGate.dropped} held suspension(s) for task ${row.id} on mesh ${meshId}: worker session ${row.assignedSessionId ?? "?"} demonstrably dead \u2014 ${reclaimReason} proceeds to a new attempt`);
+          }
           const terminalEvidence = await pollAssignedTaskTerminalEvidence(components, mesh, row);
           if (terminalEvidence) {
             deliveredNoTurnUnknownStreak.delete(streakKey);
@@ -59985,6 +60478,7 @@ ${cleanBody}`;
       const assigned = getQueue(meshId, { status: ["assigned"] });
       if (!assigned.length) return;
       const nowMs = Date.now();
+      const store = MeshRuntimeStore.getInstance();
       const assignedNodeIsLocal = (assignedNodeId) => {
         if (!assignedNodeId) return true;
         if (selfIds.some((id) => daemonIdsEquivalent(id, assignedNodeId))) return true;
@@ -59995,6 +60489,7 @@ ${cleanBody}`;
       };
       for (const row of assigned) {
         if (Number.isFinite(Date.parse(row.dispatchTimestamp ?? ""))) continue;
+        restampReboundMeshWorkerAssignment(components, store, meshId, row);
         const updatedMs = Date.parse(row.updatedAt ?? "");
         const createdMs = Date.parse(row.createdAt ?? "");
         const anchorMs = Number.isFinite(updatedMs) ? updatedMs : createdMs;
@@ -60470,6 +60965,7 @@ ${cleanBody}`;
               if (recovered.length > 0) {
                 LOG2.info("TurnLedger", `Restart recovery: reconstructed ${recovered.length} active turn attempt(s) for mesh ${mesh.id} (${recovered.map((a) => `${a.taskId.slice(0, 8)}@${a.stage}`).join(", ")})`);
               }
+              drainHeldTurnSuspensionsForMesh(mesh.id);
             }
           } catch (e) {
             LOG2.warn("TurnLedger", `Restart attempt reconstruction failed (reconcile continues on row state): ${e?.message || e}`);
@@ -62467,7 +62963,7 @@ ${cleanBody}`;
       return out;
     }
     function buttonBlockApprovalCue(spec, text) {
-      if (/Enter to select/i.test(text) && /Esc to cancel/i.test(text)) return false;
+      if (/Enter to select/i.test(text)) return false;
       const labels = extractButtonLabels(spec, text);
       if (labels.length < 2) return false;
       if (pickApprovalButton(labels).index < 0) return false;
@@ -62475,8 +62971,7 @@ ${cleanBody}`;
     }
     function isAskUserQuestionPickerSignature(text) {
       if (!text) return false;
-      const hasSelectFooter = /Enter to select/i.test(text) && /Esc to cancel/i.test(text);
-      if (!hasSelectFooter) return false;
+      if (!/Enter to select/i.test(text)) return false;
       return PICKER_OPTION_ROW.test(text);
     }
     function modalMatches(spec, input) {
@@ -62625,8 +63120,7 @@ ${cleanBody}`;
     }
     function isAskUserQuestionPickerSignature2(text) {
       if (!text) return false;
-      const hasSelectFooter = /Enter to select/i.test(text) && /Esc to cancel/i.test(text);
-      if (!hasSelectFooter) return false;
+      if (!/Enter to select/i.test(text)) return false;
       return PICKER_OPTION_ROW2.test(text);
     }
     function findQuestionLineIndex(spec, lines) {
@@ -67745,7 +68239,7 @@ ${lastSnapshot}`;
       return headers;
     }
     function isClaudeTuiSelectFooter(text) {
-      return /Enter to select/i.test(text) && /Esc to cancel/i.test(text);
+      return /Enter to select/i.test(text);
     }
     function detectClaudeTuiMultiSelect(screenText) {
       if (/Space to (?:select|toggle)|toggle selection|select multiple|select all that apply/i.test(screenText)) {
@@ -75803,6 +76297,16 @@ ${effect.notification.body || ""}`.trim();
         const status = adapter.getStatus();
         const targetInstance = getTargetInstance(h, args);
         const targetState = targetInstance?.getState?.();
+        const heldPrompt = status?.activeInteractivePrompt ?? targetState?.activeChat?.activeInteractivePrompt ?? null;
+        if (heldPrompt && typeof heldPrompt.promptId === "string" && heldPrompt.promptId) {
+          LOG2.info("Command", `[resolveAction] refused \u2014 session holds interactive prompt ${heldPrompt.promptId} (waiting_choice, not an approval)`);
+          return {
+            success: false,
+            error: `Session is awaiting a multi-choice answer (waiting_choice), not an approval. Use mesh_answer_question with promptId "${heldPrompt.promptId}" instead of mesh_approve.`,
+            waitingChoice: true,
+            promptId: heldPrompt.promptId
+          };
+        }
         const surfacedModal = targetState?.activeChat?.activeModal && Array.isArray(targetState.activeChat.activeModal.buttons) && targetState.activeChat.activeModal.buttons.some((candidate) => typeof candidate === "string" && candidate.trim()) ? targetState.activeChat.activeModal : null;
         const statusModal = status?.activeModal && Array.isArray(status.activeModal.buttons) && status.activeModal.buttons.some((candidate) => typeof candidate === "string" && candidate.trim()) ? status.activeModal : null;
         const parsedStatus = !statusModal && !surfacedModal && typeof adapter.getScriptParsedStatus === "function" ? (() => {
@@ -88106,9 +88610,13 @@ ${buttons.join("\n")}`;
         }
         const parsedStatus = null;
         const rawStatus = adapterStatus.status;
+        const interactivePrompt = adapterStatus.activeInteractivePrompt ?? null;
+        const activeModal = adapterStatus.activeModal ?? null;
+        const activeModalKind = activeModal && typeof activeModal.kind === "string" ? activeModal.kind : null;
+        const isQuestionPicker = rawStatus === "waiting_approval" && !!interactivePrompt && (!activeModal || activeModalKind === "picker");
         const autoApproveActive = this.maybeAutoApproveStatus(adapterStatus, now);
         const autoApproveHoldIdle = this.autoApproveBusy && rawStatus === "idle";
-        const newStatus = autoApproveActive || autoApproveHoldIdle ? "generating" : rawStatus;
+        const newStatus = isQuestionPicker ? "waiting_choice" : autoApproveActive || autoApproveHoldIdle ? "generating" : rawStatus;
         const dirName = workingDirBasename(this.workingDir);
         const chatTitle = `${this.provider.name} \xB7 ${dirName}`;
         const partial2 = this.adapter.getPartialResponse();
@@ -88155,7 +88663,7 @@ ${buttons.join("\n")}`;
               }
               this.generatingDebounceTimer = null;
             }, 3e3);
-          } else if (newStatus === "waiting_approval") {
+          } else if (newStatus === "waiting_approval" && !(previousStatus === "waiting_choice" && !adapterStatus.activeModal)) {
             this.suppressIdleHistoryReplay = false;
             if (this.generatingDebouncePending) {
               if (this.generatingDebounceTimer) {
@@ -88195,6 +88703,23 @@ ${buttons.join("\n")}`;
                 modalButtons: modal?.buttons
               });
             }
+          } else if (newStatus === "waiting_choice") {
+            this.suppressIdleHistoryReplay = false;
+            if (this.generatingDebouncePending) {
+              if (this.generatingDebounceTimer) {
+                clearTimeout(this.generatingDebounceTimer);
+                this.generatingDebounceTimer = null;
+              }
+              this.pushEvent({ event: "agent:generating_started", ...this.generatingDebouncePending });
+              this.generatingDebouncePending = null;
+            }
+            if (this.completedDebounceTimer) {
+              clearTimeout(this.completedDebounceTimer);
+              this.completedDebounceTimer = null;
+            }
+            this.completedDebouncePending = null;
+            if (!this.generatingStartedAt) this.generatingStartedAt = now;
+            this.busyEpoch++;
           } else if (newStatus === "generating" && this.lastStatus === "waiting_approval") {
             this.lastApprovalEventFingerprint = "";
           } else if (newStatus === "idle" && (this.lastStatus === "generating" || this.lastStatus === "waiting_approval")) {
@@ -88367,7 +88892,6 @@ ${buttons.join("\n")}`;
           }
           this.lastStatus = newStatus;
         }
-        const interactivePrompt = adapterStatus.activeInteractivePrompt ?? null;
         if (interactivePrompt && newStatus !== "waiting_approval") {
           const firstQuestion = interactivePrompt.questions?.[0];
           const promptKey = `${interactivePrompt.promptId}::${firstQuestion?.question ?? ""}`;
@@ -88477,9 +89001,12 @@ ${buttons.join("\n")}`;
           this.events.push(enrichedEvent);
         }
         if (TERMINAL_MESH_EVENTS.has(event.event) && this.settings.meshActiveTaskId) {
-          try {
-            this.detachMeshAssignment();
-          } catch {
+          const readyWithTurnInFlight = event.event === "agent:ready" && (this.generatingStartedAt !== 0 || this.completedDebouncePending !== null || this.generatingDebouncePending !== null);
+          if (!readyWithTurnInFlight) {
+            try {
+              this.detachMeshAssignment();
+            } catch {
+            }
           }
         }
       }
@@ -88651,6 +89178,9 @@ ${buttons.join("\n")}`;
         if (!this.shouldUsePtyAutoApprove()) return;
         if (!this.isMeshWorkerSession()) return;
         if (adapterStatus?.status !== "waiting_approval") return;
+        const nudgeModal = adapterStatus.activeModal;
+        const nudgeModalKind = nudgeModal && typeof nudgeModal.kind === "string" ? nudgeModal.kind : null;
+        if (adapterStatus.activeInteractivePrompt && (!nudgeModal || nudgeModalKind === "picker")) return;
         if (!this.autoApproveMaskStalled(now)) return;
         const currentSignature = this.approvableModalSignature(adapterStatus.activeModal);
         const settleProgressing = !!currentSignature && this.pendingAutoApprovalSince > 0 && currentSignature === this.pendingAutoApprovalSignature;