@astrosheep/square 0.3.12 → 0.3.13

package/dist/cli/square-commands.js

@@ -1,13 +1,13 @@
 import { cmdActivity } from '../activity.js';
-import { loadSquare } from '../artifact.js';
-import { cmdCompact } from '../compact.js';
-import { SquareError, formatHardCap, validateName, } from '../model.js';
-import { participantCommandPrefix, renderEventCli, renderPublicTail, withPathOutput, } from '../presentation.js';
-import { hasAutomaticDeliveryIdentity, localParticipantOwner, recordLocalDone, recordLocalJoin } from '../registry.js';
-import { sweepPendingNotifications } from '../notifications.js';
-import { inSquareCount, isCurrentlyJoined, nowMs, resolveRosterName } from '../runtime.js';
-import { createSquare, execute } from '../square-application.js';
-import { formatActivityId, parseActivityId } from '../square-core.js';
+import { formatActivityId, formatHardCap, parseActivityId, } from '../model.js';
+import { participantCommandPrefix, participantIdentity, renderEventCli, renderAmbientEvent, withPathOutput, } from '../presentation.js';
+import { hasAutomaticDeliveryIdentity, localParticipantOwner, recordLocalDone, recordLocalJoin, } from '../registry.js';
+import { sweepPendingNotifications, wakeNotifierForSquare } from '../notifications.js';
+import { nowMs } from '../runtime.js';
+import { createSquare, openSquare } from '../square-file-adapter.js';
+import { closeOpenSquare } from '../open-square.js';
+import { Square } from '../square-wiring.js';
+import { entryPresentation, eventPresentation } from '../views.js';
 import { fail, parseHardCap, parsePositiveInteger, readPipedBodyFallback, readStdinSync, requireParticipant, requireValue, resolveBody, usage, } from './context.js';
 function parseBuild(argv) {
     const options = { force: false, hardCap: null };
@@ -79,57 +79,55 @@ function parseJoin(argv, context) {
 export const joinCommand = {
     parse: parseJoin,
     async execute(intent, context) {
-        validateName(intent.name);
+        const beforeSquare = await openSquare(context.squarePath, { clock: nowMs });
+        const before = await entryPresentation(beforeSquare, intent.name, intent.lastN);
+        await closeOpenSquare(beforeSquare);
+        const square = await Square.at({ path: context.squarePath, clock: nowMs, notifier: wakeNotifierForSquare(context.squarePath) });
         try {
-            const committed = await execute(context.squarePath, { type: 'join', name: intent.name, now: nowMs() });
-            const joinedName = committed.result.joinedName;
-            const isRejoin = !committed.result.addParticipant;
-            const after = loadSquare(context.squarePath);
-            const preamble = after.preamble.at(-1) === '---' ? after.preamble.slice(0, -1) : after.preamble;
+            const participant = await square.join(intent.name);
+            const joinedName = participant.name;
+            const isRejoin = before.joined;
+            const reconnect = isRejoin
+                && localParticipantOwner(context.squarePath, joinedName) !== undefined;
+            if (isRejoin && !intent.kick && !reconnect) {
+                fail([
+                    `✕ ${participantIdentity(joinedName)} shoos you out of the square`,
+                    `  · a same-named participant stands here — the name is taken`,
+                    `  · --kick banishes her and the name becomes yours`,
+                    `» ${participantCommandPrefix(context.squarePath, joinedName)} join --kick`,
+                ].join('\n'));
+            }
+            const afterSquare = await openSquare(context.squarePath, { clock: nowMs });
+            const after = await entryPresentation(afterSquare, joinedName, intent.lastN);
+            await closeOpenSquare(afterSquare);
             recordLocalJoin(joinedName, context.squarePath);
             await sweepPendingNotifications(context.squarePath);
-            const activities = renderPublicTail(after.acts, intent.lastN, nowMs(), joinedName);
-            const contextText = preamble.join('\n').trim();
+            const activities = after.recentActivities.map((event) => renderAmbientEvent(event, joinedName, {
+                now: nowMs(),
+                preview: intent.lastN === null ? undefined : 200,
+                actNumber: event.kind === 'say' ? after.sayNumbers[event.index] : undefined,
+            })).filter(Boolean).join('\n\n');
+            const contextText = after.joinContext;
             const fallback = hasAutomaticDeliveryIdentity()
                 ? []
                 : ['', `» ${participantCommandPrefix(context.squarePath, joinedName)} catch --idle 30m`, '  no session delivery detected — keep this catch open for new activity'];
-            const scene = after.warmup.join('\n').trim();
+            const scene = after.scene;
+            const entryLine = !isRejoin
+                ? '● You stepped into the square'
+                : reconnect && !intent.kick
+                    ? '● you are already in the square'
+                    : `✓ you banished the original ${participantIdentity(joinedName)} — the name is yours`;
             const output = [
-                `● You stepped into the square`,
-                ...(isRejoin || scene === '' ? [] : ['', scene]),
+                entryLine,
+                ...(reconnect || scene === '' ? [] : ['', scene]),
                 ...(isRejoin || contextText === '' ? [] : ['', 'context', contextText]),
-                ...(activities === '' ? [] : ['', 'recent activity', activities]),
+                ...(isRejoin || activities === '' ? [] : ['', 'recent activity', activities]),
                 ...fallback,
             ].join('\n');
-            return withPathOutput(context.squarePath, output, { participantCount: inSquareCount(after) });
+            return withPathOutput(context.squarePath, output, { participantCount: after.participantCount });
         }
-        catch (error) {
-            if (!(error instanceof SquareError) || error.code !== 'conflict')
-                throw error;
-            const doc = loadSquare(context.squarePath);
-            const joinedName = resolveRosterName(doc, intent.name);
-            if (joinedName === undefined || !isCurrentlyJoined(doc.acts, joinedName))
-                throw error;
-            const reconnect = localParticipantOwner(context.squarePath, joinedName) !== undefined;
-            if (!intent.kick && !reconnect) {
-                fail([
-                    `✕ ${joinedName} shoos you out of the square`,
-                    `  · a same-named participant stands here — the name is taken`,
-                    `  · --kick banishes her and the name becomes yours`,
-                    `» ${participantCommandPrefix(context.squarePath, joinedName)} join --kick`,
-                ].join('\n'));
-            }
-            recordLocalJoin(joinedName, context.squarePath);
-            await sweepPendingNotifications(context.squarePath);
-            const fallback = hasAutomaticDeliveryIdentity()
-                ? ''
-                : `\n» ${participantCommandPrefix(context.squarePath, joinedName)} catch --idle 30m\n  no session delivery detected — keep this catch open for new activity`;
-            const line = reconnect && !intent.kick
-                ? `● you are already in the square`
-                : `✓ you banished the original ${joinedName} — the name is yours`;
-            const scene = doc.warmup.join('\n').trim();
-            const showScene = !(reconnect && !intent.kick) && scene !== '';
-            return withPathOutput(context.squarePath, `${line}${showScene ? `\n\n${scene}` : ''}${fallback}`, { participantCount: inSquareCount(doc) });
+        finally {
+            await square.close();
         }
     },
     present: (result) => process.stdout.write(result),
@@ -195,10 +193,15 @@ export const doneCommand = {
     parse: parseDone,
     async execute(intent, context) {
         const body = resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim();
-        const committed = await execute(context.squarePath, { type: 'done', name: intent.name, body, now: nowMs() });
-        const name = committed.acts[0].actor;
+        const square = await Square.at({ path: context.squarePath, clock: nowMs, notifier: wakeNotifierForSquare(context.squarePath) });
+        const participant = await square.join(intent.name);
+        const result = await participant.done(body);
+        await square.close();
+        const name = result.activity.actor;
         recordLocalDone(name, context.squarePath);
-        return withPathOutput(context.squarePath, `× ${name} steps out of the square — done · just now`, { participantCount: inSquareCount(loadSquare(context.squarePath)) });
+        const presentation = await openSquare(context.squarePath, { clock: nowMs });
+        const participantCount = (await entryPresentation(presentation, name).finally(() => closeOpenSquare(presentation))).participantCount;
+        return withPathOutput(context.squarePath, `○ ${participantIdentity(name)} steps out of the square — done · just now`, { participantCount });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -210,9 +213,19 @@ function parseHold(argv, context) {
 export const holdCommand = {
     parse: parseHold,
     async execute(intent, context) {
-        const committed = await execute(context.squarePath, { type: 'hold', actor: intent.name, body: resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim(), now: nowMs() });
-        const doc = loadSquare(context.squarePath);
-        return withPathOutput(context.squarePath, renderEventCli(committed.acts[0]), { participantCount: inSquareCount(doc), held: true });
+        const square = await Square.at({ path: context.squarePath, clock: nowMs, notifier: wakeNotifierForSquare(context.squarePath) });
+        try {
+            const participant = await square.join(intent.name);
+            const result = await participant.hold(resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim());
+            await square.close();
+            const presentationSquare = await openSquare(context.squarePath, { clock: nowMs });
+            const presentation = await eventPresentation(presentationSquare, result.activity.id);
+            await closeOpenSquare(presentationSquare);
+            return withPathOutput(context.squarePath, renderEventCli(presentation.activity), { participantCount: presentation.participantCount, held: true });
+        }
+        finally {
+            await square.close();
+        }
     },
     present: (result) => process.stdout.write(result),
 };
@@ -223,25 +236,19 @@ export const resumeCommand = {
         return { name: requireParticipant(context.name) };
     },
     async execute(intent, context) {
-        const committed = await execute(context.squarePath, { type: 'resume', actor: intent.name, now: nowMs() });
-        const doc = loadSquare(context.squarePath);
-        return withPathOutput(context.squarePath, renderEventCli(committed.acts[0]), { participantCount: inSquareCount(doc) });
-    },
-    present: (result) => process.stdout.write(result),
-};
-export const compactCommand = {
-    parse(argv, context) {
-        let keep = 50;
-        for (let index = 0; index < argv.length; index++) {
-            if (argv[index] !== '--keep')
-                usage(context.command);
-            keep = parsePositiveInteger(requireValue(argv, index, argv[index]), argv[index]);
-            index += 1;
+        const square = await Square.at({ path: context.squarePath, clock: nowMs, notifier: wakeNotifierForSquare(context.squarePath) });
+        try {
+            const participant = await square.join(intent.name);
+            const result = await participant.resume();
+            await square.close();
+            const presentationSquare = await openSquare(context.squarePath, { clock: nowMs });
+            const presentation = await eventPresentation(presentationSquare, result.activity.id);
+            await closeOpenSquare(presentationSquare);
+            return withPathOutput(context.squarePath, renderEventCli(presentation.activity), { participantCount: presentation.participantCount });
+        }
+        finally {
+            await square.close();
         }
-        return { keep };
-    },
-    async execute(intent, context) {
-        await cmdCompact(context.squarePath, intent);
     },
-    present: () => { },
+    present: (result) => process.stdout.write(result),
 };

package/dist/cmd/notify-once.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/codex-hook.d.ts

@@ -0,0 +1,10 @@
+import type { InboxMembership } from './model.js';
+export interface CodexHookInput {
+    session_id?: unknown;
+    hook_event_name?: unknown;
+    cwd?: unknown;
+    source?: unknown;
+}
+export declare function codexHookResponse(input: CodexHookInput, lookup?: (sessionId: string) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv): Promise<object | undefined>;
+export declare function runCodexHook(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;
+export declare function runCodexHookAsync(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;

package/dist/codex-hook.js

@@ -1,13 +1,14 @@
 import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
-export function codexHookResponse(input, lookup = sessionInbox, env = process.env) {
+import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
+export async function codexHookResponse(input, lookup = sessionInbox, env = process.env) {
     if (typeof input.session_id !== 'string' || input.session_id === '')
         return undefined;
     if (input.hook_event_name !== 'PostToolUse')
         return undefined;
     return presentPendingAtBoundary(input.session_id, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: context } }), lookup, env);
 }
-export function runCodexHook(inputText, env = process.env) {
+export async function runCodexHook(inputText, env = process.env) {
     let input;
     try {
         input = JSON.parse(inputText);
@@ -17,6 +18,37 @@ export function runCodexHook(inputText, env = process.env) {
     }
     if (input === null || typeof input !== 'object')
         return '';
-    const response = codexHookResponse(input, sessionInbox, env);
+    const response = await codexHookResponse(input, sessionInbox, env);
     return response === undefined ? '' : `${JSON.stringify(response)}\n`;
 }
+export async function runCodexHookAsync(inputText, env = process.env) {
+    let input;
+    try {
+        input = JSON.parse(inputText);
+    }
+    catch {
+        return '';
+    }
+    if (input === null || typeof input !== 'object')
+        return '';
+    const value = input;
+    if (typeof value.session_id !== 'string' || typeof value.cwd !== 'string')
+        return runCodexHook(inputText, env);
+    if (value.hook_event_name === 'SessionStart' || value.hook_event_name === 'SessionResume') {
+        try {
+            const context = await automaticSessionStart('codex', value.session_id, value.cwd, env);
+            return context === undefined ? '' : `${JSON.stringify({ hookSpecificOutput: { hookEventName: value.hook_event_name, additionalContext: context } })}\n`;
+        }
+        catch {
+            return '';
+        }
+    }
+    if (value.hook_event_name === 'SessionEnd') {
+        try {
+            await automaticSessionEnd('codex', value.session_id, value.cwd, env);
+        }
+        catch { /* end remains bounded */ }
+        return '';
+    }
+    return runCodexHook(inputText, env);
+}

package/dist/decisions.d.ts

@@ -0,0 +1,92 @@
+import { type ActivitiesOptions, type Act, type StoredAct, type SquareState, type Reach, type HardCap } from './model.js';
+import { peerPublicActs, peerRoomChanges } from './activity-feed.js';
+export interface UnreadActivitySummary {
+    name: string;
+    count: number;
+    latestActivityAgeMs: number;
+    previews: UnreadActivityPreview[];
+}
+export interface UnreadActivityPreview {
+    number: number;
+    act: Extract<StoredAct, {
+        kind: 'say';
+    }>;
+}
+export declare function resolveKnownName(squareState: SquareState, name: string): string;
+export interface DecideJoinResult {
+    joinedName: string;
+    addParticipant: boolean;
+    joinAct?: Extract<Act, {
+        kind: 'join';
+    }>;
+}
+export declare function decideJoin(squareState: SquareState, name: string, now: number): DecideJoinResult;
+export type ActDecision = {
+    type: 'sent';
+    act: Act;
+    confirmation: string;
+    ownActCount: number;
+    pendingPublic: ReturnType<typeof peerPublicActs>;
+    pendingRoomChanges: ReturnType<typeof peerRoomChanges>;
+} | {
+    type: 'blocked';
+    activitySummaries: UnreadActivitySummary[];
+    unreadRoomChanges: ReturnType<typeof peerRoomChanges>;
+} | {
+    type: 'capped';
+    count: number;
+    hardCap: number;
+} | {
+    type: 'throttled';
+    delayMs: number;
+} | {
+    type: 'held';
+    reason: string | undefined;
+} | {
+    type: 'bell_quota';
+    nextAt: number;
+};
+export declare function decideAct(squareState: SquareState, input: {
+    name: string;
+    body: string;
+    force: boolean;
+    now: number;
+    reach?: Reach;
+    reply?: number;
+}): ActDecision;
+export declare function coreDone(squareState: SquareState, name: string, body: string, now: number): Extract<Act, {
+    kind: 'done';
+}>;
+export declare function coreHold(squareState: SquareState, actor: string, body: string, now: number): Extract<Act, {
+    kind: 'hold';
+}>;
+export declare function coreResume(squareState: SquareState, actor: string, now: number): Extract<Act, {
+    kind: 'resume';
+}>;
+export interface ParticipantStatus {
+    name: string;
+    state: 'active' | 'done' | 'not joined';
+    activityCount: number;
+    lastActiveAt: number | undefined;
+    presence: CorePresenceState;
+    presenceAt: number | undefined;
+    unreadActivityCount: number;
+    pendingMentionCount: number;
+}
+export type CorePresenceState = 'never-joined' | 'active' | 'watching' | 'done';
+export interface StatusResult {
+    hardCap: HardCap;
+    throttlePerMinute: number | undefined;
+    activeCount: number;
+    doneCount: number;
+    holdActive: boolean;
+    holdReason: string | undefined;
+    holdActor: string | undefined;
+    holdAt: number | undefined;
+    participants: ParticipantStatus[];
+    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[];

package/dist/decisions.js

@@ -1,28 +1,30 @@
 import { SquareError, sameName, validateName, } from './model.js';
+import { participantIdentity } from './participant-identity.js';
 import { UNREAD_BLOCK_GRACE_MS, actId, actStableIndex, foldedState, freshWatchLease, getReadState, publicActs, readCursor, resolveRosterName, rosterNames, matchesMentionTarget, THROTTLE_WINDOW_MS, } from './runtime.js';
 import { actDelta, peerPublicActs, peerRoomChanges } from './activity-feed.js';
 import { extractMentions, formatActivityId, validate } from './square-core.js';
 import { deriveDeliveryModel } from './delivery.js';
 import { compileSearchPattern } from './search.js';
-export function resolveKnownName(doc, name) {
+export function resolveKnownName(squareState, name) {
     validateName(name);
-    const known = resolveRosterName(doc, name);
+    const known = resolveRosterName(squareState, name);
     if (known === undefined) {
-        const roster = rosterNames(doc);
-        throw new SquareError('invalid_args', `Unknown participant "${name}". Expected one of: ${roster.join(', ')}.`);
+        const roster = rosterNames(squareState);
+        throw new SquareError('invalid_args', `Unknown participant "${participantIdentity(name)}". Expected one of: ${roster.map(participantIdentity).join(', ')}.`);
     }
     return known;
 }
 function participantState(state, name) {
     return state.participants.find((participant) => sameName(participant.name, name));
 }
-export function decideJoin(doc, name, now) {
-    const knownName = resolveRosterName(doc, name);
+export function decideJoin(squareState, name, now) {
+    validateName(name);
+    const knownName = resolveRosterName(squareState, name);
     const joinedName = knownName ?? name;
-    const state = foldedState(doc);
+    const state = foldedState(squareState);
     const result = validate(state, { kind: 'join', actor: joinedName, at: now });
     if (!result.ok && result.reason === 'already_joined') {
-        throw new SquareError('conflict', `A participant named "${joinedName}" is already in this square.`);
+        return { joinedName, addParticipant: false };
     }
     return {
         joinedName,
@@ -30,22 +32,39 @@ export function decideJoin(doc, name, now) {
         joinAct: { kind: 'join', actor: joinedName, at: now },
     };
 }
+function resolveStandingName(squareState, requestedName) {
+    validateName(requestedName);
+    const name = resolveRosterName(squareState, requestedName);
+    if (name === undefined)
+        throw new SquareError('not_joined', `${participantIdentity(requestedName)} has not joined this square`);
+    return name;
+}
+function requireStanding(squareState, act) {
+    const result = validate(foldedState(squareState), act);
+    if (result.ok)
+        return;
+    if (result.reason === 'done')
+        throw new SquareError('already_done', `${act.actor === undefined ? 'participant' : participantIdentity(act.actor)} is already done`);
+    if (result.reason === 'not_joined')
+        throw new SquareError('not_joined', `${act.actor === undefined ? 'participant' : participantIdentity(act.actor)} has not joined this square`);
+    throw new Error(`Unexpected standing validation result: ${result.reason}`);
+}
 const UNREAD_PREVIEW_LIMIT = 3;
-export function decideAct(doc, input) {
+export function decideAct(squareState, input) {
     const { now, force } = input;
-    const name = resolveKnownName(doc, input.name);
+    const name = resolveStandingName(squareState, input.name);
     const body = input.body;
     if (body.trim() === '')
         throw new SquareError('invalid_args', 'express body cannot be empty');
     const reach = input.reach;
     const reply = input.reply;
     if (reply !== undefined) {
-        if (!Number.isSafeInteger(reply) || reply < 0 || reply >= doc.runtime.nextActIndex) {
+        if (!Number.isSafeInteger(reply) || reply < 0 || reply >= squareState.runtime.nextActIndex) {
             const label = Number.isSafeInteger(reply) && reply >= 0 ? formatActivityId(reply) : String(reply);
             throw new SquareError('invalid_args', `Unknown reply activity: ${label}`);
         }
     }
-    const state = foldedState(doc);
+    const state = foldedState(squareState);
     if (reach !== 'bell'
         && extractMentions(body).length === 0) {
         throw new SquareError('invalid_args', 'express requires an @mention unless using --bell');
@@ -55,10 +74,10 @@ export function decideAct(doc, input) {
         kind: 'say', actor: name, at: now, body,
         ...(reach !== undefined ? { reach } : {}),
         ...(reply !== undefined ? { reply } : {}),
-    }, { hardCap: doc.hardCap, throttlePerMinute: doc.throttlePerMinute, throttleWindowMs: THROTTLE_WINDOW_MS });
+    }, { hardCap: squareState.hardCap, throttlePerMinute: squareState.throttlePerMinute, throttleWindowMs: THROTTLE_WINDOW_MS });
     if (!result.ok) {
         if (result.reason === 'done')
-            throw new SquareError('conflict', `${name} is done; rejoin to express again`);
+            throw new SquareError('already_done', `${name} is already done`);
         if (result.reason === 'held')
             return { type: 'held', reason: result.hold.reason };
         if (result.reason === 'hard_cap')
@@ -68,9 +87,9 @@ export function decideAct(doc, input) {
         if (result.reason === 'bell_quota')
             return { type: 'bell_quota', nextAt: result.nextAt };
         if (result.reason === 'not_joined')
-            throw new SquareError('conflict', `${name} has not joined this square`);
+            throw new SquareError('not_joined', `${name} has not joined this square`);
     }
-    const delta = actDelta(doc.acts, readCursor(doc, name));
+    const delta = actDelta(squareState.acts, readCursor(squareState, name));
     const unreadPublic = peerPublicActs(delta, name);
     const unreadRoomChanges = peerRoomChanges(delta, name);
     const sayCountByActor = new Map();
@@ -122,21 +141,29 @@ export function decideAct(doc, input) {
         pendingRoomChanges: unreadRoomChanges,
     };
 }
-export function coreDone(doc, name, body, now) {
-    const resolvedName = resolveKnownName(doc, name);
-    return { kind: 'done', actor: resolvedName, at: now, body: body.replace(/\r\n/g, '\n').trim() };
+export function coreDone(squareState, name, body, now) {
+    const resolvedName = resolveStandingName(squareState, name);
+    const act = { kind: 'done', actor: resolvedName, at: now, body: body.replace(/\r\n/g, '\n').trim() };
+    requireStanding(squareState, act);
+    return act;
 }
-export function coreHold(_doc, actor, body, now) {
-    return { kind: 'hold', actor, at: now, body: body.replace(/\r\n/g, '\n').trim() };
+export function coreHold(squareState, actor, body, now) {
+    const resolvedName = resolveStandingName(squareState, actor);
+    const act = { kind: 'hold', actor: resolvedName, at: now, body: body.replace(/\r\n/g, '\n').trim() };
+    requireStanding(squareState, act);
+    return act;
 }
-export function coreResume(_doc, actor, now) {
-    return { kind: 'resume', actor, at: now };
+export function coreResume(squareState, actor, now) {
+    const resolvedName = resolveStandingName(squareState, actor);
+    const act = { kind: 'resume', actor: resolvedName, at: now };
+    requireStanding(squareState, act);
+    return act;
 }
-function presenceFor(doc, snapshot, name, now) {
+function presenceFor(squareState, snapshot, name, now) {
     if (snapshot?.done)
         return { state: 'done', lastAt: snapshot.lastActiveAt };
-    const cursor = getReadState(doc, name);
-    const lease = freshWatchLease(doc, name, now);
+    const cursor = getReadState(squareState, name);
+    const lease = freshWatchLease(squareState, name, now);
     if (lease !== undefined)
         return { state: 'watching', lastAt: cursor?.updatedAt ?? lease.heartbeatAt };
     const lastAt = cursor?.updatedAt ?? (snapshot?.joined ? snapshot.lastActiveAt : undefined);
@@ -144,16 +171,16 @@ function presenceFor(doc, snapshot, name, now) {
         ? { state: 'never-joined', lastAt: undefined }
         : { state: 'active', lastAt };
 }
-function buildParticipantStatuses(doc, now, state = foldedState(doc)) {
-    const delivery = deriveDeliveryModel(doc);
+function buildParticipantStatuses(squareState, now, state = foldedState(squareState)) {
+    const delivery = deriveDeliveryModel(squareState);
     return state.participants.map((snapshot) => {
         const participant = snapshot.name;
-        const presence = presenceFor(doc, snapshot, participant, now);
+        const presence = presenceFor(squareState, snapshot, participant, now);
         const participantStatus = snapshot?.done ? 'done' : snapshot?.joined ? 'active' : 'not joined';
-        const consumedThrough = readCursor(doc, participant);
+        const consumedThrough = readCursor(squareState, participant);
         let unreadActivityCount = 0;
         if (snapshot?.joined) {
-            for (const act of doc.acts) {
+            for (const act of squareState.acts) {
                 if (actStableIndex(act) <= consumedThrough || act.actor === undefined || sameName(act.actor, participant))
                     continue;
                 if (act.kind !== 'read')
@@ -172,43 +199,44 @@ function buildParticipantStatuses(doc, now, state = foldedState(doc)) {
         };
     });
 }
-export function coreStatus(doc, now) {
-    const state = foldedState(doc);
-    const latestAct = publicActs(doc.acts).at(-1);
+export function coreStatus(squareState, now) {
+    const state = foldedState(squareState);
+    const latestAct = publicActs(squareState.acts).at(-1);
     return {
-        hardCap: doc.hardCap,
-        throttlePerMinute: doc.throttlePerMinute,
+        hardCap: squareState.hardCap,
+        throttlePerMinute: squareState.throttlePerMinute,
         activeCount: state.joined.length,
         doneCount: state.done.length,
         holdActive: state.hold.active,
         holdReason: state.hold.reason,
         holdActor: state.hold.actor,
         holdAt: state.hold.at,
-        participants: buildParticipantStatuses(doc, now, state),
+        participants: buildParticipantStatuses(squareState, now, state),
         latestAct,
         now,
     };
 }
-export function coreParticipants(doc, now) {
-    return buildParticipantStatuses(doc, now);
+export function coreParticipants(squareState, now) {
+    return buildParticipantStatuses(squareState, now);
 }
-export function coreActivities(doc, opts) {
+export function coreActivities(squareState, opts) {
     const participants = opts.participants ?? [];
-    const canonicalParticipants = participants.map((participant) => resolveKnownName(doc, participant));
-    const viewer = opts.viewer !== undefined ? resolveKnownName(doc, opts.viewer) : undefined;
-    let acts = [...doc.acts];
-    // --at establishes a context window first; other filters AND inside it.
-    if (opts.atIndex != null) {
+    const canonicalParticipants = participants.map((participant) => resolveKnownName(squareState, participant));
+    const viewer = opts.viewer !== undefined ? resolveKnownName(squareState, opts.viewer) : undefined;
+    let acts = [...squareState.acts];
+    // --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;
         const after = opts.afterContext ?? 0;
-        const centerPos = acts.findIndex((act) => act.index === opts.atIndex);
-        if (centerPos < 0)
-            return [];
-        acts = acts.slice(Math.max(0, centerPos - before), centerPos + after + 1);
-    }
-    if (opts.ids !== undefined && opts.ids.length > 0) {
-        const wanted = new Set(opts.ids);
-        acts = acts.filter((act) => wanted.has(act.index));
+        const selected = new Set();
+        for (const atIndex of opts.atIndexes) {
+            const centerPos = acts.findIndex((act) => act.index === atIndex);
+            if (centerPos < 0)
+                continue;
+            for (const act of acts.slice(Math.max(0, centerPos - before), centerPos + after + 1))
+                selected.add(act.index);
+        }
+        acts = acts.filter((act) => selected.has(act.index));
     }
     if (opts.afterIndex != null)
         acts = acts.filter((act) => act.index > opts.afterIndex);
@@ -220,13 +248,13 @@ export function coreActivities(doc, opts) {
     if (opts.after != null)
         acts = acts.filter((act) => act.at > opts.after);
     if (opts.mention != null) {
-        const mention = resolveKnownName(doc, opts.mention);
+        const mention = resolveKnownName(squareState, opts.mention);
         acts = acts.filter((act) => act.kind === 'say' && (act.reach === 'bell' || matchesMentionTarget(act, mention)));
     }
     if (opts.pending) {
         if (viewer === undefined)
             return [];
-        const pendingIndexes = new Set(deriveDeliveryModel(doc).pendingFor(viewer).map((notification) => notification.item.index));
+        const pendingIndexes = new Set(deriveDeliveryModel(squareState).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;
@@ -249,25 +277,3 @@ export function coreActivities(doc, opts) {
     }
     return acts;
 }
-export function coreCompact(doc, keep) {
-    if (doc.acts.length <= keep)
-        return { archived: [], doc };
-    const splitAt = doc.acts.length - keep;
-    const archived = doc.acts.slice(0, splitAt);
-    const retained = doc.acts.slice(splitAt);
-    const cutoffIndex = actStableIndex(archived[archived.length - 1]);
-    const unread = foldedState(doc).participants
-        .filter((participant) => participant.joined && readCursor(doc, participant.name) < cutoffIndex)
-        .map((participant) => participant.name);
-    if (unread.length > 0) {
-        throw new SquareError('conflict', `Refusing to compact: ${unread.join(', ')} ${unread.length === 1 ? 'has' : 'have'} not read through the activities being archived.`);
-    }
-    return {
-        archived,
-        doc: {
-            ...doc,
-            acts: retained,
-            runtime: doc.runtime,
-        },
-    };
-}