@astrosheep/square 0.3.88 → 0.3.89

package/dist/artifact.js

@@ -121,9 +121,9 @@ const readMethods = [
     'activity', 'activityHeads', 'activities', 'activityCount', 'contextIndexes', 'sayOrdinals', 'recentSayTimes',
     'audience', 'directed', 'directedAt', 'directedCount', 'pendingAudience',
     'receipt', 'receiptFacts', 'receiptAssignments', 'lease', 'participantCounts', 'seat', 'seatsForBody', 'completedSeatsForBody',
-    'deliveryEvidence', 'deliveryByToken', 'cancelledThrough',
+    'deliveryEvidence', 'deliveryByToken', 'cancelledThrough', 'deliveryDeferrals',
 ];
-const writeMethods = ['applyLanding', 'markSeen', 'putLease', 'removeLease', 'storeSeat', 'removeSeat', 'updateWakeAddress', 'cancelThrough', 'claimDelivery', 'prepareDelivery', 'completeDelivery', 'observeNativeDelivery'];
+const writeMethods = ['applyLanding', 'markSeen', 'putLease', 'removeLease', 'storeSeat', 'removeSeat', 'updateWakeAddress', 'cancelThrough', 'claimDelivery', 'prepareDelivery', 'completeDelivery', 'observeNativeDelivery', 'putDeliveryDeferral', 'renewDeliveryDeferral', 'releaseDeliveryDeferral'];
 /** One connection, ordered operations, guarded synchronous transaction capabilities. */
 export function createArtifactPort(location, initial, externalSignal) {
     let database;
@@ -161,12 +161,11 @@ export function createArtifactPort(location, initial, externalSignal) {
         }
         return database;
     }
-    function queue(operation, signal) {
+    function queue(operation, operationSignal) {
         if (inCallback)
             throw new TypeError('Square artifact operations cannot nest inside a callback.');
         if (closed)
             return Promise.reject(new Error('Square artifact is closed'));
-        const operationSignal = combined(signal);
         const result = tail.then(() => {
             abort(operationSignal);
             return operation(operationSignal);
@@ -229,19 +228,22 @@ export function createArtifactPort(location, initial, externalSignal) {
     const revision = signal => queue(async (s) => {
         const db = await connection(s);
         return inSqliteTransaction(db, false, () => validate(db), (header) => header.revision, s);
-    }, signal);
+    }, combined(signal));
     return {
         read: (select, signal) => queue(async (s) => {
             const { value, version } = await transaction(select, false, s);
             return { value, version };
-        }, signal),
-        transactAs: (authority, change, signal) => queue(s => transaction(change, true, s, authority), signal),
+        }, combined(signal)),
+        transactAs: (authority, change, signal) => queue(s => transaction(change, true, s, authority), combined(signal)),
+        // Keep the acquired connection and authority, not the cancelled work lifetime. A
+        // blocked evidence commit/cleanup gets five seconds, and close still cancels it.
+        settleAs: (authority, change) => queue(s => transaction(change, true, s, authority), AbortSignal.any([cancel.signal, AbortSignal.timeout(5000)])),
         revision,
         async deliveryRevision(signal) {
             return queue(async (s) => {
                 const db = await connection(s);
                 return inSqliteTransaction(db, false, () => validate(db), (header) => header.deliveryRevision, s);
-            }, signal);
+            }, combined(signal));
         },
         async claimDelivery(input, signal) {
             return (await this.transactAs({ kind: 'participant', seat: input.seat }, (facts) => facts.claimDelivery(input), signal)).value;
@@ -374,7 +376,7 @@ export async function writeSquareFile(location, state, signal) {
             const revision = createSqliteDriver(db).header().revision;
             if (revision === Number.MAX_SAFE_INTEGER)
                 throw invalidArtifact('revision cannot advance beyond the safe integer limit.');
-            for (const table of ['landed_audience', 'attention', 'participants', 'delivery_cancellations', 'delivery_evidence', 'seats', 'catch_leases', 'receipts', 'activities', 'square_meta'])
+            for (const table of ['landed_audience', 'attention', 'participants', 'delivery_deferrals', 'delivery_cancellations', 'delivery_evidence', 'seats', 'catch_leases', 'receipts', 'activities', 'square_meta'])
                 db.exec(`DROP TABLE ${table}`);
             initializeSqlite(db, state, revision + 1);
         }, signal);

