@astrosheep/square 0.3.24 → 0.3.26

package/claude-plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.24",
+  "version": "0.3.26",
   "description": "Native Claude Code turn-boundary delivery for Square participants",
   "author": {
     "name": "Square"

package/codex-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.24",
+  "version": "0.3.26",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/dist/activity-feed.d.ts

@@ -5,10 +5,10 @@ export interface ActivityFeedFilter {
 }
 export declare function actDelta(acts: StoredAct[], cursor: number): StoredAct[];
 /** Visible activities after the participant's derived continuous-seen prefix. */
-export declare function deliveryDelta(squareState: SquareState, name: string): StoredAct[];
+export declare function deliveryDelta(squareState: SquareState, name: string, delivery?: import("./delivery.js").DeliveryModel): StoredAct[];
 export declare function peerRoomChanges(delta: StoredAct[], name: string): RoomChangeAct[];
 export declare function peerPublicActs(delta: StoredAct[], name: string): PublicAct[];
-export declare function directedPeerSays(squareState: SquareState, delta: StoredAct[], name: string): Extract<StoredAct, {
+export declare function directedPeerSays(squareState: SquareState, delta: StoredAct[], name: string, delivery?: import("./delivery.js").DeliveryModel): Extract<StoredAct, {
     kind: 'say';
 }>[];
 export declare function matchesFeedFilter(act: StoredAct, filter: ActivityFeedFilter, recipients?: readonly string[]): boolean;

package/dist/activity-feed.js

@@ -1,13 +1,11 @@
 import { sameName } from './model.js';
-import { landedAudienceIncludes } from './square-core.js';
-import { readCursor } from './runtime.js';
-import { matchesCatchFilter } from './delivery.js';
+import { deriveDeliveryModel, matchesCatchFilter } from './delivery.js';
 export function actDelta(acts, cursor) {
     return acts.filter((act) => act.index > cursor);
 }
 /** Visible activities after the participant's derived continuous-seen prefix. */
-export function deliveryDelta(squareState, name) {
-    return actDelta(squareState.acts, readCursor(squareState, name));
+export function deliveryDelta(squareState, name, delivery = deriveDeliveryModel(squareState)) {
+    return actDelta(squareState.acts, delivery.cursorFor(name));
 }
 export function peerRoomChanges(delta, name) {
     return delta.filter((act) => act.actor !== undefined && !sameName(act.actor, name) && act.kind !== 'say' && act.kind !== 'read');
@@ -15,8 +13,8 @@ export function peerRoomChanges(delta, name) {
 export function peerPublicActs(delta, name) {
     return delta.filter((act) => act.actor !== undefined && !sameName(act.actor, name) && (act.kind === 'say' || act.kind === 'done'));
 }
-export function directedPeerSays(squareState, delta, name) {
-    return delta.filter((act) => landedAudienceIncludes(squareState.acts, act, name));
+export function directedPeerSays(squareState, delta, name, delivery = deriveDeliveryModel(squareState)) {
+    return delta.filter((act) => delivery.directedTo(act, name));
 }
 function matchesParticipants(act, participants) {
     return participants === undefined || (act.actor !== undefined && participants.some((participant) => sameName(participant, act.actor)));

package/dist/cli/observation-commands.js

@@ -13,6 +13,7 @@ import { openSquare } from '../square-file-adapter.js';
 import { closeOpenSquare } from '../open-square.js';
 import { historyPresentation, participantsPresentation, statusPresentation } from '../views.js';
 import { fail, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdinSync, requireParticipant, requireSquarePath, requireValue, usage, } from './context.js';
+const STATUS_PARTICIPANT_PREVIEW_LIMIT = 10;
 export const listCommand = {
     parse: (argv) => argv,
     async execute(argv, context) {
@@ -95,8 +96,9 @@ export const catchCommand = {
     },
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        await cmdWatch(squarePath, requireParticipant(context.name), intent);
-        await sweepPendingNotifications(squarePath);
+        const caught = await cmdWatch(squarePath, requireParticipant(context.name), intent);
+        if (caught !== false)
+            await sweepPendingNotifications(squarePath);
     },
     present: () => { },
 };
@@ -382,7 +384,7 @@ export const statusCommand = {
                     return aViewer ? -1 : 1;
                 return (b.lastActiveAt ?? -Infinity) - (a.lastActiveAt ?? -Infinity) || a.name.localeCompare(b.name);
             });
-            const people = active.length === 0 ? ['  ○ nobody in the square'] : active.map((participant) => {
+            const people = active.length === 0 ? ['  ○ nobody in the square'] : active.slice(0, STATUS_PARTICIPANT_PREVIEW_LIMIT).map((participant) => {
                 const glyph = participant.presence === 'watching'
                     ? '◎'
                     : participant.activityCount > 0 ? '●' : '○';
@@ -401,6 +403,10 @@ export const statusCommand = {
                             : 'caught up';
                 return `  ${glyph} ${participantIdentity(participant.name)} · ${summary}${attention === '' ? '' : ` · ${attention}`}`;
             });
+            if (active.length > STATUS_PARTICIPANT_PREVIEW_LIMIT) {
+                people.push(`  ○ … ${active.length - STATUS_PARTICIPANT_PREVIEW_LIMIT} more participants`);
+                people.push(`» ${commandPrefix(squarePath)} participants`);
+            }
             const cap = result.hardCap === null ? 'unlimited' : String(result.hardCap);
             const hold = result.holdActive
                 ? `· ${result.holdActor === undefined ? 'someone' : participantIdentity(result.holdActor)} raised a hand${result.holdReason ? ` — ${result.holdReason}` : ''} · ${result.holdAt === undefined

package/dist/decisions.d.ts

@@ -1,6 +1,7 @@
 import { type ActivitiesOptions, type Act, type StoredAct, type SquareState, type Reach, type HardCap } from './model.js';
 import { directedPeerSays, peerRoomChanges } from './activity-feed.js';
 import { type Perception } from './square-core.js';
+import { type DeliveryModel } from './delivery.js';
 export interface UnreadActivitySummary {
     name: string;
     count: number;
@@ -106,6 +107,6 @@ export interface StatusResult {
     latestAct: StoredAct | undefined;
     now: number;
 }
-export declare function coreStatus(squareState: SquareState, now: number): StatusResult;
-export declare function coreParticipants(squareState: SquareState, now: number): ParticipantStatus[];
-export declare function coreActivities(squareState: SquareState, opts: ActivitiesOptions): StoredAct[];
+export declare function coreStatus(squareState: SquareState, now: number, delivery?: DeliveryModel): StatusResult;
+export declare function coreParticipants(squareState: SquareState, now: number, delivery?: DeliveryModel): ParticipantStatus[];
+export declare function coreActivities(squareState: SquareState, opts: ActivitiesOptions, suppliedDelivery?: DeliveryModel): StoredAct[];

package/dist/decisions.js

@@ -1,9 +1,9 @@
 import { SquareError, sameName, validateName, } from './model.js';
 import { participantIdentity } from './participant-identity.js';
-import { UNREAD_BLOCK_GRACE_MS, actId, actStableIndex, foldedState, freshWatchLease, publicActs, readCursor, resolveRosterName, rosterNames, THROTTLE_WINDOW_MS, } from './runtime.js';
+import { UNREAD_BLOCK_GRACE_MS, actId, actStableIndex, foldedState, freshWatchLease, publicActs, resolveRosterName, rosterNames, THROTTLE_WINDOW_MS, } from './runtime.js';
 import { actDelta, directedPeerSays } from './activity-feed.js';
 import { formatActivityId, isIgnored, isListening, listeningTo, validate } from './square-core.js';
-import { deriveDeliveryModel, perceiveActivity } from './delivery.js';
+import { deriveDeliveryModel } from './delivery.js';
 import { compileSearchPattern } from './search.js';
 export function resolveKnownName(squareState, name) {
     validateName(name);
@@ -100,8 +100,9 @@ export function decideAct(squareState, input) {
         if (result.reason === 'not_joined')
             throw new SquareError('not_joined', `${name} has not joined this square`);
     }
-    const delta = actDelta(squareState.acts, readCursor(squareState, name));
-    const unreadPublic = directedPeerSays(squareState, delta, name);
+    const delivery = deriveDeliveryModel(squareState);
+    const delta = actDelta(squareState.acts, delivery.cursorFor(name));
+    const unreadPublic = directedPeerSays(squareState, delta, name, delivery);
     const unreadRoomChanges = [];
     const sayCountByActor = new Map();
     const unreadByParticipant = new Map();
@@ -119,7 +120,7 @@ export function decideAct(squareState, input) {
             latestAt: currentSummary === undefined ? item.at : Math.max(currentSummary.latestAt, item.at),
             previews: [
                 ...(currentSummary?.previews ?? []),
-                { number: sayCountByActor.get(actorKey) ?? 1, act: item, perception: perceiveActivity(squareState, item, name) },
+                { number: sayCountByActor.get(actorKey) ?? 1, act: item, perception: delivery.perceive(item, name) },
             ].slice(-UNREAD_PREVIEW_LIMIT),
         });
     }
@@ -189,10 +190,10 @@ export function coreResume(squareState, actor, now) {
     requireStanding(squareState, act);
     return act;
 }
-function presenceFor(squareState, snapshot, name, now) {
+function presenceFor(squareState, snapshot, name, now, delivery) {
     if (snapshot?.done)
         return { state: 'done', lastAt: snapshot.lastActiveAt };
-    const cursorAt = squareState.acts.findLast((act) => act.index <= readCursor(squareState, name))?.at;
+    const cursorAt = squareState.acts.findLast((act) => act.index <= delivery.cursorFor(name))?.at;
     const lease = freshWatchLease(squareState, name, now);
     if (lease !== undefined)
         return { state: 'watching', lastAt: cursorAt ?? lease.heartbeatAt };
@@ -201,19 +202,19 @@ function presenceFor(squareState, snapshot, name, now) {
         ? { state: 'never-joined', lastAt: undefined }
         : { state: 'active', lastAt };
 }
-function buildParticipantStatuses(squareState, now, state = foldedState(squareState)) {
-    const delivery = deriveDeliveryModel(squareState);
+function buildParticipantStatuses(squareState, now, state = foldedState(squareState), suppliedDelivery) {
+    const delivery = suppliedDelivery ?? deriveDeliveryModel(squareState);
     return state.participants.map((snapshot) => {
         const participant = snapshot.name;
-        const presence = presenceFor(squareState, snapshot, participant, now);
+        const presence = presenceFor(squareState, snapshot, participant, now, delivery);
         const participantStatus = snapshot?.done ? 'done' : snapshot?.joined ? 'active' : 'not joined';
-        const consumedThrough = readCursor(squareState, participant);
+        const consumedThrough = delivery.cursorFor(participant);
         let unreadActivityCount = 0;
         if (snapshot?.joined) {
             for (const act of squareState.acts) {
                 if (actStableIndex(act) <= consumedThrough)
                     continue;
-                if (directedPeerSays(squareState, [act], participant).length > 0)
+                if (directedPeerSays(squareState, [act], participant, delivery).length > 0)
                     unreadActivityCount++;
             }
         }
@@ -230,7 +231,7 @@ function buildParticipantStatuses(squareState, now, state = foldedState(squareSt
         };
     });
 }
-export function coreStatus(squareState, now) {
+export function coreStatus(squareState, now, delivery) {
     const state = foldedState(squareState);
     const latestAct = publicActs(squareState.acts).at(-1);
     return {
@@ -242,19 +243,21 @@ export function coreStatus(squareState, now) {
         holdReason: state.hold.reason,
         holdActor: state.hold.actor,
         holdAt: state.hold.at,
-        participants: buildParticipantStatuses(squareState, now, state),
+        participants: buildParticipantStatuses(squareState, now, state, delivery),
         latestAct,
         now,
     };
 }
-export function coreParticipants(squareState, now) {
-    return buildParticipantStatuses(squareState, now);
+export function coreParticipants(squareState, now, delivery) {
+    return buildParticipantStatuses(squareState, now, undefined, delivery);
 }
-export function coreActivities(squareState, opts) {
+export function coreActivities(squareState, opts, suppliedDelivery) {
     const participants = opts.participants ?? [];
     const canonicalParticipants = participants.map((participant) => resolveKnownName(squareState, participant));
     const viewer = opts.viewer !== undefined ? resolveKnownName(squareState, opts.viewer) : undefined;
     let acts = [...squareState.acts];
+    let delivery = suppliedDelivery;
+    const projected = () => delivery ??= deriveDeliveryModel(squareState);
     // --at establishes one or more context windows first; other filters AND inside their union.
     if (opts.atIndexes !== undefined && opts.atIndexes.length > 0) {
         const before = opts.beforeContext ?? 0;
@@ -280,13 +283,12 @@ export function coreActivities(squareState, opts) {
         acts = acts.filter((act) => act.at > opts.after);
     if (opts.mention != null) {
         const mention = resolveKnownName(squareState, opts.mention);
-        const delivery = deriveDeliveryModel(squareState);
-        acts = acts.filter((act) => act.kind === 'say' && delivery.plan(act).some((item) => sameName(item.recipient, mention)));
+        acts = acts.filter((act) => act.kind === 'say' && projected().plan(act).some((item) => sameName(item.recipient, mention)));
     }
     if (opts.pending) {
         if (viewer === undefined)
             return [];
-        const pendingIndexes = new Set(deriveDeliveryModel(squareState).pendingFor(viewer).map((notification) => notification.item.index));
+        const pendingIndexes = new Set(projected().pendingFor(viewer).map((notification) => notification.item.index));
         acts = acts.filter((act) => pendingIndexes.has(act.index));
     }
     const search = opts.grep !== undefined ? { pattern: opts.grep, fixed: false } : opts.fixed !== undefined ? { pattern: opts.fixed, fixed: true } : undefined;

package/dist/delivery.d.ts

@@ -57,6 +57,14 @@ export interface CatchFilterShape {
 export interface DeliveryModel {
     plan(item: StoredAct): PlannedNotification[];
     pendingFor(recipient: string): PlannedNotification[];
+    directedTo(item: StoredAct, recipient: string): boolean;
+    perceive(item: StoredAct, viewer: string): Perception;
+    cursorFor(recipient: string): number;
+    isSeen(recipient: string, actOrIndex: StoredAct | number): boolean;
+    knownParticipant(name: string): string | undefined;
+    participants(): readonly string[];
+    joinedRecipients(): readonly string[];
+    readonly replayedActivityCount: number;
 }
 export declare function isActivitySeen(squareState: SquareState, name: string, actOrIndex: StoredAct | number): boolean;
 /**
@@ -64,10 +72,10 @@ export declare function isActivitySeen(squareState: SquareState, name: string, a
  * All consumers share these targets instead of reinterpreting artifact text or cursor state.
  */
 export declare function deriveDeliveryModel(squareState: SquareState): DeliveryModel;
-export declare function planActNotifications(squareState: SquareState, item: StoredAct): PlannedNotification[];
-export declare function perceiveActivity(squareState: SquareState, item: StoredAct, viewer: string): Perception;
+export declare function planActNotifications(squareState: SquareState, item: StoredAct, delivery?: DeliveryModel): PlannedNotification[];
+export declare function perceiveActivity(squareState: SquareState, item: StoredAct, viewer: string, delivery?: DeliveryModel): Perception;
 /** Mark only the notifications selected by the canonical catch projection as fully seen. */
-export declare function markSeenNotifications(squareState: SquareState, recipient: string, delivered: StoredAct[], at?: number): boolean;
+export declare function markSeenNotifications(squareState: SquareState, recipient: string, delivered: StoredAct[], at?: number, delivery?: DeliveryModel): boolean;
 /** Canonical say-activity filter shared by catch selection and hook ownership. */
 export declare function matchesCatchFilter(activity: CatchFilterShape, filter: WatchLeaseFilter): boolean;
 /** True only when the live catch's own filters would deliver this notification. */

package/dist/delivery.js

@@ -1,24 +1,29 @@
 import { findParticipantName, sameName, } from './model.js';
-import { audienceBefore, audienceOf, formatActivityId } from './square-core.js';
-import { isCurrentlyJoined, lastJoinIndex, matchesMentionTarget, observationFor, recordObservation, resolveRosterName, rosterNames } from './runtime.js';
+import { audienceOf, formatActivityId, replayLandedAudiences } from './square-core.js';
+import { matchesMentionTarget, readCursor, recordObservation } from './runtime.js';
 export function notificationMessageId(squarePath, actIndex) {
     return `square:${squarePath}#${formatActivityId(actIndex)}`;
 }
-function canonicalRecipient(squareState, name) {
-    return resolveRosterName(squareState, name) ?? name;
-}
 export function isActivitySeen(squareState, name, actOrIndex) {
-    const index = typeof actOrIndex === 'number' ? actOrIndex : actOrIndex.index;
-    return observationFor(squareState, canonicalRecipient(squareState, name), index)?.state === 'seen';
+    return deriveDeliveryModel(squareState).isSeen(name, actOrIndex);
 }
 /**
  * Derive delivery behavior once from the decoded Square state.
  * All consumers share these targets instead of reinterpreting artifact text or cursor state.
  */
 export function deriveDeliveryModel(squareState) {
-    const roster = rosterNames(squareState).filter((name) => isCurrentlyJoined(squareState.acts, name));
+    const landed = replayLandedAudiences(squareState.acts);
+    const roster = [...landed.joined];
     const plannedByIndex = new Map();
     let pendingByRecipient;
+    function canonicalRecipient(name) {
+        return landed.resolveParticipant(name) ?? name;
+    }
+    function isSeen(requestedRecipient, actOrIndex) {
+        const recipient = canonicalRecipient(requestedRecipient);
+        const index = typeof actOrIndex === 'number' ? actOrIndex : actOrIndex.index;
+        return squareState.runtime.observations?.[recipient]?.[formatActivityId(index)]?.state === 'seen';
+    }
     function plan(item) {
         if (item.kind !== 'say')
             return [];
@@ -27,7 +32,7 @@ export function deriveDeliveryModel(squareState) {
             return [...cached];
         const sayItem = item;
         const audience = audienceOf(sayItem);
-        const recipients = audienceBefore(squareState.acts, sayItem);
+        const recipients = landed.recipientsFor(sayItem);
         const planned = recipients.map((recipient) => {
             const route = audience.kind === 'bell'
                 ? 'bell'
@@ -43,7 +48,7 @@ export function deriveDeliveryModel(squareState) {
             return [];
         if (pendingByRecipient === undefined) {
             pendingByRecipient = new Map(roster.map((name) => [name, []]));
-            const joinedAfter = new Map(roster.map((name) => [name, lastJoinIndex(squareState.acts, name)]));
+            const joinedAfter = new Map(roster.map((name) => [name, landed.lastJoinIndex(name)]));
             for (const act of squareState.acts) {
                 if (act.kind !== 'say')
                     continue;
@@ -51,7 +56,7 @@ export function deriveDeliveryModel(squareState) {
                     const joinedAt = joinedAfter.get(planned.recipient);
                     if (joinedAt === undefined || act.index <= joinedAt)
                         continue;
-                    if (isActivitySeen(squareState, planned.recipient, act.index))
+                    if (isSeen(planned.recipient, act.index))
                         continue;
                     pendingByRecipient.get(planned.recipient)?.push(planned);
                 }
@@ -59,23 +64,38 @@ export function deriveDeliveryModel(squareState) {
         }
         return [...(pendingByRecipient.get(recipient) ?? [])];
     }
-    return { plan, pendingFor };
+    function directedTo(item, recipient) {
+        return item.kind === 'say' && landed.includes(item, recipient);
+    }
+    function perceive(item, viewer) {
+        if (item.kind !== 'say' || sameName(item.actor, viewer))
+            return 'full';
+        return directedTo(item, viewer) ? 'full' : 'presence';
+    }
+    return {
+        plan,
+        pendingFor,
+        directedTo,
+        perceive,
+        cursorFor: (recipient) => readCursor(squareState, recipient, landed),
+        isSeen,
+        knownParticipant: (name) => landed.resolveParticipant(name),
+        participants: () => landed.participants,
+        joinedRecipients: () => roster,
+        replayedActivityCount: landed.replayedActivityCount,
+    };
 }
-export function planActNotifications(squareState, item) {
-    return deriveDeliveryModel(squareState).plan(item);
+export function planActNotifications(squareState, item, delivery = deriveDeliveryModel(squareState)) {
+    return delivery.plan(item);
 }
-export function perceiveActivity(squareState, item, viewer) {
-    if (item.kind !== 'say' || sameName(item.actor, viewer))
-        return 'full';
-    return deriveDeliveryModel(squareState).plan(item).some((planned) => sameName(planned.recipient, viewer))
-        ? 'full'
-        : 'presence';
+export function perceiveActivity(squareState, item, viewer, delivery = deriveDeliveryModel(squareState)) {
+    return delivery.perceive(item, viewer);
 }
 /** Mark only the notifications selected by the canonical catch projection as fully seen. */
-export function markSeenNotifications(squareState, recipient, delivered, at = Date.now()) {
+export function markSeenNotifications(squareState, recipient, delivered, at = Date.now(), delivery = deriveDeliveryModel(squareState)) {
     const deliveredIndexes = new Set(delivered.map((item) => item.index));
     let changed = false;
-    for (const notification of deriveDeliveryModel(squareState).pendingFor(recipient)) {
+    for (const notification of delivery.pendingFor(recipient)) {
         if (!deliveredIndexes.has(notification.item.index))
             continue;
         changed = recordObservation(squareState, notification.recipient, notification.item.index, 'seen', at) || changed;

package/dist/notifications.d.ts

@@ -1,4 +1,5 @@
-import { planActNotifications, type WakeAdapter } from './delivery.js';
+import { planActNotifications, type DeliveryModel, type WakeAdapter } from './delivery.js';
+import { type SquareState } from './model.js';
 import { matchesMentionTarget } from './runtime.js';
 import { type ActivityId } from './square-core.js';
 import type { WakeNotifier } from './square-facade.js';
@@ -26,5 +27,7 @@ export interface SweepPendingNotificationsOptions extends WorkerLaunchOptions {
     now?: number;
     limit?: number;
 }
+/** Select sweep candidates from one frozen snapshot and one delivery replay. */
+export declare function pendingNotificationSweepFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, limit: number, deriveDelivery?: (snapshot: SquareState) => DeliveryModel): number[];
 /** Reconsider old pending attention at a bounded action boundary using the existing worker. */
 export declare function sweepPendingNotifications(squarePath: string, opts?: SweepPendingNotificationsOptions): Promise<number[]>;

package/dist/notifications.js

@@ -2,7 +2,7 @@ import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { fileURLToPath } from 'node:url';
-import { leaseOwnsNotification, planActNotifications, } from './delivery.js';
+import { deriveDeliveryModel, leaseOwnsNotification, planActNotifications, } from './delivery.js';
 import { sessionInbox } from './inbox.js';
 import { hasPresentedAttention } from './presented.js';
 import { SquareError } from './model.js';
@@ -256,6 +256,23 @@ export function wakeNotifierForSquare(squarePath, env = process.env) {
         },
     };
 }
+/** Select sweep candidates from one frozen snapshot and one delivery replay. */
+export function pendingNotificationSweepFromState(squarePath, state, now, env, limit, deriveDelivery = deriveDeliveryModel) {
+    const delivery = deriveDelivery(state);
+    const pending = pendingDeliveriesFromState(state, delivery);
+    const evidence = wakeEvidenceProjectionFromState(squarePath, state, now, env, delivery);
+    const indexes = new Set();
+    for (const recipient of pending) {
+        for (const note of recipient.notifications) {
+            if (now - note.item.at <= wakeGraceMs(env))
+                continue;
+            if (!wakeIsEligible(evidence.evidence(recipient.recipient, note.item.index)))
+                continue;
+            indexes.add(note.item.index);
+        }
+    }
+    return [...indexes].sort((left, right) => left - right).slice(0, Math.max(0, limit));
+}
 /** Reconsider old pending attention at a bounded action boundary using the existing worker. */
 export async function sweepPendingNotifications(squarePath, opts = {}) {
     const env = opts.env ?? process.env;
@@ -271,19 +288,7 @@ export async function sweepPendingNotifications(squarePath, opts = {}) {
     finally {
         await closeOpenSquare(square);
     }
-    const pending = pendingDeliveriesFromState(state);
-    const evidence = wakeEvidenceProjectionFromState(squarePath, state, now, env);
-    const indexes = new Set();
-    for (const delivery of pending) {
-        for (const note of delivery.notifications) {
-            if (now - note.item.at <= wakeGraceMs(env))
-                continue;
-            if (!wakeIsEligible(evidence.evidence(delivery.recipient, note.item.index)))
-                continue;
-            indexes.add(note.item.index);
-        }
-    }
-    const selected = [...indexes].sort((a, b) => a - b).slice(0, Math.max(0, limit));
+    const selected = pendingNotificationSweepFromState(squarePath, state, now, env, limit);
     const workerPath = fileURLToPath(new URL('./cmd/notify-once.js', import.meta.url));
     for (const actIndex of selected) {
         (opts.launchWorker ?? launchWorker)(workerPath, ['--location', squarePath, '--act-index', String(actIndex)]);

package/dist/presence.d.ts

@@ -1,6 +1,7 @@
+import { type DeliveryModel } from './delivery.js';
 import type { OpenSquare } from './open-square.js';
 import type { CatchOptions, CatchResult } from './square-facade.js';
-export declare function catchUp(square: OpenSquare, name: string, options?: CatchOptions): Promise<CatchResult>;
+export declare function catchUp(square: OpenSquare, name: string, options?: CatchOptions, deriveDelivery?: (state: import('./model.js').SquareState) => DeliveryModel): Promise<CatchResult>;
 /** Commit seen only for complete, actually rendered boundary bodies. */
 export declare function markBoundarySeen(squarePath: string, name: string, ownerId: string | undefined, actIndexes: readonly number[], at?: number): Promise<void>;
 export declare function markNotificationNotified(square: OpenSquare, name: string, actIndex: number, ownerId: string | undefined, at?: number): Promise<void>;

package/dist/presence.js

@@ -1,23 +1,22 @@
 import { extractMentions, formatActivityId } from './square-core.js';
 import { deliveryDelta, directedPeerSays, matchesFeedFilter } from './activity-feed.js';
-import { markSeenNotifications, perceiveActivity } from './delivery.js';
+import { deriveDeliveryModel, markSeenNotifications } from './delivery.js';
 import { SquareError } from './model.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
 import { resolveKnownName } from './decisions.js';
-import { readCursor } from './runtime.js';
 import { recordObservation } from './runtime.js';
-function expose(squareState, activity, viewer) {
+function expose(squareState, activity, viewer, delivery) {
     if (activity.kind === 'read' || activity.actor === undefined)
         throw new Error(`Cannot expose stored activity ${formatActivityId(activity.index)}`);
-    const perception = perceiveActivity(squareState, activity, viewer);
+    const perception = delivery.perceive(activity, viewer);
     const result = { id: formatActivityId(activity.index), at: activity.at, kind: activity.kind, actor: activity.actor, mentions: activity.kind === 'say' ? extractMentions(activity.body) : [], ...('body' in activity && activity.body !== undefined ? { body: activity.body } : {}), ...('target' in activity ? { target: activity.target } : {}), ...(activity.kind === 'say' && activity.reply !== undefined ? { reply: formatActivityId(activity.reply) } : {}) };
     if (perception === 'full' || !('body' in result))
         return { ...result, perception };
     const { body: _body, ...withoutBody } = result;
     return { ...withoutBody, perception };
 }
-export async function catchUp(square, name, options = {}) {
+export async function catchUp(square, name, options = {}, deriveDelivery = deriveDeliveryModel) {
     const idle = options.idle ?? 0;
     if (!Number.isFinite(idle) || idle < 0)
         throw new SquareError('invalid_args', 'Catch idle duration must be a non-negative number');
@@ -26,15 +25,15 @@ export async function catchUp(square, name, options = {}) {
         const attempt = await square.cell.transact((state, version) => {
             const at = square.clock();
             const viewer = resolveKnownName(state, name);
-            const delta = deliveryDelta(state, viewer);
+            const delivery = deriveDelivery(state);
+            const delta = deliveryDelta(state, viewer, delivery);
             const filter = { ...(options.from === undefined ? {} : { participants: [...options.from] }), ...(options.mention === true ? { mention: viewer } : {}) };
-            const delivered = directedPeerSays(state, delta, viewer).filter((activity) => matchesFeedFilter(activity, filter))
+            const delivered = directedPeerSays(state, delta, viewer, delivery).filter((activity) => matchesFeedFilter(activity, filter))
                 .filter((activity, index, activities) => activities.findIndex((candidate) => candidate.index === activity.index) === index)
                 .sort((left, right) => left.index - right.index);
-            const seenChanged = delivered.reduce((changed, activity) => recordObservation(state, viewer, activity.index, 'seen', at) || changed, false)
-                || markSeenNotifications(state, viewer, delivered, at);
-            const cursor = readCursor(state, viewer);
-            return { ...(seenChanged ? { state } : {}), result: { version, caught: { activities: delivered.map((activity) => expose(state, activity, viewer)), consumedThrough: cursor < 0 ? null : formatActivityId(cursor), idleExpired: false } } };
+            const seenChanged = delivered.length === 0 ? false : markSeenNotifications(state, viewer, delivered, at, delivery);
+            const cursor = delivery.cursorFor(viewer);
+            return { ...(seenChanged ? { state } : {}), result: { version, caught: { activities: delivered.map((activity) => expose(state, activity, viewer, delivery)), consumedThrough: cursor < 0 ? null : formatActivityId(cursor), idleExpired: false } } };
         });
         if (attempt.caught.activities.length > 0 || idle === 0)
             return attempt.caught;

package/dist/presentation.d.ts

@@ -92,5 +92,6 @@ export declare function renderWatchOutput(history: StoredAct[], publicItems: Pub
     mention?: string;
     viewer: string;
     showCatchHint?: boolean;
-    squareState: SquareState;
+    squareState?: SquareState;
+    perceptions?: ReadonlyMap<number, Perception>;
 }): string;

package/dist/presentation.js

@@ -456,7 +456,8 @@ export function renderWatchOutput(history, publicItems, roomChanges, opts) {
             .map((act) => renderAmbientEvent(act, opts.viewer, {
             actNumber: act.kind === 'say' ? sayNumberFor(history, act) : undefined,
             mention: opts.mention,
-            squareState: opts.squareState,
+            ...(opts.perceptions?.has(act.index) ? { perception: opts.perceptions.get(act.index) } : {}),
+            ...(opts.squareState === undefined ? {} : { squareState: opts.squareState }),
         }))
             .filter(Boolean)
             .join('\n\n');

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import { type ActivityId, type Reach } from './square-core.js';
+import { type ActivityId, type LandedAudienceReplay, type Reach } from './square-core.js';
 import { type StoredAct, type SquareState, type HoldState, type ActivityObservation, type ObservationState, type WatchLease } from './model.js';
 export declare const WATCH_HEARTBEAT_MS: number;
 export declare const SLEEP_MS: number;
@@ -36,7 +36,7 @@ export declare function publicActs(acts: StoredAct[]): Array<Extract<StoredAct,
 }>>;
 export declare function observationFor(squareState: SquareState, name: string, index: number): ActivityObservation | undefined;
 export declare function recordObservation(squareState: SquareState, name: string, index: number, state: ObservationState, at?: number, ownerId?: string): boolean;
-export declare function readCursor(squareState: SquareState, name: string): number;
+export declare function readCursor(squareState: SquareState, name: string, landed?: LandedAudienceReplay): number;
 export declare function latestActIndex(acts: StoredAct[]): number;
 export declare function freshWatchLease(squareState: SquareState, name: string, at?: number): WatchLease | undefined;
 export declare function watchLease(squareState: SquareState, name: string): WatchLease | undefined;

package/dist/runtime.js

@@ -1,4 +1,4 @@
-import { audienceIncludes, audienceOf, fold, formatActivityId, landedAudienceIncludes } from './square-core.js';
+import { audienceIncludes, audienceOf, fold, formatActivityId, replayLandedAudiences } from './square-core.js';
 import { SquareError, findParticipantName, nameKey, sameName, } from './model.js';
 function parseIntegerEnvValue(name, raw, fallback) {
     if (raw === undefined)
@@ -162,21 +162,22 @@ export function recordObservation(squareState, name, index, state, at = Date.now
     ((squareState.runtime.observations ??= {})[key] ??= {})[id] = next;
     return true;
 }
-export function readCursor(squareState, name) {
-    const boundary = lastJoinIndex(squareState.acts, name) ?? -1;
+export function readCursor(squareState, name, landed = replayLandedAudiences(squareState.acts)) {
+    const recipient = landed.resolveParticipant(name) ?? name;
+    const boundary = landed.lastJoinIndex(recipient) ?? -1;
     let cursor = boundary;
     for (const act of squareState.acts) {
         if (act.index <= boundary || act.kind === 'read' || act.actor === undefined)
             continue;
-        if (sameName(act.actor, name)) {
+        if (sameName(act.actor, recipient)) {
             cursor = act.index;
             continue;
         }
-        if (!landedAudienceIncludes(squareState.acts, act, name)) {
+        if (!landed.includes(act, recipient)) {
             cursor = act.index;
             continue;
         }
-        if (observationFor(squareState, name, act.index)?.state !== 'seen')
+        if (squareState.runtime.observations?.[recipient]?.[formatActivityId(act.index)]?.state !== 'seen')
             break;
         cursor = act.index;
     }

package/dist/square-core.d.ts

@@ -82,6 +82,15 @@ export interface FoldedSquareState {
     /** Derived sender blocks; kept outside the artifact schema. */
     ignored: Map<string, Participant[]>;
 }
+export interface LandedAudienceReplay {
+    readonly participants: readonly Participant[];
+    readonly joined: readonly Participant[];
+    readonly replayedActivityCount: number;
+    recipientsFor(activity: Act): readonly Participant[];
+    includes(activity: Act, participant: Participant): boolean;
+    lastJoinIndex(participant: Participant): number | undefined;
+    resolveParticipant(name: Participant): Participant | undefined;
+}
 export type ValidationResult = {
     ok: true;
 } | {
@@ -120,14 +129,11 @@ export declare function audienceIncludes(audience: Audience, name: string): bool
 export declare function resolveAudience(audience: Audience, candidateNames: readonly string[]): string[];
 export declare function activeListeners(state: FoldedSquareState, sender: string): string[];
 export declare function isIgnored(state: FoldedSquareState, listener: string, sender: string): boolean;
-export declare function audienceBefore(acts: readonly Act[], say: Extract<Act, {
-    kind: 'say';
-}>): string[];
-/** Whether a peer say was directed to this participant when it landed. */
-export declare function landedAudienceIncludes(acts: readonly Act[], activity: Act, viewer: string): boolean;
 export declare function listeningTo(state: FoldedSquareState, listener: string): string[];
 export declare function isListening(state: FoldedSquareState, listener: string, sender: string): boolean;
 export declare function fold(acts: readonly Act[]): FoldedSquareState;
+/** Replay the activity stream once to fix every say's audience at landing. */
+export declare function replayLandedAudiences(acts: readonly Act[]): LandedAudienceReplay;
 export declare function validate(state: FoldedSquareState, act: Act, options?: SquareValidationOptions): ValidationResult;
 export declare function perceive(act: Act, viewer: Participant | string): Perception;
 export {};

package/dist/square-core.js

@@ -67,11 +67,9 @@ export function activeListeners(state, sender) {
 export function isIgnored(state, listener, sender) {
     return (state.ignored.get(nameKey(listener)) ?? []).some((target) => sameName(target, sender));
 }
-export function audienceBefore(acts, say) {
-    const position = acts.findIndex((act) => act === say || ('index' in act && 'index' in say && act.index === say.index));
-    const before = fold(position < 0 ? acts : acts.slice(0, position));
+function recipientsAtLanding(before, say) {
     const audience = audienceOf(say);
-    const mentionTargets = resolveAudience(audience, before.joined);
+    const mentionTargets = resolveAudience(audience, before.participants.filter((participant) => participant.joined).map((participant) => participant.name));
     const listeners = activeListeners(before, say.actor);
     const recipients = [];
     for (const name of [...mentionTargets, ...listeners]) {
@@ -83,12 +81,6 @@ export function audienceBefore(acts, say) {
     }
     return recipients;
 }
-/** Whether a peer say was directed to this participant when it landed. */
-export function landedAudienceIncludes(acts, activity, viewer) {
-    if (activity.kind !== 'say' || sameName(activity.actor, viewer))
-        return false;
-    return audienceBefore(acts, activity).some((recipient) => sameName(recipient, viewer));
-}
 export function listeningTo(state, listener) {
     return [...(state.listening.get(nameKey(listener)) ?? [])];
 }
@@ -142,97 +134,154 @@ function bellRecentAt(state, actor, at, windowMs) {
     }
     return latest;
 }
-export function fold(acts) {
+function createFoldAccumulator() {
     const ordered = [];
     const byKey = new Map();
     const hold = { active: false };
-    const state = {
-        participants: ordered,
-        hold,
-        joined: [],
-        done: [],
-        throttleActivityAts: [],
-        bellSayAtsByActor: new Map(),
-        listening: new Map(),
-        ignored: new Map(),
+    return {
+        byKey,
+        ordered,
+        state: {
+            participants: ordered,
+            hold,
+            joined: [],
+            done: [],
+            throttleActivityAts: [],
+            bellSayAtsByActor: new Map(),
+            listening: new Map(),
+            ignored: new Map(),
+        },
     };
-    for (const act of acts) {
-        const actor = actorOf(act);
-        const snapshot = actor === undefined ? undefined : touchParticipant(byKey, ordered, actor);
-        switch (act.kind) {
-            case 'join':
-                if (snapshot !== undefined) {
-                    snapshot.joined = true;
-                    snapshot.done = false;
-                    snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
-                }
-                break;
-            case 'done':
-                if (snapshot !== undefined) {
-                    snapshot.joined = false;
-                    snapshot.done = true;
-                    snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
-                    state.listening.delete(nameKey(snapshot.name));
-                }
-                break;
-            case 'listen': {
-                const key = nameKey(act.actor);
-                const targets = state.listening.get(key) ?? [];
-                if (!targets.some((target) => sameName(target, act.target)))
-                    targets.push(act.target);
-                state.listening.set(key, targets);
-                const ignored = (state.ignored.get(key) ?? []).filter((target) => !sameName(target, act.target));
-                if (ignored.length === 0)
-                    state.ignored.delete(key);
-                else
-                    state.ignored.set(key, ignored);
-                break;
+}
+function applyActivity(accumulator, act) {
+    const { state, byKey, ordered } = accumulator;
+    const actor = actorOf(act);
+    const snapshot = actor === undefined ? undefined : touchParticipant(byKey, ordered, actor);
+    switch (act.kind) {
+        case 'join':
+            if (snapshot !== undefined) {
+                snapshot.joined = true;
+                snapshot.done = false;
+                snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
             }
-            case 'ignore': {
-                const key = nameKey(act.actor);
-                const targets = (state.listening.get(key) ?? []).filter((target) => !sameName(target, act.target));
-                if (targets.length === 0)
-                    state.listening.delete(key);
-                else
-                    state.listening.set(key, targets);
-                const ignored = state.ignored.get(key) ?? [];
-                if (!ignored.some((target) => sameName(target, act.target)))
-                    ignored.push(act.target);
-                state.ignored.set(key, ignored);
-                break;
+            break;
+        case 'done':
+            if (snapshot !== undefined) {
+                snapshot.joined = false;
+                snapshot.done = true;
+                snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
+                state.listening.delete(nameKey(snapshot.name));
             }
-            case 'say':
-                if (snapshot !== undefined) {
-                    snapshot.activityCount += 1;
-                    snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
-                }
-                pushThrottleAt(state, act.at);
-                if (act.reach === 'bell')
-                    pushBellAt(state, act.actor, act.at);
-                break;
-            case 'hold':
-                hold.active = true;
-                hold.at = act.at;
-                hold.reason = act.body;
-                hold.actor = act.actor;
-                break;
-            case 'resume':
-                hold.active = false;
-                delete hold.at;
-                delete hold.reason;
-                delete hold.actor;
-                break;
-            case 'read':
-                if (snapshot !== undefined) {
-                    snapshot.lastReadThrough = Math.max(snapshot.lastReadThrough, act.through);
-                }
-                break;
+            break;
+        case 'listen': {
+            const key = nameKey(act.actor);
+            const targets = state.listening.get(key) ?? [];
+            if (!targets.some((target) => sameName(target, act.target)))
+                targets.push(act.target);
+            state.listening.set(key, targets);
+            const ignored = (state.ignored.get(key) ?? []).filter((target) => !sameName(target, act.target));
+            if (ignored.length === 0)
+                state.ignored.delete(key);
+            else
+                state.ignored.set(key, ignored);
+            break;
+        }
+        case 'ignore': {
+            const key = nameKey(act.actor);
+            const targets = (state.listening.get(key) ?? []).filter((target) => !sameName(target, act.target));
+            if (targets.length === 0)
+                state.listening.delete(key);
+            else
+                state.listening.set(key, targets);
+            const ignored = state.ignored.get(key) ?? [];
+            if (!ignored.some((target) => sameName(target, act.target)))
+                ignored.push(act.target);
+            state.ignored.set(key, ignored);
+            break;
         }
+        case 'say':
+            if (snapshot !== undefined) {
+                snapshot.activityCount += 1;
+                snapshot.lastActiveAt = act.at ?? snapshot.lastActiveAt;
+            }
+            pushThrottleAt(state, act.at);
+            if (act.reach === 'bell')
+                pushBellAt(state, act.actor, act.at);
+            break;
+        case 'hold':
+            state.hold.active = true;
+            state.hold.at = act.at;
+            state.hold.reason = act.body;
+            state.hold.actor = act.actor;
+            break;
+        case 'resume':
+            state.hold.active = false;
+            delete state.hold.at;
+            delete state.hold.reason;
+            delete state.hold.actor;
+            break;
+        case 'read':
+            if (snapshot !== undefined) {
+                snapshot.lastReadThrough = Math.max(snapshot.lastReadThrough, act.through);
+            }
+            break;
     }
+}
+function finishFold(accumulator) {
+    const { state, ordered } = accumulator;
     state.joined = ordered.filter((item) => item.joined).map((item) => item.name);
     state.done = ordered.filter((item) => item.done).map((item) => item.name);
     return state;
 }
+export function fold(acts) {
+    const accumulator = createFoldAccumulator();
+    for (const act of acts)
+        applyActivity(accumulator, act);
+    return finishFold(accumulator);
+}
+/** Replay the activity stream once to fix every say's audience at landing. */
+export function replayLandedAudiences(acts) {
+    const accumulator = createFoldAccumulator();
+    const byActivity = new Map();
+    const byIndex = new Map();
+    const lastJoinByKey = new Map();
+    for (const act of acts) {
+        if (act.kind === 'say') {
+            const recipients = recipientsAtLanding(accumulator.state, act);
+            byActivity.set(act, recipients);
+            const index = 'index' in act ? act.index : undefined;
+            if (typeof index === 'number')
+                byIndex.set(index, recipients);
+        }
+        if (act.kind === 'join' && 'index' in act && typeof act.index === 'number') {
+            lastJoinByKey.set(nameKey(act.actor), act.index);
+        }
+        applyActivity(accumulator, act);
+    }
+    const state = finishFold(accumulator);
+    const participants = state.participants.map((participant) => participant.name);
+    function recipientsFor(activity) {
+        const direct = byActivity.get(activity);
+        if (direct !== undefined)
+            return direct;
+        const index = 'index' in activity ? activity.index : undefined;
+        return typeof index === 'number' ? byIndex.get(index) ?? [] : [];
+    }
+    function resolveParticipant(name) {
+        return participants.find((participant) => sameName(participant, name));
+    }
+    return {
+        participants,
+        joined: state.joined,
+        replayedActivityCount: acts.length,
+        recipientsFor,
+        includes: (activity, participant) => activity.kind === 'say'
+            && !sameName(activity.actor, participant)
+            && recipientsFor(activity).some((recipient) => sameName(recipient, participant)),
+        lastJoinIndex: (participant) => lastJoinByKey.get(nameKey(participant)),
+        resolveParticipant,
+    };
+}
 export function validate(state, act, options = {}) {
     const actor = actorOf(act);
     const current = actor === undefined ? undefined : currentParticipant(state, actor);

package/dist/views.d.ts

@@ -1,6 +1,6 @@
 import { type ActivityId } from './square-core.js';
 import { coreParticipants, coreStatus } from './decisions.js';
-import { type PlannedNotification } from './delivery.js';
+import { type DeliveryModel, type PlannedNotification } from './delivery.js';
 import { type ActivitiesOptions, type ActivityObservation, type InboxNotification, type PublicAct, type RoomChangeAct, type SquareState, type StoredAct } from './model.js';
 import type { OpenSquare } from './open-square.js';
 import type { Activity, HistoryQuery, ParticipantStatus, PerceivedActivity, SquareSnapshot } from './square-facade.js';
@@ -96,7 +96,7 @@ export declare function watchPresentation(square: OpenSquare, name: string): Pro
 export declare function inboxProjection(square: OpenSquare, name: string, ownerId: string): Promise<InboxProjection>;
 export declare function streamProjection(square: OpenSquare, cursor: number, recipient?: string): Promise<StreamProjection>;
 export declare function notificationForAct(square: OpenSquare, actIndex: number): Promise<readonly PlannedNotification[]>;
-export declare function pendingDeliveriesFromState(state: SquareState): readonly PendingDeliveryProjection[];
+export declare function pendingDeliveriesFromState(state: SquareState, delivery?: DeliveryModel): readonly PendingDeliveryProjection[];
 export declare function pendingDeliveries(square: OpenSquare): Promise<readonly PendingDeliveryProjection[]>;
 export declare function notificationEvidence(square: OpenSquare, recipient: string, actIndex: number): Promise<{
     readonly delivered: boolean;

package/dist/views.js

@@ -1,16 +1,16 @@
 import { extractMentions, formatActivityId, parseActivityId } from './square-core.js';
 import { deliveryDelta, directedPeerSays } from './activity-feed.js';
 import { coreActivities, coreParticipants, coreStatus, resolveKnownName } from './decisions.js';
-import { deriveDeliveryModel, isActivitySeen, perceiveActivity, planActNotifications } from './delivery.js';
+import { deriveDeliveryModel, isActivitySeen } from './delivery.js';
 import { SquareError, nameKey } from './model.js';
-import { countSays, currentHold, foldedState, freshWatchLease, inSquareCount, isCurrentlyJoined, observationFor, readCursor, resolveRosterName, rosterNames, watchTerminalStatus } from './runtime.js';
+import { countSays, currentHold, foldedState, freshWatchLease, inSquareCount, isCurrentlyJoined, resolveRosterName, rosterNames, watchTerminalStatus } from './runtime.js';
 function expose(stored) {
     if (stored.kind === 'read' || stored.actor === undefined)
         throw new Error(`Cannot expose stored activity ${formatActivityId(stored.index)}`);
     return { id: formatActivityId(stored.index), at: stored.at, kind: stored.kind, actor: stored.actor, ...('body' in stored && stored.body !== undefined ? { body: stored.body } : {}), mentions: stored.kind === 'say' ? extractMentions(stored.body) : [], ...('target' in stored ? { target: stored.target } : {}), ...(stored.kind === 'say' && stored.reply !== undefined ? { reply: formatActivityId(stored.reply) } : {}) };
 }
-function exposePerceived(state, stored, viewer) {
-    const perception = perceiveActivity(state, stored, viewer);
+function exposePerceived(stored, viewer, delivery) {
+    const perception = delivery.perceive(stored, viewer);
     const activity = expose(stored);
     if (perception === 'full' || activity.body === undefined)
         return { ...activity, perception };
@@ -36,12 +36,16 @@ function selectHistory(stored, query) {
     return query.order === 'desc' ? selected.reverse() : selected;
 }
 function statuses(square, state) {
-    return coreStatus(state, square.clock()).participants.filter((participant) => participant.state !== 'not joined').map((participant) => ({ name: participant.name, state: participant.state === 'done' ? 'done' : 'joined', consumedThrough: readCursor(state, participant.name) < 0 ? null : formatActivityId(readCursor(state, participant.name)), watching: participant.presence === 'watching', listening: participant.listening }));
+    const delivery = deriveDeliveryModel(state);
+    return coreStatus(state, square.clock(), delivery).participants.filter((participant) => participant.state !== 'not joined').map((participant) => {
+        const cursor = delivery.cursorFor(participant.name);
+        return { name: participant.name, state: participant.state === 'done' ? 'done' : 'joined', consumedThrough: cursor < 0 ? null : formatActivityId(cursor), watching: participant.presence === 'watching', listening: participant.listening };
+    });
 }
-function anchors(state) {
+function anchors(state, delivery) {
     const result = {};
-    for (const name of rosterNames(state)) {
-        const activity = state.acts.findLast((candidate) => candidate.index <= readCursor(state, name) && (candidate.kind === 'say' || candidate.kind === 'done'));
+    for (const name of delivery.participants()) {
+        const activity = state.acts.findLast((candidate) => candidate.index <= delivery.cursorFor(name) && (candidate.kind === 'say' || candidate.kind === 'done'));
         if (activity !== undefined)
             result[activity.index] = [...(result[activity.index] ?? []), name];
     }
@@ -59,30 +63,26 @@ function sayNumbers(state) {
     return result;
 }
 export async function history(square, query = {}) { const { state } = await square.cell.read(); return selectHistory(coreActivities(state, historyOptions(query)), query).map(expose); }
-export async function participantHistory(square, name, query = {}) { const { state } = await square.cell.read(); const viewer = resolveKnownName(state, name); const effective = query.all === true || query.limit !== undefined ? query : { ...query, limit: 10 }; return selectHistory(coreActivities(state, historyOptions(effective, viewer)), effective).map((activity) => exposePerceived(state, activity, viewer)); }
+export async function participantHistory(square, name, query = {}) { const { state } = await square.cell.read(); const viewer = resolveKnownName(state, name); const delivery = deriveDeliveryModel(state); const effective = query.all === true || query.limit !== undefined ? query : { ...query, limit: 10 }; return selectHistory(coreActivities(state, historyOptions(effective, viewer), delivery), effective).map((activity) => exposePerceived(activity, viewer, delivery)); }
 export async function resolveParticipant(square, name) { const { state } = await square.cell.read(); return { name: resolveKnownName(state, name), roster: rosterNames(state) }; }
 export async function currentParticipant(square, name) { const { state } = await square.cell.read(); const known = resolveRosterName(state, name); return known !== undefined && isCurrentlyJoined(state.acts, known) ? known : undefined; }
 export async function participants(square) { const { state } = await square.cell.read(); return statuses(square, state); }
 export async function snapshot(square) { const { state } = await square.cell.read(); const folded = foldedState(state); return { context: [...state.preamble, ...state.warmup].join('\n'), actCount: state.acts.filter((activity) => activity.kind !== 'read').length, hardCap: state.hardCap, ...(state.throttlePerMinute === undefined ? {} : { throttlePerMinute: state.throttlePerMinute }), held: folded.hold.active && folded.hold.actor !== undefined ? { by: folded.hold.actor, ...(folded.hold.reason === undefined ? {} : { reason: folded.hold.reason }) } : null, participants: statuses(square, state), delivered(name, id) { return isActivitySeen(state, name, parseRequiredActivityId(id)); } }; }
-export async function activityPresentation(square, name) { const { state } = await square.cell.read(); const known = resolveKnownName(state, name); const delta = deliveryDelta(state, known); const hold = currentHold(state.acts); return { name: known, roster: rosterNames(state), pendingPublic: directedPeerSays(state, delta, known), pendingRoomChanges: [], activities: state.acts, state, participantCount: inSquareCount(state), held: hold.active, ...(hold.reason === undefined ? {} : { holdReason: hold.reason }), ownActivityCount: countSays(state.acts, known), hardCap: state.hardCap }; }
+export async function activityPresentation(square, name) { const { state } = await square.cell.read(); const known = resolveKnownName(state, name); const delivery = deriveDeliveryModel(state); const delta = deliveryDelta(state, known, delivery); const hold = currentHold(state.acts); return { name: known, roster: rosterNames(state), pendingPublic: directedPeerSays(state, delta, known, delivery), pendingRoomChanges: [], activities: state.acts, state, participantCount: inSquareCount(state), held: hold.active, ...(hold.reason === undefined ? {} : { holdReason: hold.reason }), ownActivityCount: countSays(state.acts, known), hardCap: state.hardCap }; }
 export async function entryPresentation(square, name, lastN = 10) { const { state } = await square.cell.read(); const known = resolveRosterName(state, name) ?? name; const publicActivities = state.acts.filter((activity) => activity.kind === 'say' || activity.kind === 'done'); return { joined: isCurrentlyJoined(state.acts, known), scene: state.warmup.join('\n').trim(), context: state.preamble.join('\n').trim(), joinContext: (state.preamble.at(-1) === '---' ? state.preamble.slice(0, -1) : state.preamble).join('\n').trim(), recentActivities: lastN === null ? publicActivities : publicActivities.slice(-lastN), state, sayNumbers: sayNumbers(state), participantCount: inSquareCount(state) }; }
-export async function historyPresentation(square, options) { const { state } = await square.cell.read(); return { activities: coreActivities(state, options).map((activity) => ({ ...activity, perception: options.viewer === undefined ? 'full' : perceiveActivity(state, activity, options.viewer) })), sayNumbers: sayNumbers(state), presenceAnchors: anchors(state), participantCount: inSquareCount(state) }; }
-export async function participantsPresentation(square) { const { state } = await square.cell.read(); return coreParticipants(state, square.clock()); }
+export async function historyPresentation(square, options) { const { state } = await square.cell.read(); const delivery = deriveDeliveryModel(state); return { activities: coreActivities(state, options, delivery).map((activity) => ({ ...activity, perception: options.viewer === undefined ? 'full' : delivery.perceive(activity, options.viewer) })), sayNumbers: sayNumbers(state), presenceAnchors: anchors(state, delivery), participantCount: inSquareCount(state) }; }
+export async function participantsPresentation(square) { const { state } = await square.cell.read(); const delivery = deriveDeliveryModel(state); return coreParticipants(state, square.clock(), delivery); }
 export async function listPresentation(square) { const { state } = await square.cell.read(); return { context: state.preamble, participants: foldedState(state).participants.filter((participant) => participant.joined).sort((left, right) => (right.lastActiveAt ?? -Infinity) - (left.lastActiveAt ?? -Infinity) || left.name.localeCompare(right.name)).map((participant) => participant.name), activities: state.acts.filter((activity) => activity.kind === 'say').length }; }
-export async function statusPresentation(square) { const { state } = await square.cell.read(); const status = coreStatus(state, square.clock()); return { state, status, ...(status.latestAct?.kind === 'say' ? { latestActNumber: countSays(state.acts, status.latestAct.actor) } : {}) }; }
+export async function statusPresentation(square) { const { state } = await square.cell.read(); const delivery = deriveDeliveryModel(state); const status = coreStatus(state, square.clock(), delivery); return { state, status, ...(status.latestAct?.kind === 'say' ? { latestActNumber: countSays(state.acts, status.latestAct.actor) } : {}) }; }
 export async function eventPresentation(square, id) { const { state } = await square.cell.read(); const activity = state.acts.find((candidate) => candidate.index === parseRequiredActivityId(id)); if (activity === undefined)
     throw new SquareError('invalid_args', `Unknown activity id: ${id}`); return { activity, participantCount: inSquareCount(state), held: currentHold(state.acts).active }; }
-export async function watchPresentation(square, name) { const { state } = await square.cell.read(); const known = resolveKnownName(state, name); const now = square.clock(); const terminal = watchTerminalStatus(state, known); return { activities: state.acts, state, participantCount: inSquareCount(state), presence: { participants: coreParticipants(state, now), now }, ...(terminal === undefined ? {} : { terminalStatus: terminal }) }; }
-export async function inboxProjection(square, name, ownerId) { const { state } = await square.cell.read(); const known = resolveRosterName(state, name); if (known === undefined || !isCurrentlyJoined(state.acts, known))
-    return { name, joined: false, notifications: [] }; const lease = freshWatchLease(state, known, square.clock()); return { name: known, joined: true, notifications: deriveDeliveryModel(state).pendingFor(known).map(({ item, route }) => ({ actIndex: item.index, actor: item.actor, at: item.at, route, body: item.body })), ...(lease?.ownerId === ownerId ? { catchLease: lease } : {}) }; }
-export async function streamProjection(square, cursor, recipient) { const { state } = await square.cell.read(); return { activities: state.acts.filter((activity) => activity.index > cursor).flatMap((activity) => { if (recipient === undefined)
-        return [{ activity }]; const notification = planActNotifications(state, activity).find((candidate) => nameKey(candidate.recipient) === nameKey(recipient)); return notification === undefined ? [] : [{ activity, route: notification.route }]; }), cursor: Math.max(cursor, ...state.acts.map((activity) => activity.index)) }; }
-export async function notificationForAct(square, actIndex) { const { state } = await square.cell.read(); const activity = state.acts.find((candidate) => candidate.index === actIndex); return activity === undefined ? [] : planActNotifications(state, activity); }
-export function pendingDeliveriesFromState(state) {
-    return [...new Set(state.acts.filter((activity) => activity.kind === 'join').map((activity) => activity.actor))]
-        .filter((name) => isCurrentlyJoined(state.acts, name))
-        .map((recipient) => ({ recipient, notifications: deriveDeliveryModel(state).pendingFor(recipient) }));
-}
+export async function watchPresentation(square, name) { const { state } = await square.cell.read(); const known = resolveKnownName(state, name); const now = square.clock(); const terminal = watchTerminalStatus(state, known); const delivery = deriveDeliveryModel(state); return { activities: state.acts, state, participantCount: inSquareCount(state), presence: { participants: coreParticipants(state, now, delivery), now }, ...(terminal === undefined ? {} : { terminalStatus: terminal }) }; }
+export async function inboxProjection(square, name, ownerId) { const { state } = await square.cell.read(); const delivery = deriveDeliveryModel(state); const known = delivery.knownParticipant(name); if (known === undefined || !delivery.joinedRecipients().some((recipient) => nameKey(recipient) === nameKey(known)))
+    return { name, joined: false, notifications: [] }; const lease = freshWatchLease(state, known, square.clock()); return { name: known, joined: true, notifications: delivery.pendingFor(known).map(({ item, route }) => ({ actIndex: item.index, actor: item.actor, at: item.at, route, body: item.body })), ...(lease?.ownerId === ownerId ? { catchLease: lease } : {}) }; }
+export async function streamProjection(square, cursor, recipient) { const { state } = await square.cell.read(); const delivery = recipient === undefined ? undefined : deriveDeliveryModel(state); return { activities: state.acts.filter((activity) => activity.index > cursor).flatMap((activity) => { if (delivery === undefined || recipient === undefined)
+        return [{ activity }]; const notification = delivery.plan(activity).find((candidate) => nameKey(candidate.recipient) === nameKey(recipient)); return notification === undefined ? [] : [{ activity, route: notification.route }]; }), cursor: Math.max(cursor, ...state.acts.map((activity) => activity.index)) }; }
+export async function notificationForAct(square, actIndex) { const { state } = await square.cell.read(); const activity = state.acts.find((candidate) => candidate.index === actIndex); return activity === undefined ? [] : deriveDeliveryModel(state).plan(activity); }
+export function pendingDeliveriesFromState(state, delivery = deriveDeliveryModel(state)) { return delivery.joinedRecipients().map((recipient) => ({ recipient, notifications: delivery.pendingFor(recipient) })); }
 export async function pendingDeliveries(square) { const { state } = await square.cell.read(); return pendingDeliveriesFromState(state); }
-export async function notificationEvidence(square, recipient, actIndex) { const { state } = await square.cell.read(); return { delivered: isActivitySeen(state, recipient, actIndex), observation: observationFor(state, recipient, actIndex) }; }
-export async function notificationDelivered(square, recipient, actIndex) { const { state } = await square.cell.read(); return isActivitySeen(state, recipient, actIndex); }
+export async function notificationEvidence(square, recipient, actIndex) { const { state } = await square.cell.read(); const delivery = deriveDeliveryModel(state); const known = delivery.knownParticipant(recipient) ?? recipient; return { delivered: delivery.isSeen(known, actIndex), observation: state.runtime.observations?.[known]?.[formatActivityId(actIndex)] }; }
+export async function notificationDelivered(square, recipient, actIndex) { const { state } = await square.cell.read(); return deriveDeliveryModel(state).isSeen(recipient, actIndex); }

package/dist/wake-evidence.d.ts

@@ -1,4 +1,5 @@
 import { type WakeRoute } from './model.js';
+import { type DeliveryModel } from './delivery.js';
 import { type SquareState } from './model.js';
 import { type WakeAttempt } from './wake-attempts.js';
 export interface WakeEvidence {
@@ -14,7 +15,7 @@ export interface WakeEvidenceProjection {
 }
 /** Capture the primary wake facts once and derive any number of eligibility decisions from them. */
 export declare function wakeEvidenceProjection(squarePath: string, now: number, env: NodeJS.ProcessEnv): Promise<WakeEvidenceProjection>;
-export declare function wakeEvidenceProjectionFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv): WakeEvidenceProjection;
+export declare function wakeEvidenceProjectionFromState(squarePath: string, state: SquareState, now: number, env: NodeJS.ProcessEnv, delivery?: DeliveryModel): WakeEvidenceProjection;
 /** Project every wake decision from the same primary evidence. */
 export declare function wakeEvidence(squarePath: string, recipient: string, actIndex: number, now: number, env: NodeJS.ProcessEnv): Promise<WakeEvidence>;
 export declare function wakeIsEligible(evidence: WakeEvidence): boolean;

package/dist/wake-evidence.js

@@ -1,4 +1,4 @@
-import { isActivitySeen } from './delivery.js';
+import { deriveDeliveryModel } from './delivery.js';
 import { nameKey } from './model.js';
 import { readPresentedAttentions } from './presented.js';
 import { canonicalSquarePath, readActiveBindings } from './registry.js';
@@ -11,7 +11,7 @@ import { entryPresentation } from './views.js';
 function attentionKey(squarePath, recipient, actIndex) {
     return JSON.stringify([canonicalSquarePath(squarePath), nameKey(recipient), actIndex]);
 }
-function projectionFromState(squarePath, state, now, env) {
+function projectionFromState(squarePath, state, now, env, delivery = deriveDeliveryModel(state)) {
     const canonicalPath = canonicalSquarePath(squarePath);
     const owners = new Map();
     for (const binding of readActiveBindings(now)) {
@@ -52,7 +52,7 @@ function projectionFromState(squarePath, state, now, env) {
             const presented = [...(presentedByAttention.get(key) ?? [])]
                 .some((ownerId) => recipientOwners.has(ownerId));
             return {
-                delivered: isActivitySeen(state, recipient, actIndex),
+                delivered: delivery.isSeen(recipient, actIndex),
                 notified: (() => {
                     const observation = observationFor(state, recipient, actIndex);
                     return observation?.state === 'notified'
@@ -80,8 +80,8 @@ export async function wakeEvidenceProjection(squarePath, now, env) {
         await closeOpenSquare(square);
     }
 }
-export function wakeEvidenceProjectionFromState(squarePath, state, now, env) {
-    return projectionFromState(squarePath, state, now, env);
+export function wakeEvidenceProjectionFromState(squarePath, state, now, env, delivery) {
+    return projectionFromState(squarePath, state, now, env, delivery);
 }
 /** Project every wake decision from the same primary evidence. */
 export async function wakeEvidence(squarePath, recipient, actIndex, now, env) {

package/dist/watch.d.ts

@@ -1,2 +1,3 @@
 import { type WatchOptions } from './model.js';
-export declare function cmdWatch(squarePath: string, name: string, opts: WatchOptions): Promise<void>;
+/** `false` is reserved for a quiet --now; idle completion preserves its existing sweep boundary. */
+export declare function cmdWatch(squarePath: string, name: string, opts: WatchOptions): Promise<boolean | undefined>;

package/dist/watch.js

@@ -19,10 +19,15 @@ function watchOutputResult(squarePath, presentation, name, caught, opts = {}) {
     const delivered = caught.activities.flatMap((activity) => {
         const index = parseActivityId(activity.id);
         const stored = index === undefined ? undefined : presentation.activities.find((item) => item.index === index);
-        return stored === undefined ? [] : [stored];
+        return stored === undefined ? [] : [{ activity: stored, perception: activity.perception }];
     });
-    const publicItems = delivered.filter((item) => item.kind === 'say' || item.kind === 'done');
-    const roomChanges = delivered.filter((item) => item.kind === 'join' || item.kind === 'done' || item.kind === 'hold' || item.kind === 'resume');
+    const publicItems = delivered
+        .map(({ activity }) => activity)
+        .filter((item) => item.kind === 'say' || item.kind === 'done');
+    const roomChanges = delivered
+        .map(({ activity }) => activity)
+        .filter((item) => item.kind === 'join' || item.kind === 'done' || item.kind === 'hold' || item.kind === 'resume');
+    const perceptions = new Map(delivered.map(({ activity, perception }) => [activity.index, perception]));
     return {
         type: 'output',
         stdout: renderWatchOutput([...presentation.activities], publicItems, roomChanges, {
@@ -30,7 +35,7 @@ function watchOutputResult(squarePath, presentation, name, caught, opts = {}) {
             squarePath,
             viewer: name,
             showCatchHint: !hasAutomaticDeliveryIdentity(),
-            squareState: presentation.state,
+            perceptions,
         }),
         ...(opts.status ? { status: opts.status } : {}),
     };
@@ -118,12 +123,14 @@ async function cmdWatchNow(squarePath, name, opts) {
             ? watchOutputResult(squarePath, presentation, name, caught, { mention: opts.mention, ...(status ? { status } : {}) })
             : { type: 'terminal', status: status ?? 'empty-now' };
         await finishWatchResult(square, squarePath, name, result, undefined);
+        return caught.activities.length > 0;
     }
     finally {
         await facade.close();
         await closeOpenSquare(square);
     }
 }
+/** `false` is reserved for a quiet --now; idle completion preserves its existing sweep boundary. */
 export async function cmdWatch(squarePath, name, opts) {
     let square;
     try {
@@ -144,8 +151,7 @@ export async function cmdWatch(squarePath, name, opts) {
     }
     if (opts.now) {
         await closeOpenSquare(square);
-        await cmdWatchNow(squarePath, name, opts);
-        return;
+        return cmdWatchNow(squarePath, name, opts);
     }
     const start = await beginWatch(square, squarePath, name, opts);
     if (start.type === 'active') {

package/extensions/square-pi.js

@@ -44,6 +44,14 @@ export default function squarePiExtension(pi) {
     });
   };
 
+  // A transport may keep its promise pending while Pi is shutting down or
+  // replacing a session. Never make a lifecycle hook wait for that transport.
+  const stopWatcher = () => {
+    watcherAbort?.abort();
+    watcher = undefined;
+    watcherAbort = undefined;
+  };
+
   const wake = async (piContext, token, signal) => {
     while (sessionId !== undefined && token === generation && !signal.aborted) {
       const deferredRetry = retryAfterChange;
@@ -91,10 +99,7 @@ export default function squarePiExtension(pi) {
 
   pi.on('session_start', async (_event, ctx) => {
     generation += 1;
-    watcherAbort?.abort();
-    if (watcher) await watcher;
-    watcher = undefined;
-    watcherAbort = undefined;
+    stopWatcher();
     handledPending.clear();
     retryAfterChange = false;
     sessionId = ctx.sessionManager.getSessionId();
@@ -130,10 +135,7 @@ export default function squarePiExtension(pi) {
 
   pi.on('session_shutdown', async () => {
     generation += 1;
-    watcherAbort?.abort();
-    if (watcher) await watcher;
-    watcher = undefined;
-    watcherAbort = undefined;
+    stopWatcher();
     for (const waiter of settledWaiters) waiter.resolve();
     settledWaiters = [];
     if (sessionId && sessionCwd) await automaticSessionEnd('pi', sessionId, sessionCwd);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.24",
+  "version": "0.3.26",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {