@astrosheep/square 0.3.23 → 0.3.25

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

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.23",
+  "version": "0.3.25",
   "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.23",
+  "version": "0.3.25",
   "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/automatic-session.js

@@ -38,7 +38,7 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
             return undefined;
         const channel = provider === 'claude' ? 'claude-code' : provider;
         recordSessionJoin(sessionId, name, squarePath, channel, { ...env, [providerEnv[provider]]: sessionId });
-        return `${name} came back`;
+        return undefined;
     }
     finally {
         await square.close();

package/dist/cli/observation-commands.js

@@ -4,7 +4,7 @@ import { sessionInbox } from '../inbox.js';
 import { sweepPendingNotifications } from '../notifications.js';
 import { cmdListSquares } from '../list.js';
 import { parseActivityId, sameName } from '../model.js';
-import { commandPrefix, participantCommandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEvent, withPathOutput, } from '../presentation.js';
+import { commandPrefix, participantCommandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEvent, renderPresenceAnchor, withPathOutput, } from '../presentation.js';
 import { actId, nowMs } from '../runtime.js';
 import { cmdStream, cmdStreamNdjson } from '../stream.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.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: () => { },
 };
@@ -293,8 +295,9 @@ function renderHistoryProjection(projection, visible, full, squarePath, viewer,
             : renderAmbientEvent(activity, viewer, options);
         if (rendered !== '')
             chunks.push(rendered);
-        for (const name of projection.presenceAnchors[activity.index] ?? [])
-            chunks.push(`→ ${participantIdentity(name)} was here`);
+        const participants = projection.presenceAnchors[activity.index];
+        if (participants !== undefined)
+            chunks.push(renderPresenceAnchor(participants));
     }
     if (chunks.length === 0)
         return 'latest\n  ○ no public activity in this view';
@@ -381,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 ? '●' : '○';
@@ -400,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';
@@ -14,10 +14,10 @@ import { retireWakeRoute } from './routes.js';
 import { openSquare } from './square-file-adapter.js';
 import { markNotificationNotified } from './square-wiring.js';
 import { closeOpenSquare } from './open-square.js';
-import { entryPresentation, notificationDelivered, notificationForAct, pendingDeliveries, resolveParticipant } from './views.js';
+import { entryPresentation, notificationDelivered, notificationForAct, pendingDeliveriesFromState, resolveParticipant } from './views.js';
 import { claimNotificationLease, releaseNotificationLease, transitionNotificationLease } from './wakes.js';
 import { nextWakeAttemptNumber, recordRecoveredUnknown, recordWakeAttempt, } from './wake-attempts.js';
-import { wakeEvidence, wakeIsEligible } from './wake-evidence.js';
+import { wakeEvidence, wakeEvidenceProjectionFromState, wakeIsEligible } from './wake-evidence.js';
 import { WakePort } from './wake-port.js';
 const NOTIFY_LEASE_MS = 5 * 60 * 1000;
 export { planActNotifications, matchesMentionTarget };
@@ -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;
@@ -264,18 +281,14 @@ export async function sweepPendingNotifications(squarePath, opts = {}) {
     const now = opts.now ?? Date.now();
     const limit = opts.limit ?? 8;
     const square = await openSquare(squarePath, { clock: () => now });
-    const pending = await pendingDeliveries(square).finally(() => closeOpenSquare(square));
-    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(await wakeEvidence(squarePath, delivery.recipient, note.item.index, now, env)))
-                continue;
-            indexes.add(note.item.index);
-        }
+    let state;
+    try {
+        ({ state } = await entryPresentation(square, ''));
+    }
+    finally {
+        await closeOpenSquare(square);
     }
-    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

@@ -75,6 +75,7 @@ export declare function renderActivityBlocked(opts: ActivityBlockedOptions): str
 export declare function renderExpressWaiting(opts: ExpressWaitingOptions): string;
 export declare function renderExpressNoWait(opts: ExpressNoWaitOptions): string;
 export declare function renderPublicTail(squareState: SquareState, events: StoredAct[], lastN: number | null | undefined, now?: number, viewer?: string): string;
+export declare function renderPresenceAnchor(names: readonly string[]): string;
 export declare function renderActivitiesView(squareState: SquareState, visible: StoredAct[], lastN: number | null | undefined, full: boolean | undefined, squarePath: string, viewer?: string, mode?: 'ambient' | 'archive'): string;
 export declare function renderGrepActivitiesView(visible: StoredAct[], totalMatches: number, full: boolean | undefined, squarePath: string, pattern: string, fixed?: boolean): string;
 export declare function renderActivityLimit(opts: ActivityLimitOptions): string;
@@ -91,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

@@ -291,8 +291,9 @@ function lastPresenceAnchor(squareState, name) {
     }
     return -1;
 }
-function renderLastPresenceMarker(name) {
-    return `→ ${participantIdentity(name)} was here`;
+export function renderPresenceAnchor(names) {
+    const participants = names.map((name) => participantIdentity(name)).join(', ');
+    return names.length === 1 ? `→ ${participants} was here` : `→ ${participants} were here`;
 }
 export function renderActivitiesView(squareState, visible, lastN, full, squarePath, viewer = '', mode = 'ambient') {
     const publicVisible = visible.filter((act) => act.kind === 'say' || act.kind === 'done');
@@ -315,9 +316,9 @@ export function renderActivitiesView(squareState, visible, lastN, full, squarePa
             : renderAmbientEvent(act, viewer, { ...opts, squareState });
         if (rendered !== '')
             chunks.push(rendered);
-        for (const participant of markers.get(act.index) ?? []) {
-            chunks.push(renderLastPresenceMarker(participant));
-        }
+        const participants = markers.get(act.index);
+        if (participants !== undefined)
+            chunks.push(renderPresenceAnchor(participants));
     }
     if (chunks.length === 0)
         return 'latest\n  ○ no public activity in this view';
@@ -455,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');