@openrig/cli 0.6.14 → 0.7.1

package/daemon/dist/domain/queue-repository.js

@@ -1,17 +1,21 @@
-import { readWakeLadderBackstop } from "./queue-wake-ladder.js";
+import { PROMPT_ALERT_TAG, readWakeLadderBackstop } from "./queue-wake-ladder.js";
+import { withUrgentLine } from "./urgent-line.js";
+import { quietCustodyBackstop, quietHoldCustody } from "./quiet-hold-custody.js";
 import { createHash } from "node:crypto";
-import { loadHumanRegistry, resolveRegisteredHumanAddress } from "./gateway/human-registry.js";
+import { loadHumanRegistry, resolveRegisteredHumanAddress, slackSubscriptionFor, withHumanAlertTag } from "./gateway/human-registry.js";
 import { resolveExternal } from "./gateway/external-admission.js";
 import { QueueTransitionLog } from "./queue-transition-log.js";
 import { WAKE_INTENT_PREFIX } from "./outbox-handler.js";
 import { derivePickup } from "./queue-pickup.js";
 import { lastMeaningfulTransition, readWaitingView } from "./queue-waiting.js";
 import { wrapPaneEnvelope } from "../lib/pane-envelope.js";
+import { isBoundTerminalSeat } from "./terminal-seat.js";
 import { renderQueueHandoffNudge } from "./queue-nudge-text.js";
 import { getSelfHostId } from "./hosts/fanout-contract.js";
 import { parseSessionName, isHumanSeatSessionRef } from "./session-name.js";
 import { parseReplyToChoice, formatReplyToChoice, describeReplyToFallback, REPLY_TO_CHOICE_ACTOR } from "./reply-to-choice.js";
 import { classifyDestination } from "./gateway/destination-resolver.js";
+import { effectiveGateRoles } from "./gate-predicate.js";
 import { computeClosureRequiredAt, validateClosure, } from "./hot-potato-enforcer.js";
 import { isHumanSeatSession, validateHumanPark, validateHumanRoute } from "./human-route-enforcer.js";
 import { QueueWakeRepository, USAGE_LIMIT_BLOCKER_TAG, } from "./queue-wake-repository.js";
@@ -61,6 +65,10 @@ export function hasLiveHumanGate(item) {
     return isBlockerLive(item.state) && isHumanSeatSessionRef(item.destinationSession);
 }
 const AUTO_UNPARK_WAKE_TAG = "queue:auto-unpark:blocker";
+/** A durable wake OpenRig's own scheduling triggered (an auto-unpark, a row OpenRig creates), not an agent's create or
+ *  handoff: it keeps that source when it's replayed later. Send, broadcast, queue create and the cross-host forward never
+ *  set it from a request; the trusted local outbox recorder (/api/queue/outbox/record) accepts caller tags by design. */
+const WAKE_TRIGGER_OPENRIG_TAG = "queue:wake-trigger:openrig";
 const AUTO_UNPARK_BLOCKER_TAG_PREFIX = "queue:auto-unpark:blocker-ref:";
 /** The actor on the transition routeToFallback writes; the row's own history is how a later reroute finds the line it wrote. */
 const FALLBACK_ACTOR = "system:queue-fallback";
@@ -123,6 +131,17 @@ export function classifyNudgeFailure(lastNudgeResult) {
     return "unknown";
 }
 export const QUEUE_PRIORITIES = ["routine", "urgent", "critical"];
