@dsh-enhanced/assistant-delivery 0.1.62 → 0.1.64

package/lib/store.js

@@ -1366,6 +1366,8 @@ function leaseTargetJson(target) {
 }
 export class DeliveryStore {
     database;
+    /** Scan position only; every candidate is authorized again before a provider retry. */
+    progressRecoveryCursors = new Map();
     databaseInstanceId;
     now;
     codeGenerator;
@@ -2606,6 +2608,214 @@ export class DeliveryStore {
             .get(channel, account, eventId);
         return row === undefined ? undefined : inboxFromRow(row);
     }
+    progressAuthority(intent, credentialFingerprint) {
+        if (!/^[0-9a-f]{64}$/u.test(credentialFingerprint))
+            return undefined;
+        const target = canonicalTarget(intent.target);
+        const inbox = this.getInboxByProviderEvent(target.conversation.channel, target.conversation.account, intent.eventId);
+        const binding = this.getBinding(intent.bindingId);
+        const activeBinding = this.getActiveBinding(target.conversation);
+        const principal = this.getPrincipal(target.principal);
+        if (inbox?.bindingId !== intent.bindingId || binding?.status !== 'active'
+            || activeBinding?.id !== binding.id || principal?.status !== 'active'
+            || JSON.stringify(canonicalTarget({ conversation: binding.conversation, principal: binding.principal })) !== JSON.stringify(target)
+            || JSON.stringify(canonicalTarget({ conversation: inbox.envelope.conversation,
+                principal: inbox.envelope.principal })) !== JSON.stringify(target))
+            return undefined;
+        return { inbox, binding, targetHash: createHash('sha256').update(JSON.stringify(target)).digest('hex') };
+    }
+    progressRecord(row, inbox) {
+        return {
+            bindingId: row.binding_id,
+            eventId: inbox.eventId,
+            target: { conversation: inbox.envelope.conversation, principal: inbox.envelope.principal },
+            ...(row.provider_handle === null ? {} : { providerHandle: row.provider_handle }),
+            sequence: row.sequence,
+            step: row.step,
+            showDetails: row.show_details === 1,
+            state: row.state,
+            ...(row.terminal_kind === null ? {} : { terminal: row.terminal_kind === 'failed'
+                    ? { kind: 'failed', ...(row.terminal_code === null ? {} : { code: row.terminal_code }) }
+                    : { kind: row.terminal_kind } }),
+        };
+    }
+    progressRow(inboxId) {
+        return this.database.prepare('SELECT * FROM delivery_progress WHERE inbox_id = ?').get(inboxId);
+    }
+    /** Reserve before provider I/O; a stranded creating row must never trigger another create. */
+    beginProgress(intent, credentialFingerprint, sequence, showDetails) {
+        this.assertOpen();
+        if (intent.update.kind !== 'started' || !Number.isSafeInteger(sequence) || sequence < 1
+            || typeof showDetails !== 'boolean')
+            return undefined;
+        return this.transaction(() => {
+            const authority = this.progressAuthority(intent, credentialFingerprint);
+            if (authority === undefined || authority.inbox.status !== 'claimed')
+                return undefined;
+            const previous = this.progressRow(authority.inbox.id);
+            if (previous !== undefined) {
+                return previous.binding_id === intent.bindingId && previous.binding_version === authority.binding.version
+                    && previous.binding_generation === authority.binding.generation
+                    && previous.target_hash === authority.targetHash && previous.credential_hash === credentialFingerprint
+                    ? { record: this.progressRecord(previous, authority.inbox), created: false } : undefined;
+            }
+            this.database.prepare(`INSERT INTO delivery_progress(
+        inbox_id, binding_id, binding_version, binding_generation, target_hash, credential_hash,
+        sequence, step, show_details, state, created_at, updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, 'creating', ?, ?)`).run(authority.inbox.id, intent.bindingId, authority.binding.version, authority.binding.generation, authority.targetHash, credentialFingerprint, sequence, showDetails ? 1 : 0, this.now(), this.now());
+            return { record: this.progressRecord(this.progressRow(authority.inbox.id), authority.inbox), created: true };
+        });
+    }
+    getProgress(intent, credentialFingerprint) {
+        this.assertOpen();
+        const authority = this.progressAuthority(intent, credentialFingerprint);
+        if (authority === undefined)
+            return undefined;
+        const row = this.progressRow(authority.inbox.id);
+        if (row === undefined || row.binding_id !== intent.bindingId || row.binding_version !== authority.binding.version
+            || row.binding_generation !== authority.binding.generation || row.target_hash !== authority.targetHash
+            || row.credential_hash !== credentialFingerprint)
+            return undefined;
+        return this.progressRecord(row, authority.inbox);
+    }
+    attachProgressHandle(intent, credentialFingerprint, providerHandle) {
+        this.assertOpen();
+        if (typeof providerHandle !== 'string' || providerHandle.length < 2 || Buffer.byteLength(providerHandle) > 2_048)
+            return undefined;
+        return this.transaction(() => {
+            const current = this.getProgress(intent, credentialFingerprint);
+            if (current?.state !== 'creating')
+                return undefined;
+            const inbox = this.getInboxByProviderEvent(intent.target.conversation.channel, intent.target.conversation.account, intent.eventId);
+            this.database.prepare(`UPDATE delivery_progress SET provider_handle = ?,
+        state = CASE WHEN terminal_kind IS NULL THEN 'active' ELSE 'pending' END,
+        retry_attempts = CASE WHEN terminal_kind IS NULL THEN 0 ELSE 1 END,
+        next_retry_at = CASE WHEN terminal_kind IS NULL THEN 0 ELSE ? END, updated_at = ?
+        WHERE inbox_id = ? AND state = 'creating' AND provider_handle IS NULL`).run(providerHandle, this.now() + 10_000, this.now(), inbox.id);
+            return this.getProgress(intent, credentialFingerprint);
+        });
+    }
+    advanceProgress(intent, credentialFingerprint) {
+        this.assertOpen();
+        return this.transaction(() => {
+            const current = this.getProgress(intent, credentialFingerprint);
+            if (current?.state !== 'active' || current.providerHandle === undefined)
+                return undefined;
+            const inbox = this.getInboxByProviderEvent(intent.target.conversation.channel, intent.target.conversation.account, intent.eventId);
+            this.database.prepare(`UPDATE delivery_progress SET step = step + 1, updated_at = ?
+        WHERE inbox_id = ? AND state = 'active' AND step < 9007199254740991`).run(this.now(), inbox.id);
+            return this.getProgress(intent, credentialFingerprint);
+        });
+    }
+    stageProgressTerminal(intent, credentialFingerprint) {
+        this.assertOpen();
+        if (!['completed', 'failed', 'paused'].includes(intent.update.kind))
+            return undefined;
+        return this.transaction(() => {
+            const authority = this.progressAuthority(intent, credentialFingerprint);
+            if (authority === undefined)
+                return undefined;
+            const inbox = authority.inbox;
+            const code = intent.update.kind === 'failed' ? intent.update.code?.slice(0, 80) ?? null : null;
+            const current = this.getProgress(intent, credentialFingerprint);
+            if (current === undefined) {
+                if (this.progressRow(inbox.id) !== undefined)
+                    return undefined;
+                // A terminal may bypass queued provider steps before `started` reserved a row. Fence the
+                // would-be create instead of constructing an untracked progress message after completion.
+                this.database.prepare(`INSERT INTO delivery_progress(
+          inbox_id, binding_id, binding_version, binding_generation, target_hash, credential_hash,
+          sequence, step, show_details, state, terminal_kind, terminal_code, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, 1, 0, 0, 'creating', ?, ?, ?, ?)`).run(inbox.id, intent.bindingId, authority.binding.version, authority.binding.generation, authority.targetHash, credentialFingerprint, intent.update.kind, code, this.now(), this.now());
+                return this.getProgress(intent, credentialFingerprint);
+            }
+            if (current.state === 'creating') {
+                this.database.prepare(`UPDATE delivery_progress SET terminal_kind = ?, terminal_code = ?, updated_at = ?
+          WHERE inbox_id = ? AND state = 'creating'`).run(intent.update.kind, code, this.now(), inbox.id);
+                return this.getProgress(intent, credentialFingerprint);
+            }
+            if (current.state !== 'active')
+                return current;
+            this.database.prepare(`UPDATE delivery_progress SET state = 'pending', terminal_kind = ?, terminal_code = ?,
+        step = step + 1, retry_attempts = 1, next_retry_at = ?, updated_at = ?
+        WHERE inbox_id = ? AND state = 'active'`).run(intent.update.kind, code, this.now() + 10_000, this.now(), inbox.id);
+            return this.getProgress(intent, credentialFingerprint);
+        });
+    }
+    confirmProgressTerminal(intent, credentialFingerprint) {
+        this.assertOpen();
+        const current = this.getProgress(intent, credentialFingerprint);
+        if (current?.state !== 'pending')
+            return;
+        const inbox = this.getInboxByProviderEvent(intent.target.conversation.channel, intent.target.conversation.account, intent.eventId);
+        this.database.prepare("UPDATE delivery_progress SET state = 'delivered', updated_at = ? WHERE inbox_id = ? AND state = 'pending'")
+            .run(this.now(), inbox.id);
+    }
+    /** Only authoritative settled Inbox rows are eligible for restart repair. */
+    recoverProgress(channel, account, credentialFingerprint, limit, authorize) {
+        this.assertOpen();
+        if (!/^[0-9a-f]{64}$/u.test(credentialFingerprint) || !Number.isSafeInteger(limit) || limit < 1 || limit > 1_000)
+            return [];
+        const cursorKey = JSON.stringify([channel, account]);
+        const previous = this.progressRecoveryCursors.get(cursorKey);
+        const cursor = previous?.credentialFingerprint === credentialFingerprint ? previous : undefined;
+        let nextCursor;
+        const result = this.transaction(() => {
+            const rows = this.database.prepare(`SELECT progress.* FROM delivery_progress AS progress
+        JOIN inbox_messages AS inbox ON inbox.id = progress.inbox_id
+        WHERE inbox.channel = ? AND inbox.account = ? AND progress.credential_hash = ?
+          AND inbox.status IN ('processed', 'dead_letter')
+          AND progress.state IN ('active', 'pending') AND progress.provider_handle IS NOT NULL
+          AND progress.retry_attempts < 8 AND progress.next_retry_at <= ?
+          AND (? = 0 OR progress.created_at > ?
+            OR (progress.created_at = ? AND progress.inbox_id > ?))
+        ORDER BY progress.created_at, progress.inbox_id LIMIT ?`).all(channel, account, credentialFingerprint, this.now(), cursor === undefined ? 0 : 1, cursor?.createdAt ?? 0, cursor?.createdAt ?? 0, cursor?.inboxId ?? '', limit);
+            if (rows.length === 0)
+                return [];
+            const recovered = [];
+            for (const row of rows) {
+                nextCursor = { credentialFingerprint, createdAt: row.created_at, inboxId: row.inbox_id };
+                const inbox = this.getInbox(row.inbox_id);
+                if (inbox === undefined || inbox.bindingId !== row.binding_id)
+                    continue;
+                const intent = { bindingId: row.binding_id, eventId: inbox.eventId,
+                    target: { conversation: inbox.envelope.conversation, principal: inbox.envelope.principal }, update: { kind: 'started' } };
+                const current = this.getProgress(intent, credentialFingerprint);
+                if (current === undefined)
+                    continue;
+                const binding = this.getBinding(row.binding_id);
+                if (authorize !== undefined && !authorize(binding, inbox))
+                    continue;
+                if (this.database.prepare(`SELECT 1 FROM delivery_session_leases
+          WHERE session_id = ? AND state = 'dispatched' AND lease_until > ?`).get(binding.sessionId, this.now()) !== undefined)
+                    continue;
+                const execution = this.database.prepare('SELECT status, quiescent FROM delivery_foreground_executions WHERE inbox_id = ?')
+                    .get(inbox.id);
+                if (inbox.status === 'dead_letter' && inbox.failureCode === 'dispatch-ambiguous' && execution?.status === 'pending') {
+                    this.database.prepare(`UPDATE delivery_foreground_executions SET status = 'unknown', quiescent = 0,
+            completed_at = MAX(dispatched_at, ?), execution_ref = inbox_id WHERE inbox_id = ? AND status = 'pending'`)
+                        .run(this.now(), inbox.id);
+                }
+                const succeeded = inbox.status === 'processed' && execution?.status === 'succeeded' && execution.quiescent === 1;
+                const terminal = current.terminal?.kind === 'failed' || current.terminal?.kind === 'paused'
+                    ? current.terminal
+                    : succeeded ? { kind: 'completed' }
+                        : { kind: 'failed', code: 'INTERRUPTED_RESULT_UNKNOWN' };
+                this.database.prepare(`UPDATE delivery_progress SET state = 'pending', terminal_kind = ?, terminal_code = ?,
+          step = step + ?, retry_attempts = retry_attempts + 1, next_retry_at = ?, updated_at = ?
+          WHERE inbox_id = ? AND state IN ('active', 'pending') AND retry_attempts < 8`).run(terminal.kind, terminal.kind === 'failed' ? terminal.code ?? null : null, row.state === 'active' || row.terminal_kind !== terminal.kind ? 1 : 0, this.now() + Math.min(300_000, 10_000 * (2 ** row.retry_attempts)), this.now(), inbox.id);
+                recovered.push(this.getProgress(intent, credentialFingerprint));
+                // Claim one retry per sweep so stopping cannot consume a later record's retry budget.
+                break;
+            }
+            return recovered;
+        });
+        if (nextCursor === undefined)
+            this.progressRecoveryCursors.delete(cursorKey);
+        else
+            this.progressRecoveryCursors.set(cursorKey, nextCursor);
+        return result;
+    }
     /** Return the oldest durable admission that did not finish before another Inbox. */
     findPendingInboundBefore(input) {
         this.assertOpen();
@@ -2649,6 +2859,95 @@ export class DeliveryStore {
     `).all(afterSequence, limit);
         return rows.map(inboxFromRow);
     }
+    /** Scan durable, unacknowledged dispatched turns without replaying their Agent work. */
+    listInterruptedInboxNotices(input = {}) {
+        this.assertOpen();
+        const afterSequence = input.afterSequence ?? 0;
+        if (!Number.isSafeInteger(afterSequence) || afterSequence < 0) {
+            throw new DeliveryStoreError('conflict', 'invalid interrupted Inbox cursor');
+        }
+        const limit = boundedMaintenanceLimit(input.limit, 100, 'interrupted Inbox');
+        const rows = this.database.prepare(`${inboxSelect}
+      WHERE inbox_messages.status = 'dead_letter'
+        AND inbox_messages.failure_code IN ('dispatch-ambiguous', 'agent-task-timeout')
+        AND json_extract(inbox_messages.envelope_json, '$.kind') = 'text'
+        AND inbox_messages.channel != 'web'
+        AND inbox_messages.binding_id IS NOT NULL
+        AND EXISTS (
+          SELECT 1 FROM delivery_foreground_executions AS execution
+          WHERE execution.inbox_id = inbox_messages.id
+        )
+        AND admission_sequence > ?
+        AND NOT EXISTS (
+          SELECT 1 FROM dead_letter_resolutions AS resolution
+          WHERE resolution.kind = 'inbox' AND resolution.message_id = inbox_messages.id
+            AND resolution.attempt_count = inbox_messages.attempt_count
+        )
+        AND NOT EXISTS (
+          SELECT 1 FROM outbox_messages AS reply
+          WHERE reply.idempotency_key IN (
+            'inbound:' || inbox_messages.id || ':reply',
+            'inbound:' || inbox_messages.event_id || ':reply',
+            'inbound:' || inbox_messages.id || ':interrupted'
+          )
+        )
+      ORDER BY admission_sequence LIMIT ?
+    `).all(afterSequence, limit);
+        return rows.map(inboxFromRow);
+    }
+    /** The final notice decision and Outbox insert share one SQLite writer fence. */
+    enqueueInterruptedInboxNotice(input) {
+        this.assertOpen();
+        return this.transaction(() => {
+            if (!this.interruptedInboxNoticeCurrent(input)) {
+                throw new DeliveryStoreError('version-conflict', 'interrupted Inbox notice lost its exact owner or reply fence');
+            }
+            return this.enqueueIntent(input.intent, false);
+        });
+    }
+    /** Recheck a queued interruption notice immediately before an adapter send. */
+    canSendInterruptedInboxNotice(record) {
+        this.assertOpen();
+        const key = record.intent.idempotencyKey;
+        if (!key.startsWith('inbound:') || !key.endsWith(':interrupted'))
+            return false;
+        const inboxId = key.slice('inbound:'.length, -':interrupted'.length);
+        const binding = this.getBinding(record.intent.bindingId);
+        return binding !== undefined
+            && this.getOutboxByIdempotencyKey(key)?.id === record.id
+            && this.interruptedInboxNoticeCurrent({ inboxId, binding, intent: record.intent });
+    }
+    interruptedInboxNoticeCurrent(input) {
+        const inbox = this.getInbox(input.inboxId);
+        const binding = inbox?.bindingId === undefined ? undefined : this.getBinding(inbox.bindingId);
+        const owner = binding === undefined ? undefined : this.getBindingPrincipal(binding.id);
+        const execution = this.database.prepare(`
+        SELECT principal_record_id, principal_version, binding_id, binding_version,
+          binding_generation, workspace, preset
+        FROM delivery_foreground_executions WHERE inbox_id = ?
+    `).get(input.inboxId);
+        return inbox?.status === 'dead_letter'
+            && (inbox.failureCode === 'dispatch-ambiguous' || inbox.failureCode === 'agent-task-timeout')
+            && inbox.envelope.kind === 'text' && inbox.channel !== 'web'
+            && binding?.status === 'active' && binding.id === input.binding.id
+            && binding.version === input.binding.version && binding.generation === input.binding.generation
+            && binding.sessionId === input.binding.sessionId
+            && this.getActiveBinding(inbox.envelope.conversation)?.id === binding.id
+            && owner?.status === 'active' && owner.role === 'owner'
+            && execution?.principal_record_id === owner.id && execution.principal_version === owner.version
+            && execution.binding_id === binding.id && execution.binding_version === binding.version
+            && execution.binding_generation === binding.generation
+            && execution.workspace === binding.workspace && execution.preset === binding.agentPreset
+            && principalHash(inbox.envelope.principal) === principalHash(binding.principal)
+            && conversationHash(inbox.envelope.conversation) === conversationHash(binding.conversation)
+            && input.intent.bindingId === binding.id
+            && input.intent.replyToEventId === inbox.eventId
+            && input.intent.idempotencyKey === `inbound:${inbox.id}:interrupted`
+            && this.getDeadLetterResolution({ kind: 'inbox', id: inbox.id,
+                attemptCount: inbox.attemptCount }) === undefined
+            && this.getOutboxByIdempotencyKey(`inbound:${inbox.id}:reply`) === undefined
+            && this.getOutboxByIdempotencyKey(`inbound:${inbox.eventId}:reply`) === undefined;
+    }
     listInbox(input = {}) {
         this.assertOpen();
         const limit = Math.max(1, Math.min(100, input.limit ?? 20));
@@ -2804,6 +3103,40 @@ export class DeliveryStore {
         }
         return this.getInbox(inboxId);
     }
+    /** A durable control message wins even while its async binding transition is waiting. */
+    hasRestartCancellationAfter(inboxId, binding) {
+        this.assertOpen();
+        const rows = this.database.prepare(`SELECT message.envelope_json FROM inbox_messages AS message
+      JOIN delivery_inbox_admissions AS admission ON admission.inbox_id = message.id
+      WHERE admission.admission_sequence > (SELECT admission_sequence FROM delivery_inbox_admissions WHERE inbox_id = ?)
+        AND message.status != 'dead_letter'
+        AND json_extract(message.envelope_json, '$.kind') = 'command'
+        AND json_extract(message.envelope_json, '$.conversation') = json(?)
+        AND json_extract(message.envelope_json, '$.principal') = json(?)`)
+            .all(inboxId, conversationJson(binding.conversation), principalJson(binding.principal));
+        return rows.some(row => isExactDeliveryCommand(parseDeliveryCommand(JSON.parse(row.envelope_json)), 'stop', 'new', 'clear'));
+    }
+    /** The fence and Inbox claims share this database's write transaction. */
+    setRestartFence(requestId, sourceInvocationId) {
+        this.assertOpen();
+        this.transaction(() => {
+            const current = this.getRestartFence();
+            if (current !== undefined && (current.requestId !== requestId || current.sourceInvocationId !== sourceInvocationId)) {
+                throw new DeliveryStoreError('conflict', 'another restart owns the delivery drain fence');
+            }
+            this.database.prepare('INSERT OR IGNORE INTO delivery_restart_fence VALUES (1, ?, ?)').run(requestId, sourceInvocationId);
+        });
+    }
+    getRestartFence() {
+        this.assertOpen();
+        const row = this.database.prepare('SELECT request_id, source_invocation_id FROM delivery_restart_fence WHERE singleton = 1')
+            .get();
+        return row === undefined ? undefined : { requestId: row.request_id, sourceInvocationId: row.source_invocation_id };
+    }
+    clearRestartFence(requestId) {
+        this.assertOpen();
+        this.database.prepare('DELETE FROM delivery_restart_fence WHERE singleton = 1 AND request_id = ?').run(requestId);
+    }
     claimInbox(input) {
         this.assertOpen();
         const ownerId = validateBindingText(input.ownerId, 'ownerId', 256);
@@ -2819,6 +3152,8 @@ export class DeliveryStore {
         const now = this.now();
         const claims = [];
         this.transaction(() => {
+            if (this.getRestartFence() !== undefined)
+                return;
             this.database.prepare(`
         UPDATE inbox_messages SET status = 'dead_letter', failure_code = 'attempts-exhausted',
           next_attempt_at = NULL, updated_at = ?
@@ -4397,93 +4732,98 @@ export class DeliveryStore {
         const claims = [];
         const validatedOwnerRouteIds = [];
         this.transaction(() => {
-            this.database.prepare(`
-        UPDATE outbox_messages SET status = 'dead', failure_code = 'attempts-exhausted',
-          next_attempt_at = NULL, updated_at = ?
-        WHERE rowid IN (
-          SELECT candidate.rowid FROM outbox_messages AS candidate
-          WHERE candidate.status = 'retry_wait' AND candidate.next_attempt_at <= ?
-            AND (
-              SELECT COUNT(*) FROM outbox_attempts AS history
-              WHERE history.outbox_id = candidate.id AND history.operation = 'send'
-            ) >= ?
-          ORDER BY candidate.rowid LIMIT ?
-        )
-      `).run(now, now, input.maxAttempts, maintenanceLimit);
-            this.database.prepare(`
-        UPDATE outbox_messages SET status = 'dead', failure_code = 'reconcile-attempts-exhausted',
-          next_attempt_at = NULL, updated_at = ?
-        WHERE rowid IN (
-          SELECT candidate.rowid FROM outbox_messages AS candidate
-          WHERE candidate.status = 'unknown_after_send'
-            AND NOT EXISTS (
-              SELECT 1 FROM dead_letter_resolutions AS resolution
-              WHERE resolution.kind = 'outbox' AND resolution.message_id = candidate.id
-                AND resolution.attempt_count = candidate.attempt_count AND resolution.resolution = 'cancel'
-            )
-            AND (
-              SELECT COUNT(*) FROM outbox_attempts AS history
-              WHERE history.outbox_id = candidate.id AND history.operation = 'reconcile'
-            ) >= ?
-          ORDER BY candidate.rowid LIMIT ?
-        )
-      `).run(now, input.maxAttempts, maintenanceLimit);
-            const ownerRouteRows = this.database.prepare(`
-        SELECT id FROM outbox_messages
-        WHERE status IN ('pending', 'retry_wait') AND claimed_by IS NULL
-          AND (next_attempt_at IS NULL OR next_attempt_at <= ?)
-          AND json_type(intent_json, '$.metadata."dsh.route.authority"') IS NOT NULL
-        ORDER BY rowid LIMIT ?
-      `).all(now, maintenanceLimit);
-            const ownerRouteGuard = input.ownerRouteGuard ?? { ownerRoutes: [], authorize: () => false };
-            for (const row of ownerRouteRows) {
-                const record = this.getOutbox(row.id);
-                if (record === undefined)
-                    continue;
-                const inspected = this.inspectOwnerRouteDispatch(record, ownerRouteGuard);
-                if (inspected.kind === 'deferred') {
-                    this.deferOwnerRouteBeforeClaim(record, inspected.failureCode, now, now + Math.max(1, Math.min(input.leaseMs, 30_000)));
-                    continue;
-                }
-                if (inspected.kind !== 'authorized') {
-                    const failureCode = inspected.kind === 'denied'
-                        ? inspected.failureCode
-                        : 'owner-route-receipt-invalid';
-                    this.deadLetterOwnerRouteBeforeClaim(record, ownerId, failureCode, now);
-                    continue;
-                }
-                if (!this.ownerRouteIsProvablyUnsent(record)) {
-                    this.deadLetterOwnerRouteBeforeClaim(record, ownerId, 'owner-route-send-proof-missing', now);
-                    continue;
-                }
-                if (!this.rebindOwnerRouteBeforeClaim(record, inspected)) {
-                    this.deadLetterOwnerRouteBeforeClaim(record, ownerId, 'owner-route-rebind-conflict', now);
-                    continue;
+            const restartFenceActive = this.getRestartFence() !== undefined;
+            // Drain without changing queued retries or unresolved sends. Only a
+            // plain maintenance acknowledgement may start during this fence.
+            if (!restartFenceActive) {
+                this.database.prepare(`
+          UPDATE outbox_messages SET status = 'dead', failure_code = 'attempts-exhausted',
+            next_attempt_at = NULL, updated_at = ?
+          WHERE rowid IN (
+            SELECT candidate.rowid FROM outbox_messages AS candidate
+            WHERE candidate.status = 'retry_wait' AND candidate.next_attempt_at <= ?
+              AND (
+                SELECT COUNT(*) FROM outbox_attempts AS history
+                WHERE history.outbox_id = candidate.id AND history.operation = 'send'
+              ) >= ?
+            ORDER BY candidate.rowid LIMIT ?
+          )
+        `).run(now, now, input.maxAttempts, maintenanceLimit);
+                this.database.prepare(`
+          UPDATE outbox_messages SET status = 'dead', failure_code = 'reconcile-attempts-exhausted',
+            next_attempt_at = NULL, updated_at = ?
+          WHERE rowid IN (
+            SELECT candidate.rowid FROM outbox_messages AS candidate
+            WHERE candidate.status = 'unknown_after_send'
+              AND NOT EXISTS (
+                SELECT 1 FROM dead_letter_resolutions AS resolution
+                WHERE resolution.kind = 'outbox' AND resolution.message_id = candidate.id
+                  AND resolution.attempt_count = candidate.attempt_count AND resolution.resolution = 'cancel'
+              )
+              AND (
+                SELECT COUNT(*) FROM outbox_attempts AS history
+                WHERE history.outbox_id = candidate.id AND history.operation = 'reconcile'
+              ) >= ?
+            ORDER BY candidate.rowid LIMIT ?
+          )
+        `).run(now, input.maxAttempts, maintenanceLimit);
+                const ownerRouteRows = this.database.prepare(`
+          SELECT id FROM outbox_messages
+          WHERE status IN ('pending', 'retry_wait') AND claimed_by IS NULL
+            AND (next_attempt_at IS NULL OR next_attempt_at <= ?)
+            AND json_type(intent_json, '$.metadata."dsh.route.authority"') IS NOT NULL
+          ORDER BY rowid LIMIT ?
+        `).all(now, maintenanceLimit);
+                const ownerRouteGuard = input.ownerRouteGuard ?? { ownerRoutes: [], authorize: () => false };
+                for (const row of ownerRouteRows) {
+                    const record = this.getOutbox(row.id);
+                    if (record === undefined)
+                        continue;
+                    const inspected = this.inspectOwnerRouteDispatch(record, ownerRouteGuard);
+                    if (inspected.kind === 'deferred') {
+                        this.deferOwnerRouteBeforeClaim(record, inspected.failureCode, now, now + Math.max(1, Math.min(input.leaseMs, 30_000)));
+                        continue;
+                    }
+                    if (inspected.kind !== 'authorized') {
+                        const failureCode = inspected.kind === 'denied'
+                            ? inspected.failureCode
+                            : 'owner-route-receipt-invalid';
+                        this.deadLetterOwnerRouteBeforeClaim(record, ownerId, failureCode, now);
+                        continue;
+                    }
+                    if (!this.ownerRouteIsProvablyUnsent(record)) {
+                        this.deadLetterOwnerRouteBeforeClaim(record, ownerId, 'owner-route-send-proof-missing', now);
+                        continue;
+                    }
+                    if (!this.rebindOwnerRouteBeforeClaim(record, inspected)) {
+                        this.deadLetterOwnerRouteBeforeClaim(record, ownerId, 'owner-route-rebind-conflict', now);
+                        continue;
+                    }
+                    validatedOwnerRouteIds.push(record.id);
                 }
-                validatedOwnerRouteIds.push(record.id);
+                this.database.prepare(`
+          UPDATE outbox_messages SET status = 'dead', failure_code = CASE
+              WHEN status = 'unknown_after_send' THEN 'binding-revoked-unknown'
+              ELSE 'binding-revoked'
+            END,
+            next_attempt_at = NULL, updated_at = ?
+          WHERE rowid IN (
+            SELECT candidate.rowid FROM outbox_messages AS candidate
+            WHERE candidate.status IN ('pending', 'retry_wait', 'unknown_after_send')
+              AND json_type(candidate.intent_json, '$.metadata."dsh.route.authority"') IS NULL
+              AND NOT EXISTS (
+                SELECT 1 FROM dead_letter_resolutions AS resolution
+                WHERE resolution.kind = 'outbox' AND resolution.message_id = candidate.id
+                  AND resolution.attempt_count = candidate.attempt_count AND resolution.resolution = 'cancel'
+              )
+              AND NOT EXISTS (
+                SELECT 1 FROM conversation_bindings AS binding
+                WHERE binding.id = candidate.binding_id AND binding.status = 'active'
+              )
+            ORDER BY candidate.rowid LIMIT ?
+          )
+        `).run(now, maintenanceLimit);
             }
-            this.database.prepare(`
-        UPDATE outbox_messages SET status = 'dead', failure_code = CASE
-            WHEN status = 'unknown_after_send' THEN 'binding-revoked-unknown'
-            ELSE 'binding-revoked'
-          END,
-          next_attempt_at = NULL, updated_at = ?
-        WHERE rowid IN (
-          SELECT candidate.rowid FROM outbox_messages AS candidate
-          WHERE candidate.status IN ('pending', 'retry_wait', 'unknown_after_send')
-            AND json_type(candidate.intent_json, '$.metadata."dsh.route.authority"') IS NULL
-            AND NOT EXISTS (
-              SELECT 1 FROM dead_letter_resolutions AS resolution
-              WHERE resolution.kind = 'outbox' AND resolution.message_id = candidate.id
-                AND resolution.attempt_count = candidate.attempt_count AND resolution.resolution = 'cancel'
-            )
-            AND NOT EXISTS (
-              SELECT 1 FROM conversation_bindings AS binding
-              WHERE binding.id = candidate.binding_id AND binding.status = 'active'
-            )
-          ORDER BY candidate.rowid LIMIT ?
-        )
-      `).run(now, maintenanceLimit);
             const ownerRouteClaimClause = validatedOwnerRouteIds.length === 0
                 ? `AND (
             json_type(candidate.intent_json, '$.metadata."dsh.route.authority"') IS NULL
@@ -4498,6 +4838,13 @@ export class DeliveryStore {
         SELECT candidate.id, candidate.status FROM outbox_messages AS candidate
         WHERE candidate.status IN ('pending', 'retry_wait', 'unknown_after_send')
           AND candidate.claimed_by IS NULL
+          ${restartFenceActive ? `AND candidate.status IN ('pending', 'retry_wait')
+          AND candidate.idempotency_key GLOB 'inbound:*:maintenance'
+          AND json_extract(candidate.intent_json, '$.format') = 'plain'
+          AND json_type(candidate.intent_json, '$.metadata') IS NULL
+          AND json_type(candidate.intent_json, '$.approval') IS NULL
+          AND json_type(candidate.intent_json, '$.modelPicker') IS NULL
+          AND json_type(candidate.intent_json, '$.permissionPicker') IS NULL` : ''}
           AND NOT EXISTS (
             SELECT 1 FROM dead_letter_resolutions AS resolution
             WHERE resolution.kind = 'outbox' AND resolution.message_id = candidate.id
@@ -4532,6 +4879,7 @@ export class DeliveryStore {
             WHERE earlier.lane_hash = candidate.lane_hash
               AND earlier.rowid < candidate.rowid
               AND earlier.status NOT IN ('accepted', 'delivered', 'read', 'dead')
+              ${restartFenceActive ? "AND earlier.idempotency_key GLOB 'inbound:*:maintenance'" : ''}
               AND NOT EXISTS (
                 SELECT 1 FROM dead_letter_resolutions AS resolution
                 WHERE resolution.kind = 'outbox' AND resolution.message_id = earlier.id