package/dist/boundary-presentation.d.ts

@@ -7,7 +7,8 @@ export declare function renderPendingAtBoundary(inbox: PendingMembership[]): str
  *
  * `lookup` returns the session's memberships for this boundary. It may reuse an observation it has
  * verified against the current presence binding and artifact revision; the boundary still projects
- * presentation evidence live, and `presentPending` still re-checks the pending head, join, ownership
- * claim and seen CAS. A source that cannot verify its reuse must read the inbox again.
+ * presentation evidence live. Every item is claimed and revalidated before the batch sink;
+ * after success, captured-seat commits record only its included items without an eligibility veto.
+ * A source that cannot verify its reuse must read the inbox again.
  */
 export declare function presentPendingAtBoundary<T>(identity: Body, present: (context: string) => T | Promise<T>, lookup?: (identity: Body, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<PendingMembership[]> | PendingMembership[], env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<T | undefined>;

package/dist/boundary-presentation.js

@@ -2,35 +2,11 @@ import { squareIndexPath } from './square-index.js';
 import { createHash } from 'node:crypto';
 import { withFileLock } from './file-lock.js';
 import { createArtifactPort } from './artifact.js';
-import { presentPending } from './presentation-operations.js';
+import { preparePendingPresentation } from './presentation-operations.js';
 import { sessionInbox, projectBoundaryEligibility, pendingAtBoundary, pendingKey } from './inbox.js';
 import { attentionBodyIsClipped, renderAttentionPreview, renderSquareReminder } from './attention-presentation.js';
 export { pendingAtBoundary };
 const CONTEXT_MAX = 1200;
-const presentationLocks = new Map();
-/** One settled promise loses to an abort so an in-process presentation wait stays bounded too. */
-async function awaitWithSignal(promise, signal) {
-    if (signal === undefined)
-        return promise;
-    let onAbort;
-    try {
-        await Promise.race([
-            promise,
-            new Promise((_, reject) => {
-                if (signal.aborted) {
-                    reject(signal.reason ?? new Error('Presentation aborted'));
-                    return;
-                }
-                onAbort = () => reject(signal.reason ?? new Error('Presentation aborted'));
-                signal.addEventListener('abort', onAbort, { once: true });
-            }),
-        ]);
-    }
-    finally {
-        if (onAbort !== undefined)
-            signal.removeEventListener('abort', onAbort);
-    }
-}
 export function renderPendingAtBoundary(inbox) {
     return renderBoundary(inbox).context;
 }
@@ -77,70 +53,67 @@ async function presentPendingAtBoundaryUnlocked(identity, present, lookup = sess
     const pending = await projectBoundaryEligibility(inbox);
     if (pending.length === 0 || signal?.aborted)
         return undefined;
-    const delivered = renderBoundary(pending);
-    if (delivered.context === '')
-        return undefined;
-    let result;
-    let rendered = false;
-    const renderOnce = async () => { if (!rendered) {
-        rendered = true;
-        result = await present(delivered.context);
-    } };
-    for (const entry of delivered.complete) {
-        let artifact;
-        try {
-            artifact = createArtifactPort(entry.membership.location, undefined, signal);
-            try {
-                await artifact.read(facts => facts.header(), signal);
-            }
-            catch {
-                continue;
+    const artifacts = new Map();
+    const claims = [];
+    try {
+        // Claim the entire candidate batch before its one external effect. No later item needs
+        // a new claim (and new eligibility decision) after its bytes have already been rendered.
+        for (const entry of renderBoundary(pending).complete) {
+            const { location, seat } = entry.membership;
+            let artifact = artifacts.get(location);
+            if (artifact === undefined) {
+                // This boundary owns the connection until all effect evidence/cleanup has settled.
+                // Request cancellation travels with pre-effect operations, not that lifetime.
+                artifact = createArtifactPort(location);
+                artifacts.set(location, artifact);
             }
             for (const index of entry.actIndexes) {
-                const key = pendingKey(entry.membership, index);
-                const prior = presentationLocks.get(key);
-                if (prior !== undefined) {
-                    await awaitWithSignal(prior, signal);
-                    if (signal?.aborted)
-                        return undefined;
-                    if (!rendered)
-                        return undefined;
-                    continue;
-                }
-                const work = presentPending({ artifact, location: entry.membership.location, participant: entry.membership.seat.participant, activity: index, seat: entry.membership.seat, sink: { present: renderOnce }, markSeen: entry.markSeen, now: Date.now(), signal }).then(async (outcome) => {
-                    // A stale projection can outlive its activity; still surface the bounded preview,
-                    // but there is no artifact observation to commit.
-                    if (!outcome.presented) {
-                        const exists = await artifact.read((facts) => facts.activity(index) !== undefined, signal).catch(() => undefined);
-                        if (exists?.value === false)
-                            await renderOnce();
-                    }
-                });
-                presentationLocks.set(key, work);
-                try {
-                    await work;
-                }
-                finally {
-                    presentationLocks.delete(key);
-                }
-                if (!rendered)
-                    return undefined;
+                const claim = await preparePendingPresentation({ artifact, location, participant: seat.participant,
+                    activity: index, seat, markSeen: entry.markSeen, signal });
+                if (claim !== undefined)
+                    claims.push({ key: pendingKey(entry.membership, index), claim });
             }
         }
-        finally {
-            if (artifact !== undefined)
-                await artifact.close();
+        const eligible = new Set();
+        for (const { key, claim } of claims)
+            if (await claim.eligible())
+                eligible.add(key);
+        const fresh = renderBoundary(pending.map(membership => ({ ...membership,
+            notifications: membership.notifications.filter(note => eligible.has(pendingKey(membership, note.actIndex))),
+        })));
+        const included = new Set(fresh.complete.flatMap(entry => entry.actIndexes.map(index => pendingKey(entry.membership, index))));
+        if (included.size === 0 || signal?.aborted)
+            return undefined;
+        const rendered = claims.filter(({ key }) => included.has(key));
+        let result;
+        try {
+            result = await present(fresh.context);
         }
+        catch (error) {
+            await Promise.all(rendered.map(({ claim }) => claim.release('failed', error instanceof Error ? error.message : String(error))));
+            throw error;
+        }
+        // These are successful sink effects, not fresh delivery attempts. Settle the entire
+        // rendered set before closing any connection, even if one member's settlement fails.
+        const settlements = await Promise.allSettled(rendered.map(({ claim }) => claim.recordPresented()));
+        for (const settlement of settlements)
+            if (settlement.status === 'rejected')
+                throw settlement.reason;
+        return result;
+    }
+    finally {
+        await Promise.all(claims.map(({ claim }) => claim.release()));
+        await Promise.all([...artifacts.values()].map(artifact => artifact.close()));
     }
-    return result;
 }
 /**
  * Serialize a boundary across hook processes so one stale inbox cannot render twice.
  *
  * `lookup` returns the session's memberships for this boundary. It may reuse an observation it has
  * verified against the current presence binding and artifact revision; the boundary still projects
- * presentation evidence live, and `presentPending` still re-checks the pending head, join, ownership
- * claim and seen CAS. A source that cannot verify its reuse must read the inbox again.
+ * presentation evidence live. Every item is claimed and revalidated before the batch sink;
+ * after success, captured-seat commits record only its included items without an eligibility veto.
+ * A source that cannot verify its reuse must read the inbox again.
  */
 export async function presentPendingAtBoundary(identity, present, lookup = sessionInbox, env = process.env, signal) {
     const indexPath = squareIndexPath(env);

package/dist/cli/context.js

@@ -160,9 +160,7 @@ function commandIdentity(env) {
     if (selected === undefined)
         return {};
     const body = { channel: selected.channel, session: selected.session };
-    const wakeAddress = selected.channel === 'codex'
-        ? { kind: 'codex-queue', address: { threadId: selected.session } }
-        : paseo === undefined ? undefined : { kind: 'paseo', address: { agentId: paseo.session } };
+    const wakeAddress = paseo === undefined ? undefined : { kind: 'paseo', address: { agentId: paseo.session } };
     return { body, ...(wakeAddress === undefined ? {} : { wakeAddress }) };
 }
 /** Adapter lifetime only; each callback uses the actual public resource API. */

package/dist/delivery-deferral.d.ts

@@ -0,0 +1,28 @@
+import { type ActivityMetadata, type ActivityId } from './model.js';
+import type { SeatRef, SquareRead } from './ports.js';
+export type MetadataScalar = null | boolean | number | string;
+export interface MetadataMatch {
+    readonly fields: readonly Readonly<{
+        path: readonly string[];
+        equals: MetadataScalar;
+    }>[];
+}
+export interface DeliveryDeferral {
+    readonly id: string;
+    readonly expiresAt: string;
+}
+export interface DeliveryDeferralFact {
+    readonly participant: string;
+    readonly generation: ActivityId;
+    readonly id: string;
+    readonly match: MetadataMatch;
+    readonly expiresAt: number;
+}
+export declare const MAX_DELIVERY_DEFERRAL_MS: number;
+export declare function validateMetadataMatch(value: unknown): MetadataMatch;
+export declare function validateDeferralDuration(value: unknown): number;
+export declare function validateDeferralId(value: unknown): string;
+export declare function matchesMetadata(metadata: ActivityMetadata | undefined, match: MetadataMatch): boolean;
+export declare function matchingDeferrals(deferrals: readonly DeliveryDeferralFact[], metadata: ActivityMetadata | undefined, now: number): readonly DeliveryDeferralFact[];
+export declare function deliveryDeferralExpiry(facts: SquareRead, captured: SeatRef, index: number, now: number): number | undefined;
+export declare function earliestMatchingDeferralExpiry(deferrals: readonly DeliveryDeferralFact[], metadata: ActivityMetadata | undefined, now: number): number | undefined;

package/dist/delivery-deferral.js

@@ -0,0 +1,83 @@
+import { SquareError, sameBody } from './model.js';
+export const MAX_DELIVERY_DEFERRAL_MS = 24 * 60 * 60 * 1000;
+export function validateMetadataMatch(value) {
+    const fail = () => { throw new SquareError('invalid_args', 'Invalid metadata match.'); };
+    const record = (item) => {
+        if (typeof item !== 'object' || item === null || Array.isArray(item))
+            return false;
+        const prototype = Object.getPrototypeOf(item);
+        return (prototype === Object.prototype || prototype === null) && Object.getOwnPropertySymbols(item).length === 0
+            && Object.getOwnPropertyNames(item).every(key => {
+                const descriptor = Object.getOwnPropertyDescriptor(item, key);
+                return descriptor.enumerable && 'value' in descriptor;
+            });
+    };
+    const dense = (item) => Array.isArray(item)
+        && Object.getOwnPropertySymbols(item).length === 0 && Object.keys(item).length === item.length
+        && Object.getOwnPropertyNames(item).length === item.length + 1
+        && Array.from({ length: item.length }, (_, index) => Object.getOwnPropertyDescriptor(item, index))
+            .every(descriptor => descriptor !== undefined && descriptor.enumerable && 'value' in descriptor);
+    if (!record(value) || Object.keys(value).length !== 1 || !Object.hasOwn(value, 'fields'))
+        return fail();
+    const fields = value.fields;
+    if (!dense(fields) || fields.length === 0)
+        return fail();
+    const paths = new Set();
+    const validated = fields.map((field) => {
+        if (!record(field) || Object.keys(field).length !== 2
+            || !Object.hasOwn(field, 'path') || !Object.hasOwn(field, 'equals'))
+            return fail();
+        const { path, equals } = field;
+        if (!dense(path) || path.length === 0 || !path.every((part) => typeof part === 'string' && part.length > 0))
+            return fail();
+        if (!(equals === null || typeof equals === 'string' || typeof equals === 'boolean'
+            || typeof equals === 'number' && Number.isFinite(equals)))
+            return fail();
+        const key = JSON.stringify(path);
+        if (paths.has(key))
+            return fail();
+        paths.add(key);
+        return Object.freeze({ path: Object.freeze([...path]), equals: equals });
+    });
+    return Object.freeze({ fields: Object.freeze(validated) });
+}
+export function validateDeferralDuration(value) {
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw new SquareError('invalid_args', 'Delivery deferral duration must be a positive safe integer.');
+    return Math.min(value, MAX_DELIVERY_DEFERRAL_MS);
+}
+export function validateDeferralId(value) {
+    if (typeof value !== 'string' || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value))
+        throw new SquareError('invalid_args', 'Invalid delivery deferral id.');
+    return value;
+}
+export function matchesMetadata(metadata, match) {
+    if (metadata === undefined)
+        return false;
+    return match.fields.every(({ path, equals }) => {
+        let value = metadata;
+        for (const segment of path) {
+            if (typeof value !== 'object' || value === null || Array.isArray(value) || !Object.hasOwn(value, segment))
+                return false;
+            value = value[segment];
+        }
+        return value === equals && (value === null || typeof value !== 'object');
+    });
+}
+export function matchingDeferrals(deferrals, metadata, now) {
+    return deferrals.filter((lease) => lease.expiresAt > now && matchesMetadata(metadata, lease.match));
+}
+export function deliveryDeferralExpiry(facts, captured, index, now) {
+    const seat = facts.seat(captured.participant);
+    if (seat === undefined || seat.generation !== captured.generation || !sameBody(seat.body, captured.body))
+        return undefined;
+    const leases = facts.deliveryDeferrals(seat.participant, seat.generation);
+    if (!leases.some(lease => lease.expiresAt > now))
+        return undefined;
+    const activity = facts.activity(index);
+    return activity?.kind === 'say' ? earliestMatchingDeferralExpiry(leases, activity.metadata, now) : undefined;
+}
+export function earliestMatchingDeferralExpiry(deferrals, metadata, now) {
+    const matches = matchingDeferrals(deferrals, metadata, now);
+    return matches.length ? Math.min(...matches.map((lease) => lease.expiresAt)) : undefined;
+}

package/dist/delivery-operations.js

@@ -5,6 +5,7 @@ import { pendingHead, pendingHeads, pendingRecipients, presentationBlocksWake }
 import { asSeatRef } from './seats.js';
 import { canonicalPath } from './canonical-path.js';
 import { freshWatchLease } from './runtime.js';
+import { deliveryDeferralExpiry } from './delivery-deferral.js';
 import { leaseOwnsNotification } from './delivery.js';
 function routeFor(location, seat, now) {
     if (seat.wakeAddress === undefined)
@@ -33,7 +34,8 @@ async function currentness(artifact, request, now) {
         const caught = head !== undefined && lease !== undefined && leaseOwnsNotification(lease, {
             actor: request.actor, route: head.route, recipient: request.participant,
         });
-        return { current: activityPending && !cancelled && !presented && !caught, activityPending, seatCurrent, cancelled, presented };
+        const deferred = deliveryDeferralExpiry(facts, request.seat, index, now) !== undefined;
+        return { current: activityPending && !cancelled && !presented && !caught && !deferred, activityPending, seatCurrent, cancelled, presented };
     });
     return value;
 }
@@ -50,14 +52,14 @@ async function attemptWakeWithin(transport, request, timeoutMs, beforeSend) {
             clearTimeout(timer);
     }
 }
-async function candidates(artifact, requested) {
+async function candidates(artifact, requested, now = Date.now()) {
     const { value } = await artifact.read((facts) => {
         const heads = requested === undefined
             ? facts.roster().flatMap((participant) => participant.joined ? pendingHeads(facts, participant.name) : [])
             : pendingRecipients(facts, requested);
         return heads.flatMap((head) => {
             const seat = facts.seat(head.recipient);
-            return seat === undefined ? [] : [{ seat, head }];
+            return seat === undefined || deliveryDeferralExpiry(facts, seat, head.index, now) !== undefined ? [] : [{ seat, head }];
         });
     });
     return value;
@@ -84,7 +86,7 @@ export async function deliverPending(input) {
         : typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
     if (input.activity !== undefined && requested === undefined)
         return { attempted: 0, accepted: 0, failed: 0, unknown: 0, notCapable: 0 };
-    const pending = await candidates(input.artifact, requested);
+    const pending = await candidates(input.artifact, requested, input.now ?? Date.now());
     let attempted = 0, accepted = 0, failed = 0, unknown = 0, notCapable = 0;
     for (const { seat, head } of pending) {
         const route = routeFor(location, seat, input.now ?? Date.now());
@@ -121,7 +123,7 @@ export async function deliverPending(input) {
         let suppressed = false;
         const beforeSend = async () => {
             try {
-                final = await currentness(input.artifact, withClaim, Date.now());
+                final = await currentness(input.artifact, withClaim, input.now ?? Date.now());
                 suppressed = !final.current;
             }
             catch {
@@ -177,7 +179,7 @@ export async function deliverPending(input) {
 export async function sweepPending(input) {
     if (input.limit <= 0)
         return [];
-    const pending = await candidates(input.artifact);
+    const pending = await candidates(input.artifact, undefined, input.now);
     const selected = [];
     for (const { head } of pending) {
         if (input.now - head.at <= input.graceMs)

package/dist/delivery.js

@@ -1,12 +1,15 @@
 import { renderAttentionPreview, renderSquareReminder } from './attention-presentation.js';
 import { parseActivityId } from './square-core.js';
+import { deliveryDeferralExpiry } from './delivery-deferral.js';
 import { matchesCatchSelection } from './catch-selection.js';
 /** Exact stored activity projection for transports that send an awareness reminder. */
 export function wakePreview(facts, request) {
     const index = parseActivityId(request.activity);
     const head = index === undefined ? undefined : pendingHead(facts, request.participant, index);
     const item = index === undefined ? undefined : facts.activity(index);
-    if (head === undefined || item?.kind !== 'say')
+    const seat = facts.seat(request.participant);
+    if (head === undefined || item?.kind !== 'say' || seat === undefined
+        || deliveryDeferralExpiry(facts, request.seat, item.index, Date.now()) !== undefined)
         return undefined;
     return renderSquareReminder([renderAttentionPreview({
             squarePath: request.location, recipient: request.participant, actIndex: item.index,

package/dist/inbox.js

@@ -5,6 +5,7 @@ import { canonicalPath } from './canonical-path.js';
 import { formatActivityId, parseActivityId } from './square-core.js';
 import { freshWatchLease, WATCH_STALE_MS } from './runtime.js';
 import { pendingHead, pendingNotifications, leaseOwnsNotification } from './delivery.js';
+import { deliveryDeferralExpiry } from './delivery-deferral.js';
 import { attentionBodyIsClipped, renderAttentionPreview, renderSquareReminder } from './attention-presentation.js';
 export function pendingKey(membership, actIndex) {
     return membership.location + '\0' + membership.seat.participant.toLocaleLowerCase() + '\0' + actIndex;
@@ -17,15 +18,25 @@ export function pendingAtBoundary(inbox) {
         return { ...membership, notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.seat.participant })) };
     }).filter((membership) => membership.notifications.length > 0);
 }
-function eligibleNotifications(facts, membership) {
+function eligibleNotifications(facts, membership, now = Date.now()) {
     const seat = facts.seat(membership.seat.participant);
     if (seat === undefined || seat.generation !== membership.seat.generation
         || !sameBody(seat.body, membership.seat.body))
-        return [];
+        return { notifications: [] };
     const cancelledThrough = facts.cancelledThrough(seat.participant, seat.generation);
-    return membership.notifications.filter(notification => (cancelledThrough === undefined || notification.actIndex > cancelledThrough)
-        && !facts.deliveryEvidence(seat.participant, seat.generation, formatActivityId(notification.actIndex))
-            .some(row => row.kind === 'presentation' && (row.outcome === 'presented' || row.outcome === 'clipped')));
+    let expiry = Infinity;
+    const notifications = membership.notifications.filter(notification => {
+        if (cancelledThrough !== undefined && notification.actIndex <= cancelledThrough
+            || facts.deliveryEvidence(seat.participant, seat.generation, formatActivityId(notification.actIndex))
+                .some(row => row.kind === 'presentation' && (row.outcome === 'presented' || row.outcome === 'clipped')))
+            return false;
+        const deferredUntil = deliveryDeferralExpiry(facts, seat, notification.actIndex, now);
+        if (deferredUntil === undefined)
+            return true;
+        expiry = Math.min(expiry, deferredUntil);
+        return false;
+    });
+    return { notifications, ...(expiry === Infinity ? {} : { deliveryDeferralExpiry: expiry }) };
 }
 /** Revalidate a supplied batch immediately before the boundary's independent claim/send checks. */
 export async function projectBoundaryEligibility(inbox) {
@@ -40,8 +51,8 @@ export async function projectBoundaryEligibility(inbox) {
         const artifact = createArtifactPort(location);
         try {
             const { value } = await artifact.read(facts => memberships.flatMap(membership => {
-                const notifications = eligibleNotifications(facts, membership);
-                return notifications.length === 0 ? [] : [{ ...membership, notifications }];
+                const eligibility = eligibleNotifications(facts, membership);
+                return eligibility.notifications.length === 0 ? [] : [{ ...membership, ...eligibility }];
             }));
             pending.push(...value);
         }
@@ -146,7 +157,7 @@ async function projectPending(candidates, cache, signal) {
                 // without a conversation revision and must not force body hydration or self-wake retries.
                 return { cached, pending: cached.value.map(membership => {
                         const catchLease = freshWatchLease(facts, membership.seat.participant);
-                        return { ...membership, notifications: eligibleNotifications(facts, membership),
+                        return { ...membership, ...eligibleNotifications(facts, membership),
                             ...(catchLease === undefined ? {} : { catchLease }) };
                     }) };
             }, signal);
@@ -184,7 +195,7 @@ export function nativePendingPreview(facts, input) {
     if (!head || (lease !== undefined && leaseOwnsNotification(lease, head)))
         return undefined;
     const item = facts.activity(input.actIndex);
-    if (item?.kind !== 'say')
+    if (item?.kind !== 'say' || deliveryDeferralExpiry(facts, seat, input.actIndex, input.now) !== undefined)
         return undefined;
     return { payload: renderSquareReminder([renderAttentionPreview({ squarePath: input.location, recipient: input.participant, actIndex: item.index,
                 actor: item.actor, route: head.route, body: item.body ?? '(structured activity)' })]), clipped: attentionBodyIsClipped(item.body ?? '(structured activity)') };
@@ -322,7 +333,7 @@ export async function observeSessionPending(identity, suppliedEnv = process.env)
                         return [];
                     // Eligibility may change at lease expiry without any storage write.
                     const leaseExpiry = Math.min(Infinity, ...inbox.flatMap((membership) => membership.catchLease === undefined ? [] : [Math.min(membership.catchLease.expiresAt, membership.catchLease.heartbeatAt + WATCH_STALE_MS + 1)]));
-                    const nextExpiry = leaseExpiry;
+                    const nextExpiry = Math.min(leaseExpiry, ...inbox.map(membership => membership.deliveryDeferralExpiry ?? Infinity));
                     const duration = Math.min(remaining, Math.max(1, nextExpiry - Date.now()));
                     const cancelled = new AbortController();
                     const waitSignal = AbortSignal.any([signal, cancelled.signal]);

package/dist/mcp.js

@@ -44,9 +44,6 @@ export function createSquareMcpServer(options) {
                                 : baseEnv;
                     square = await Square.at({
                         ...options, env, body, cwd: claude?.cwd ?? options.cwd,
-                        // A call-local Codex thread uses its native queue even when managed by Paseo.
-                        wakeAddress: claude === undefined && typeof threadId === 'string' && threadId.trim()
-                            ? { kind: 'codex-queue', address: { threadId } } : options.wakeAddress,
                         path: location ?? options.path,
                         participant: participant ?? options.participant,
                         // The server owner is bound to its configured square; overrides close after each call.

package/dist/model.d.ts

@@ -119,6 +119,7 @@ export interface LocatedSeat {
 export interface PendingMembership extends LocatedSeat {
     readonly notifications: InboxNotification[];
     readonly catchLease?: WatchLease;
+    readonly deliveryDeferralExpiry?: number;
 }
 export interface WatchOptions {
     id?: ActivityId;

package/dist/operation-presentation.js

@@ -293,10 +293,6 @@ export function renderStatusResult(squarePath, data) {
     const output = [
         style('dim', counts),
         ...(hold === undefined ? [] : ['', hold]), '', style('dim', 'around the square'), ...people, '', style('dim', 'latest'), ...latest,
-        ...(data.listening === undefined ? [] : [
-            '', style('dim', 'you listen to'),
-            ...(data.listening.length === 0 ? ['  ○ not turned toward anyone'] : data.listening.map((name) => `  · ${participantIdentity(name)}`)),
-        ]),
     ].join('\n');
     return withPathOutput(squarePath, output, { participantCount: presentation.standingCount, held: presentation.held });
 }

package/dist/ports.d.ts

@@ -1,4 +1,5 @@
 import type { Act, ActivityId, Body, HardCap, Seat, StoredAct, WakeAddress, WakeRoute, WatchLease } from './model.js';
+import type { MetadataMatch, DeliveryDeferralFact } from './delivery-deferral.js';
 export type ActivityIndex = number;
 export interface SquareHeader {
     readonly revision: number;
@@ -145,7 +146,7 @@ export type DeliveryClaimResult = {
     readonly claimToken: string;
     readonly attemptN: number;
 } | {
-    readonly status: 'busy' | 'terminal' | 'stale';
+    readonly status: 'busy' | 'terminal' | 'stale' | 'deferred';
     readonly evidence?: DeliveryEvidence;
 };
 export interface DeliveryPreparation {
@@ -211,6 +212,7 @@ export interface SquareRead {
     receiptFacts(requestedName: string, afterIndex: number): ReceiptFacts;
     receiptAssignments(): readonly ReceiptAssignment[];
     lease(requestedName: string): WatchLease | undefined;
+    deliveryDeferrals(participant: string, generation: ActivityId): readonly DeliveryDeferralFact[];
 }
 export interface SquareWrite extends SquareRead {
     land(activity: Act & {
@@ -229,6 +231,9 @@ export interface SquareWrite extends SquareRead {
     markSeen(requestedName: string, indexes: readonly ActivityIndex[], at: number): number;
     putLease(requestedName: string, lease: WatchLease, generation?: ActivityId): boolean;
     removeLease(requestedName: string, expectedLeaseId: string, generation?: ActivityId): boolean;
+    putDeliveryDeferral(seat: SeatRef, id: string, match: MetadataMatch, expiresAt: number, now: number): boolean;
+    renewDeliveryDeferral(seat: SeatRef, id: string, expiresAt: number, now: number): boolean;
+    releaseDeliveryDeferral(seat: SeatRef, id: string, now: number): boolean;
 }
 export interface SquareReadResult<R> {
     readonly value: R;
@@ -242,6 +247,9 @@ export interface SquareArtifactPort {
     read<R>(select: (facts: SquareRead) => R, signal?: AbortSignal): Promise<SquareReadResult<R>>;
     /** Participant/domain writes must carry an explicit authority; no body-less mutation path exists. */
     transactAs<R>(authority: ArtifactWriteAuthority, change: (facts: SquareWrite) => R, signal?: AbortSignal): Promise<SquareCommitResult<R>>;
+    /** Bounded cleanup/evidence settlement on this same connection after custody was acquired.
+     * Independent of request/lifetime cancellation; explicit close and authority fences still apply. */
+    settleAs<R>(authority: ArtifactWriteAuthority, change: (facts: SquareWrite) => R): Promise<SquareCommitResult<R>>;
     revision(signal?: AbortSignal): Promise<number>;
     deliveryRevision(signal?: AbortSignal): Promise<number>;
     claimDelivery(input: DeliveryClaimInput, signal?: AbortSignal): Promise<DeliveryClaimResult>;
@@ -349,10 +357,10 @@ export interface PresentPendingInput {
     readonly generation?: ActivityId;
     readonly now?: number;
     readonly timeoutMs?: number;
-    /** One hook deadline propagated into artifact reads/transitions so busy retries stay bounded. */
+    /** Pre-effect work control only; successful sink evidence settles independently, with a bounded lifetime. */
     readonly signal?: AbortSignal;
     /** Boundary previews that were clipped remain pending for a later full presentation. */
     readonly markSeen?: boolean;
-    /** Receiver-specific fences checked inside the artifact observation transaction. */
+    /** Receiver-specific pre-effect eligibility, never a veto of an already successful sink. */
     readonly current?: (facts: SquareRead) => boolean;
 }

package/dist/presentation-operations.d.ts

@@ -1,3 +1,22 @@
 import type { PresentationResult, PresentPendingInput } from './ports.js';
-/** Presentation is external; its claim and receipt/evidence commit are generation-fenced in the artifact. */
+/** Prepare custody before any external effect. A batch prepares every included item first. */
+export declare function preparePendingPresentation(input: Omit<PresentPendingInput, 'sink'>): Promise<{
+    activity: {
+        kind: "say";
+        actor: import("./square-core.js").Participant;
+        at?: number;
+        body?: string;
+        metadata?: import("./model.js").ActivityMetadata;
+        mentions?: readonly import("./square-core.js").Participant[];
+        reach?: import("./square-core.js").Reach;
+        reply?: number;
+    } & {
+        index: number;
+        at: number;
+    };
+    eligible(): Promise<boolean>;
+    release(outcome?: "released" | "failed", message?: string): Promise<void>;
+    recordPresented(): Promise<PresentationResult>;
+} | undefined>;
+/** Eligibility precedes the sink; only captured ownership fences its truthful completion. */
 export declare function presentPending(input: PresentPendingInput): Promise<PresentationResult>;