+/** Adds the handoff-successor and updated-since filters both list paths share. */
+function pushFollowThroughFilters(opts, conditions, params) {
+    if (opts?.handedOffFrom) {
+        conditions.push("handed_off_from = ?");
+        params.push(opts.handedOffFrom);
+    }
+    if (opts?.updatedSince) {
+        conditions.push("ts_updated >= ?");
+        params.push(opts.updatedSince);
+    }
+}
 /** The message a `--wake-after` park timer carries when its owner gives none. */
 export function defaultParkWakeMessage(qitemId) {
     return `Wake timer fired for parked qitem ${qitemId}. Resume the recorded continuation and update the row.`;
@@ -260,7 +279,7 @@ function detectTable(db, tableName) {
 // the compact projection is one thing: present text is shown, and what isn't selected is left out
 // and named in fieldsElided, never backfilled as empty.
 const COMPACT_ELIDED_FIELDS = [
-    "body", "evidenceRef", "humanDetail", "waiting", "chainOfRecord", "replyTo", "humanQuestions", "humanAnswers",
+    "body", "evidenceRef", "humanDetail", "waiting", "chainOfRecord", "replyTo", "humanQuestions", "humanAnswers", "delegatedDecision",
 ];
 function compactRow(item) {
     const row = { ...item, fieldsElided: [...COMPACT_ELIDED_FIELDS] };
@@ -406,6 +425,7 @@ export class QueueRepository {
      *     fallback real code rather than a promise in a comment). */
     outbox;
     resolveOccupantGeneration;
+    resolveSessionAddresses;
     wakeRepo;
     watchdogJobsRepo;
     /** PL-007 Workspace Primitive — true when migration 038 has applied the
@@ -418,6 +438,7 @@ export class QueueRepository {
     hasHumanIntentColumn;
     hasReplyToColumn;
     hasHumanQuestionsColumn;
+    hasDelegatedDecisionColumn;
     hasEvidenceRefColumn;
     hasMintingGenColumn;
     hasClaimedGenColumn;
@@ -439,12 +460,14 @@ export class QueueRepository {
             this.attachTransport(opts.transport);
         this.workflowFrontierPredicate = opts?.workflowFrontierPredicate;
         this.resolveOccupantGeneration = opts?.resolveOccupantGeneration;
+        this.resolveSessionAddresses = opts?.resolveSessionAddresses ?? ((name) => [name]);
         this.loadHumanRegistryFn = opts?.loadHumanRegistry ?? (() => loadHumanRegistry());
         this.hasTargetRepoColumn = detectQueueColumn(db, "target_repo");
         this.hasSummaryColumn = detectQueueColumn(db, "summary");
         this.hasHumanIntentColumn = detectQueueColumn(db, "human_intent");
         this.hasReplyToColumn = detectQueueColumn(db, "reply_to");
         this.hasHumanQuestionsColumn = detectQueueColumn(db, "human_questions");
+        this.hasDelegatedDecisionColumn = detectQueueColumn(db, "delegated_decision");
         this.hasEvidenceRefColumn = detectQueueColumn(db, "evidence_ref");
         this.hasQueueTransitionsTable = detectTable(db, "queue_transitions");
         const transitionColumns = this.hasQueueTransitionsTable
@@ -508,8 +531,8 @@ export class QueueRepository {
         }));
     }
     currentWakeIntent(entry) {
-        const row = entry.auditPointer ? this.db.prepare("SELECT state FROM queue_items WHERE qitem_id=?").get(entry.auditPointer) : undefined;
-        if (row?.state !== "pending")
+        const row = entry.auditPointer ? this.db.prepare("SELECT state, destination_session FROM queue_items WHERE qitem_id=?").get(entry.auditPointer) : undefined;
+        if (row?.state !== "pending" || row.destination_session !== entry.destinationSession)
             return false;
         const prefix = `${WAKE_INTENT_PREFIX}blocker-`;
         if (!entry.outboxId.startsWith(prefix))
@@ -522,14 +545,27 @@ export class QueueRepository {
             .get(entry.auditPointer);
         return expected === latest?.transition_id;
     }
+    /** A wake's source and urgency at the seat's level: the trigger decides the source; the row's priority (urgent or
+     *  critical) makes it urgent, marked by whoever created the row. */
+    wakeAdmission(qitemId, trigger) {
+        const row = this.getById(qitemId);
+        const urgent = row?.priority === "urgent" || row?.priority === "critical";
+        // OpenRig's own row is marked urgent by OpenRig, not by the person whose obligation it's about.
+        return { source: trigger, urgent, ...(urgent && row ? { urgentBy: trigger === "openrig" ? "OpenRig" : row.sourceSession } : {}) };
+    }
     classifyWakeResult(res) {
+        // Held by the seat's hold or interruption level (on purpose; a retry is held again) is the typing guard's; any other
+        // retention is the draft-aware delivery's (a draft, an unreadable input, a native prompt), which can clear.
         if (res.outcome === "retained")
-            return { classified: "retained", nudgeResult: res.reason?.startsWith("draft_")
-                    ? "retained:draft_aware" : "retained:typing_guard" };
+            return { classified: "retained", nudgeResult: res.reason === "typing_guard_enabled"
+                    ? "retained:typing_guard" : "retained:draft_aware" };
         if (res.ok)
             return res.verified ? { classified: "verified", nudgeResult: "verified" } : { classified: "indeterminate", nudgeResult: "delivered-ack-pending" };
         const detail = res.error ?? res.reason ?? "unknown";
-        if (res.delivery?.state === "indeterminate" || res.delivery?.state === "sending" || isWakeTimeoutSignal(res.reason) || isWakeTimeoutSignal(res.error)) {
+        // Input evidence survives receipt removal: an issued paste or uncertain Enter is never an unsent failure.
+        const inputUncertain = res.sent === true || res.inputPhase === "attempted" || res.inputPhase === "written"
+            || (res.sent !== false && res.inputPhase !== "not_reached" && (res.reason === "delivery_indeterminate" || res.reason === "submit_failed"));
+        if (inputUncertain || isWakeTimeoutSignal(res.reason) || isWakeTimeoutSignal(res.error)) {
             return { classified: "indeterminate", nudgeResult: `indeterminate:${detail}` };
         }
         return { classified: "failed", nudgeResult: `failed:${detail}` };
@@ -566,9 +602,13 @@ export class QueueRepository {
             return { kind: "human-required", level: "ALERT" };
         const destinationHuman = resolveRegisteredHumanAddress(input.destinationSession, registry.entities);
         if (input.action === "create" && destinationHuman !== null) {
+            // The person's Slack subscription decides: `every-ask` (the default) posts every ask (ALERT); `urgent-only` posts only
+            // one marked --alert, and a plain ask lands on Steering and the TUI (RECORD: below the posting dial, so no post is owed).
+            const person = registry.entities.find((entity) => entity.address === destinationHuman);
+            const posts = input.humanAlert === true || slackSubscriptionFor(person).preset === "every-ask";
             return input.humanIntent === "update"
                 ? { kind: "human-update", level: "NOTICE" }
-                : { kind: "human-required", level: "ALERT" };
+                : { kind: "human-required", level: posts ? "ALERT" : "RECORD" };
         }
         return null;
     }
@@ -590,7 +630,7 @@ export class QueueRepository {
      * `nudge:false` intends no wake ⇒ no intent. A missing outbox is enforced by the
      * guard (fail-closed, MF2), not silently skipped here.
      */
-    stageWakeIntent(successorQitemId, fromSession, toSession, identityProvenance, nudge) {
+    stageWakeIntent(successorQitemId, fromSession, toSession, identityProvenance, nudge, trigger = "agent") {
         // No wake intended (nudge:false) ⇒ no durable intent to make durable. The
         // W1-c guard is nudge-aware for the same reason: absence of an intent is a
         // defect only when a wake WAS intended.
@@ -606,7 +646,9 @@ export class QueueRepository {
             toSession,
             identityProvenance,
             bareBody: renderQueueHandoffNudge(successorQitemId, successor?.summary),
-            tags: successor?.handedOffFrom ? [`queue:return:${successor.handedOffFrom}`] : undefined,
+            tags: successor?.handedOffFrom || trigger === "openrig"
+                ? [...(successor?.handedOffFrom ? [`queue:return:${successor.handedOffFrom}`] : []), ...(trigger === "openrig" ? [WAKE_TRIGGER_OPENRIG_TAG] : [])]
+                : undefined,
         });
     }
     recordWakeIntent(input) {
@@ -617,11 +659,15 @@ export class QueueRepository {
         const stampISO = new Date().toISOString();
         const genUuid = this.resolveOccupantGeneration?.(input.fromSession) ?? undefined;
         const frozenEnvelope = wrapPaneEnvelope(input.fromSession, input.toSession, input.bareBody, { stampISO, genUuid });
+        const admission = this.wakeAdmission(input.auditPointer, input.tags?.includes(WAKE_TRIGGER_OPENRIG_TAG) ? "openrig" : "agent");
+        // An urgent wake's frozen body carries the line naming who marked it, so a person reading it held sees it too; the
+        // transport won't add it a second time when it's delivered.
         const record = {
             outboxId: input.outboxId, senderSession: input.fromSession, destinationSession: input.toSession,
-            body: frozenEnvelope, tags: input.tags, auditPointer: input.auditPointer, identityProvenance: input.identityProvenance,
+            body: admission.urgentBy ? withUrgentLine(frozenEnvelope, admission.urgentBy) : frozenEnvelope, tags: input.tags, auditPointer: input.auditPointer, identityProvenance: input.identityProvenance,
+            ...(admission.urgent ? { urgency: "urgent" } : {}),
         };
-        const target = this.transport?.retentionTarget?.(input.toSession);
+        const target = this.transport?.retentionTarget?.(input.toSession, admission);
         if (target)
             this.outbox.retain(record, target);
         else {
@@ -646,7 +692,7 @@ export class QueueRepository {
             toSession: input.destinationSession,
             identityProvenance: input.identityProvenance,
             bareBody: `Blocker ${input.blockerQitemId} resolved; parked qitem ${input.qitemId} is pending. Resume the recorded continuation and update the row.`,
-            tags: [AUTO_UNPARK_WAKE_TAG, `${AUTO_UNPARK_BLOCKER_TAG_PREFIX}${input.blockerQitemId}`, `queue:return:${input.blockerQitemId}`],
+            tags: [AUTO_UNPARK_WAKE_TAG, WAKE_TRIGGER_OPENRIG_TAG, `${AUTO_UNPARK_BLOCKER_TAG_PREFIX}${input.blockerQitemId}`, `queue:return:${input.blockerQitemId}`],
         });
     }
     deliverWakeIntentAfterCommit(outboxId) {
@@ -690,34 +736,31 @@ export class QueueRepository {
         }
     }
     /**
-     * W1-b: deliver ONE committed wake intent. MF3: CLAIM (pending→sending) before
-     * the external send, then finalize (sending→outcome) after — so overlapping
-     * drains send the wake exactly ONCE (the effect, not just the state), and a
-     * second drain of an already-claimed/resolved intent skips. Returns what
-     * happened for the drain's tally.
-     *
-     *   verified          → delivered
-     *   ok, unverified    → indeterminate   (ambiguous; never silently delivered/failed)
-     *   timeout (MF6)     → indeterminate   (may have landed — not a hard failure)
-     *   other not-ok/throw→ failed          (visible terminal state)
+     * Attempt a current committed notification. A live claim, known success or manual
+     * hold is left alone; failed/uncertain history permits another attempt. A recovery
+     * pass tracks its coalesced members only in memory so each is attempted once per pass.
      */
-    async deliverWakeIntent(outboxId) {
+    async deliverWakeIntent(outboxId, attempted = new Set()) {
         if (!this.outbox)
             return "skipped";
         if (!this.transport)
             return "skipped"; // no transport → stays pending for a later drain
+        if (attempted.has(outboxId))
+            return "skipped";
         const alreadyHeld = this.outbox.getById(outboxId);
         if (alreadyHeld?.deliveryState === "retained" || alreadyHeld?.deliveryState === "retired") {
             if (alreadyHeld.auditPointer)
                 this.recordNudgeAttempt(alreadyHeld.auditPointer, "retained:typing_guard");
             return "retained";
         }
-        // MF3: CLAIM (pending→sending) BEFORE the external send so overlapping drains
-        // cannot both send. A losing claim — the row is no longer `pending` (already
-        // resolved, in-flight under another drainer, or claimed) — simply skips: no
-        // send, no tally. This makes the external effect once, not merely the state.
-        // Claim the exact return's arrival + dependent resumes atomically. Each
-        // original frozen intent and audit pointer survives; only transport coalesces.
+        let recovering = false;
+        const claim = (entry) => {
+            if (attempted.has(entry.outboxId) || !this.outbox.claimForDelivery(entry.outboxId))
+                return false;
+            attempted.add(entry.outboxId);
+            recovering ||= entry.deliveryState !== "pending";
+            return true;
+        };
         let superseded = false;
         const actionable = (entry) => {
             const current = this.currentWakeIntent(entry);
@@ -733,21 +776,35 @@ export class QueueRepository {
         };
         const group = this.db.transaction(() => {
             const candidate = this.outbox.getById(outboxId);
-            if (!candidate || candidate.deliveryState !== "pending" || !actionable(candidate))
+            if (!candidate || !["pending", "failed", "indeterminate"].includes(candidate.deliveryState) || !actionable(candidate))
                 return [];
-            if (!this.outbox.claimForDelivery(outboxId))
+            if (!claim(candidate))
                 return [];
-            const first = this.outbox.getById(outboxId);
+            const first = candidate; // Keep each member's pre-claim uncertainty.
             const intents = [first];
             const correlation = first.tags?.find(tag => tag.startsWith("queue:return:"));
+            // Group by outcome at the seat's current level: each member is admitted with its own source and urgency, and only
+            // members with the first one's outcome (typed or held) go together. With no level (off, draft-aware), everything is
+            // admitted, so a returned result and its resume still go as one send. At a level, a routine wake never rides in on
+            // an urgent one, nor an urgent one under a routine one's hold; any other member waits for its own delivery.
+            const outcome = (entry) => {
+                const trigger = entry.tags?.includes(WAKE_TRIGGER_OPENRIG_TAG) ? "openrig" : "agent";
+                const admission = entry.auditPointer ? this.wakeAdmission(entry.auditPointer, trigger) : { source: trigger, urgent: false };
+                return this.transport?.retentionTarget?.(entry.destinationSession, { source: admission.source, urgent: admission.urgent }) ? "held" : "typed";
+            };
+            const firstOutcome = outcome(first);
             if (correlation) {
                 const peers = this.db.prepare(`SELECT outbox_id FROM outbox_entries
-          WHERE delivery_state = 'pending' AND destination_session = ? AND substr(outbox_id, 1, ?) = ?
+          WHERE delivery_state IN ('pending','failed','indeterminate') AND destination_session = ? AND substr(outbox_id, 1, ?) = ?
           AND EXISTS (SELECT 1 FROM json_each(outbox_entries.tags) WHERE value = ?)
           ORDER BY outbox_id`).all(first.destinationSession, WAKE_INTENT_PREFIX.length, WAKE_INTENT_PREFIX, correlation);
-                for (const peer of peers)
-                    if (actionable(this.outbox.getById(peer.outbox_id)) && this.outbox.claimForDelivery(peer.outbox_id))
-                        intents.push(this.outbox.getById(peer.outbox_id));
+                for (const peer of peers) {
+                    const entry = this.outbox.getById(peer.outbox_id);
+                    if (outcome(entry) !== firstOutcome)
+                        continue;
+                    if (actionable(entry) && claim(entry))
+                        intents.push(entry);
+                }
             }
             return intents;
         })();
@@ -763,11 +820,42 @@ export class QueueRepository {
             return "failed";
         }
         const qitemId = intent.auditPointer ?? outboxId;
-        // MF4: send the FROZEN envelope stored on the intent verbatim (no re-resolution).
-        const outcome = await this.performWakeSend(qitemId, intent.destinationSession, intent.senderSession, undefined, group.map(entry => entry.body).join("\n"), group.map(entry => entry.outboxId));
-        const finalState = outcome.classified === "verified" ? "delivered" : outcome.classified;
-        for (const member of group) {
-            const intent = member;
+        // Preserve the original envelope/source generation; add context without rewriting its stored bytes.
+        const recoveryNotice = recovering ? "Recovered queue notification: delivery may repeat after an earlier unconfirmed attempt.\n" : "";
+        // The group was formed on the first member's outcome, so its own source and urgency reach that same outcome at the
+        // send; the other members' bodies keep their own frozen urgent lines.
+        const trigger = group[0].tags?.includes(WAKE_TRIGGER_OPENRIG_TAG) ? "openrig" : "agent";
+        // The level can change while this send waits for the seat's lease. Under the lease, each member is admitted again with
+        // its own source and urgency; only those with the first member's outcome go with this send, and the others go back
+        // to their state before this claim (never marked delivered, held or failed) for their own delivery.
+        const released = [];
+        const recheckMembers = group.length < 2 ? undefined : (holds, held) => {
+            const keep = group.filter((entry, i) => {
+                if (i === 0)
+                    return true;
+                const memberTrigger = entry.tags?.includes(WAKE_TRIGGER_OPENRIG_TAG) ? "openrig" : "agent";
+                const admission = this.wakeAdmission(entry.auditPointer, memberTrigger);
+                return holds({ source: admission.source, urgent: admission.urgent }) === held;
+            });
+            for (const entry of group) {
+                if (keep.includes(entry))
+                    continue;
+                this.db.prepare("UPDATE outbox_entries SET delivery_state = ? WHERE outbox_id = ? AND delivery_state = 'sending'").run(entry.deliveryState, entry.outboxId);
+                released.push(entry);
+            }
+            return { text: recoveryNotice + keep.map(entry => entry.body).join("\n"), outboxIds: keep.map(entry => entry.outboxId) };
+        };
+        const outcome = await this.performWakeSend(qitemId, intent.destinationSession, intent.senderSession, undefined, recoveryNotice + group.map(entry => entry.body).join("\n"), group.map(entry => entry.outboxId), trigger, recheckMembers);
+        let reportedState = outcome.classified === "verified" ? "delivered" : outcome.classified;
+        for (const intent of group) {
+            if (released.includes(intent))
+                continue;
+            // A no-write retry cannot settle whether an earlier attempt landed.
+            const earlierUnknown = intent.deliveryState === "indeterminate" && outcome.classified === "failed";
+            const finalState = earlierUnknown ? "indeterminate" : outcome.classified === "verified" ? "delivered" : outcome.classified;
+            const nudgeResult = earlierUnknown ? `indeterminate:earlier delivery unconfirmed; retry ${outcome.nudgeResult}` : outcome.nudgeResult;
+            if (earlierUnknown)
+                reportedState = "indeterminate";
             const qitemId = intent.auditPointer;
             const blockerRef = intent.tags?.includes(AUTO_UNPARK_WAKE_TAG)
                 ? intent.tags
@@ -775,7 +863,7 @@ export class QueueRepository {
                     ?.slice(AUTO_UNPARK_BLOCKER_TAG_PREFIX.length)
                 : undefined;
             const wakeEvent = this.db.transaction(() => {
-                this.recordNudgeAttempt(qitemId, outcome.nudgeResult);
+                this.recordNudgeAttempt(qitemId, nudgeResult);
                 this.outbox.finalizeDelivery(intent.outboxId, finalState);
                 if (!blockerRef)
                     return null;
@@ -784,7 +872,7 @@ export class QueueRepository {
                     qitemId,
                     state: item.state,
                     actorSession: "queue@system",
-                    transitionNote: `blocker ${blockerRef} wake attempted; delivery=${outcome.nudgeResult}`,
+                    transitionNote: `blocker ${blockerRef} wake attempted; delivery=${nudgeResult}`,
                 });
                 this.wakeRepo.record({
                     transitionId: transition.transitionId,
@@ -792,7 +880,7 @@ export class QueueRepository {
                     phase: "fired",
                     kind: "blocker",
                     ref: blockerRef,
-                    deliveryStatus: outcome.nudgeResult,
+                    deliveryStatus: nudgeResult,
                 });
                 return this.eventBus.persistWithinTransaction({
                     type: "queue.updated",
@@ -808,32 +896,18 @@ export class QueueRepository {
             if (wakeEvent)
                 this.eventBus.notifySubscribers(wakeEvent);
         }
-        return finalState;
+        // Each released member is delivered on its own now, so this drain finishes only once every member has its outcome.
+        // One attempt per member for the whole pass: they inherit this pass's history, less themselves (released before any
+        // send, so never attempted), so nothing already sent here is regrouped, and each released member gets one attempt.
+        for (const entry of released)
+            attempted.delete(entry.outboxId);
+        for (const entry of released) {
+            await this.deliverWakeIntent(entry.outboxId, attempted).catch((err) => console.error(`Queue wake delivery failed for ${entry.outboxId}:`, err));
+        }
+        return reportedState;
     }
-    /**
-     * W1-b: the post-commit delivery for a successor's wake, and the ONE shared
-     * staged-intent delivery path. When the durable intent store is present
-     * (production), deliver the just-committed intent — which CLAIMS and FINALIZES
-     * the row, so a later recovery sweep cannot send it a second time. When it is
-     * absent (test/bootstrap), fall back to the pre-W1 best-effort nudge so behavior
-     * is unchanged where there is no intent to make durable. Called AFTER the
-     * terminal transaction commits (reversed-never: a pane write must not join the
-     * db transaction).
-     *
-     * PUBLIC as of P34: every terminal-closing writer that stages an intent must
-     * deliver through THIS path rather than {@link maybeNudge}. `maybeNudge` sends
-     * WITHOUT claiming or finalizing, so a staged intent would remain `pending` and
-     * the startup recovery sweep would deliver the same wake AGAIN. One staged
-     * intent, one delivery, one finalized row.
-     *
-     * P34 correction: the no-outbox fallback above was documented here but never
-     * implemented — `deliverWakeIntent` simply returns "skipped" with no outbox
-     * attached, so the nudge vanished SILENTLY (a skip is not an error, so nothing
-     * surfaced it). The pre-W1 callers reached this path only after the MF2 guard
-     * had already proven an outbox was attached, which is why it never showed. P34
-     * routes writers here whose harnesses attach no outbox, so the fallback is now
-     * real code rather than a promise in a comment.
-     */
+    /** Deliver after the queue transaction commits, never from inside it. The shared
+     * intent path owns claims and outcomes; without an intent store use the legacy nudge. */
     async deliverWakeForSuccessor(successorQitemId, destinationSession, nudge, sourceSession) {
         if (nudge === false)
             return;
@@ -846,69 +920,45 @@ export class QueueRepository {
         }
         await this.deliverWakeIntent(`${WAKE_INTENT_PREFIX}${successorQitemId}`);
     }
-    /**
-     * W1-b: the startup-recovery sweep. Delivers wake intents a crash left
-     * committed-but-undelivered (the terminal txn committed, the process died
-     * before the post-commit deliver). Pages in bounded batches and TERMINATES on
-     * a served short batch or on a no-progress round (a flapping transport marks
-     * rows failed = visible, so it still progresses) — never a silent cap, never a
-     * spin.
-     *
-     * MF6 (honest retry policy): the sweep retries ONLY `pending` rows — i.e. wake
-     * intents a crash left committed-but-undelivered. Terminal `failed` and
-     * `indeterminate` rows are NOT re-driven: a failed row would risk resurrecting
-     * a dead wake and an indeterminate one may already have landed (double-send).
-     * Both are left in a VISIBLE terminal state for out-of-band reconciliation. No
-     * periodic timer (out of scope, ruled); a bounded retry of failed rows is the
-     * NAMED residue, not a silent guarantee.
-     */
-    /**
-     * BLOCKING 1 (guard re-seal): the recovery-boundary reconciliation, called ONCE
-     * at startup (NOT inside the drain, which can be invoked concurrently). Moves any
-     * abandoned `sending` wake intents — a prior crashed process's claims — to
-     * `indeterminate`, WITHOUT re-sending: a claim left `sending` is ambiguous (the
-     * send may or may not have landed). Kept SEPARATE from drainPendingWakeIntents so
-     * an overlapping drain can never reconcile another drain's in-flight claim.
-     * Returns the count reconciled.
-     */
+    /** Once at startup, mark abandoned live claims unknown before recovery makes a
+     * new attempt. Never run inside a drain: another drain may still own a live send. */
     reconcileAbandonedWakeIntents() {
         if (!this.outbox)
             return 0;
         return this.outbox.reconcileAbandonedSending(WAKE_INTENT_PREFIX);
     }
+    /** Recover current notifications once per pass. A snapshot horizon and seek cursor
+     * prevent new arrivals or persistent failures from making this pass unbounded. */
     async drainPendingWakeIntents() {
         const tally = { delivered: 0, indeterminate: 0, failed: 0, retained: 0 };
         if (!this.outbox || !this.transport)
             return tally;
         const BATCH = 200;
+        const horizon = this.db.prepare("SELECT COALESCE(MAX(rowid),0) AS id FROM outbox_entries").get().id;
+        // Retire never-attempted obsolete notifications without materializing historical intents.
+        tally.failed += this.db.prepare(`UPDATE outbox_entries AS o SET delivery_state = 'failed',
+      tags = json_insert(COALESCE(tags, '[]'), '$[#]', 'queue:wake-superseded')
+      WHERE delivery_state = 'pending' AND rowid <= ? AND substr(outbox_id, 1, ?) = ?
+        AND NOT EXISTS (SELECT 1 FROM queue_items q WHERE q.qitem_id = o.audit_pointer
+          AND q.state = 'pending' AND q.destination_session = o.destination_session)`)
+            .run(horizon, WAKE_INTENT_PREFIX.length, WAKE_INTENT_PREFIX).changes;
+        const attempted = new Set();
+        let cursor = 0;
         for (;;) {
-            const pending = this.outbox.listPending(WAKE_INTENT_PREFIX, BATCH);
+            const pending = this.db.prepare(`SELECT o.rowid AS id, o.outbox_id FROM outbox_entries o
+        JOIN queue_items q ON q.qitem_id = o.audit_pointer AND q.state = 'pending'
+          AND q.destination_session = o.destination_session
+        WHERE o.rowid > ? AND o.rowid <= ? AND substr(o.outbox_id, 1, ?) = ?
+          AND o.delivery_state IN ('pending','failed','indeterminate') ORDER BY o.rowid LIMIT ?`)
+                .all(cursor, horizon, WAKE_INTENT_PREFIX.length, WAKE_INTENT_PREFIX, BATCH);
             if (pending.length === 0)
                 break;
-            let progressed = 0;
             for (const intent of pending) {
-                const outcome = await this.deliverWakeIntent(intent.outboxId);
-                if (outcome === "delivered") {
-                    tally.delivered++;
-                    progressed++;
-                }
-                else if (outcome === "indeterminate") {
-                    tally.indeterminate++;
-                    progressed++;
-                }
-                else if (outcome === "failed") {
-                    tally.failed++;
-                    progressed++;
-                }
-                else if (outcome === "retained") {
-                    tally.retained++;
-                    progressed++;
-                }
+                cursor = intent.id;
+                const outcome = await this.deliverWakeIntent(intent.outbox_id, attempted);
+                if (outcome !== "skipped")
+                    tally[outcome]++;
             }
-            // Nothing left pending changed state this round (e.g. transport gone
-            // mid-sweep) — stop rather than spin; the next daemon start retries.
-            if (progressed === 0)
-                break;
             if (pending.length < BATCH)
                 break; // served short batch ⇒ drained
         }
@@ -936,14 +986,23 @@ export class QueueRepository {
      * copies were deleted, refused at the seat boundary instead); this
      * site holds no copy of its own.
      */
-    async maybeNudge(qitemId, destinationSession, nudgeOpt, sourceSession, bodyOverride) {
+    async maybeNudge(qitemId, destinationSession, nudgeOpt, sourceSession, bodyOverride, trigger = "agent") {
         if (nudgeOpt === false)
             return;
         if (!this.transport)
             return;
-        const outcome = await this.performWakeSend(qitemId, destinationSession, sourceSession, bodyOverride);
+        const outcome = await this.performWakeSend(qitemId, destinationSession, sourceSession, bodyOverride, undefined, undefined, trigger);
         this.recordNudgeAttempt(qitemId, outcome.nudgeResult);
     }
+    /** The following startup intent drain owns durable pending wakes. Legacy packets
+     * and overdue claimed work (not eligible for that drain) still use the nudge path. */
+    async recoverLostNudge(qitemId, destinationSession, sourceSession) {
+        const outboxId = `${WAKE_INTENT_PREFIX}${qitemId}`;
+        if (this.outbox?.getById(outboxId) && this.getById(qitemId)?.state === "pending")
+            return;
+        // Boot recovery is OpenRig's own scheduling, whoever created the row.
+        await this.maybeNudge(qitemId, destinationSession, undefined, sourceSession, undefined, "openrig");
+    }
     /**
      * W1 (transactional closure): the shared wake-send CORE. Builds the pane
      * envelope, sends with verify, and CLASSIFIES the transport result into the W1
@@ -957,7 +1016,7 @@ export class QueueRepository {
      * (the "delivered-ack-pending" nudge literal). It is never promoted to
      * delivered nor demoted to failed.
      */
-    async performWakeSend(qitemId, destinationSession, sourceSession, bodyOverride, prebuiltText, committedOutboxIds) {
+    async performWakeSend(qitemId, destinationSession, sourceSession, bodyOverride, prebuiltText, committedOutboxIds, trigger = "agent", recheckMembers) {
         // DEFECT FIX qitem-20260827065907-b9ae334c (S1-class, 3 live specimens): a virtual
         // @external destination has NO pane — the queue row ITSELF is the gateway
         // subsystem's input (the Slack connector polls human-destined rows and its own
@@ -987,6 +1046,16 @@ export class QueueRepository {
         if (destClass.class === "unroutable") {
             return { classified: "failed", nudgeResult: destClass.teaching };
         }
+        // A terminal seat runs a shell or a TUI, not an agent. Typed wake text would run there as a
+        // command line (it carries the row's summary), and nothing there can claim the row. So nothing
+        // is typed; the row stays queued and visible. `failed:` keeps it on the wake ladder, whose
+        // retries come back here and type nothing before it escalates.
+        if (isBoundTerminalSeat(this.db, destinationSession)) {
+            return {
+                classified: "failed",
+                nudgeResult: `failed:terminal-seat: '${destinationSession}' is a terminal seat (runtime: terminal), not an agent, so no wake was typed into it and nothing there can claim this row. The row stays queued; route it to an agent seat.`,
+            };
+        }
         const stampISO = new Date().toISOString();
         let text;
         if (prebuiltText !== undefined) {
@@ -1016,7 +1085,11 @@ export class QueueRepository {
             text = held.body;
         }
         try {
-            const res = await this.transport.send(destinationSession, text, { verify: true, stampISO, actorSession: sourceSession, committedOutboxIds, deliveryId: committedOutboxIds ? undefined : deliveryId, auditPointer: qitemId, queueWake: true });
+            const admission = this.wakeAdmission(qitemId, trigger);
+            const res = await this.transport.send(destinationSession, text, { verify: true, stampISO, actorSession: sourceSession, committedOutboxIds,
+                deliveryId: committedOutboxIds ? undefined : deliveryId, auditPointer: qitemId, queueWake: true,
+                ...(trigger === "openrig" ? { openrigNotice: true } : {}), ...(admission.urgentBy ? { urgent: { by: admission.urgentBy } } : {}),
+                ...(recheckMembers ? { recheckMembers } : {}) });
             // OPR.0.3.2.21.FR-4(c) — wording rename: the prior literal
             // "sent-unverified" read as a failure even in the common case
             // (delivery confirmed but the synchronous ack window expired,
@@ -1039,6 +1112,30 @@ export class QueueRepository {
             return { classified: "failed", nudgeResult: `failed:${msg}` };
         }
     }
+    /** First committed return of a direct ask, including pre-shared-ID Slack replies. */
+    getHumanAnswer(qitemId, actorSession) {
+        const ask = this.getById(qitemId);
+        if (!this.hasReplyToColumn || !ask || ask.destinationSession !== actorSession
+            || ask.humanIntent === "update" || !this.isPersonAddress(actorSession))
+            return null;
+        const row = this.db.prepare(`SELECT qitem_id FROM queue_items
+      WHERE reply_to = ? AND source_session = ? AND destination_session = ?
+        AND (EXISTS (SELECT 1 FROM json_each(queue_items.tags) WHERE value = 'human-answer')
+          OR (qitem_id LIKE 'qitem-slack-inbound-%' AND COALESCE(summary, '') NOT LIKE '[Recovered after gap] %'))
+      ORDER BY ts_created, rowid LIMIT 1`).get(qitemId, actorSession, ask.sourceSession);
+        return row ? this.getById(row.qitem_id) : null;
+    }
+    /** The lookup and create's insert run synchronously before its first delivery await.
+     * Every new surface uses the same ID; old IDs and their original bodies remain intact. */
+    async createHumanAnswer(input) {
+        const existing = this.getHumanAnswer(input.inboundReplyTo, input.sourceSession);
+        if (existing)
+            return existing;
+        return this.create({ ...input,
+            qitemId: `qitem-human-answer-${createHash("sha256").update(input.inboundReplyTo).digest("hex").slice(0, 20)}`,
+            tags: [...new Set([...(input.tags ?? []), "human-answer"])],
+        });
+    }
     async create(input) {
         // FOUNDER ROOT INVARIANT (2026-08-27, supersedes 51-09 incr 4 / ruling cb19867f Q2):
         // a LOCAL write stores the bare transport identity — no self-host suffix inside one
@@ -1055,7 +1152,7 @@ export class QueueRepository {
                 try {
                     // A savepoint removes any partial intent when staging fails, while
                     // preserving ordinary create's existing acceptance of the task.
-                    this.db.transaction(() => this.stageWakeIntent(created.qitemId, input.sourceSession, input.destinationSession, input.identityProvenance ?? null, input.nudge))();
+                    this.db.transaction(() => this.stageWakeIntent(created.qitemId, input.sourceSession, input.destinationSession, input.identityProvenance ?? null, input.nudge, input.wakeTrigger))();
                     wakeStaged = true;
                 }
                 catch (err) {
@@ -1116,7 +1213,7 @@ export class QueueRepository {
                 this.deliverWakeIntentAfterCommit(`${WAKE_INTENT_PREFIX}${id}`);
         }
         else {
-            await this.maybeNudge(id, input.destinationSession, input.nudge, input.sourceSession);
+            await this.maybeNudge(id, input.destinationSession, input.nudge, input.sourceSession, undefined, input.wakeTrigger);
         }
         return this.getByIdOrThrow(id);
     }
@@ -1207,11 +1304,13 @@ export class QueueRepository {
                 throw new QueueRepositoryError("invalid_human_questions", "humanQuestions require the current queue schema; they were not saved.");
             humanQuestions = parsed.questions;
         }
+        this.assertHumanAlert(input.humanAlert, input.destinationSession, input.humanIntent);
         const id = input.qitemId ?? newQitemId();
         const ts = new Date().toISOString();
         const priority = input.priority ?? "routine";
         const tier = input.tier ?? null;
-        const tags = input.tags ? JSON.stringify(input.tags) : null;
+        const taggedAsk = withHumanAlertTag(input.tags, input.humanAlert);
+        const tags = taggedAsk ? JSON.stringify(taggedAsk) : null;
         const chain = input.chainOfRecord ? JSON.stringify(input.chainOfRecord) : null;
         const expiresAt = input.expiresAt ?? null;
         const targetRepo = input.targetRepo ?? null;
@@ -1251,6 +1350,7 @@ export class QueueRepository {
         const notification = this.classifyOwnerNotification({
             action: "create",
             humanIntent: input.humanIntent,
+            humanAlert: input.humanAlert,
             destinationSession: input.destinationSession,
             nextState: "pending",
         });
@@ -1274,6 +1374,25 @@ export class QueueRepository {
         });
         return { qitemId: id, persistedEvent };
     }
+    /** humanAlert marks an ask to a person: a person by address or by the registry (a registered person may be addressed as
+     *  their seat), as the classifier reads it, and never an update. */
+    assertHumanAlert(humanAlert, destination, humanIntent) {
+        if (humanAlert != null && typeof humanAlert !== "boolean") {
+            throw new QueueRepositoryError("invalid_human_notification", "humanAlert is true or false.");
+        }
+        if (humanAlert !== true)
+            return;
+        if (!this.isPersonAddress(destination) || humanIntent === "update") {
+            throw new QueueRepositoryError("invalid_human_notification", "humanAlert marks an ask to a person as alert-worthy: it needs a human destination, and an update isn't an ask.");
+        }
+    }
+    /** A person by address or by the registry: a registered person may be addressed as their seat or an alias. */
+    isPersonAddress(destination) {
+        if (isHumanSeatSessionRef(destination))
+            return true;
+        const registry = this.loadHumanRegistryFn();
+        return registry.ok && resolveRegisteredHumanAddress(destination, registry.entities) !== null;
+    }
     validateReplyTo(replyTo, humanIntent) {
         if (humanIntent !== "update") {
             throw new QueueRepositoryError("reply_to_requires_update", "replyTo is accepted only with humanIntent update; a decision keeps its own thread so its reply stays unambiguous.");
@@ -1301,12 +1420,14 @@ export class QueueRepository {
         if (!this.validateRig(input.toSession)) {
             throw destinationValidationError("to_session", input.toSession, this.loadHumanRegistryFn);
         }
+        this.assertHumanAlert(input.humanAlert, input.toSession);
         const newId = newQitemId();
         const ts = new Date().toISOString();
         const body = input.body ?? source.body;
         const priority = input.priority ?? source.priority;
         const tier = input.tier ?? source.tier;
-        const tags = input.tags ? JSON.stringify(input.tags) : (source.tags ? JSON.stringify(source.tags) : null);
+        const handedTags = withHumanAlertTag(input.tags ?? source.tags, input.humanAlert);
+        const tags = handedTags ? JSON.stringify(handedTags) : null;
         const chain = JSON.stringify([...(source.chainOfRecord ?? []), source.qitemId]);
         const targetRepo = input.targetRepo === undefined ? source.targetRepo : input.targetRepo;
         // OPR.0.4.4.19 FR-4/FR-5 — the handoff authors a NEW qitem; when that
@@ -1369,6 +1490,7 @@ export class QueueRepository {
             const successorNotification = this.classifyOwnerNotification({
                 action: "create",
                 destinationSession: input.toSession,
+                humanAlert: input.humanAlert,
                 nextState: "pending",
             });
             this.transitionLog.append({
@@ -1450,12 +1572,14 @@ export class QueueRepository {
         if (!this.validateRig(input.toSession)) {
             throw destinationValidationError("to_session", input.toSession, this.loadHumanRegistryFn);
         }
+        this.assertHumanAlert(input.humanAlert, input.toSession);
         const newId = newQitemId();
         const ts = new Date().toISOString();
         const body = input.body ?? source.body;
         const priority = input.priority ?? source.priority;
         const tier = input.tier ?? source.tier;
-        const tags = input.tags ? JSON.stringify(input.tags) : (source.tags ? JSON.stringify(source.tags) : null);
+        const handedTags = withHumanAlertTag(input.tags ?? source.tags, input.humanAlert);
+        const tags = handedTags ? JSON.stringify(handedTags) : null;
         const chain = JSON.stringify([...(source.chainOfRecord ?? []), source.qitemId]);
         const targetRepo = input.targetRepo === undefined ? source.targetRepo : input.targetRepo;
         // OPR.0.4.4.19 FR-4/FR-5 — same new-item enforcement as handoff().
@@ -1515,6 +1639,7 @@ export class QueueRepository {
             const successorNotification = this.classifyOwnerNotification({
                 action: "create",
                 destinationSession: input.toSession,
+                humanAlert: input.humanAlert,
                 nextState: "pending",
             });
             this.transitionLog.append({
@@ -1679,23 +1804,25 @@ export class QueueRepository {
      * Per PL-004 Phase A § Routes: GET /api/queue/whoami.
      */
     whoami(session, opts) {
+        const addresses = this.resolveSessionAddresses(session);
+        const slots = addresses.map(() => "?").join(",");
         const limit = Math.max(1, Math.min(opts?.recentLimit ?? 25, 200));
         const countByState = (state) => {
             const row = this.db
-                .prepare(`SELECT COUNT(*) AS n FROM queue_items WHERE destination_session = ? AND state = ?`)
-                .get(session, state);
+                .prepare(`SELECT COUNT(*) AS n FROM queue_items WHERE destination_session IN (${slots}) AND state = ?`)
+                .get(...addresses, state);
             return row.n;
         };
         const recent = this.db
             .prepare(`SELECT * FROM queue_items
-          WHERE destination_session = ?
+          WHERE destination_session IN (${slots})
             AND state IN ('pending','in-progress','blocked')
           ORDER BY ts_updated DESC
           LIMIT ?`)
-            .all(session, limit);
+            .all(...addresses, limit);
         const sourceTotalRow = this.db
-            .prepare(`SELECT COUNT(*) AS n FROM queue_items WHERE source_session = ?`)
-            .get(session);
+            .prepare(`SELECT COUNT(*) AS n FROM queue_items WHERE source_session IN (${slots})`)
+            .get(...addresses);
         return {
             session,
             asDestination: {
@@ -1717,9 +1844,11 @@ export class QueueRepository {
      * silently degrades into a confident answer. This is that authoritative input.
      */
     listInProgressForDestination(session) {
+        const addresses = this.resolveSessionAddresses(session);
+        const slots = addresses.map(() => "?").join(",");
         const rows = this.db
-            .prepare(`SELECT * FROM queue_items WHERE destination_session = ? AND state = 'in-progress'`)
-            .all(session);
+            .prepare(`SELECT * FROM queue_items WHERE destination_session IN (${slots}) AND state = 'in-progress'`)
+            .all(...addresses);
         return rows.map((r) => this.rowToItem(r));
     }
     /**
@@ -1730,7 +1859,7 @@ export class QueueRepository {
         if (!qitem) {
             throw new QueueRepositoryError("qitem_not_found", `qitem ${input.qitemId} not found`);
         }
-        if (qitem.destinationSession !== input.destinationSession) {
+        if (!this.resolveSessionAddresses(input.destinationSession).includes(qitem.destinationSession)) {
             throw new QueueRepositoryError("claim_destination_mismatch", `qitem ${input.qitemId} destination is ${qitem.destinationSession}, not ${input.destinationSession}`);
         }
         if (qitem.state !== "pending" && qitem.state !== "blocked") {
@@ -1874,6 +2003,11 @@ export class QueueRepository {
         const result = this.updateInTransactionalContext(input);
         return { qitemId: input.qitemId, ...result };
     }
+    /** Notify subscribers of events persisted inside a caller's own transaction (updateWithinTransaction), after it commits. */
+    notifyCommitted(events) {
+        for (const event of events)
+            this.eventBus.notifySubscribers(event);
+    }
     /** Internal read-only audit pointer for non-state receipts. Never search past a state write. */
     retainedClaimBlocker(qitemId) {
         const latest = this.transitionLog.listForQitem(qitemId).at(-1);
@@ -1916,6 +2050,19 @@ export class QueueRepository {
                 || (input.state !== undefined && input.summary != null)
                 || (input.summary != null && !hasValidSummary);
             if (disallowed) {
+                // Keep the terminal-park correction visible even when the row is already done.
+                if (input.state === "done" && input.closureReason === "blocked_on") {
+                    const validation = validateClosure({
+                        state: input.state,
+                        closureReason: input.closureReason,
+                        closureTarget: input.closureTarget,
+                    });
+                    if (!validation.ok) {
+                        throw new QueueRepositoryError(validation.code, validation.message, {
+                            validReasons: validation.validReasons,
+                        });
+                    }
+                }
                 throw new QueueRepositoryError("note_append_fields_not_admitted", "a state-preserving note append accepts only --note (and an optional same --state); state-write fields were supplied, so nothing was written");
             }
             if (hasValidSummary) {
@@ -2030,6 +2177,8 @@ export class QueueRepository {
             throw new QueueRepositoryError("invalid_human_notification", "An informational delivery cannot become a human approval park; author a separate decision request.");
         }
         const isHumanPark = input.state === "blocked" && isHumanSeatSession(effectiveBlockedOn);
+        // A done close can also store the artifact the work produced, so the finished row carries its link.
+        const isDoneClose = input.state === "done";
         // OPR.0.5.1 slice-51-06 D2 — summary/evidence_ref are persist-able ONLY at a human-seat park
         // (see the FR-6 note below). Silently ignoring them on any other transition is a data-loss trap
         // (the operator believes the metadata was saved). HARD-REJECT before ANY UPDATE/log/event so the
@@ -2039,11 +2188,14 @@ export class QueueRepository {
             const invalidFields = [];
             if (input.summary != null)
                 invalidFields.push("summary");
-            if (input.evidenceRef != null)
+            if (input.evidenceRef != null && !isDoneClose)
                 invalidFields.push("evidenceRef");
             if (invalidFields.length > 0) {
                 const flags = invalidFields.map((f) => (f === "summary" ? "--summary" : "--evidence-ref")).join(" / ");
-                throw new QueueRepositoryError("summary_evidence_not_persistable", `${invalidFields.join(" + ")} persist only on a human-seat park (state=blocked on a human seat); the '${input.state}' transition cannot store them. Remove ${flags}, or park the item (rig queue block --on <human-seat> --summary … --evidence-ref …).`, { invalidFields });
+                const where = invalidFields.map((f) => f === "summary"
+                    ? "summary persists on a human-seat park, or on its own (rig queue update <id> --summary … with no --state)"
+                    : "evidenceRef persists on a human-seat park or a done close").join("; ");
+                throw new QueueRepositoryError("summary_evidence_not_persistable", `${where}; the '${input.state}' transition cannot store ${invalidFields.length > 1 ? "them" : "it"}. Remove ${flags}, or use one of those.`, { invalidFields });
             }
         }
         // SWEEP-a (shape f2576102) — closure/blocked-field COHERENCE, beside the reference
@@ -2211,11 +2363,14 @@ export class QueueRepository {
             .run(input.state, ts, validation.closureReason, validation.closureTarget, input.handedOffTo ?? null, nextBlockedOn, nextResolution, input.qitemId);
         // FR-6: park-time summary/evidence_ref are PERSISTED onto the existing
         // item (not merely validated-then-dropped) — visible to the attention
-        // query and to Packet 2. Only the park path writes them.
+        // query and to Packet 2. A done close writes evidence_ref the same way.
         if (isHumanPark) {
             this.persistSummary(input.qitemId, input.summary ?? null);
             this.persistEvidenceRef(input.qitemId, input.evidenceRef ?? null);
         }
+        else if (isDoneClose) {
+            this.persistEvidenceRef(input.qitemId, input.evidenceRef ?? null);
+        }
         const transition = this.transitionLog.append({
             qitemId: input.qitemId,
             state: input.state,
@@ -2459,7 +2614,8 @@ export class QueueRepository {
     /** The parked row an ordinary due park timer reminds about, when its reminder may share one message with other
      *  reminders due for the same seat in the same scheduler pass: a one-shot `--wake-after` timer serving exactly one
      *  live parked row, carrying its default message. Null keeps the reminder's own send: a custom message, a shared
-     *  or attached watchdog, a repeating wait and a provider-limit timer each deliver as before. */
+     *  or attached watchdog, a repeating wait and a provider-limit timer each deliver as before. The entry carries the
+     *  current park's recorded continuation, or null, for the wake's preview. */
     parkReminderDigestEntry(jobId, message) {
         const generated = this.wakeRepo.findCurrentQitemsByGeneratedTimer(jobId);
         const bound = this.wakeRepo.findBlockedQitemsByWatchdog(jobId, true);
@@ -2473,7 +2629,7 @@ export class QueueRepository {
             return null;
         if (message !== defaultParkWakeMessage(row.qitemId))
             return null;
-        return { qitemId: row.qitemId, summary: row.summary ?? null };
+        return { qitemId: row.qitemId, summary: row.summary ?? null, continuation: this.currentParkContinuation(row.qitemId) };
     }
     /** Called by the watchdog engine after the delivery attempt is durably
      *  audited. The queue transition records that attempt independently of
@@ -2567,7 +2723,7 @@ export class QueueRepository {
             const item = this.getById(input.qitemId);
             if (item?.state !== "pending" || item.humanIntent === "update"
                 || item.destinationSession !== input.actorSession
-                || parseSessionName(item.destinationSession).kind !== "external")
+                || !this.isPersonAddress(item.destinationSession))
                 return null;
             const text = input.decision.trim();
             const unanswered = this.hasHumanQuestionsColumn && text && text !== "[file reply]"
@@ -2617,7 +2773,11 @@ export class QueueRepository {
             if (item.state !== "pending") {
                 // Slack can redeliver the click that closed it. Only to the asked human, say whether this answer is on record.
                 const onRecord = item.destinationSession === input.actorSession && item.humanAnswers?.[input.questionId] === input.optionId;
-                return { status: "not-applicable", reason: `state-${item.state}`, ...(onRecord ? { answerOnRecord: true } : {}) };
+                const delegated = item.destinationSession === input.actorSession ? item.delegatedDecision : null;
+                const decidedForThem = delegated ? { decidedBy: delegated.decidedBy, modeName: delegated.modeName, reversible: delegated.reversible,
+                    chose: delegated.choices.map((c) => c.options.find((o) => o.id === c.chosen)?.label ?? c.chosen).join(", ") } : null;
+                return { status: "not-applicable", reason: `state-${item.state}`, ...(onRecord ? { answerOnRecord: true } : {}),
+                    ...(decidedForThem ? { decidedForThem } : {}) };
             }
             if (item.destinationSession !== input.actorSession)
                 return { status: "not-applicable", reason: "not-the-asked-human" };
@@ -2634,6 +2794,101 @@ export class QueueRepository {
             return { status: "recorded", answers, complete, questions: item.humanQuestions };
         })();
     }
+    /**
+     * Record a decision made on the person's behalf, inside their mode's decision room, on the ask's own row. Only the
+     * agent that asked may record it, only on a pending decision to that person, and only while their mode has a stated
+     * decision room, read in the same transaction. A permission prompt or approval gate is never decided this way. It never writes humanAnswers or a
+     * human-decision-resolved notice: the person didn't answer. The ask is closed (done, no follow-on) so it isn't posted
+     * or re-offered, and the asking agent carries on with its choice.
+     */
+    recordDelegatedDecision(input) {
+        const refuse = (reason, message) => ({ status: "refused", reason, message });
+        if (!this.hasDelegatedDecisionColumn)
+            return refuse("schema", "this daemon's queue schema has no place for a delegated decision");
+        const result = this.db.transaction(() => {
+            const item = this.getById(input.qitemId);
+            if (!item)
+                return refuse("not-found", `qitem ${input.qitemId} not found`);
+            if (item.state !== "pending")
+                return refuse("not-pending", `${input.qitemId} is ${item.state}; only a pending ask can be decided`);
+            const person = parseSessionName(item.destinationSession);
+            if (person.kind !== "external" || item.humanIntent === "update")
+                return refuse("not-a-decision", `${input.qitemId} isn't a decision asked of a person`);
+            // A permission prompt (the wake ladder's prompt alert) or an approval gate (gate work for the human role) is never delegated.
+            if (item.tags?.includes(PROMPT_ALERT_TAG) || effectiveGateRoles({ tags: item.tags, tier: item.tier }).includes("human")) {
+                return refuse("permission-prompt", "a permission prompt or approval gate is never decided on the person's behalf");
+            }
+            // A click keeps a multi-question ask pending until every question is answered: once the person has started, it's theirs.
+            if (item.humanAnswers && Object.keys(item.humanAnswers).length > 0) {
+                return refuse("person-answering", "they've started answering; their answer stands");
+            }
+            if (item.sourceSession !== input.actorSession) {
+                return refuse("not-the-asking-agent", `only the agent that asked (${item.sourceSession}) can record a decision on this ask`);
+            }
+            const app = input.currentApplication(person.local);
+            if (!app)
+                return refuse("no-active-mode", `${person.local} has no mode on, so nothing can be decided for them`);
+            if (app.entityId !== person.local)
+                return refuse("not-the-persons-mode", `that mode is ${app.entityId}'s, not ${person.local}'s`);
+            if (!app.decisionRoom)
+                return refuse("no-decision-room", `${person.local}'s ${app.modeName} has no decision room, so nothing can be decided for them`);
+            if (app.applicationId !== input.expectedApplicationId) {
+                return refuse("mode-changed", "their mode changed since you read the room; read it again");
+            }
+            if (!input.reason.trim())
+                return refuse("invalid-choice", "say why this choice was made");
+            let choices;
+            const questions = item.humanQuestions ?? [];
+            if (questions.length > 0) {
+                const picked = new Map(input.choices.map((c) => [c.questionId ?? "", c.chosen]));
+                if (picked.size !== input.choices.length || questions.some((q) => !picked.has(q.id)) || [...picked.keys()].some((id) => !questions.some((q) => q.id === id))) {
+                    return refuse("invalid-choice", `choose one option for each question: ${questions.map((q) => q.id).join(", ")}`);
+                }
+                choices = [];
+                for (const q of questions) {
+                    const chosen = picked.get(q.id);
+                    if (!q.options.some((o) => o.id === chosen))
+                        return refuse("invalid-choice", `"${chosen}" isn't an option of ${q.id}`);
+                    choices.push({ questionId: q.id, question: q.question, options: q.options.map((o) => ({ id: o.id, label: o.label })), chosen });
+                }
+            }
+            else {
+                const chosen = input.choices.length === 1 && !input.choices[0].questionId ? input.choices[0].chosen.trim() : "";
+                if (!chosen)
+                    return refuse("invalid-choice", "this ask has no structured questions: give one choice, in words");
+                choices = [{ questionId: null, question: item.summary ?? item.body.slice(0, 200), options: [], chosen }];
+            }
+            const record = {
+                applicationId: app.applicationId, modeName: app.modeName, decisionRoom: app.decisionRoom, decidedBy: input.actorSession,
+                decidedAt: (input.now ?? new Date()).toISOString(), choices, reason: input.reason.trim(), reversible: input.reversible,
+            };
+            this.db.prepare("UPDATE queue_items SET delegated_decision = ? WHERE qitem_id = ?").run(JSON.stringify(record), input.qitemId);
+            const chose = choices.map((c) => `${c.questionId ?? "choice"}=${c.chosen}`).join(", ");
+            const closed = this.updateInTransactionalContext({
+                qitemId: input.qitemId,
+                actorSession: input.actorSession,
+                state: "done",
+                closureReason: "no-follow-on",
+                transitionNote: `delegated-decision application=${app.applicationId} mode=${app.modeName} reversible=${input.reversible} `
+                    + `chose ${chose}: decided on ${person.local}'s behalf by ${input.actorSession}, not answered by them`,
+            });
+            return { status: "closed", events: closed.persistedEvents };
+        })();
+        if (result.status === "refused")
+            return result;
+        for (const event of result.events)
+            this.eventBus.notifySubscribers(event);
+        return { status: "recorded", item: this.getById(input.qitemId) };
+    }
+    /** The decisions made on a person's behalf under one mode application, oldest first: for the account when they're back. */
+    delegatedDecisionsFor(applicationId) {
+        if (!this.hasDelegatedDecisionColumn)
+            return [];
+        const rows = this.db.prepare(`SELECT * FROM queue_items WHERE delegated_decision IS NOT NULL
+        AND json_extract(delegated_decision, '$.applicationId') = ?
+      ORDER BY json_extract(delegated_decision, '$.decidedAt'), qitem_id`).all(applicationId);
+        return rows.map((row) => this.rowToItem(row));
+    }
     getById(qitemId) {
         const row = this.db
             .prepare("SELECT * FROM queue_items WHERE qitem_id = ?")
@@ -2702,9 +2957,11 @@ export class QueueRepository {
     /** The parked query's obligation face: open rows to one destination, newest first, without the per-row
      *  projections list() derives (pickup, waiting view, delivery ledger), which this read never uses. */
     listOpenObligations(destinationSession, limit) {
+        const addresses = this.resolveSessionAddresses(destinationSession);
+        const slots = addresses.map(() => "?").join(",");
         const rows = this.db.prepare(`SELECT qitem_id, state${this.hasSummaryColumn ? ", summary" : ""} FROM queue_items
-        WHERE destination_session = ? AND state IN ('pending', 'in-progress', 'blocked')
-        ORDER BY ts_created DESC LIMIT ?`).all(destinationSession, limit);
+        WHERE destination_session IN (${slots}) AND state IN ('pending', 'in-progress', 'blocked')
+        ORDER BY ts_created DESC LIMIT ?`).all(...addresses, limit);
         return rows.map((r) => ({ qitemId: r.qitem_id, state: r.state, summary: r.summary ?? null }));
     }
     list(opts) {
@@ -2721,19 +2978,23 @@ export class QueueRepository {
             params.push(`%@${escaped}`, `%@${escaped}`);
         }
         if (opts?.asSession) {
-            conditions.push("(destination_session = ? OR source_session = ?)");
-            params.push(opts.asSession, opts.asSession);
+            const addresses = this.resolveSessionAddresses(opts.asSession);
+            const slots = addresses.map(() => "?").join(",");
+            conditions.push(`(destination_session IN (${slots}) OR source_session IN (${slots}))`);
+            params.push(...addresses, ...addresses);
         }
         if (opts?.activeOnly && !opts?.state) {
             conditions.push("state IN ('pending', 'in-progress', 'blocked')");
         }
         if (opts?.destinationSession) {
-            conditions.push("destination_session = ?");
-            params.push(opts.destinationSession);
+            const addresses = this.resolveSessionAddresses(opts.destinationSession);
+            conditions.push(`destination_session IN (${addresses.map(() => "?").join(",")})`);
+            params.push(...addresses);
         }
         if (opts?.sourceSession) {
-            conditions.push("source_session = ?");
-            params.push(opts.sourceSession);
+            const addresses = this.resolveSessionAddresses(opts.sourceSession);
+            conditions.push(`source_session IN (${addresses.map(() => "?").join(",")})`);
+            params.push(...addresses);
         }
         if (opts?.state) {
             const states = Array.isArray(opts.state) ? opts.state : [opts.state];
@@ -2745,6 +3006,7 @@ export class QueueRepository {
             conditions.push("target_repo = ?");
             params.push(opts.targetRepo);
         }
+        pushFollowThroughFilters(opts, conditions, params);
         const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
         const columns = opts?.compact ? this.compactColumns() : "*";
         const useActiveFirst = !!(opts?.rig || opts?.asSession || opts?.activeOnly);
@@ -2851,28 +3113,42 @@ export class QueueRepository {
         // clause: a qitem parked as state=blocked on a HUMAN-seat blocker is a
         // decision the human owes. Blocking on another qitem (today's shipped
         // usage) does NOT match — is_human_seat_session rejects qitem ids.
+        // An ask to a person lands here by its classification (isCurrentHumanAsk), alerted or not, so one to a registered
+        // person addressed as a seat or an alias is on Steering too; a reroute ends that.
+        const quietAsk = this.hasOwnerNotificationColumns ? `
+        OR EXISTS (SELECT 1 FROM queue_transitions ask
+          WHERE ask.qitem_id = queue_items.qitem_id AND ask.state = 'pending'
+            AND ask.owner_notification_kind = 'human-required'
+            AND ask.transition_id = (SELECT MAX(latest.transition_id) FROM queue_transitions latest
+              WHERE latest.qitem_id = queue_items.qitem_id AND latest.owner_notification_level IS NOT NULL
+                AND latest.owner_notification_kind <> 'human-decision-resolved')
+            AND NOT EXISTS (SELECT 1 FROM queue_transitions moved WHERE moved.qitem_id = ask.qitem_id
+              AND moved.transition_id > ask.transition_id AND moved.transition_note LIKE 'fallback-routed:%'))` : "";
         const conditions = [
             `state IN (${statePlaceholders})`,
             `(
         is_human_seat_session(destination_session) = 1
-        OR (state = 'blocked' AND is_human_seat_session(blocked_on) = 1)
+        OR (state = 'blocked' AND is_human_seat_session(blocked_on) = 1)${quietAsk}
       )`,
         ];
         if (this.hasHumanIntentColumn)
             conditions.push("COALESCE(human_intent, 'decision') <> 'update'");
         const params = [...states];
         if (opts?.destinationSession) {
-            conditions.push("destination_session = ?");
-            params.push(opts.destinationSession);
+            const addresses = this.resolveSessionAddresses(opts.destinationSession);
+            conditions.push(`destination_session IN (${addresses.map(() => "?").join(",")})`);
+            params.push(...addresses);
         }
         if (opts?.sourceSession) {
-            conditions.push("source_session = ?");
-            params.push(opts.sourceSession);
+            const addresses = this.resolveSessionAddresses(opts.sourceSession);
+            conditions.push(`source_session IN (${addresses.map(() => "?").join(",")})`);
+            params.push(...addresses);
         }
         if (opts?.targetRepo && this.hasTargetRepoColumn) {
             conditions.push("target_repo = ?");
             params.push(opts.targetRepo);
         }
+        pushFollowThroughFilters(opts, conditions, params);
         params.push(limit);
         const sql = `
       SELECT * FROM queue_items
@@ -3121,8 +3397,11 @@ export class QueueRepository {
                 : item.state === "blocked"
                     ? resolveRegisteredHumanAddress(item.blockedOn, registry.entities)
                     : resolveRegisteredHumanAddress(item.destinationSession, registry.entities);
+        // An ask placed on Steering without an alert (RECORD) owes no post: its ledger reports a real receipt (a posting
+        // dial set to RECORD posts it) and never a missing one.
         return humanAddress
-            ? { notificationKey: `${item.qitemId}:${transition.transitionId}`, startedAt: transition.ts }
+            ? { notificationKey: `${item.qitemId}:${transition.transitionId}`, startedAt: transition.ts,
+                ...(transition.ownerNotificationLevel === "RECORD" ? { quiet: true } : {}) }
             : "inactive";
     }
     /** OPR.0.5.6.14 — derive the current episode's delivery ledger. Receipt
@@ -3140,21 +3419,46 @@ export class QueueRepository {
     humanNotificationPostedThisEpisode(qitemId, listed) {
         if (!this.hasQueueTransitionsTable)
             return false;
-        // Only the ask's own notification binds a recipient: create writes it in state pending, to the destination of
-        // that moment. A park notice (its recipient is not retained), a resolution notice, or a later destination change
-        // (routeToFallback opens no new episode) cannot establish that the current destination received this ask.
         const owners = listed?.owners ?? this.transitionLog.ownerNotificationsForQitems([qitemId]).get(qitemId) ?? [];
+        const owner = this.currentAskNotification(qitemId, owners);
+        if (!owner)
+            return false;
+        // The ledger's episode exists only when the destination resolves to a registered human (aliases included).
+        const ledger = listed ? listed.ledger : this.deliveryLedger(qitemId, owners);
+        return ledger !== null && ledger.outcome === "posted" && ledger.episode?.notificationKey === `${qitemId}:${owner.transitionId}`;
+    }
+    /** The ask's own notification while it still binds its recipient. Only that notification does: create writes it in
+     *  state pending, to the destination of that moment. A park notice (its recipient is not retained), a resolution notice,
+     *  or a later destination change (routeToFallback opens no new episode) can't establish who has the ask now. */
+    currentAskNotification(qitemId, owners) {
         const owner = owners[0];
         if (!owner || owner.state !== "pending")
-            return false;
+            return null;
         if (owner.ownerNotificationKind !== "human-required" && owner.ownerNotificationKind !== "human-update")
-            return false;
+            return null;
         const rerouted = this.db.prepare("SELECT 1 FROM queue_transitions WHERE qitem_id = ? AND transition_id > ? AND transition_note LIKE 'fallback-routed:%' LIMIT 1").get(qitemId, owner.transitionId);
-        if (rerouted)
+        return rerouted ? null : owner;
+    }
+    /** True when this row is an ask to a person that's still theirs: its own create-time human-required notification, at
+     *  any level, not rerouted since. Every attention reader (listAttention, the list route, the Feed) uses this one
+     *  membership, whatever happened to its Slack post. */
+    isCurrentHumanAsk(qitemId, listed) {
+        if (!this.hasQueueTransitionsTable)
             return false;
-        // The ledger's episode exists only when the destination resolves to a registered human (aliases included).
-        const ledger = listed ? listed.ledger : this.deliveryLedger(qitemId, owners);
-        return ledger !== null && ledger.outcome === "posted" && ledger.episode?.notificationKey === `${qitemId}:${owner.transitionId}`;
+        const owners = listed?.owners ?? this.transitionLog.ownerNotificationsForQitems([qitemId]).get(qitemId) ?? [];
+        return this.currentAskNotification(qitemId, owners)?.ownerNotificationKind === "human-required";
+    }
+    /** True when this row's current ask was placed on Steering without a Slack alert (human-required at RECORD) and is still
+     *  with that person (not rerouted): it waits on them there by design, like a posted ask, so it isn't stuck and nothing
+     *  re-offers it. */
+    humanAskWithoutAlert(qitemId, listed) {
+        if (!this.hasQueueTransitionsTable)
+            return false;
+        const owners = listed?.owners ?? this.transitionLog.ownerNotificationsForQitems([qitemId]).get(qitemId) ?? [];
+        const owner = this.currentAskNotification(qitemId, owners);
+        // Slack never posts a quiet ask; one that was posted anyway is a posted ask, reported by its receipt.
+        return owner?.ownerNotificationKind === "human-required" && owner.ownerNotificationLevel === "RECORD"
+            && !this.humanNotificationPostedThisEpisode(qitemId, listed);
     }
     /** owners: the row's owner notifications as ownerNotificationsForQitems gives them, when the caller read them. */
     deliveryLedger(qitemId, owners) {
@@ -3226,6 +3530,8 @@ export class QueueRepository {
         const failed = currentNotes.find((note) => note.startsWith("slack-owner-notification-transport-failed "));
         if (failed)
             return { outcome: "transport-failed", detail: failed, episode };
+        if (episode?.quiet)
+            return null;
         const startedAt = episode?.startedAt ?? item.tsCreated;
         const gatewayRouted = episode !== null || item.lastNudgeResult?.startsWith("gateway-owned") === true;
         if (gatewayRouted) {
@@ -3240,6 +3546,7 @@ export class QueueRepository {
     /** The grace window before a receiptless gateway-routed row honestly reads
      *  never-posted (the connector sweep cadence bounds normal posting latency). */
     static NEVER_POSTED_WINDOW_MS = 120_000;
+    /** Record one wake attempt. */
     recordNudgeAttempt(qitemId, result) {
         const ts = new Date().toISOString();
         this.db
@@ -3461,9 +3768,19 @@ export class QueueRepository {
         if (view && ["pending", "in-progress"].includes(view.state)) {
             // #514 — the unclaimed sweep skips a pending ask already posted to its human in the current
             // episode (same predicate as runStuckSweep), so the view must not promise that sweep.
-            const awaitingHuman = view.state === "pending" && this.humanNotificationPostedThisEpisode(qitemId, listed);
+            const posted = view.state === "pending" && this.humanNotificationPostedThisEpisode(qitemId, listed);
+            const onSteering = !posted && view.state === "pending" && this.humanAskWithoutAlert(qitemId, listed);
+            const awaitingHuman = posted || onSteering;
             if (awaitingHuman) {
-                view.nextBackstop = { owner: view.owner, mechanism: "none (posted to the human; awaiting their decision)", dueAt: null, intervalSeconds: null };
+                view.nextBackstop = { owner: view.owner, mechanism: onSteering
+                        ? "none (on Steering for the human, with no Slack alert; awaiting their decision)"
+                        : "none (posted to the human; awaiting their decision)", dueAt: null, intervalSeconds: null };
+            }
+            // Quiet hours: a held ask is owned by its window's release job until it posts.
+            const quiet = awaitingHuman ? null : quietCustodyBackstop(view.owner, quietHoldCustody(this.db, qitemId));
+            if (quiet) {
+                view.nextBackstop = quiet;
+                return view;
             }
             const recovery = readWakeLadderBackstop(this.db, qitemId);
             if (recovery) {
@@ -3471,6 +3788,23 @@ export class QueueRepository {
                     view.laterBackstop = { ...view.nextBackstop, note: "Conditional safety net; current delivery/recovery ownership is evaluated first." };
                 view.nextBackstop = recovery;
             }
+            else if (!awaitingHuman && view.state === "pending" && this.db.prepare("SELECT last_nudge_result FROM queue_items WHERE qitem_id = ?")
+                .get(qitemId)?.last_nudge_result === "retained:typing_guard") {
+                // Held at the seat on purpose: not stuck, and not picked up. Nothing replays it; reading or delivering it is a
+                // deliberate step.
+                view.nextBackstop = { owner: view.owner, mechanism: "held by the seat's typing guard", dueAt: null, intervalSeconds: null, held: true,
+                    note: `Nothing was typed into ${view.owner}. Read it with rig seat held-messages ${view.owner}; changing the seat's level doesn't replay it.` };
+            }
+        }
+        if (view?.state === "blocked") {
+            // A row parked on a person carries that person's notification, which quiet hours can hold. Its quiet custody is the
+            // next step; the row's blocker is unchanged, and its own timer or wait notice stays as the later backstop.
+            const quiet = quietCustodyBackstop(view.owner, quietHoldCustody(this.db, qitemId));
+            if (quiet) {
+                if (/^(watchdog:|unconsumed wait notice)/.test(view.nextBackstop.mechanism))
+                    view.laterBackstop = view.nextBackstop;
+                view.nextBackstop = quiet;
+            }
         }
         return view;
     }
@@ -3511,6 +3845,7 @@ export class QueueRepository {
             lastMeaningfulAt: meaningful?.at,
             activity: activity?.activity,
             needsInput: activity?.needsInput.count,
+            needsInputReason: activity?.needsInput.reason,
             claimedAt: row.claimed_at,
             lastHeartbeat: row.last_heartbeat,
             postClaimMotionCount: 0, // this reader supplies the current meaningful timestamp
@@ -3546,6 +3881,7 @@ export class QueueRepository {
             replyTo: row.reply_to ?? null,
             humanQuestions: row.human_questions ? JSON.parse(row.human_questions) : null,
             humanAnswers: row.human_answers ? JSON.parse(row.human_answers) : null,
+            delegatedDecision: row.delegated_decision ? JSON.parse(row.delegated_decision) : null,
             closureReason: row.closure_reason,
             closureTarget: row.closure_target,
             closureRequiredAt: row.closure_required_at,