@songsid/agend 2.3.2 → 2.3.3-beta.1

package/dist/delivery-outbox.d.ts

@@ -291,6 +291,12 @@ export declare class DeliveryOutbox extends EventEmitter {
     };
     hasOtherPendingWork(target: string, deliveryId: string): boolean;
     withdrawWorkingRecovery(deliveryId: string, reason: string): void;
+    /**
+     * #2801: AgEnD's own notices with a key starting `prefix` that are still waiting, never begun (as #2797: an aborted
+     * attempt wrote nothing), and that `stale(sourceKey, createdAt)` says are overtaken, are not delivered — `cancelled`
+     * with `reason`, still readable (delivery_status, Fleet traffic). Returns the ids dropped.
+     */
+    withdrawWaitingNotices(prefix: string, stale: (sourceKey: string, createdAt: string) => boolean, reason: string): string[];
     private noteWorkingReferences;
     constructor(dbPath: string, managerBootId?: string);
     private initialize;
@@ -306,34 +312,20 @@ export declare class DeliveryOutbox extends EventEmitter {
     /** The owner's message back to the requester on the same correlation_id answers it — at admission. */
     private answerReplyObligation;
     /**
-     * #926 safety net 1: remind an owner that has not answered. `turn-ended`
-     * reminds once per ask, after the grace (a reply seconds after the ask is
-     * normal); `restart` batches once per daemon boot, because the interrupted
-     * turn does not resume on its own. Marked in the same transaction as the notice.
+     * #926 safety net 1: remind an owner that has not answered, once per ask, after the grace (a reply seconds after the
+     * ask is normal). Marked in the same transaction as the notice. #2802: the only reply reminder — the per-boot restart
+     * batch is gone (an owner idle after a restart gets this one, per ask, unless it was already reminded), and so are the
+     * requester's overdue and expiry notices.
      */
     remindReplyObligations(ownerInstance: string, opts: {
         now?: Date;
         graceMs: number;
-        reason: "turn-ended" | "restart";
-        since?: Date;
-        restartId?: string;
     }): number;
-    private recordReplyRestart;
-    /** Expiry is terminal for this ask; a later delivered re-ask can reopen the same tuple. */
+    /** Expiry is terminal for this ask; a later delivered re-ask can reopen the same tuple. #2802: logged, no notice. */
     expireReplyObligations(opts?: {
         now?: Date;
         ttlMs?: number;
     }): ReplyObligation[];
-    /**
-     * #926 safety net 2 (poll-on-timeout, in code): tell the requester once when
-     * the owner is not working and nothing has come back for `overdueMs` since
-     * the last ask or reminder. A still-working owner is never reported.
-     */
-    notifyOverdueReplyObligations(opts: {
-        now?: Date;
-        overdueMs: number;
-        ownerIdle: (owner: string) => boolean;
-    }): number;
     /** A system notice as a durable row, like #929's outcome notices; the key makes it idempotent. */
     private insertReplyObligationNotice;
     /**
@@ -411,11 +403,27 @@ export declare class DeliveryOutbox extends EventEmitter {
      * proof), or does not exist. A write error throws; nothing is remembered as acknowledged elsewhere.
      */
     acknowledge(deliveryId: string, by: string, atIso?: string): boolean;
+    /**
+     * #2785 (c): the texts `source` sent `target` (fleet_inbound / steer) admitted at or after `sinceIso`, newest first,
+     * looked for among the target's newest `scan` rows only. The rows are found by the target index alone and read one by
+     * one: a filter on source or time over the table would read every row's payload (both columns follow it).
+     */
+    recentTextsFrom(target: string, source: string, sinceIso: string, scan?: number): string[];
     countForTarget(target: string, states: readonly OutboxState[]): number;
     nextRetryAt(): string | null;
     /** Claim the earliest eligible target row; one caller owns each target lane. */
     claimNext(managerBootId: string, targetBootIdFor: (target: string) => string | null, blockedTargets: ReadonlySet<string>, eligible?: (delivery: OutboxDelivery) => boolean): ClaimedOutboxDelivery | undefined;
     private claimNextSync;
+    /**
+     * #2785 (b): a message still waiting while a newer one from the same sender to the same target on the same thread
+     * (correlation_id) waits behind it is not delivered — the newer one replaces it (a review round for an older PR head, a
+     * CI result since overtaken). Only agents' messages (fleet_inbound, steer) that never began: a row with any attempt
+     * other than an aborted one keeps its place. The dropped row is `cancelled`, its reason naming the newer delivery, and
+     * stays readable (delivery_status, Fleet traffic). A reply obligation opens only on delivery, from the delivered row's own
+     * payload: a row that requires a reply is replaced only by one that requires one too, else it keeps its place (#2797
+     * review — an update without requires_reply must not swallow the request it follows).
+     */
+    private supersedeThreadRows;
     /** Idempotent begin permit, committed immediately before the pane side effect. */
     begin(deliveryId: string, targetBootId: string, attemptNo: number, evidence?: DeliveryAttemptEvidence): "begun" | "duplicate" | "stale";
     /** Write-ahead fence: commit before tmux is allowed to receive Enter. */
@@ -453,8 +461,6 @@ export declare class DeliveryOutbox extends EventEmitter {
         queued: number;
         reconciliationPending: number;
     };
-    /** Atomically create a post-restart notice for an accepted operation whose response was not recorded. */
-    admitPostRestartOutcomeNotice(parent: OutboxDelivery, currentSourceBootId: string): OutboxDelivery | undefined;
     recoverTargetGeneration(targetInstance: string, currentTargetBootId: string): {
         queued: number;
         reconciliationPending: number;
@@ -464,7 +470,6 @@ export declare class DeliveryOutbox extends EventEmitter {
     getReconciliationCandidates(targetInstance: string): DeliveryReconciliationCandidate[];
     /** Atomically settle one old attempt using only its boot/attempt fence. */
     reconcileAttempt(deliveryId: string, targetBootId: string, attemptNo: number, outcome: "delivered" | "retry_wait" | "uncertain", evidence: string): boolean;
-    getUnansweredAccepted(sourceInstance: string, currentBootId: string): OutboxDelivery[];
     close(): void;
     /** False once the database connection is closed: callers on timers check it before reading. */
     get isOpen(): boolean;

package/dist/delivery-outbox.js

@@ -13,18 +13,6 @@ export const DURABLE_DELIVERY_MAX_ATTEMPTS = 8;
 export const DURABLE_DELIVERY_MAX_AGE_MS = 24 * 60 * 60_000;
 export const DURABLE_DELIVERY_ABORT_BACKOFF_MS = 5_000;
 export const DEFAULT_REPLY_OBLIGATION_TTL_MS = 24 * 60 * 60_000;
-const RESTART_REPLY_DISPLAY_LIMIT = 10;
-/** Keep each preview on one physical line and bound even an arbitrary correlation ID. */
-function replyPreview(value) {
-    const escaped = value.replace(/[\u0000-\u001f\u007f]/g, c => JSON.stringify(c).slice(1, -1));
-    const bytes = Buffer.from(escaped);
-    if (bytes.length <= 256)
-        return escaped;
-    let end = 253;
-    while ((bytes[end] & 0xc0) === 0x80)
-        end--;
-    return bytes.subarray(0, end).toString("utf8") + "…";
-}
 /** The one mapping from validated tool/CLI arguments to a selector. */
 export function deliveryStatusSelector(args) {
     const page = { ...(args.limit !== undefined ? { limit: args.limit } : {}), ...(args.cursor ? { cursor: args.cursor } : {}) };
@@ -66,6 +54,15 @@ function payloadRequiresReply(payload) {
     const meta = payload && typeof payload === "object" ? payload.meta : undefined;
     return !!meta && typeof meta === "object" && meta.requires_reply === "true";
 }
+/** Whether a row's payload asks for a reply (an unreadable payload: no). */
+function rowRequiresReply(row) {
+    try {
+        return payloadRequiresReply(JSON.parse(row.payload_json));
+    }
+    catch {
+        return false;
+    }
+}
 function payloadMessageId(payload) {
     const meta = payload && typeof payload === "object" ? payload.meta : undefined;
     const id = meta && typeof meta === "object" ? meta.message_id : undefined;
@@ -354,6 +351,27 @@ export class DeliveryOutbox extends EventEmitter {
         if (changed)
             this.emit("state", { deliveryId, state: "cancelled" });
     }
+    /**
+     * #2801: AgEnD's own notices with a key starting `prefix` that are still waiting, never begun (as #2797: an aborted
+     * attempt wrote nothing), and that `stale(sourceKey, createdAt)` says are overtaken, are not delivered — `cancelled`
+     * with `reason`, still readable (delivery_status, Fleet traffic). Returns the ids dropped.
+     */
+    withdrawWaitingNotices(prefix, stale, reason) {
+        const rows = this.db.prepare(`SELECT delivery_id, source_key, created_at FROM deliveries
+      WHERE kind=? AND state IN ('queued','retry_wait') AND substr(source_key,1,?)=? ORDER BY created_seq`)
+            .all(SYSTEM_NOTICE_KIND, prefix.length, prefix);
+        const picked = rows.filter((r) => stale(r.source_key, r.created_at));
+        if (!picked.length)
+            return [];
+        const begun = this.db.prepare("SELECT 1 FROM delivery_attempts WHERE delivery_id=? AND state<>'aborted' LIMIT 1");
+        const now = new Date().toISOString();
+        const cancel = this.db.prepare(`UPDATE deliveries SET state='cancelled',finished_at=?,updated_at=?,last_error=?,next_attempt_at=NULL
+      WHERE delivery_id=? AND state IN ('queued','retry_wait')`);
+        const done = this.db.transaction(() => picked.filter((r) => !begun.get(r.delivery_id) && cancel.run(now, now, reason, r.delivery_id).changes === 1).map((r) => r.delivery_id))();
+        for (const deliveryId of done)
+            this.emit("state", { deliveryId, state: "cancelled" });
+        return done;
+    }
     noteWorkingReferences(instances) {
         // The transaction has committed. Telemetry must not change its result.
         try {
@@ -470,8 +488,7 @@ export class DeliveryOutbox extends EventEmitter {
         PRIMARY KEY (correlation_id, requester_instance, owner_instance)
       );
       CREATE INDEX IF NOT EXISTS idx_reply_obligation_owner_state ON reply_obligations(owner_instance, state);
-      -- A notice can be pruned while its boot is still alive. Keep the claim
-      -- independently: no notice FK/cascade and no request or message content.
+      -- #2802: no longer written (the per-boot restart reminder is gone); kept so existing databases keep their schema.
       CREATE TABLE IF NOT EXISTS reply_restart_markers (
         owner_instance TEXT NOT NULL,
         restart_id TEXT NOT NULL,
@@ -635,47 +652,16 @@ export class DeliveryOutbox extends EventEmitter {
     `).run(now, answer.delivery_id, answer.correlation_id, answer.source_instance, answer.target_instance);
     }
     /**
-     * #926 safety net 1: remind an owner that has not answered. `turn-ended`
-     * reminds once per ask, after the grace (a reply seconds after the ask is
-     * normal); `restart` batches once per daemon boot, because the interrupted
-     * turn does not resume on its own. Marked in the same transaction as the notice.
+     * #926 safety net 1: remind an owner that has not answered, once per ask, after the grace (a reply seconds after the
+     * ask is normal). Marked in the same transaction as the notice. #2802: the only reply reminder — the per-boot restart
+     * batch is gone (an owner idle after a restart gets this one, per ask, unless it was already reminded), and so are the
+     * requester's overdue and expiry notices.
      */
     remindReplyObligations(ownerInstance, opts) {
         const now = opts.now ?? new Date();
         const nowIso = now.toISOString();
         const graceCutoff = new Date(now.getTime() - opts.graceMs).toISOString();
-        const sinceIso = (opts.since ?? now).toISOString();
         const inserted = this.db.transaction(() => {
-            if (opts.reason === "restart") {
-                const restartId = opts.restartId ?? sinceIso;
-                const key = `reply-pending:restart:${JSON.stringify([ownerInstance, restartId])}`;
-                if (this.db.prepare("SELECT 1 FROM reply_restart_markers WHERE owner_instance=? AND restart_id=?")
-                    .get(ownerInstance, restartId))
-                    return 0;
-                // Adopt an existing notice from the earlier implementation/rollback
-                // without stamping a new ask or producing another notice.
-                const prior = this.db.prepare("SELECT created_at FROM deliveries WHERE source_key=?").get(key);
-                if (prior) {
-                    this.recordReplyRestart(ownerInstance, restartId, prior.created_at);
-                    return 0;
-                }
-                const total = this.db.prepare("SELECT count(*) n FROM reply_obligations WHERE owner_instance=? AND state='open'")
-                    .get(ownerInstance).n;
-                if (!total)
-                    return 0;
-                const preview = this.db.prepare(`SELECT requester_instance,correlation_id,last_asked_at FROM reply_obligations
-          WHERE owner_instance=? AND state='open' ORDER BY last_asked_at,correlation_id,requester_instance LIMIT ?`)
-                    .all(ownerInstance, RESTART_REPLY_DISPLAY_LIMIT);
-                const lines = preview.map(row => `${replyPreview(row.requester_instance)}; correlation_id=${replyPreview(row.correlation_id)}; asked=${replyPreview(row.last_asked_at)}`);
-                if (total > preview.length)
-                    lines.push(t("delivery.reply_restart_more", total - preview.length));
-                const content = t("delivery.reply_restart") + "\n" + lines.join("\n");
-                if (!this.insertReplyObligationNotice(ownerInstance, null, key, content, nowIso))
-                    return 0;
-                this.recordReplyRestart(ownerInstance, restartId, nowIso);
-                this.db.prepare("UPDATE reply_obligations SET nudged_at=? WHERE owner_instance=? AND state='open'").run(nowIso, ownerInstance);
-                return 1;
-            }
             const due = this.db.prepare("SELECT * FROM reply_obligations WHERE owner_instance=? AND state='open' AND nudged_at IS NULL AND last_asked_at <= ?")
                 .all(ownerInstance, graceCutoff);
             let count = 0;
@@ -694,11 +680,7 @@ export class DeliveryOutbox extends EventEmitter {
             this.emit("admitted");
         return inserted;
     }
-    recordReplyRestart(owner, restartId, now) {
-        this.db.prepare("INSERT INTO reply_restart_markers(owner_instance,restart_id,reminded_at) VALUES (?,?,?)")
-            .run(owner, restartId, now);
-    }
-    /** Expiry is terminal for this ask; a later delivered re-ask can reopen the same tuple. */
+    /** Expiry is terminal for this ask; a later delivered re-ask can reopen the same tuple. #2802: logged, no notice. */
     expireReplyObligations(opts = {}) {
         const now = opts.now ?? new Date();
         const ttl = opts.ttlMs !== undefined && Number.isFinite(opts.ttlMs) && opts.ttlMs > 0 ? opts.ttlMs : DEFAULT_REPLY_OBLIGATION_TTL_MS;
@@ -708,58 +690,19 @@ export class DeliveryOutbox extends EventEmitter {
             const due = this.db.prepare("SELECT * FROM reply_obligations WHERE state='open' AND last_asked_at<=? ORDER BY last_asked_at")
                 .all(cutoff);
             for (const row of due) {
-                if (!row.overdue_notified_at) {
-                    const key = `reply-overdue:${row.correlation_id}:${row.requester_instance}:${row.owner_instance}:${row.last_asked_at}`;
-                    this.insertReplyObligationNotice(row.requester_instance, row.correlation_id, key, t("delivery.reply_expired", row.owner_instance, row.correlation_id, row.last_asked_at), nowIso);
-                }
-                this.db.prepare(`UPDATE reply_obligations SET state='expired',expired_at=?,overdue_notified_at=COALESCE(overdue_notified_at,?)
+                this.db.prepare(`UPDATE reply_obligations SET state='expired',expired_at=?
           WHERE correlation_id=? AND requester_instance=? AND owner_instance=? AND state='open'`)
-                    .run(nowIso, nowIso, row.correlation_id, row.requester_instance, row.owner_instance);
+                    .run(nowIso, row.correlation_id, row.requester_instance, row.owner_instance);
                 row.state = "expired";
                 row.expired_at = nowIso;
-                row.overdue_notified_at ??= nowIso;
             }
             return due.map(mapObligation);
         })();
         if (expired.length) {
-            this.emit("admitted");
             this.noteWorkingReferences(expired.flatMap(row => [row.ownerInstance, row.requesterInstance]));
         }
         return expired;
     }
-    /**
-     * #926 safety net 2 (poll-on-timeout, in code): tell the requester once when
-     * the owner is not working and nothing has come back for `overdueMs` since
-     * the last ask or reminder. A still-working owner is never reported.
-     */
-    notifyOverdueReplyObligations(opts) {
-        if (!(opts.overdueMs > 0))
-            return 0;
-        const now = opts.now ?? new Date();
-        const nowIso = now.toISOString();
-        const inserted = this.db.transaction(() => {
-            const open = this.db.prepare(`
-        SELECT * FROM reply_obligations WHERE state='open' AND overdue_notified_at IS NULL ORDER BY opened_at
-      `).all();
-            let count = 0;
-            for (const row of open) {
-                const quietSince = Math.max(Date.parse(row.last_asked_at), row.nudged_at ? Date.parse(row.nudged_at) : 0);
-                if (now.getTime() - quietSince < opts.overdueMs || !opts.ownerIdle(row.owner_instance))
-                    continue;
-                const content = t("delivery.reply_overdue", row.owner_instance, row.correlation_id, row.last_asked_at, row.nudged_at ? t("delivery.reply_reminded", row.nudged_at) : "");
-                const key = `reply-overdue:${row.correlation_id}:${row.requester_instance}:${row.owner_instance}:${row.last_asked_at}`;
-                if (this.insertReplyObligationNotice(row.requester_instance, row.correlation_id, key, content, nowIso))
-                    count++;
-                this.db.prepare(`
-          UPDATE reply_obligations SET overdue_notified_at=? WHERE correlation_id=? AND requester_instance=? AND owner_instance=? AND state='open'
-        `).run(nowIso, row.correlation_id, row.requester_instance, row.owner_instance);
-            }
-            return count;
-        })();
-        if (inserted > 0)
-            this.emit("admitted");
-        return inserted;
-    }
     /** A system notice as a durable row, like #929's outcome notices; the key makes it idempotent. */
     insertReplyObligationNotice(target, correlationId, sourceKey, content, now) {
         const noticeId = randomUUID();
@@ -1089,6 +1032,31 @@ export class DeliveryOutbox extends EventEmitter {
     `).run(atIso, by, deliveryId);
         return result.changes === 1;
     }
+    /**
+     * #2785 (c): the texts `source` sent `target` (fleet_inbound / steer) admitted at or after `sinceIso`, newest first,
+     * looked for among the target's newest `scan` rows only. The rows are found by the target index alone and read one by
+     * one: a filter on source or time over the table would read every row's payload (both columns follow it).
+     */
+    recentTextsFrom(target, source, sinceIso, scan = 30) {
+        const rows = this.db.prepare("SELECT rowid AS r FROM deliveries WHERE target_instance=? ORDER BY created_seq DESC LIMIT ?")
+            .all(target, scan);
+        const read = this.db.prepare("SELECT source_instance, kind, created_at, payload_json FROM deliveries WHERE rowid=?");
+        const texts = [];
+        for (const { r } of rows) {
+            const row = read.get(r);
+            if (!row || row.created_at < sinceIso)
+                continue;
+            if (row.source_instance !== source || (row.kind !== "fleet_inbound" && row.kind !== "steer"))
+                continue;
+            try {
+                const content = JSON.parse(row.payload_json).content;
+                if (typeof content === "string")
+                    texts.push(content);
+            }
+            catch { /* an unreadable payload says nothing */ }
+        }
+        return texts;
+    }
     countForTarget(target, states) {
         if (states.length === 0)
             return 0;
@@ -1111,10 +1079,12 @@ export class DeliveryOutbox extends EventEmitter {
     }
     claimNextSync(managerBootId, targetBootIdFor, blockedTargets, eligible) {
         const now = new Date().toISOString();
-        const rows = this.db.prepare(`
+        const pending = this.db.prepare(`
       SELECT * FROM deliveries WHERE state IN ('queued','retry_wait')
       ORDER BY created_seq
     `).all();
+        const superseded = this.supersedeThreadRows(pending, now);
+        const rows = superseded.size ? pending.filter(row => !superseded.has(row.delivery_id)) : pending;
         // The oldest pending row owns its target lane even while it is in retry
         // backoff or the target is temporarily unavailable. Later rows must not
         // pass it merely because they happen to be eligible first.
@@ -1153,6 +1123,48 @@ export class DeliveryOutbox extends EventEmitter {
         }
         return undefined;
     }
+    /**
+     * #2785 (b): a message still waiting while a newer one from the same sender to the same target on the same thread
+     * (correlation_id) waits behind it is not delivered — the newer one replaces it (a review round for an older PR head, a
+     * CI result since overtaken). Only agents' messages (fleet_inbound, steer) that never began: a row with any attempt
+     * other than an aborted one keeps its place. The dropped row is `cancelled`, its reason naming the newer delivery, and
+     * stays readable (delivery_status, Fleet traffic). A reply obligation opens only on delivery, from the delivered row's own
+     * payload: a row that requires a reply is replaced only by one that requires one too, else it keeps its place (#2797
+     * review — an update without requires_reply must not swallow the request it follows).
+     */
+    supersedeThreadRows(pending, now) {
+        const newest = new Map();
+        const keyOf = (row) => (row.kind === "fleet_inbound" || row.kind === "steer") && row.correlation_id
+            ? `${row.source_instance}\u0000${row.target_instance}\u0000${row.correlation_id}` : null;
+        for (const row of pending) {
+            const key = keyOf(row);
+            if (key)
+                newest.set(key, row);
+        } // ascending: the last wins
+        const candidates = pending.filter(row => { const key = keyOf(row); return key !== null && newest.get(key).delivery_id !== row.delivery_id; });
+        if (!candidates.length)
+            return new Set();
+        const begun = this.db.prepare("SELECT 1 FROM delivery_attempts WHERE delivery_id=? AND state<>'aborted' LIMIT 1");
+        const cancel = this.db.prepare(`UPDATE deliveries SET state='cancelled',finished_at=?,updated_at=?,last_error=?,next_attempt_at=NULL
+      WHERE delivery_id=? AND state IN ('queued','retry_wait')`);
+        const done = this.db.transaction(() => {
+            const out = [];
+            for (const row of candidates) {
+                if (begun.get(row.delivery_id))
+                    continue;
+                const newer = newest.get(keyOf(row));
+                if (rowRequiresReply(row) && !rowRequiresReply(newer))
+                    continue;
+                const by = newer.delivery_id;
+                if (cancel.run(now, now, `superseded by ${by}`, row.delivery_id).changes === 1)
+                    out.push(row.delivery_id);
+            }
+            return out;
+        })();
+        for (const deliveryId of done)
+            this.emit("state", { deliveryId, state: "cancelled" });
+        return new Set(done);
+    }
     /** Idempotent begin permit, committed immediately before the pane side effect. */
     begin(deliveryId, targetBootId, attemptNo, evidence) {
         const now = new Date().toISOString();
@@ -1508,60 +1520,6 @@ export class DeliveryOutbox extends EventEmitter {
         });
         return transaction();
     }
-    /** Atomically create a post-restart notice for an accepted operation whose response was not recorded. */
-    admitPostRestartOutcomeNotice(parent, currentSourceBootId) {
-        const sourceKey = `post-restart:${parent.sourceInstance}:${parent.sourceDaemonBootId}:${parent.operationId}:${parent.targetInstance}`;
-        const operationId = `notice:${parent.sourceDaemonBootId}:${parent.operationId}:${parent.targetInstance}`;
-        const now = new Date().toISOString();
-        const deliveryId = randomUUID();
-        const noticeText = t("delivery.post_restart", parent.targetInstance, statusSummary(parent.state), parent.operationId, parent.state);
-        const payload = {
-            type: "fleet_inbound",
-            content: noticeText,
-            meta: {
-                user: "AgEnD recovery",
-                user_id: "agend-system",
-                message_id: `delivery-notice-${parent.operationId}-${parent.targetInstance}`,
-                chat_id: "",
-                thread_id: "",
-                source: "delivery-outbox",
-            },
-        };
-        const transaction = this.db.transaction(() => {
-            const prior = this.db.prepare(`
-        SELECT d.* FROM outcome_notices n JOIN deliveries d ON d.delivery_id=n.notice_delivery_id
-        WHERE n.source_instance=? AND n.source_daemon_boot_id=? AND n.operation_id=? AND n.target_instance=?
-      `).get(parent.sourceInstance, parent.sourceDaemonBootId, parent.operationId, parent.targetInstance);
-            if (prior)
-                return mapRow(prior);
-            const terminalNotice = this.db.prepare(`
-        SELECT d.* FROM failure_notices n JOIN deliveries d ON d.delivery_id=n.notice_delivery_id
-        WHERE n.parent_delivery_id=?
-      `).get(parent.deliveryId);
-            if (terminalNotice)
-                return mapRow(terminalNotice);
-            const reserved = this.db.prepare(`
-        INSERT OR IGNORE INTO outcome_notices
-        (source_instance,source_daemon_boot_id,operation_id,target_instance,notice_delivery_id,created_at)
-        VALUES (?,?,?,?,?,?)
-      `).run(parent.sourceInstance, parent.sourceDaemonBootId, parent.operationId, parent.targetInstance, deliveryId, now);
-            if (reserved.changes !== 1)
-                return undefined;
-            this.db.prepare(`
-        INSERT INTO deliveries (
-          delivery_id,operation_id,source_key,source_instance,source_daemon_boot_id,
-          target_instance,target_session,kind,correlation_id,payload_json,state,
-          attempt_no,created_seq,manager_boot_id,created_at,updated_at,accepted_at
-        ) VALUES (?,?,?,?,?,?,NULL,'post_restart_outcome_notice',NULL,?,'queued',0,
-          (SELECT COALESCE(MAX(created_seq),0)+1 FROM deliveries),NULL,?,?,?)
-      `).run(deliveryId, operationId, sourceKey, "agend-system", currentSourceBootId, parent.sourceInstance, JSON.stringify(payload), now, now, now);
-            return mapRow(this.db.prepare("SELECT * FROM deliveries WHERE delivery_id=?").get(deliveryId));
-        });
-        const notice = transaction();
-        if (notice)
-            this.emit("admitted", notice);
-        return notice;
-    }
     recoverTargetGeneration(targetInstance, currentTargetBootId) {
         const now = new Date().toISOString();
         const transaction = this.db.transaction(() => {
@@ -1655,17 +1613,6 @@ export class DeliveryOutbox extends EventEmitter {
             this.emit("state", { deliveryId, state: outcome });
         return changed;
     }
-    getUnansweredAccepted(sourceInstance, currentBootId) {
-        const rows = this.db.prepare(`
-      SELECT * FROM deliveries
-      WHERE source_instance=? AND source_daemon_boot_id<>? AND response_delivered_at IS NULL
-        -- Scheduler admission has no waiting source-agent tool response; its
-        -- stable run key and durable row are the recovery/lookup contract.
-        AND kind NOT IN ('raw_paste')
-      ORDER BY created_seq
-    `).all(sourceInstance, currentBootId);
-        return rows.map(mapRow);
-    }
     close() {
         this.db.close();
     }
@@ -1796,6 +1743,7 @@ export class DeliveryOutbox extends EventEmitter {
     }
     /** Must be called inside the same SQLite transaction as the terminal transition. */
     insertFailureNotice(parent, outcome, reason, now) {
+        // post_restart_outcome_notice: no longer written (#2802), but a row from before may still be queued.
         if (parent.kind === "delivery_outcome_notice" || parent.kind === "post_restart_outcome_notice"
             || parent.kind === REPLY_OBLIGATION_NOTICE_KIND || parent.kind === SYSTEM_NOTICE_KIND || parent.kind === WORKING_RECOVERY_KIND)
             return;