@astrosheep/square 0.3.94 → 0.3.96

package/dist/notifications.js

@@ -32,6 +32,8 @@ export async function createDefaultWakeTransport(env = process.env, suppliedTran
     }
     const { createClaudeWakeTransport } = await import('./claude-delivery.js');
     transports['claude-native'] = createClaudeWakeTransport(env);
+    const { HttpWakeTransport } = await import('./http-delivery.js');
+    transports.http = new HttpWakeTransport({ env });
     return createWakeTransport(transports);
 }
 /** Route selection only: all implementations receive the same request and final gate. */

package/dist/operation-presentation.d.ts

@@ -24,8 +24,7 @@ export declare function renderStatusResult(squarePath: string, data: StatusResul
 export declare function renderListeningResult(squarePath: string, data: ListeningResult): string | undefined;
 export type ListenerVerb = 'listen' | 'ignore' | 'unlisten';
 export declare function renderListenerChange(squarePath: string, verb: ListenerVerb, data: ListenerChangeResult): string | undefined;
-export type LifecycleVerb = 'hold' | 'resume' | 'done';
-export declare function renderLifecycleResult(squarePath: string, verb: LifecycleVerb, data: LifecycleResult): string | undefined;
+export declare function renderLifecycleResult(squarePath: string, data: LifecycleResult): string | undefined;
 /** The refusal facts a transport has after normalizing a failure, without the live error. */
 export interface FailureReport {
     readonly code: string;

package/dist/operation-presentation.js

@@ -2,7 +2,7 @@
 // render through these functions, so a person sees the same square either way.
 import { sameName } from './model.js';
 import { formatActivityId } from './square-core.js';
-import { commandPrefix, joinRecoveryCommand, participantCommandPrefix, participantIdentity, participantsRecoveryCommand, quoteShell, renderAmbientEvent, renderAmbientEventFacts, renderEventCli, renderGrepActivitiesView, renderPresenceAnchor, renderRoomChangeText, renderWatchAlreadyActive, renderWatchReplaced, renderWatchStatus, takeoverRecoveryLines, withPathOutput, } from './presentation.js';
+import { commandPrefix, joinRecoveryCommand, participantCommandPrefix, participantIdentity, participantsRecoveryCommand, quoteShell, renderAmbientEvent, renderAmbientEventFacts, renderEventCli, renderGrepActivitiesView, renderPresenceAnchor, renderWatchAlreadyActive, renderWatchReplaced, renderWatchStatus, takeoverRecoveryLines, withPathOutput, } from './presentation.js';
 import { formatRelativeTime, formatTimestamp } from './time.js';
 import { style } from './tty-style.js';
 export const PARTICIPANTS_DEFAULT_LIMIT = 20;
@@ -34,7 +34,7 @@ export function renderJoinResult(data, owner) {
         ...(after.enrichmentUnavailable ? ['  · joined; recent activity and context are unavailable right now'] : []),
         ...(isRejoin || activities === '' ? [] : ['', style('dim', 'recent activity'), activities]),
         ...fallback,
-    ].join('\n'), { participantCount: after.standingCount, held: after.held });
+    ].join('\n'), { participantCount: after.standingCount });
 }
 function isGestureOnly(body) {
     return /\*[^*]*\*/.test(body) && body.replace(/\*[^*]*\*/g, '').trim() === '';
@@ -63,7 +63,7 @@ export function renderExpression(squarePath, data, owner) {
         : `\n○ ${participantIdentity(data.replyAuthorNotHere)} isn't in the square right now — the reply landed without reaching them`;
     const unmatchedNotice = data.unmatchedMentions?.length
         ? `\n  · ${data.unmatchedMentions.map((token) => `@${token} isn't standing here`).join('; ')} — ${activity.mentions.length === 0 && activity.reply === undefined ? 'activity landed bare' : 'left as literal text'}` : '';
-    return withPathOutput(projection.location ?? squarePath, confirmation + (data.hint ? `\n${style('dim', `· ${data.hint}`)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount, held: projection.held });
+    return withPathOutput(projection.location ?? squarePath, confirmation + (data.hint ? `\n${style('dim', `· ${data.hint}`)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount });
 }
 function continuationCommand(squarePath, name, options, owner) {
     const args = ['--now'];
@@ -83,7 +83,7 @@ export function renderCatchOutcome(squarePath, data, options = {}, owner) {
     const location = projection.location ?? squarePath;
     const name = projection.participant;
     const stop = data.reason === 'drained' && data.activities.length > 0 ? undefined : data.reason;
-    const header = { participantCount: projection.standingCount, held: projection.held };
+    const header = { participantCount: projection.standingCount };
     const statusOptions = {
         squarePath: location, name, owner, presence: projection.presence,
         showCatchHint: !projection.deliveryAvailable,
@@ -256,11 +256,6 @@ export function renderStatusResult(squarePath, data) {
         }
     }
     const cap = data.hardCap === null ? 'unlimited' : `${data.hardCap} each`;
-    const held = data.held;
-    const holdTime = held?.at === undefined ? 'just now' : formatRelativeTime(held.at, data.now);
-    const hold = held !== null
-        ? `· ${held.by === undefined ? 'someone' : participantIdentity(held.by)} raised a hand${held.reason ? ` — ${held.reason}` : ''}${style('dim', ` · ${holdTime}`)}`
-        : undefined;
     const visible = data.latestActivity === undefined
         ? { text: '', bodyClipped: false }
         : renderAmbientEventFacts(data.latestActivity, presentation.viewer, {
@@ -293,13 +288,13 @@ export function renderStatusResult(squarePath, data) {
     ].join(' · ');
     const output = [
         style('dim', counts),
-        ...(hold === undefined ? [] : ['', hold]), '', style('dim', 'around the square'), ...people, '', style('dim', 'latest'), ...latest,
+        '', 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: data.held !== null });
+    return withPathOutput(squarePath, output, { participantCount: presentation.standingCount });
 }
 export function renderListeningResult(squarePath, data) {
     const projection = data.observation;
@@ -308,7 +303,7 @@ export function renderListeningResult(squarePath, data) {
     const body = data.listening.length === 0
         ? `○ ${participantIdentity(projection.participant)} is not turned toward anyone`
         : ['listening', ...data.listening.map((target) => `  · ${participantIdentity(target)}`)].join('\n');
-    return withPathOutput(squarePath, body, { participantCount: projection.standingCount, held: projection.held });
+    return withPathOutput(squarePath, body, { participantCount: projection.standingCount });
 }
 export function renderListenerChange(squarePath, verb, data) {
     const projection = data.observation;
@@ -324,19 +319,16 @@ export function renderListenerChange(squarePath, verb, data) {
             : verb === 'ignore' ? `${actor} already ignores ${target} — only bells will reach you from them`
                 : `${actor} is not listening to ${target}`;
     return withPathOutput(squarePath, `${data.activity === null ? '○' : '·'} ${action}`, {
-        participantCount: projection.standingCount, held: projection.held,
+        participantCount: projection.standingCount,
     });
 }
-export function renderLifecycleResult(squarePath, verb, data) {
+export function renderLifecycleResult(squarePath, data) {
     const projection = data.observation;
     if (projection === undefined)
         return undefined;
-    const header = { participantCount: projection.standingCount, held: projection.held };
-    if (verb === 'done') {
-        return withPathOutput(projection.location ?? squarePath, `○ you stepped out — your footsteps fade · ${data.activity.id}`, header);
-    }
-    const line = `${renderRoomChangeText(data.activity)} · ${data.activity.id} · just now`;
-    return withPathOutput(projection.location ?? squarePath, verb === 'hold' ? `· ${line}` : `✓ ${line}`, header);
+    return withPathOutput(projection.location ?? squarePath, `○ you stepped out — your footsteps fade · ${data.activity.id}`, {
+        participantCount: projection.standingCount,
+    });
 }
 /** Refusal lines with the same recovery commands the CLI prints. */
 export function renderFailureLines(failure, options = {}) {

package/dist/ports.d.ts

@@ -1,4 +1,5 @@
 import type { Act, ActivityId, Owner, HardCap, Seat, StoredAct, WakeAddress, WakeRoute, WatchLease } from './model.js';
+import type { AttemptOutcome } from './delivery-attempts.js';
 import type { MetadataMatch, DeliveryDeferralFact } from './delivery-deferral.js';
 export type ActivityIndex = number;
 export interface SquareHeader {
@@ -35,7 +36,7 @@ export interface ActivityHead {
     readonly index: ActivityIndex;
     readonly at: number;
     readonly kind: StoredAct['kind'];
-    readonly actor?: string;
+    readonly actor: string;
     readonly reach?: 'bell';
     readonly reply?: ActivityIndex;
 }
@@ -47,7 +48,6 @@ export interface ActivityFilter {
     readonly kinds?: readonly StoredAct['kind'][];
     readonly actors?: readonly string[];
     readonly actorMatch?: 'identity' | 'exact';
-    readonly actorRequired?: true;
     readonly afterAt?: number;
 }
 export interface IndexPage {
@@ -71,12 +71,9 @@ export interface DirectedHead {
     readonly at: number;
     readonly actor: string;
     readonly recipient: string;
-    readonly route: 'mention' | 'reply' | 'attention' | 'bell';
-}
-export interface LandedRecipient {
-    readonly recipient: string;
-    readonly route: DirectedHead['route'];
+    readonly route: import('./attention.js').AudienceRoute;
 }
+export type LandedRecipient = import('./attention.js').AudienceRecipient;
 export interface ReceiptFacts {
     readonly latestAt?: number;
     readonly latestActorActivityIndex?: number;
@@ -87,6 +84,9 @@ export interface ReceiptAssignment {
 }
 export type SeatRef = Pick<Seat, 'participant' | 'owner' | 'generation'>;
 export type ArtifactWriteAuthority = {
+    readonly kind: 'send';
+    readonly actor: string;
+} | {
     readonly kind: 'participant';
     readonly seat: SeatRef;
 } | {
@@ -109,7 +109,7 @@ export interface DeliveryEvidence {
     readonly generation: ActivityId;
     readonly activity: ActivityId;
     readonly kind: 'wake' | 'presentation';
-    readonly outcome: 'dispatching' | 'accepted' | 'failed' | 'unknown' | 'released' | 'presented' | 'clipped';
+    readonly outcome: AttemptOutcome;
     readonly attemptN: number;
     readonly at: number;
     readonly expiresAt?: number;
@@ -178,12 +178,6 @@ export interface SquareRead {
     roster(): readonly ParticipantFact[];
     attention(listener: string): readonly AttentionFact[];
     incomingAttention(sender: string): readonly AttentionFact[];
-    hold(): {
-        readonly active: boolean;
-        readonly at?: number;
-        readonly reason?: string;
-        readonly actor?: string;
-    };
     activity(index: ActivityIndex): StoredAct | undefined;
     activityHeads(filter: ActivityFilter, page: IndexPage): FactPage<ActivityHead>;
     activities(indexes: readonly ActivityIndex[]): readonly StoredAct[];

package/dist/presentation-operations.d.ts

@@ -1,22 +1,18 @@
 import type { PresentationResult, PresentPendingInput } from './ports.js';
 /** 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 preparePendingPresentation(input: Omit<PresentPendingInput, 'sink'>): Promise<import("./delivery-effects.js").PreparedPresentation<{
+    kind: "say";
+    actor: import("./square-core.js").Participant;
+    at?: number;
+    body?: string;
+    metadata?: import("./model.js").ActivityMetadata;
+    delivery?: import("./model.js").ActivityDelivery;
+    mentions?: readonly import("./square-core.js").Participant[];
+    reach?: import("./square-core.js").Reach;
+    reply?: number;
+} & {
+    index: number;
+    at: number;
+}> | undefined>;
+/** Square sinks explicitly classify rejection as failed; the public effect core defaults to unknown. */
 export declare function presentPending(input: PresentPendingInput): Promise<PresentationResult>;

package/dist/presentation-operations.js

@@ -4,6 +4,7 @@ import { isSquareError } from './model.js';
 import { pendingHead, sameJoin } from './delivery.js';
 import { deliveryDeferralExpiry } from './delivery-deferral.js';
 import { asSeatRef } from './seats.js';
+import { preparePresentation, presentPrepared } from './delivery-effects.js';
 /** Prepare custody before any external effect. A batch prepares every included item first. */
 export async function preparePendingPresentation(input) {
     const index = typeof input.activity === 'number' ? input.activity : parseActivityId(input.activity);
@@ -30,67 +31,56 @@ export async function preparePendingPresentation(input) {
             && sameJoin(facts, participant);
     };
     const claimToken = randomUUID();
-    const claimed = await input.artifact.claimDelivery({ seat: ref, activity: formatActivityId(index), kind: 'presentation',
-        at: input.now ?? Date.now(), leaseMs: input.timeoutMs ?? 5000, claimToken }, input.signal).catch(() => ({ status: 'stale' }));
-    if (claimed.status !== 'acquired')
-        return undefined;
-    let effectObserved = false, released = false;
-    return {
-        activity: item,
-        async eligible() {
-            return (await input.artifact.read(facts => owns(facts) && input.current?.(facts) !== false
-                && pendingHead(facts, participant.name, index) !== undefined
-                && deliveryDeferralExpiry(facts, seat, index, input.now ?? Date.now()) === undefined, input.signal).catch(() => undefined))?.value === true;
-        },
-        async release(outcome = 'released', message) {
-            if (effectObserved || released)
-                return;
-            released = true;
-            await input.artifact.settleAs({ kind: 'participant', seat: ref }, facts => facts.completeDelivery({
-                seat: ref, activity: formatActivityId(index), claimToken, outcome, at: Date.now(),
-                ...(message === undefined ? {} : { message }),
-            })).catch(() => false);
+    return preparePresentation({
+        payload: item, coverage: input.markSeen === false ? 'clipped' : 'full',
+        port: {
+            async claim(signal) {
+                const claimed = await input.artifact.claimDelivery({ seat: ref, activity: formatActivityId(index), kind: 'presentation',
+                    at: input.now ?? Date.now(), leaseMs: input.timeoutMs ?? 5000, claimToken }, signal).catch(() => ({ status: 'stale' }));
+                return claimed.status === 'acquired' ? { token: claimToken, ordinal: claimed.attemptN } : undefined;
+            },
+            async current(signal) {
+                return (await input.artifact.read(facts => owns(facts) && input.current?.(facts) !== false
+                    && pendingHead(facts, participant.name, index) !== undefined
+                    && deliveryDeferralExpiry(facts, seat, index, input.now ?? Date.now()) === undefined, signal ?? input.signal)).value;
+            },
+            async settle(claim, completion) {
+                const success = completion.outcome === 'presented' || completion.outcome === 'clipped';
+                const { value } = await input.artifact.settleAs({ kind: 'participant', seat: ref }, facts => {
+                    // Captured ownership fences truth; post-effect policy/cancellation cannot veto it.
+                    if (!owns(facts))
+                        return false;
+                    if (!facts.completeDelivery({ seat: ref, activity: formatActivityId(index), claimToken: claim.token,
+                        outcome: completion.outcome, at: success ? input.now ?? Date.now() : Date.now(),
+                        ...(completion.reason === 'threw' ? { message: completion.error instanceof Error ? completion.error.message : String(completion.error) } : {}),
+                    }))
+                        return false;
+                    if (completion.outcome === 'presented')
+                        facts.markSeen(participant.name, [index], input.now ?? Date.now());
+                    return true;
+                }).catch(error => {
+                    if (!success || isSquareError(error) && error.code === 'already_joined')
+                        return { value: false };
+                    throw error;
+                });
+                return value;
+            },
         },
-        async recordPresented() {
-            // Success is an observed external fact, not another eligibility decision. Neither
-            // post-effect cancellation nor a new deferral can erase it and authorize replay.
-            effectObserved = true;
-            const outcome = input.markSeen === false ? 'clipped' : 'presented';
-            const { value: committed } = await input.artifact.settleAs({ kind: 'participant', seat: ref }, facts => {
-                if (!owns(facts))
-                    return false;
-                if (!facts.completeDelivery({ seat: ref, activity: formatActivityId(index), claimToken, outcome, at: input.now ?? Date.now() }))
-                    return false;
-                if (input.markSeen !== false)
-                    facts.markSeen(participant.name, [index], input.now ?? Date.now());
-                return true;
-            }).catch(error => {
-                if (isSquareError(error) && error.code === 'already_joined')
-                    return { value: false };
-                throw error;
-            });
-            return committed ? { presented: true, activity: item } : { presented: false };
-        },
-    };
+    }, { signal: input.signal });
 }
-/** Eligibility precedes the sink; only captured ownership fences its truthful completion. */
+/** Square sinks explicitly classify rejection as failed; the public effect core defaults to unknown. */
 export async function presentPending(input) {
     const prepared = await preparePendingPresentation(input);
     if (prepared === undefined)
         return { presented: false };
-    try {
-        if (!await prepared.eligible() || input.signal?.aborted)
-            return { presented: false };
-        try {
-            await input.sink.present(prepared.activity);
-        }
-        catch (error) {
-            await prepared.release('failed', error instanceof Error ? error.message : String(error));
-            throw error;
-        }
-        return await prepared.recordPresented();
-    }
-    finally {
-        await prepared.release();
-    }
+    const report = await presentPrepared(prepared, activity => input.sink.present(activity), {
+        signal: input.signal, classifyError: () => 'failed',
+    });
+    if (report.observation.kind === 'threw')
+        throw report.observation.error;
+    const result = report.settlements[0].result;
+    if (result.persistence.status === 'error')
+        throw result.persistence.error;
+    return report.observation.kind === 'returned' && result.persistence.status === 'recorded'
+        ? { presented: true, activity: prepared.payload } : { presented: false };
 }

package/dist/presentation.d.ts

@@ -5,7 +5,6 @@ import type { Activity, UnreadActivitySummary, ParticipantSummary } from './squa
 export type WatchStatus = 'idle' | 'drained' | 'quorum' | 'capped';
 interface HeaderOptions {
     participantCount?: number;
-    held?: boolean;
     /** Refusal bodies go to stderr, which stays literal even when it is a TTY. */
     plain?: boolean;
 }
@@ -14,7 +13,6 @@ interface ParticipantOutputOptions {
     squarePath: string;
     name: string;
     participantCount?: number;
-    held?: boolean;
 }
 interface ActivityLimitOptions extends ParticipantOutputOptions {
     count?: number;
@@ -27,17 +25,13 @@ interface ActivityBlockedOptions extends ParticipantOutputOptions {
     draftPath?: string;
 }
 interface ExpressWaitingOptions {
-    reason: 'throttled' | 'held';
+    reason: 'throttled';
     delayMs?: number;
-    holder?: string;
-    holdReason?: string;
 }
 interface ExpressNoWaitOptions extends ParticipantOutputOptions {
-    reason: 'throttled' | 'held';
+    reason: 'throttled';
     retryCommand: string;
     delayMs?: number;
-    holder?: string;
-    holdReason?: string;
     draftPath?: string;
 }
 interface WatchStatusOptions extends ParticipantOutputOptions {
@@ -56,7 +50,6 @@ export declare function withPathOutput(squarePath: string, body?: string, opts?:
 /** The same header/blank/body layout as withPathOutput, for refusal bodies written to stderr. */
 export declare function formatRefusal(squarePath: string, bodyLines: string[], opts?: {
     participantCount?: number;
-    held?: boolean;
 }): string;
 export declare function refusalText(error: unknown): string;
 export declare function quoteShell(value: string): string;

package/dist/presentation.js

@@ -4,7 +4,6 @@ import path from 'node:path';
 import { participantIdentity } from './participant-identity.js';
 export { participantIdentity } from './participant-identity.js';
 import { formatActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
-import { HELD_WAIT_BUDGET_MS } from './runtime.js';
 import { formatDuration, formatRelativeTime, formatTimestamp } from './time.js';
 import { grepSnippet } from './search.js';
 import { style } from './tty-style.js';
@@ -27,8 +26,7 @@ export function displayPath(squarePath, cwd = process.cwd()) {
 }
 export function withPathOutput(squarePath, body = '', opts = {}) {
     const count = opts.participantCount ?? 0;
-    const heldSuffix = opts.held ? ' — a hand is raised' : '';
-    const line = `· ${displayPath(squarePath)} — ${count} in the square${heldSuffix}`;
+    const line = `· ${displayPath(squarePath)} — ${count} in the square`;
     return [opts.plain === true ? line : style('dim', line), ...(body === '' ? [] : ['', body])].join('\n') + '\n';
 }
 /** The same header/blank/body layout as withPathOutput, for refusal bodies written to stderr. */
@@ -123,10 +121,6 @@ export function renderRoomChangeText(event) {
             return `${identity} stepped into the square`;
         case 'done':
             return `${identity} stepped out of the square`;
-        case 'hold':
-            return `${identity} raised a hand${event.body ? ` — ${event.body}` : ''}`;
-        case 'resume':
-            return `${identity} lowered the hand`;
         case 'listen':
             return `${identity} turned an ear toward ${participantIdentity(event.target ?? 'someone')}`;
         case 'ignore':
@@ -159,10 +153,6 @@ function renderEventCliFacts(event, opts = {}) {
     switch (event.kind) {
         case 'join':
             return { text: `· ${renderRoomChangeText(event)}`, bodyClipped: false };
-        case 'hold':
-            return { text: `· ${renderRoomChangeText(event)}`, bodyClipped: false };
-        case 'resume':
-            return { text: `${style('release', '✓')} ${renderRoomChangeText(event)}`, bodyClipped: false };
         case 'listen':
         case 'ignore':
         case 'unlisten':
@@ -254,7 +244,7 @@ export function renderActivityBlocked(opts) {
         `${readNowCommand}`,
         '  · take it in, then retry:',
         withDraftInput(opts.retryCommand, opts.draftPath),
-    ].join('\n'), { participantCount: opts.participantCount, held: opts.held });
+    ].join('\n'), { participantCount: opts.participantCount });
 }
 /** An indeterminate or already-committed send only points to inspection, never resend. */
 export function renderActivityUncertain(opts) {
@@ -268,47 +258,22 @@ export function renderActivityUncertain(opts) {
         `${commandPrefix(opts.squarePath)} history${opts.landedId === undefined ? ' --limit 10' : ` --at ${opts.landedId}`} --no-truncate`,
     ], opts);
 }
-/** A blank or whitespace hold reason is absent, never an empty sensory line. */
-function holdReasonLines(reason) {
-    const text = reason?.trim() ?? '';
-    return text === '' ? [] : [style('dim', `  · ${text}`)];
-}
-function heldMainLine(holder, styled) {
-    const glyph = styled ? style('blocked', '✕') : '·';
-    const who = holder === undefined ? 'a hand is raised' : `${participantIdentity(holder)} has a hand raised`;
-    return `${glyph} ${who} — voices drop, yours too`;
-}
 export function renderExpressWaiting(opts) {
-    if (opts.reason === 'throttled') {
-        return [
-            '· the square is packed — your activity is waiting',
-            `  · a lull opens in ${formatDuration(opts.delayMs)}`,
-            '  · --no-wait saves a draft and returns now',
-        ].join('\n');
-    }
     return [
-        heldMainLine(opts.holder, false),
-        ...holdReasonLines(opts.holdReason),
-        `  · your activity is waiting — after ${formatDuration(HELD_WAIT_BUDGET_MS)} it saves a draft and stops`,
+        '· the square is packed — your activity is waiting',
+        `  · a lull opens in ${formatDuration(opts.delayMs)}`,
         '  · --no-wait saves a draft and returns now',
     ].join('\n');
 }
 export function renderExpressNoWait(opts) {
     const retryCommand = opts.retryCommand;
-    const lines = opts.reason === 'throttled'
-        ? [
-            `${style('blocked', '✕')} the square is packed — shoulder to shoulder`,
-            `  · a lull opens in ${formatDuration(opts.delayMs)}`,
-            ...draftSavedLines(opts.draftPath),
-            `${withDraftInput(retryCommand, opts.draftPath)}`,
-        ]
-        : [
-            heldMainLine(opts.holder, true),
-            ...holdReasonLines(opts.holdReason),
-            ...draftSavedLines(opts.draftPath),
-            `${withDraftInput(retryCommand, opts.draftPath)}`,
-        ];
-    return withPathOutput(opts.squarePath, lines.join('\n'), { participantCount: opts.participantCount, held: opts.held });
+    const lines = [
+        `${style('blocked', '✕')} the square is packed — shoulder to shoulder`,
+        `  · a lull opens in ${formatDuration(opts.delayMs)}`,
+        ...draftSavedLines(opts.draftPath),
+        `${withDraftInput(retryCommand, opts.draftPath)}`,
+    ];
+    return withPathOutput(opts.squarePath, lines.join('\n'), { participantCount: opts.participantCount });
 }
 export function renderPresenceAnchor(names) {
     const visibleNames = names.slice(0, MAX_IDENTITY_SET_SIZE);
@@ -327,7 +292,7 @@ export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squa
     let truncated = false;
     for (const act of publicVisible) {
         const rawBody = act.body ?? '';
-        const header = `${style('dim', formatActivityId(act.index))} · ${act.actor === undefined ? 'unknown' : participantIdentity(act.actor)} · ${style('dim', formatTimestamp(act.at))}`;
+        const header = `${style('dim', formatActivityId(act.index))} · ${participantIdentity(act.actor)} · ${style('dim', formatTimestamp(act.at))}`;
         if (perception?.(act) === 'presence') {
             chunks.push(header);
             continue;
@@ -369,7 +334,7 @@ export function renderActivityLimit(opts) {
         ...draftSavedLines(opts.draftPath),
         '  · your draft stays unsent; done only steps out',
         doneCommand,
-    ].join('\n'), { participantCount: opts.participantCount, held: opts.held });
+    ].join('\n'), { participantCount: opts.participantCount });
 }
 export function renderWatchAlreadyActive(opts) {
     return [

package/dist/receive.d.ts

@@ -0,0 +1,66 @@
+/** Synchronous capabilities borrowed from one caller-owned transaction. */
+export interface Item<K extends string | number, D> {
+    readonly key: K;
+    readonly data: D;
+}
+export interface Address<V> {
+    readonly recipient: string;
+    readonly via: V;
+}
+export interface ReceivedHead<K extends string | number, V> {
+    readonly key: K;
+    readonly via: V;
+}
+export interface ReceiptRef<K extends string | number> {
+    readonly recipient: string;
+    readonly item: K;
+}
+export type Selection<K extends string | number, Q> = {
+    readonly kind: 'page';
+    readonly query: Q;
+    readonly limit: number;
+} | {
+    readonly kind: 'exact';
+    readonly key: K;
+    readonly remainingQuery: Q;
+};
+export interface ReceiveRead<K extends string | number, D, V, Q> {
+    heads(recipient: string, query: Q, options: {
+        readonly unconsumed: boolean;
+        readonly limit: number;
+    }): readonly ReceivedHead<K, V>[];
+    addressed(recipient: string, item: K): ReceivedHead<K, V> | undefined;
+    load(keys: readonly K[]): ReadonlyMap<K, D>;
+    count(recipient: string, query: Q, unconsumed: boolean): number;
+    receipt(ref: ReceiptRef<K>): {
+        readonly at: number;
+    } | undefined;
+}
+export interface ReceiveWrite<K extends string | number, D, V, Q> extends ReceiveRead<K, D, V, Q> {
+    insertItem(item: Item<K, D>): void;
+    insertAddress(item: K, address: Address<V>, order: number): void;
+    /** True only for a new coordinate; an existing receipt retains its first timestamp. */
+    insertReceipt(ref: ReceiptRef<K>, at: number): boolean;
+}
+export declare class ReceiveError<K extends string | number = string | number> extends Error {
+    readonly code: 'not_addressed' | 'missing_item';
+    readonly key: K;
+    constructor(code: 'not_addressed' | 'missing_item', key: K);
+}
+/** Storage rejects duplicate items/addresses; the caller rolls back the whole admission. */
+export declare function receive<K extends string | number, D, V>(tx: Pick<ReceiveWrite<K, D, V, unknown>, 'insertItem' | 'insertAddress'>, input: {
+    readonly item: Item<K, D>;
+    readonly audience: readonly Address<V>[];
+}): void;
+/** Queries filter before limiting. Exact selection ignores consumption, not addressing. */
+export declare function selectReceivedHeads<K extends string | number, V, Q>(tx: Pick<ReceiveRead<K, unknown, V, Q>, 'heads' | 'addressed'>, recipient: string, selection: Selection<K, Q>): readonly ReceivedHead<K, V>[];
+/** Record captured coordinates without reselecting or checking their current eligibility. */
+export declare function recordConsumed<K extends string | number>(tx: Pick<ReceiveWrite<K, unknown, unknown, unknown>, 'insertReceipt'>, refs: readonly ReceiptRef<K>[], at: number): number;
+/** Selection, hydration, receipts and remaining count must share the caller's transaction. */
+export declare function consumeReceived<K extends string | number, D, V, Q>(tx: Pick<ReceiveWrite<K, D, V, Q>, 'heads' | 'addressed' | 'load' | 'insertReceipt' | 'count'>, recipient: string, selection: Selection<K, Q>, at: number): {
+    readonly items: readonly (Item<K, D> & {
+        readonly via: V;
+    })[];
+    readonly newlyConsumed: number;
+    readonly remaining: number;
+};

package/dist/receive.js

@@ -0,0 +1,54 @@
+export class ReceiveError extends Error {
+    code;
+    key;
+    constructor(code, key) {
+        super(`${code}: ${String(key)}`);
+        this.code = code;
+        this.key = key;
+        this.name = 'ReceiveError';
+    }
+}
+/** Storage rejects duplicate items/addresses; the caller rolls back the whole admission. */
+export function receive(tx, input) {
+    tx.insertItem(input.item);
+    input.audience.forEach((address, order) => tx.insertAddress(input.item.key, address, order));
+}
+/** Queries filter before limiting. Exact selection ignores consumption, not addressing. */
+export function selectReceivedHeads(tx, recipient, selection) {
+    if (selection.kind === 'page') {
+        if (typeof selection.limit !== 'number')
+            throw new TypeError('Receive limit must be a number.');
+        if (!Number.isSafeInteger(selection.limit) || selection.limit < 1)
+            throw new RangeError('Receive limit must be a positive safe integer.');
+        return tx.heads(recipient, selection.query, { unconsumed: true, limit: selection.limit });
+    }
+    const head = tx.addressed(recipient, selection.key);
+    if (head === undefined)
+        throw new ReceiveError('not_addressed', selection.key);
+    return [head];
+}
+/** Record captured coordinates without reselecting or checking their current eligibility. */
+export function recordConsumed(tx, refs, at) {
+    if (typeof at !== 'number')
+        throw new TypeError('Receipt time must be a number.');
+    if (!Number.isFinite(at))
+        throw new RangeError('Receipt time must be finite.');
+    let count = 0;
+    for (const ref of refs)
+        if (tx.insertReceipt(ref, at))
+            count++;
+    return count;
+}
+/** Selection, hydration, receipts and remaining count must share the caller's transaction. */
+export function consumeReceived(tx, recipient, selection, at) {
+    const heads = selectReceivedHeads(tx, recipient, selection);
+    const data = tx.load(heads.map(head => head.key));
+    const items = heads.map(head => {
+        if (!data.has(head.key))
+            throw new ReceiveError('missing_item', head.key);
+        return { key: head.key, data: data.get(head.key), via: head.via };
+    });
+    const newlyConsumed = recordConsumed(tx, heads.map(head => ({ recipient, item: head.key })), at);
+    const remaining = tx.count(recipient, selection.kind === 'page' ? selection.query : selection.remainingQuery, true);
+    return { items, newlyConsumed, remaining };
+}