@songsid/agend 2.1.7-beta.4 → 2.1.7-beta.6

package/dist/delivery-outbox.js

@@ -1,11 +1,44 @@
 import Database from "better-sqlite3";
-import { randomUUID } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { EventEmitter } from "node:events";
 import { chmodSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 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;
+/** 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 } : {}) };
+    if (args.delivery_id)
+        return { deliveryId: args.delivery_id };
+    if (args.operation_id)
+        return { operationId: args.operation_id, ...page };
+    if (args.message_id)
+        return { messageId: args.message_id, ...page };
+    return { correlationId: args.correlation_id, ...page };
+}
+/** sha256 of a delivered text, as hex. The same function hashes admission and paste. */
+export function deliveryContentDigest(text) {
+    return createHash("sha256").update(text, "utf8").digest("hex");
+}
+/** The text a durable row delivers, for kinds whose payload carries one. */
+function payloadContent(payload) {
+    const content = payload && typeof payload === "object" ? payload.content : undefined;
+    return typeof content === "string" ? content : null;
+}
+/** #926 reminders and overdue notices; never themselves the subject of a failure notice. */
+export const REPLY_OBLIGATION_NOTICE_KIND = "reply_obligation_notice";
+/** Kinds that carry a peer request or its answer. Broadcasts are one-to-many and deferred (#926 §6). */
+const REPLY_OBLIGATION_KINDS = ["fleet_inbound", "steer"];
+function payloadRequiresReply(payload) {
+    const meta = payload && typeof payload === "object" ? payload.meta : undefined;
+    return !!meta && typeof meta === "object" && meta.requires_reply === "true";
+}
+function payloadMessageId(payload) {
+    const meta = payload && typeof payload === "object" ? payload.meta : undefined;
+    const id = meta && typeof meta === "object" ? meta.message_id : undefined;
+    return typeof id === "string" && id.length > 0 ? id : null;
+}
 function mapRow(row) {
     return {
         deliveryId: row.delivery_id,
@@ -19,13 +52,168 @@ function mapRow(row) {
         kind: row.kind,
         correlationId: row.correlation_id,
         payload: JSON.parse(row.payload_json),
-        state: row.state,
+        state: row.state === "submission_started" && row.reconciliation_pending === 1
+            ? "reconciliation_pending"
+            : row.state,
         attemptNo: row.attempt_no,
         createdSeq: row.created_seq,
         managerBootId: row.manager_boot_id,
         responseDeliveredAt: row.response_delivered_at,
         nextAttemptAt: row.next_attempt_at,
         lastError: row.last_error,
+        reconciliationPending: row.reconciliation_pending === 1,
+    };
+}
+function safeErrorSummary(error) {
+    if (!error)
+        return null;
+    const normalized = error.toLowerCase();
+    if (normalized.includes("ttl expired"))
+        return "Delivery expired before the target became available.";
+    if (normalized.includes("attempt limit"))
+        return "Delivery exhausted its bounded retry attempts.";
+    if (normalized.includes("reconcil") || normalized.includes("uncertain") || normalized.includes("restart")) {
+        return "Submission may have occurred; do not resend until the outcome is reconciled.";
+    }
+    return "A delivery error was recorded; details are omitted for safety.";
+}
+function statusSummary(state) {
+    switch (state) {
+        case "queued": return "Accepted and waiting for delivery.";
+        case "delivering": return "Waiting for the target to become ready; submission has not started.";
+        case "retry_wait": return "Waiting for a bounded retry; submission has not started for the next attempt.";
+        case "submission_started":
+        case "reconciliation_pending": return "Submission may have occurred; do not resend.";
+        case "delivered": return "Delivery was confirmed; this does not mean the agent finished processing it.";
+        case "failed": return "Delivery failed after bounded retries or expiry.";
+        case "uncertain": return "Delivery may have occurred; do not resend blindly.";
+        case "cancelled": return "Delivery was cancelled.";
+    }
+}
+function safeToRetry(state) {
+    return state === "queued" || state === "delivering" || state === "retry_wait" || state === "failed";
+}
+function hasTable(db, table) {
+    return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name=?").get(table);
+}
+/** The obligation a request row opened, if any; absent on databases from before #926. */
+function obligationFor(db, correlationId, requester, owner) {
+    if (!correlationId || !hasTable(db, "reply_obligations"))
+        return null;
+    const row = db.prepare(`
+    SELECT state, opened_at, last_asked_at, nudged_at, overdue_notified_at, answered_at FROM reply_obligations
+    WHERE correlation_id=? AND requester_instance=? AND owner_instance=?
+  `).get(correlationId, requester, owner);
+    return row ?? null;
+}
+function hasColumn(db, table, column) {
+    return db.prepare(`PRAGMA table_info(${table})`).all().some(c => c.name === column);
+}
+/** Derived from the stored payload, so it is the same for pre-#856 rows. */
+function rowContentEvidence(payloadJson, withContent) {
+    let payload = null;
+    try {
+        payload = JSON.parse(payloadJson);
+    }
+    catch { /* corrupt row: report no evidence */ }
+    const content = payloadContent(payload);
+    return {
+        message_id: payloadMessageId(payload),
+        content_sha256: content === null ? null : deliveryContentDigest(content),
+        ...(withContent ? { content } : {}),
+    };
+}
+function queryStatusPage(db, selector, callerInstance) {
+    const where = [];
+    const params = [];
+    // An operator may read a database written before the column existed.
+    const messageIdColumn = hasColumn(db, "deliveries", "message_id")
+        ? "d.message_id" : "json_extract(d.payload_json,'$.meta.message_id')";
+    if (selector.deliveryId) {
+        where.push("d.delivery_id = ?");
+        params.push(selector.deliveryId);
+    }
+    else if (selector.operationId) {
+        where.push("d.operation_id = ?");
+        params.push(selector.operationId);
+    }
+    else if (selector.messageId) {
+        where.push(`${messageIdColumn} = ?`);
+        params.push(selector.messageId);
+    }
+    else {
+        where.push("d.correlation_id = ?");
+        params.push(selector.correlationId);
+    }
+    if (callerInstance !== null) {
+        where.push("(d.source_instance = ? OR d.target_instance = ?)");
+        params.push(callerInstance, callerInstance);
+    }
+    if (selector.cursor) {
+        const cursorScope = ["c.delivery_id = ?"];
+        const cursorParams = [selector.cursor];
+        if (selector.operationId) {
+            cursorScope.push("c.operation_id = ?");
+            cursorParams.push(selector.operationId);
+        }
+        else if (selector.messageId) {
+            cursorScope.push(`${messageIdColumn.replace(/\bd\./g, "c.")} = ?`);
+            cursorParams.push(selector.messageId);
+        }
+        else {
+            cursorScope.push("c.correlation_id = ?");
+            cursorParams.push(selector.correlationId);
+        }
+        if (callerInstance !== null) {
+            cursorScope.push("(c.source_instance = ? OR c.target_instance = ?)");
+            cursorParams.push(callerInstance, callerInstance);
+        }
+        where.push(`d.created_seq > (SELECT c.created_seq FROM deliveries c WHERE ${cursorScope.join(" AND ")} LIMIT 1)`);
+        params.push(...cursorParams);
+    }
+    const limit = selector.deliveryId ? 1 : Math.max(1, Math.min(100, selector.limit ?? 20));
+    const rows = db.prepare(`
+    SELECT d.delivery_id,d.operation_id,d.correlation_id,d.source_instance,d.target_instance,
+      d.kind,
+      CASE WHEN d.state='submission_started' AND d.reconciliation_pending=1
+        THEN 'reconciliation_pending' ELSE d.state END AS state,
+      d.attempt_no,d.created_at,d.updated_at,d.last_error,d.payload_json
+    FROM deliveries d
+    WHERE ${where.join(" AND ")}
+    ORDER BY d.created_seq
+    LIMIT ?
+  `).all(...params, limit + 1);
+    const hasMore = rows.length > limit;
+    const visible = rows.slice(0, limit);
+    return {
+        items: visible.map(row => ({
+            delivery_id: row.delivery_id,
+            operation_id: row.operation_id,
+            correlation_id: row.correlation_id,
+            source_instance: row.source_instance,
+            target_instance: row.target_instance,
+            kind: row.kind,
+            state: row.state,
+            attempt_no: row.attempt_no,
+            created_at: row.created_at,
+            updated_at: row.updated_at,
+            status_summary: statusSummary(row.state),
+            error_summary: safeErrorSummary(row.last_error),
+            safe_to_retry: safeToRetry(row.state),
+            // Text only for the explicit verification query (#856), and only to the
+            // row's own source/target; every other query keeps #982's redaction.
+            ...rowContentEvidence(row.payload_json, callerInstance !== null && !!selector.messageId),
+            reply_obligation: obligationFor(db, row.correlation_id, row.source_instance, row.target_instance),
+        })),
+        next_cursor: hasMore ? visible.at(-1)?.delivery_id ?? null : null,
+    };
+}
+function mapObligation(row) {
+    return {
+        correlationId: row.correlation_id, requesterInstance: row.requester_instance, ownerInstance: row.owner_instance,
+        requestDeliveryId: row.request_delivery_id, openedAt: row.opened_at, lastAskedAt: row.last_asked_at, state: row.state,
+        nudgedAt: row.nudged_at, overdueNotifiedAt: row.overdue_notified_at, answeredAt: row.answered_at,
+        answeredDeliveryId: row.answered_delivery_id,
     };
 }
 /** Durable admission and fenced state transitions for the fleet delivery queue. */
@@ -63,6 +251,7 @@ export class DeliveryOutbox extends EventEmitter {
         created_seq INTEGER NOT NULL UNIQUE,
         manager_boot_id TEXT,
         response_delivered_at TEXT,
+        reconciliation_pending INTEGER NOT NULL DEFAULT 0,
         next_attempt_at TEXT,
         last_error TEXT,
         created_at TEXT NOT NULL,
@@ -77,6 +266,10 @@ export class DeliveryOutbox extends EventEmitter {
         ON deliveries(target_instance, state, created_seq);
       CREATE INDEX IF NOT EXISTS idx_delivery_operation_source
         ON deliveries(source_instance, operation_id);
+      CREATE INDEX IF NOT EXISTS idx_delivery_operation_seq
+        ON deliveries(operation_id, created_seq);
+      CREATE INDEX IF NOT EXISTS idx_delivery_correlation_seq
+        ON deliveries(correlation_id, created_seq);
 
       CREATE TABLE IF NOT EXISTS delivery_attempts (
         delivery_id TEXT NOT NULL REFERENCES deliveries(delivery_id),
@@ -87,6 +280,15 @@ export class DeliveryOutbox extends EventEmitter {
         abort_at TEXT,
         finished_at TEXT,
         evidence TEXT,
+        backend TEXT,
+        window_id TEXT,
+        transcript_path TEXT,
+        transcript_offset INTEGER,
+        transcript_session_id TEXT,
+        submission_mode TEXT,
+        backend_version TEXT,
+        queue_resume_policy TEXT,
+        enter_started_at TEXT,
         PRIMARY KEY (delivery_id, target_daemon_boot_id, attempt_no)
       );
 
@@ -99,13 +301,225 @@ export class DeliveryOutbox extends EventEmitter {
         created_at TEXT NOT NULL,
         PRIMARY KEY (source_instance, source_daemon_boot_id, operation_id, target_instance)
       );
+      CREATE TABLE IF NOT EXISTS reply_obligations (
+        correlation_id TEXT NOT NULL,
+        requester_instance TEXT NOT NULL,
+        owner_instance TEXT NOT NULL,
+        request_delivery_id TEXT NOT NULL,
+        opened_at TEXT NOT NULL,
+        last_asked_at TEXT NOT NULL,
+        state TEXT NOT NULL CHECK (state IN ('open','answered')),
+        nudged_at TEXT,
+        overdue_notified_at TEXT,
+        answered_at TEXT,
+        answered_delivery_id TEXT,
+        PRIMARY KEY (correlation_id, requester_instance, owner_instance)
+      );
+      CREATE INDEX IF NOT EXISTS idx_reply_obligation_owner_state ON reply_obligations(owner_instance, state);
       CREATE TABLE IF NOT EXISTS failure_notices (
         parent_delivery_id TEXT PRIMARY KEY,
         notice_delivery_id TEXT NOT NULL UNIQUE,
         created_at TEXT NOT NULL
       );
-      PRAGMA user_version = 1;
     `);
+        // Additive migration: existing Phase 1 databases keep their row identities,
+        // foreign keys, and WAL while gaining reconciliation evidence columns.
+        this.ensureColumn("deliveries", "reconciliation_pending", "INTEGER NOT NULL DEFAULT 0");
+        this.ensureColumn("delivery_attempts", "backend", "TEXT");
+        this.ensureColumn("delivery_attempts", "window_id", "TEXT");
+        this.ensureColumn("delivery_attempts", "transcript_path", "TEXT");
+        this.ensureColumn("delivery_attempts", "transcript_offset", "INTEGER");
+        this.ensureColumn("delivery_attempts", "transcript_session_id", "TEXT");
+        this.ensureColumn("delivery_attempts", "submission_mode", "TEXT");
+        this.ensureColumn("delivery_attempts", "backend_version", "TEXT");
+        this.ensureColumn("delivery_attempts", "queue_resume_policy", "TEXT");
+        this.ensureColumn("delivery_attempts", "enter_started_at", "TEXT");
+        // #856: a receiver can look a message up by the ID in its envelope, and
+        // admission vs pane-write digests tell transport rewrites apart from a
+        // receiver acting on a message nobody sent.
+        this.ensureColumn("deliveries", "message_id", "TEXT");
+        this.ensureColumn("deliveries", "content_sha256", "TEXT");
+        this.ensureColumn("delivery_attempts", "pasted_content_sha256", "TEXT");
+        this.ensureColumn("delivery_attempts", "pasted_bytes_sha256", "TEXT");
+        this.ensureColumn("delivery_attempts", "content_digest_mismatch", "INTEGER NOT NULL DEFAULT 0");
+        this.db.exec("CREATE INDEX IF NOT EXISTS idx_delivery_message_id ON deliveries(message_id)");
+        this.backfillMessageEvidence();
+        this.db.pragma("user_version = 4");
+    }
+    /**
+     * #926: a delivered `requires_reply` request opens (or, asked again,
+     * re-opens) the owner's obligation. Runs inside the delivered transition.
+     * An answer admitted before the request finished its submission proof —
+     * an owner can reply while the daemon is still confirming — counts.
+     */
+    openReplyObligation(request, now) {
+        if (!REPLY_OBLIGATION_KINDS.includes(request.kind) || !request.correlation_id)
+            return;
+        let payload = null;
+        try {
+            payload = JSON.parse(request.payload_json);
+        }
+        catch {
+            return;
+        }
+        if (!payloadRequiresReply(payload))
+            return;
+        const earlyAnswer = this.db.prepare(`
+      SELECT delivery_id FROM deliveries
+      WHERE correlation_id=? AND source_instance=? AND target_instance=? AND created_seq > ?
+        AND kind IN (${REPLY_OBLIGATION_KINDS.map(() => "?").join(",")})
+      ORDER BY created_seq LIMIT 1
+    `).get(request.correlation_id, request.target_instance, request.source_instance, request.created_seq, ...REPLY_OBLIGATION_KINDS);
+        this.db.prepare(`
+      INSERT INTO reply_obligations(correlation_id, requester_instance, owner_instance, request_delivery_id,
+        opened_at, last_asked_at, state, answered_at, answered_delivery_id)
+      VALUES (@cid, @requester, @owner, @request, @now, @now, @state, @answeredAt, @answeredId)
+      ON CONFLICT(correlation_id, requester_instance, owner_instance) DO UPDATE SET
+        request_delivery_id=excluded.request_delivery_id, last_asked_at=excluded.last_asked_at,
+        state=excluded.state, nudged_at=NULL, overdue_notified_at=NULL,
+        answered_at=excluded.answered_at, answered_delivery_id=excluded.answered_delivery_id
+    `).run({
+            cid: request.correlation_id, requester: request.source_instance, owner: request.target_instance,
+            request: request.delivery_id, now,
+            state: earlyAnswer ? "answered" : "open",
+            answeredAt: earlyAnswer ? now : null, answeredId: earlyAnswer?.delivery_id ?? null,
+        });
+    }
+    /** The owner's message back to the requester on the same correlation_id answers it — at admission. */
+    answerReplyObligation(answer, now) {
+        if (!REPLY_OBLIGATION_KINDS.includes(answer.kind) || !answer.correlation_id)
+            return;
+        this.db.prepare(`
+      UPDATE reply_obligations SET state='answered', answered_at=?, answered_delivery_id=?
+      WHERE correlation_id=? AND owner_instance=? AND requester_instance=? AND state='open'
+    `).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` reminds once per restart, because the interrupted turn
+     * does not resume on its own. Marked in the same transaction as the notice.
+     */
+    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(() => {
+            const due = this.db.prepare(opts.reason === "turn-ended"
+                ? "SELECT * FROM reply_obligations WHERE owner_instance=? AND state='open' AND nudged_at IS NULL AND last_asked_at <= ?"
+                : "SELECT * FROM reply_obligations WHERE owner_instance=? AND state='open' AND (nudged_at IS NULL OR nudged_at < ?)").all(ownerInstance, opts.reason === "turn-ended" ? graceCutoff : sinceIso);
+            let count = 0;
+            for (const row of due) {
+                const content = opts.reason === "turn-ended"
+                    ? `[system:reply-pending] Your turn ended without answering ${row.requester_instance} (correlation_id ${row.correlation_id}, asked ${row.last_asked_at}). Send your conclusion with report_result (correlation_id ${row.correlation_id}) now — text you write in the terminal does not reach them.`
+                    : `[system:reply-pending] A restart interrupted your work on correlation_id ${row.correlation_id} from ${row.requester_instance} (asked ${row.last_asked_at}). Resume it and answer with report_result (correlation_id ${row.correlation_id}); terminal text does not reach them.`;
+                const key = `reply-pending:${opts.reason}:${row.correlation_id}:${row.requester_instance}:${row.owner_instance}:${opts.reason === "turn-ended" ? row.last_asked_at : sinceIso}`;
+                if (this.insertReplyObligationNotice(row.owner_instance, row.correlation_id, key, content, nowIso))
+                    count++;
+                this.db.prepare(`
+          UPDATE reply_obligations SET nudged_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;
+    }
+    /**
+     * #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 = `[system:reply-overdue] ${row.owner_instance} has not answered correlation_id ${row.correlation_id} (asked ${row.last_asked_at}${row.nudged_at ? `, reminded ${row.nudged_at}` : ""}) and is not working on anything now. Check with describe_instance or delivery_status (correlation_id ${row.correlation_id}), or ask again.`;
+                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();
+        const payload = {
+            type: "fleet_inbound",
+            content,
+            meta: {
+                user: "AgEnD delivery outbox", user_id: "agend-system", message_id: `reply-obligation-${noticeId}`,
+                chat_id: "", thread_id: "", source: "delivery-outbox",
+            },
+        };
+        return this.db.prepare(`
+      INSERT OR IGNORE INTO deliveries (
+        delivery_id,operation_id,source_key,source_instance,source_daemon_boot_id,
+        target_instance,target_session,target_daemon_boot_id,kind,correlation_id,payload_json,message_id,content_sha256,state,
+        attempt_no,created_seq,manager_boot_id,created_at,updated_at,accepted_at
+      ) VALUES (?,?,?,'agend-system',?,?,NULL,NULL,?,?,?,?,?,'queued',0,
+        (SELECT COALESCE(MAX(created_seq),0)+1 FROM deliveries),NULL,?,?,?)
+    `).run(noticeId, `notice:${sourceKey}`, sourceKey, this.managerBootId, target, REPLY_OBLIGATION_NOTICE_KIND, correlationId, JSON.stringify(payload), payload.meta.message_id, deliveryContentDigest(content), now, now, now).changes === 1;
+    }
+    /** The owner's open obligations, oldest first (#926). */
+    openReplyObligations(ownerInstance) {
+        const rows = this.db.prepare(`
+      SELECT * FROM reply_obligations WHERE owner_instance=? AND state='open' ORDER BY opened_at, correlation_id
+    `).all(ownerInstance);
+        return rows.map(mapObligation);
+    }
+    getReplyObligation(correlationId, requesterInstance, ownerInstance) {
+        const row = this.db.prepare(`
+      SELECT * FROM reply_obligations WHERE correlation_id=? AND requester_instance=? AND owner_instance=?
+    `).get(correlationId, requesterInstance, ownerInstance);
+        return row ? mapObligation(row) : undefined;
+    }
+    /** Rows admitted before #856 get the same message_id / digest a new row would. */
+    backfillMessageEvidence() {
+        const rows = this.db.prepare(`
+      SELECT delivery_id, payload_json FROM deliveries WHERE message_id IS NULL AND content_sha256 IS NULL
+    `).all();
+        if (rows.length === 0)
+            return;
+        const update = this.db.prepare("UPDATE deliveries SET message_id=?, content_sha256=? WHERE delivery_id=?");
+        this.db.transaction(() => {
+            for (const row of rows) {
+                let payload = null;
+                try {
+                    payload = JSON.parse(row.payload_json);
+                }
+                catch {
+                    continue;
+                }
+                const content = payloadContent(payload);
+                update.run(payloadMessageId(payload), content === null ? null : deliveryContentDigest(content), row.delivery_id);
+            }
+        })();
+    }
+    ensureColumn(table, column, definition) {
+        const columns = this.db.prepare(`PRAGMA table_info(${table})`).all();
+        if (columns.some(item => item.name === column))
+            return;
+        this.db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
     }
     /** Commit admission before returning success. Duplicate source keys return their original row. */
     admit(input) {
@@ -114,11 +528,11 @@ export class DeliveryOutbox extends EventEmitter {
         const insert = this.db.prepare(`
       INSERT OR IGNORE INTO deliveries (
         delivery_id, operation_id, source_key, source_instance, source_daemon_boot_id,
-        target_instance, target_session, kind, correlation_id, payload_json, state,
+        target_instance, target_session, kind, correlation_id, payload_json, message_id, content_sha256, state,
         attempt_no, created_seq, manager_boot_id, created_at, updated_at, accepted_at
       ) VALUES (
         @delivery_id, @operation_id, @source_key, @source_instance, @source_daemon_boot_id,
-        @target_instance, @target_session, @kind, @correlation_id, @payload_json, 'queued',
+        @target_instance, @target_session, @kind, @correlation_id, @payload_json, @message_id, @content_sha256, 'queued',
         0, (SELECT COALESCE(MAX(created_seq), 0) + 1 FROM deliveries), NULL,
         @created_at, @updated_at, @accepted_at
       )
@@ -136,6 +550,8 @@ export class DeliveryOutbox extends EventEmitter {
                 kind: input.kind,
                 correlation_id: input.correlationId ?? null,
                 payload_json: JSON.stringify(input.payload),
+                message_id: payloadMessageId(input.payload),
+                content_sha256: (content => content === null ? null : deliveryContentDigest(content))(payloadContent(input.payload)),
                 created_at: now,
                 updated_at: now,
                 accepted_at: now,
@@ -143,6 +559,8 @@ export class DeliveryOutbox extends EventEmitter {
             const row = select.get(input.sourceKey);
             if (!row)
                 throw new Error("outbox admission committed without a readable row");
+            if (result.changes === 1)
+                this.answerReplyObligation(row, now);
             return { delivery: mapRow(row), inserted: result.changes === 1 };
         });
         return transaction();
@@ -157,6 +575,26 @@ export class DeliveryOutbox extends EventEmitter {
     `).all(sourceInstance, operationId);
         return rows.map(mapRow);
     }
+    /**
+     * Query only rows owned by the authenticated instance as source or target.
+     * This method accepts caller identity separately from user arguments so a
+     * caller cannot widen its own visibility with a forged source name.
+     */
+    queryStatusForInstance(callerInstance, selector) {
+        return queryStatusPage(this.db, selector, callerInstance);
+    }
+    /** Open the existing outbox without migrations or writes for the operator CLI. */
+    static queryStatusReadOnly(dbPath, selector) {
+        const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+        try {
+            db.pragma("busy_timeout = 1000");
+            db.pragma("query_only = ON");
+            return queryStatusPage(db, selector, null);
+        }
+        finally {
+            db.close();
+        }
+    }
     listPending() {
         const rows = this.db.prepare(`
       SELECT * FROM deliveries
@@ -182,6 +620,10 @@ export class DeliveryOutbox extends EventEmitter {
         // 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.
+        const reconciliationTargets = new Set(this.db.prepare(`
+      SELECT DISTINCT target_instance FROM deliveries
+      WHERE state='submission_started' AND reconciliation_pending=1
+    `).all().map(item => item.target_instance));
         const visitedTargets = new Set();
         for (const row of rows) {
             if (visitedTargets.has(row.target_instance))
@@ -189,6 +631,10 @@ export class DeliveryOutbox extends EventEmitter {
             visitedTargets.add(row.target_instance);
             if (blockedTargets.has(row.target_instance))
                 continue;
+            // A recovered submission owns only its target lane while its evidence is
+            // classified; independent targets can keep dispatching.
+            if (reconciliationTargets.has(row.target_instance))
+                continue;
             if (row.state === "retry_wait" && row.next_attempt_at && row.next_attempt_at > now)
                 continue;
             const targetBootId = targetBootIdFor(row.target_instance);
@@ -210,7 +656,7 @@ export class DeliveryOutbox extends EventEmitter {
         return undefined;
     }
     /** Idempotent begin permit, committed immediately before the pane side effect. */
-    begin(deliveryId, targetBootId, attemptNo) {
+    begin(deliveryId, targetBootId, attemptNo, evidence) {
         const now = new Date().toISOString();
         const transaction = this.db.transaction(() => {
             const row = this.db.prepare("SELECT * FROM deliveries WHERE delivery_id=?").get(deliveryId);
@@ -228,6 +674,10 @@ export class DeliveryOutbox extends EventEmitter {
             const started = this.db.prepare(`
         SELECT COUNT(*) AS count FROM delivery_attempts WHERE delivery_id=?
       `).get(deliveryId);
+            // Only a digest on BOTH sides can disagree: a pre-#856 row or a caller
+            // that could not hash is "unknown", never a mismatch.
+            const mismatch = !!row.content_sha256 && !!evidence?.pastedContentSha256
+                && row.content_sha256 !== evidence.pastedContentSha256;
             if (started.count >= DURABLE_DELIVERY_MAX_ATTEMPTS) {
                 const update = this.db.prepare(`
           UPDATE deliveries SET state='failed',updated_at=?,finished_at=?,last_error='delivery submission attempt limit reached'
@@ -239,22 +689,41 @@ export class DeliveryOutbox extends EventEmitter {
                 return { outcome: "stale", failed: true };
             }
             this.db.prepare(`
-        INSERT INTO delivery_attempts(delivery_id,target_daemon_boot_id,attempt_no,state,begin_ack_at)
-        VALUES (?,?,?,'begun',?)
-      `).run(deliveryId, targetBootId, attemptNo, now);
+        INSERT INTO delivery_attempts(
+          delivery_id,target_daemon_boot_id,attempt_no,state,begin_ack_at,
+          backend,window_id,transcript_path,transcript_offset,transcript_session_id,submission_mode,
+          backend_version,queue_resume_policy,pasted_content_sha256,pasted_bytes_sha256,content_digest_mismatch
+        ) VALUES (?,?,?,'begun',?,?,?,?,?,?,?,?,?,?,?,?)
+      `).run(deliveryId, targetBootId, attemptNo, now, evidence?.backend ?? null, evidence?.windowId ?? null, evidence?.transcriptPath ?? null, evidence?.transcriptOffset ?? null, evidence?.transcriptSessionId ?? null, evidence?.submissionMode ?? null, evidence?.backendVersion ?? null, evidence?.queueResumePolicy ?? null, evidence?.pastedContentSha256 ?? null, evidence?.pastedBytesSha256 ?? null, mismatch ? 1 : 0);
             this.db.prepare(`
         UPDATE deliveries SET state='submission_started', submitted_at=?, updated_at=?
         WHERE delivery_id=? AND state='delivering'
       `).run(now, now, deliveryId);
-            return { outcome: "begun", failed: false };
+            return { outcome: "begun", failed: false, mismatch };
         });
         const result = transaction();
+        if (result.mismatch) {
+            this.emit("content_digest_mismatch", { deliveryId, targetBootId, attemptNo, targetInstance: this.get(deliveryId)?.targetInstance });
+        }
         if (result.outcome === "begun")
             this.emit("state", { deliveryId, state: "submission_started" });
         else if (result.failed)
             this.emit("state", { deliveryId, state: "failed" });
         return result.outcome;
     }
+    /** Write-ahead fence: commit before tmux is allowed to receive Enter. */
+    markEnterStarted(deliveryId, targetBootId, attemptNo) {
+        const now = new Date().toISOString();
+        const changed = this.db.prepare(`
+      UPDATE delivery_attempts SET enter_started_at=COALESCE(enter_started_at,?)
+      WHERE delivery_id=? AND target_daemon_boot_id=? AND attempt_no=? AND state='begun'
+        AND EXISTS (
+          SELECT 1 FROM deliveries WHERE delivery_id=? AND target_daemon_boot_id=?
+            AND attempt_no=? AND state='submission_started'
+        )
+    `).run(now, deliveryId, targetBootId, attemptNo, deliveryId, targetBootId, attemptNo).changes;
+        return changed === 1;
+    }
     /** Safe only when the caller can prove no pane write occurred for this attempt. */
     abort(deliveryId, targetBootId, attemptNo, reason) {
         const now = new Date().toISOString();
@@ -281,7 +750,7 @@ export class DeliveryOutbox extends EventEmitter {
             if (updateAttempt.changes !== 1)
                 return false;
             const updateDelivery = this.db.prepare(`
-        UPDATE deliveries SET state='retry_wait',updated_at=?,last_error=?,next_attempt_at=?
+        UPDATE deliveries SET state='retry_wait',reconciliation_pending=0,updated_at=?,last_error=?,next_attempt_at=?
         WHERE delivery_id=? AND state='submission_started' AND target_daemon_boot_id=? AND attempt_no=?
       `).run(now, reason.slice(0, 300), new Date(Date.now() + DURABLE_DELIVERY_ABORT_BACKOFF_MS).toISOString(), deliveryId, targetBootId, attemptNo);
             if (updateDelivery.changes !== 1)
@@ -298,7 +767,7 @@ export class DeliveryOutbox extends EventEmitter {
         const transaction = this.db.transaction(() => {
             const parent = this.db.prepare("SELECT * FROM deliveries WHERE delivery_id=?").get(deliveryId);
             const result = this.db.prepare(`
-        UPDATE deliveries SET state=?,updated_at=?,finished_at=?,last_error=?
+        UPDATE deliveries SET state=?,reconciliation_pending=0,updated_at=?,finished_at=?,last_error=?
         WHERE delivery_id=? AND target_daemon_boot_id=? AND attempt_no=? AND state='submission_started'
       `).run(outcome, now, now, outcome === "delivered" ? null : (evidence ?? outcome).slice(0, 300), deliveryId, targetBootId, attemptNo);
             if (result.changes !== 1) {
@@ -312,6 +781,8 @@ export class DeliveryOutbox extends EventEmitter {
             if (parent && (outcome === "failed" || outcome === "uncertain")) {
                 this.insertFailureNotice(parent, outcome, evidence ?? outcome, now);
             }
+            if (parent && outcome === "delivered")
+                this.openReplyObligation(parent, now);
             return { changed: true, accepted: true };
         });
         const result = transaction();
@@ -368,7 +839,7 @@ export class DeliveryOutbox extends EventEmitter {
             this.emit("state", { deliveryId, state: "failed" });
         return changed;
     }
-    /** Expire unavailable/pre-submit rows instead of leaving them queued forever. */
+    /** Bound both unavailable rows and unresolved reconciliation without stealing a live lease. */
     expireStale(nowMs = Date.now(), maxAgeMs = DURABLE_DELIVERY_MAX_AGE_MS) {
         const cutoff = new Date(nowMs - maxAgeMs).toISOString();
         const now = new Date(nowMs).toISOString();
@@ -383,23 +854,46 @@ export class DeliveryOutbox extends EventEmitter {
         WHERE delivery_id=? AND state IN ('queued','retry_wait')
       `);
             let changed = 0;
+            let uncertain = 0;
             for (const row of stale) {
                 if (update.run(now, now, row.delivery_id).changes !== 1)
                     continue;
                 this.insertFailureNotice(row, "failed", "delivery TTL expired before target became available", now);
                 changed++;
             }
-            return changed;
+            const unresolved = this.db.prepare(`
+        SELECT * FROM deliveries
+        WHERE state='submission_started' AND reconciliation_pending=1 AND created_at<=?
+        ORDER BY created_seq
+      `).all(cutoff);
+            const markUncertain = this.db.prepare(`
+        UPDATE deliveries SET state='uncertain',reconciliation_pending=0,updated_at=?,finished_at=?,
+          last_error='reconciliation TTL expired without sufficient evidence'
+        WHERE delivery_id=? AND state='submission_started' AND reconciliation_pending=1
+      `);
+            for (const row of unresolved) {
+                if (markUncertain.run(now, now, row.delivery_id).changes !== 1)
+                    continue;
+                this.db.prepare(`
+          UPDATE delivery_attempts SET state='uncertain',finished_at=?,evidence='reconciliation TTL expired without sufficient evidence'
+          WHERE delivery_id=? AND target_daemon_boot_id=? AND attempt_no=? AND state='begun'
+        `).run(now, row.delivery_id, row.target_daemon_boot_id, row.attempt_no);
+                this.insertFailureNotice(row, "uncertain", "reconciliation TTL expired without sufficient evidence", now);
+                changed++;
+                uncertain++;
+            }
+            return { changed, uncertain };
         });
-        const changed = transaction();
-        if (changed)
-            this.emit("expired", { count: changed });
-        return changed;
+        const result = transaction();
+        if (result.changed)
+            this.emit("expired", { count: result.changed, uncertain: result.uncertain });
+        return result.changed;
     }
     /** Next queued/retry expiry for bounded maintenance scheduling. */
     nextExpiryAt() {
         const row = this.db.prepare(`
-      SELECT MIN(created_at) AS created_at FROM deliveries WHERE state IN ('queued','retry_wait')
+      SELECT MIN(created_at) AS created_at FROM deliveries
+      WHERE state IN ('queued','retry_wait') OR (state='submission_started' AND reconciliation_pending=1)
     `).get();
         return row.created_at ? new Date(Date.parse(row.created_at) + DURABLE_DELIVERY_MAX_AGE_MS).toISOString() : null;
     }
@@ -414,23 +908,17 @@ export class DeliveryOutbox extends EventEmitter {
     recoverForBoot(managerBootId) {
         const now = new Date().toISOString();
         const transaction = this.db.transaction(() => {
-            const uncertainRows = this.db.prepare(`
-        SELECT * FROM deliveries WHERE manager_boot_id IS NOT NULL AND manager_boot_id<>? AND state='submission_started'
-      `).all(managerBootId);
             const queued = this.db.prepare(`
         UPDATE deliveries SET state='queued',manager_boot_id=NULL,target_daemon_boot_id=NULL,next_attempt_at=NULL,updated_at=?
         WHERE manager_boot_id IS NOT NULL AND manager_boot_id<>? AND state IN ('delivering','retry_wait')
       `).run(now, managerBootId).changes;
-            // Until transcript reconciliation is enabled, never blindly replay a row
-            // whose pane side effect may already have happened.
-            const uncertain = this.db.prepare(`
-        UPDATE deliveries SET state='uncertain',updated_at=?,finished_at=?,last_error='process restarted during submission; reconciliation required'
+            // Keep the submission fence and target lane while bounded pane/transcript
+            // evidence is captured. Never replay an in-flight row blindly.
+            const reconciliationPending = this.db.prepare(`
+        UPDATE deliveries SET reconciliation_pending=1,updated_at=?,last_error='process restarted during submission; reconciliation required'
         WHERE manager_boot_id IS NOT NULL AND manager_boot_id<>? AND state='submission_started'
-      `).run(now, now, managerBootId).changes;
-            for (const row of uncertainRows) {
-                this.insertFailureNotice(row, "uncertain", "process restarted during submission; reconciliation required", now);
-            }
-            return { queued, uncertain };
+      `).run(now, managerBootId).changes;
+            return { queued, reconciliationPending };
         });
         return transaction();
     }
@@ -491,34 +979,103 @@ export class DeliveryOutbox extends EventEmitter {
     recoverTargetGeneration(targetInstance, currentTargetBootId) {
         const now = new Date().toISOString();
         const transaction = this.db.transaction(() => {
-            const uncertainRows = this.db.prepare(`
-        SELECT * FROM deliveries WHERE target_instance=? AND target_daemon_boot_id IS NOT NULL
-          AND target_daemon_boot_id<>? AND state='submission_started'
-      `).all(targetInstance, currentTargetBootId);
             const queued = this.db.prepare(`
         UPDATE deliveries SET state='queued',manager_boot_id=NULL,target_daemon_boot_id=NULL,next_attempt_at=NULL,updated_at=?
         WHERE target_instance=? AND target_daemon_boot_id IS NOT NULL AND target_daemon_boot_id<>?
           AND state IN ('delivering','retry_wait')
       `).run(now, targetInstance, currentTargetBootId).changes;
-            const uncertain = this.db.prepare(`
-        UPDATE deliveries SET state='uncertain',updated_at=?,finished_at=?,last_error='target daemon generation changed during submission; reconciliation required'
+            const reconciliationPending = this.db.prepare(`
+        UPDATE deliveries SET reconciliation_pending=1,updated_at=?,last_error='target daemon generation changed during submission; reconciliation required'
         WHERE target_instance=? AND target_daemon_boot_id IS NOT NULL AND target_daemon_boot_id<>?
           AND state='submission_started'
-      `).run(now, now, targetInstance, currentTargetBootId).changes;
-            for (const row of uncertainRows) {
-                this.insertFailureNotice(row, "uncertain", "target daemon generation changed during submission; reconciliation required", now);
-            }
-            return { queued, uncertain };
+      `).run(now, targetInstance, currentTargetBootId).changes;
+            return { queued, reconciliationPending };
         });
         const result = transaction();
-        if (result.queued + result.uncertain > 0)
+        if (result.queued + result.reconciliationPending > 0)
             this.emit("generation_recovered", { targetInstance, ...result });
         return result;
     }
+    /** Fence in-flight writes before an in-process target stop begins. */
+    markTargetReconciliationPending(targetInstance, targetBootId) {
+        const now = new Date().toISOString();
+        return this.db.prepare(`
+      UPDATE deliveries SET reconciliation_pending=1,updated_at=?,last_error='target daemon stopping; reconciliation required'
+      WHERE target_instance=? AND target_daemon_boot_id=? AND state='submission_started'
+    `).run(now, targetInstance, targetBootId).changes;
+    }
+    getReconciliationCandidates(targetInstance) {
+        const rows = this.db.prepare(`
+      SELECT d.*, a.target_daemon_boot_id AS attempt_target_boot_id,
+        a.attempt_no AS attempt_attempt_no, a.backend AS attempt_backend,
+        a.window_id AS attempt_window_id, a.transcript_path AS attempt_transcript_path,
+        a.transcript_offset AS attempt_transcript_offset,
+        a.transcript_session_id AS attempt_transcript_session_id,
+        a.submission_mode AS attempt_submission_mode, a.backend_version AS attempt_backend_version,
+        a.queue_resume_policy AS attempt_queue_resume_policy,
+        a.enter_started_at AS attempt_enter_started_at
+      FROM deliveries d JOIN delivery_attempts a ON a.delivery_id=d.delivery_id
+        AND a.attempt_no=d.attempt_no AND a.target_daemon_boot_id=d.target_daemon_boot_id
+      WHERE d.target_instance=? AND d.state='submission_started' AND d.reconciliation_pending=1
+      ORDER BY d.created_seq
+    `).all(targetInstance);
+        return rows.map(row => ({
+            ...mapRow(row),
+            attempt: {
+                targetDaemonBootId: row.attempt_target_boot_id,
+                attemptNo: row.attempt_attempt_no,
+                backend: row.attempt_backend,
+                backendVersion: row.attempt_backend_version,
+                windowId: row.attempt_window_id,
+                transcriptPath: row.attempt_transcript_path,
+                transcriptOffset: row.attempt_transcript_offset,
+                transcriptSessionId: row.attempt_transcript_session_id,
+                submissionMode: row.attempt_submission_mode,
+                queueResumePolicy: row.attempt_queue_resume_policy,
+                enterStartedAt: row.attempt_enter_started_at,
+            },
+        }));
+    }
+    /** Atomically settle one old attempt using only its boot/attempt fence. */
+    reconcileAttempt(deliveryId, targetBootId, attemptNo, outcome, evidence) {
+        const now = new Date().toISOString();
+        const transaction = this.db.transaction(() => {
+            const parent = this.db.prepare("SELECT * FROM deliveries WHERE delivery_id=?").get(deliveryId);
+            if (!parent || parent.state !== "submission_started" || parent.target_daemon_boot_id !== targetBootId
+                || parent.attempt_no !== attemptNo || parent.reconciliation_pending !== 1)
+                return false;
+            const terminal = outcome !== "retry_wait";
+            const changed = this.db.prepare(`
+        UPDATE deliveries SET state=?,reconciliation_pending=0,manager_boot_id=?,
+          target_daemon_boot_id=?,updated_at=?,finished_at=?,last_error=?,next_attempt_at=?
+        WHERE delivery_id=? AND state='submission_started' AND reconciliation_pending=1
+          AND target_daemon_boot_id=? AND attempt_no=?
+      `).run(outcome, outcome === "retry_wait" ? null : parent.manager_boot_id, outcome === "retry_wait" ? null : targetBootId, now, terminal ? now : null, outcome === "delivered" ? null : evidence.slice(0, 300), outcome === "retry_wait" ? new Date(Date.now() + DURABLE_DELIVERY_ABORT_BACKOFF_MS).toISOString() : null, deliveryId, targetBootId, attemptNo).changes;
+            if (changed !== 1)
+                return false;
+            const attemptState = outcome === "retry_wait" ? "aborted" : outcome;
+            this.db.prepare(`
+        UPDATE delivery_attempts SET state=?,abort_at=?,finished_at=?,evidence=?
+        WHERE delivery_id=? AND target_daemon_boot_id=? AND attempt_no=? AND state='begun'
+      `).run(attemptState, outcome === "retry_wait" ? now : null, terminal ? now : null, evidence.slice(0, 300), deliveryId, targetBootId, attemptNo);
+            if (outcome === "uncertain")
+                this.insertFailureNotice(parent, "uncertain", evidence, now);
+            if (outcome === "delivered")
+                this.openReplyObligation(parent, now);
+            return true;
+        });
+        const changed = transaction();
+        if (changed)
+            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);
@@ -528,7 +1085,8 @@ export class DeliveryOutbox extends EventEmitter {
     }
     /** Must be called inside the same SQLite transaction as the terminal transition. */
     insertFailureNotice(parent, outcome, reason, now) {
-        if (parent.kind === "delivery_outcome_notice" || parent.kind === "post_restart_outcome_notice")
+        if (parent.kind === "delivery_outcome_notice" || parent.kind === "post_restart_outcome_notice"
+            || parent.kind === REPLY_OBLIGATION_NOTICE_KIND)
             return;
         const noticeId = randomUUID();
         const operationId = `notice:${parent.operation_id}:${parent.delivery_id}`;