@astrosheep/square 0.3.4 → 0.3.6

package/dist/cli/square-commands.js

@@ -0,0 +1,219 @@
+import { cmdActivity } from '../activity.js';
+import { loadSquare } from '../artifact.js';
+import { cmdCompact } from '../compact.js';
+import { SquareError, formatHardCap, validateName, } from '../model.js';
+import { participantCommandPrefix, quoteShell, renderEventCli, renderPublicTail, withPathOutput, } from '../presentation.js';
+import { hasAutomaticDeliveryIdentity, recordLocalDone, recordLocalJoin } from '../registry.js';
+import { inSquareCount, isCurrentlyJoined, nowMs, resolveRosterName } from '../runtime.js';
+import { createSquare, execute } from '../square-application.js';
+import { fail, parseHardCap, parsePositiveInteger, readPipedBodyFallback, readStdinSync, requireParticipant, requireValue, resolveBody, usage, } from './context.js';
+function parseBuild(argv) {
+    const options = { force: false, hardCap: null };
+    for (let index = 0; index < argv.length; index++) {
+        const flag = argv[index];
+        switch (flag) {
+            case '--cap':
+                options.hardCap = parseHardCap(requireValue(argv, index, flag));
+                index += 1;
+                break;
+            case '--template':
+                options.template = requireValue(argv, index, flag);
+                index += 1;
+                break;
+            case '--throttle':
+            case '--throttle-per-minute':
+                options.throttlePerMinute = parsePositiveInteger(requireValue(argv, index, flag), flag);
+                index += 1;
+                break;
+            case '--force':
+            case '-f':
+                options.force = true;
+                break;
+            default:
+                fail(`Unknown build option: ${flag}`);
+        }
+    }
+    if (options.template !== undefined && !/^[a-zA-Z0-9-]+$/.test(options.template)) {
+        fail('Invalid template name: only letters, digits, and hyphens allowed.');
+    }
+    if (options.throttlePerMinute !== undefined && options.throttlePerMinute <= 0) {
+        fail('Invalid build option: --throttle must be a positive integer.');
+    }
+    const snippet = readStdinSync();
+    if (snippet.trim() === '')
+        fail('Missing Markdown body snippet on stdin.');
+    return { options, snippet };
+}
+export const buildCommand = {
+    parse: (argv) => parseBuild(argv),
+    async execute(intent, context) {
+        await createSquare(context.squarePath, intent.options, intent.snippet);
+        const cap = intent.options.hardCap === null ? 'unlimited' : formatHardCap(intent.options.hardCap);
+        const throttle = intent.options.throttlePerMinute === undefined ? [] : [`  · throttle ${intent.options.throttlePerMinute}/min`];
+        return withPathOutput(context.squarePath, ['✓ built', `  · cap ${cap}`, ...throttle, '  · participants (none seeded — first join adds names)'].join('\n'), { participantCount: 0 });
+    },
+    present: (result) => process.stdout.write(result),
+};
+function parseJoin(argv, context) {
+    let lastN = 10;
+    for (let index = 0; index < argv.length; index++) {
+        if (argv[index] === '--last') {
+            lastN = parsePositiveInteger(requireValue(argv, index, argv[index]), argv[index]);
+            index += 1;
+        }
+        else if (argv[index] === '--all') {
+            lastN = null;
+        }
+        else {
+            usage(context.command);
+        }
+    }
+    return { name: requireParticipant(context.name), lastN };
+}
+export const joinCommand = {
+    parse: parseJoin,
+    async execute(intent, context) {
+        validateName(intent.name);
+        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;
+            recordLocalJoin(joinedName, context.squarePath);
+            const activities = renderPublicTail(after.acts, intent.lastN, nowMs(), joinedName);
+            const contextText = preamble.join('\n').trim();
+            const fallback = hasAutomaticDeliveryIdentity()
+                ? []
+                : ['', `» ${participantCommandPrefix(context.squarePath, joinedName)} catch --idle 30m`, '  no session delivery detected — keep this catch open for new activity'];
+            const output = [
+                `● ${joinedName} stepped into the square`,
+                ...(isRejoin || contextText === '' ? [] : ['', 'context', contextText]),
+                ...(activities === '' ? [] : ['', 'recent activity', activities]),
+                ...(isRejoin ? [] : ['', `» ${participantCommandPrefix(context.squarePath, joinedName)} warmup`]),
+                ...fallback,
+            ].join('\n');
+            return withPathOutput(context.squarePath, output, { participantCount: inSquareCount(after) });
+        }
+        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;
+            recordLocalJoin(joinedName, 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`;
+            return withPathOutput(context.squarePath, `● ${joinedName} is already in the square${fallback}`, { participantCount: inSquareCount(doc) });
+        }
+    },
+    present: (result) => process.stdout.write(result),
+};
+function parseActivity(argv, context) {
+    let force = false;
+    let noWait = false;
+    let beside;
+    let bell = false;
+    const bodyArgs = [];
+    for (let index = 0; index < argv.length; index++) {
+        const argument = argv[index];
+        if (argument === '-f' || argument === '--force')
+            force = true;
+        else if (argument === '--no-wait')
+            noWait = true;
+        else if (argument === '--beside') {
+            beside = requireValue(argv, index, argument);
+            index += 1;
+        }
+        else if (argument === '--bell')
+            bell = true;
+        else
+            bodyArgs.push(argument);
+    }
+    if (bell && beside !== undefined)
+        fail('Invalid express options: --beside and --bell are mutually exclusive.');
+    const reach = bell ? 'bell' : beside === undefined ? undefined : { beside };
+    if (bodyArgs.length !== 1) {
+        if (bodyArgs.length === 0) {
+            const piped = readPipedBodyFallback();
+            if (piped !== undefined)
+                return { name: requireParticipant(context.name), activity: piped, force, noWait, reach };
+        }
+        fail("express requires a body argument (a quoted string or '-' with piped stdin)");
+    }
+    return { name: requireParticipant(context.name), activity: bodyArgs[0], force, noWait, reach };
+}
+export const expressCommand = {
+    parse: parseActivity,
+    async execute(intent, context) {
+        const reachArg = intent.reach === 'bell' ? ' --bell' : intent.reach === undefined ? '' : ` --beside ${quoteShell(intent.reach.beside)}`;
+        await cmdActivity(context.squarePath, intent.name, intent.activity, resolveBody, {
+            force: intent.force,
+            noWait: intent.noWait,
+            reach: intent.reach,
+            forceCommand: `${participantCommandPrefix(context.squarePath, intent.name)} express --force${reachArg} -`,
+        });
+    },
+    present: () => { },
+};
+function parseDone(argv, context) {
+    if (argv.length > 1)
+        usage(context.command);
+    return { name: requireParticipant(context.name), body: argv.length === 1 ? argv[0] : readPipedBodyFallback() };
+}
+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;
+        recordLocalDone(name, context.squarePath);
+        return withPathOutput(context.squarePath, `× ${name} steps out of the square — done · just now`, { participantCount: inSquareCount(loadSquare(context.squarePath)) });
+    },
+    present: (result) => process.stdout.write(result),
+};
+function parseHold(argv, context) {
+    if (argv.length > 1)
+        usage(context.command);
+    return { name: requireParticipant(context.name), body: argv[0] };
+}
+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 });
+    },
+    present: (result) => process.stdout.write(result),
+};
+export const resumeCommand = {
+    parse(argv, context) {
+        if (argv.length !== 0)
+            usage(context.command);
+        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;
+        }
+        return { keep };
+    },
+    async execute(intent, context) {
+        await cmdCompact(context.squarePath, intent);
+    },
+    present: () => { },
+};

package/dist/cmd/notify-once.js

@@ -1,37 +1,39 @@
 #!/usr/bin/env node
-import { setTimeout as sleep } from 'node:timers/promises';
 import { resolve } from 'node:path';
-import { notificationDeliveryWaitMs, processActNotificationsOnce, } from '../notifications.js';
-function parseArgs(argv) {
+import { setTimeout as sleep } from 'node:timers/promises';
+import { recordNotificationFailure } from '../notification-failures.js';
+import { notificationDeliveryWaitMs, processActNotificationsOnce } from '../notifications.js';
+function args(argv) {
     let squarePath;
     let actIndex;
-    for (let index = 0; index < argv.length; index++) {
-        const argument = argv[index];
-        if (argument === '--square-path' && argv[index + 1] !== undefined) {
+    for (let index = 0; index < argv.length; index += 1) {
+        if (argv[index] === '--square-path' && argv[index + 1] !== undefined)
             squarePath = resolve(argv[++index]);
-            continue;
-        }
-        if (argument === '--act-index' && argv[index + 1] !== undefined) {
-            const value = Number(argv[++index]);
-            if (Number.isInteger(value) && value >= 0)
-                actIndex = value;
-            continue;
-        }
-        throw new Error(`Unknown notify-once argument: ${argument}`);
+        else if (argv[index] === '--act-index' && /^\d+$/.test(argv[index + 1] ?? ''))
+            actIndex = Number(argv[++index]);
+        else
+            throw new Error(`Unknown notify-once argument: ${argv[index]}`);
     }
-    if (!squarePath || actIndex === undefined) {
+    if (squarePath === undefined || actIndex === undefined)
         throw new Error('notify-once requires --square-path and --act-index.');
-    }
     return { squarePath, actIndex };
 }
 async function main() {
-    if (process.env['SQUARE_DISABLE_PASEO_WAKE'] === '1')
+    if (process.env.SQUARE_DISABLE_PASEO_WAKE === '1')
         return;
-    const { squarePath, actIndex } = parseArgs(process.argv.slice(2));
+    const { squarePath, actIndex } = args(process.argv.slice(2));
     await sleep(notificationDeliveryWaitMs());
     await processActNotificationsOnce(squarePath, actIndex);
 }
-main().catch(() => {
-    // Detached notification delivery must never surface as a CLI failure.
+main().catch((error) => {
+    const squarePath = process.argv.includes('--square-path') ? process.argv[process.argv.indexOf('--square-path') + 1] : undefined;
+    if (squarePath) {
+        recordNotificationFailure(squarePath, {
+            actIndex: Number(process.argv[process.argv.indexOf('--act-index') + 1]) || 0,
+            sink: 'worker',
+            message: error instanceof Error ? error.message : String(error),
+            diagnostic: { phase: 'worker' },
+        });
+    }
     process.exitCode = 0;
 });

package/dist/compact.js

@@ -1,9 +1,6 @@
-import fs from 'node:fs';
-import { loadSquare, renderArtifactAct } from './artifact.js';
 import { SquareError } from './model.js';
 import { withPathOutput } from './presentation.js';
-import { withSquareLock, writeSquareDoc } from './runtime.js';
-import { coreCompact } from './decisions.js';
+import { execute } from './square-application.js';
 function sidecarPath(squarePath) {
     return squarePath.replace(/\.md$/, '') + '.archive.md';
 }
@@ -12,21 +9,11 @@ export async function cmdCompact(squarePath, opts) {
         let archivedCount;
         let keptCount;
         const archive = sidecarPath(squarePath);
-        await withSquareLock(squarePath, () => {
-            const doc = loadSquare(squarePath);
-            const result = coreCompact(doc, opts.keep);
-            archivedCount = result.archived.length;
-            keptCount = result.doc.acts.length;
-            if (archivedCount > 0) {
-                const sidecarExists = fs.existsSync(archive);
-                const block = result.archived
-                    .map((act, index) => renderArtifactAct(act, { first: !sidecarExists && index === 0 }))
-                    .join('\n');
-                fs.appendFileSync(archive, block + '\n');
-                writeSquareDoc(squarePath, result.doc);
-            }
-        });
-        const summary = ['✓ compacted', `  · archived ${archivedCount} acts`, `  · kept ${keptCount} acts`, ...(archivedCount > 0 ? [`  · sidecar ${archive}`] : [])].join('\n');
+        const committed = await execute(squarePath, { type: 'compact', keep: opts.keep, archivePath: archive });
+        const result = committed.result;
+        archivedCount = result.archived.length;
+        keptCount = result.doc.acts.length;
+        const summary = ['✓ compacted', `  · archived ${archivedCount} activities`, `  · kept ${keptCount} activities`, ...(archivedCount > 0 ? [`  · sidecar ${archive}`] : [])].join('\n');
         process.stdout.write(withPathOutput(squarePath, summary));
     }
     catch (err) {

package/dist/decisions.js

@@ -1,6 +1,6 @@
 import { SquareError, sameName, validateName, } from './model.js';
-import { UNREAD_BLOCK_GRACE_MS, actStableIndex, currentHold, foldedState, freshWatchLease, getReadState, publicActs, readCursor, resolveRosterName, rosterNames, extractMentions, matchesMentionTarget, isPostJoinActivity, isDeliveryDelivered, THROTTLE_WINDOW_MS, } from './runtime.js';
-import { indexedDelta, peerPublicActs, peerRoomChanges } from './activity-feed.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 { validate } from './square-core.js';
 import { deriveDeliveryModel } from './delivery.js';
 import { compileSearchPattern } from './search.js';
@@ -36,14 +36,14 @@ export function decideAct(doc, input) {
     const name = resolveKnownName(doc, input.name);
     const body = input.body;
     if (body.trim() === '')
-        throw new SquareError('invalid_args', 'act body cannot be empty');
+        throw new SquareError('invalid_args', 'express body cannot be empty');
     const reach = input.reach;
     const state = foldedState(doc);
     const current = participantState(state, name);
     const result = validate(state, { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}) }, { hardCap: doc.hardCap, throttlePerMinute: doc.throttlePerMinute, throttleWindowMs: THROTTLE_WINDOW_MS });
     if (!result.ok) {
         if (result.reason === 'done')
-            throw new SquareError('conflict', `${name} is done; rejoin to act again`);
+            throw new SquareError('conflict', `${name} is done; rejoin to express again`);
         if (result.reason === 'held')
             return { type: 'held', reason: result.hold.reason };
         if (result.reason === 'hard_cap')
@@ -55,26 +55,26 @@ export function decideAct(doc, input) {
         if (result.reason === 'not_joined')
             throw new SquareError('conflict', `${name} has not joined this square`);
     }
-    const delta = indexedDelta(doc.acts, readCursor(doc, name));
+    const delta = actDelta(doc.acts, readCursor(doc, name));
     const unreadPublic = peerPublicActs(delta, name);
     const unreadRoomChanges = peerRoomChanges(delta, name);
     const sayCountByActor = new Map();
     const unreadByParticipant = new Map();
     for (const item of delta) {
-        if (item.act.kind === 'say') {
-            const key = item.act.actor.toLocaleLowerCase();
+        if (item.kind === 'say') {
+            const key = item.actor.toLocaleLowerCase();
             sayCountByActor.set(key, (sayCountByActor.get(key) ?? 0) + 1);
         }
-        if (item.act.kind !== 'say' || sameName(item.act.actor, name))
+        if (item.kind !== 'say' || sameName(item.actor, name))
             continue;
-        const actorKey = item.act.actor.toLocaleLowerCase();
-        const currentSummary = unreadByParticipant.get(item.act.actor);
-        unreadByParticipant.set(item.act.actor, {
+        const actorKey = item.actor.toLocaleLowerCase();
+        const currentSummary = unreadByParticipant.get(item.actor);
+        unreadByParticipant.set(item.actor, {
             count: (currentSummary?.count ?? 0) + 1,
-            latestAt: currentSummary === undefined ? item.act.at : Math.max(currentSummary.latestAt, item.act.at),
+            latestAt: currentSummary === undefined ? item.at : Math.max(currentSummary.latestAt, item.at),
             previews: [
                 ...(currentSummary?.previews ?? []),
-                { number: sayCountByActor.get(actorKey) ?? 1, act: item.act },
+                { number: sayCountByActor.get(actorKey) ?? 1, act: item },
             ].slice(-UNREAD_PREVIEW_LIMIT),
         });
     }
@@ -112,35 +112,23 @@ export function coreHold(_doc, actor, body, now) {
 export function coreResume(_doc, actor, now) {
     return { kind: 'resume', actor, at: now, body: '' };
 }
-export function corePresence(doc, now) {
-    const state = foldedState(doc);
-    return rosterNames(doc).map((participant) => {
-        const snapshot = participantState(state, participant);
-        if (snapshot?.done)
-            return { name: participant, state: 'done', lastAt: snapshot.lastActiveAt };
-        const cursor = getReadState(doc, participant);
-        const lease = freshWatchLease(doc, participant, now);
-        if (lease !== undefined)
-            return { name: participant, state: 'watching', lastAt: cursor?.updatedAt ?? lease.heartbeatAt };
-        const lastAt = cursor?.updatedAt ?? (snapshot?.joined ? snapshot.lastActiveAt : undefined);
-        if (lastAt === undefined)
-            return { name: participant, state: 'never-joined', lastAt: undefined };
-        return { name: participant, state: 'active', lastAt };
-    });
+function presenceFor(doc, snapshot, name, now) {
+    if (snapshot?.done)
+        return { state: 'done', lastAt: snapshot.lastActiveAt };
+    const cursor = getReadState(doc, name);
+    const lease = freshWatchLease(doc, name, now);
+    if (lease !== undefined)
+        return { state: 'watching', lastAt: cursor?.updatedAt ?? lease.heartbeatAt };
+    const lastAt = cursor?.updatedAt ?? (snapshot?.joined ? snapshot.lastActiveAt : undefined);
+    return lastAt === undefined
+        ? { state: 'never-joined', lastAt: undefined }
+        : { state: 'active', lastAt };
 }
 function buildParticipantStatuses(doc, now, state = foldedState(doc)) {
     const delivery = deriveDeliveryModel(doc);
-    return state.participants.map(({ name: participant }) => {
-        const snapshot = participantState(state, participant);
-        const cursor = getReadState(doc, participant);
-        const lease = freshWatchLease(doc, participant, now);
-        const presence = snapshot?.done
-            ? { state: 'done', lastAt: snapshot.lastActiveAt }
-            : lease !== undefined
-                ? { state: 'watching', lastAt: cursor?.updatedAt ?? lease.heartbeatAt }
-                : cursor !== undefined || snapshot?.joined
-                    ? { state: 'active', lastAt: cursor?.updatedAt ?? snapshot?.lastActiveAt }
-                    : { state: 'never-joined', lastAt: undefined };
+    return state.participants.map((snapshot) => {
+        const participant = snapshot.name;
+        const presence = presenceFor(doc, snapshot, participant, now);
         const participantStatus = snapshot?.done ? 'done' : snapshot?.joined ? 'active' : 'not joined';
         const consumedThrough = readCursor(doc, participant);
         let unreadActivityCount = 0;
@@ -170,7 +158,6 @@ export function coreStatus(doc, now) {
     return {
         hardCap: doc.hardCap,
         throttlePerMinute: doc.throttlePerMinute,
-        participantCount: state.joined.length,
         activeCount: state.joined.length,
         doneCount: state.done.length,
         holdActive: state.hold.active,
@@ -183,77 +170,62 @@ export function coreStatus(doc, now) {
     };
 }
 export function coreParticipants(doc, now) {
-    return { participants: buildParticipantStatuses(doc, now), now };
-}
-/** True when a say is a bell or explicitly @viewer — not broadcast. */
-function addressesViewer(act, viewer) {
-    if (act.kind !== 'say')
-        return false;
-    if (act.reach === 'bell')
-        return true;
-    return extractMentions(act.body).some((name) => sameName(name, viewer));
+    return buildParticipantStatuses(doc, now);
 }
 export function coreActivities(doc, 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.map((act) => ({ act, index: actStableIndex(act) }));
+    let acts = [...doc.acts];
     // --at establishes a context window first; other filters AND inside it.
     if (opts.atIndex != null) {
         const before = opts.beforeContext ?? 0;
         const after = opts.afterContext ?? 0;
-        const centerPos = acts.findIndex((item) => item.index === opts.atIndex);
+        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(({ index }) => wanted.has(index));
+        acts = acts.filter((act) => wanted.has(act.index));
     }
     if (opts.afterIndex != null)
-        acts = acts.filter(({ index }) => index > opts.afterIndex);
+        acts = acts.filter((act) => act.index > opts.afterIndex);
     if (canonicalParticipants.length > 0) {
-        acts = acts.filter(({ act }) => (act.kind === 'say' && act.reach === 'bell') ||
-            (act.actor !== undefined && canonicalParticipants.some((participant) => sameName(participant, act.actor))));
+        acts = acts.filter((act) => act.actor !== undefined && canonicalParticipants.some((participant) => sameName(participant, act.actor)));
     }
     if (opts.before != null)
-        acts = acts.filter(({ act }) => act.at < opts.before);
+        acts = acts.filter((act) => act.at < opts.before);
     if (opts.after != null)
-        acts = acts.filter(({ act }) => act.at > opts.after);
+        acts = acts.filter((act) => act.at > opts.after);
     if (opts.mention != null) {
         const mention = resolveKnownName(doc, opts.mention);
-        acts = acts.filter(({ act }) => act.kind === 'say' && (act.reach === 'bell' || matchesMentionTarget(act, mention)));
-    }
-    if (opts.mentionsViewer) {
-        if (viewer === undefined)
-            return [];
-        acts = acts.filter(({ act }) => addressesViewer(act, viewer));
+        acts = acts.filter((act) => act.kind === 'say' && (act.reach === 'bell' || matchesMentionTarget(act, mention)));
     }
     if (opts.pending) {
         if (viewer === undefined)
             return [];
-        acts = acts.filter(({ act, index }) => {
-            if (!addressesViewer(act, viewer))
-                return false;
-            if (!isPostJoinActivity(doc.acts, viewer, index))
-                return false;
-            return !isDeliveryDelivered(doc, viewer, index);
-        });
+        const pendingIndexes = new Set(deriveDeliveryModel(doc).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;
     if (search !== undefined && search.pattern !== '') {
-        // Search output is defined over the same public say/done activities in every
-        // presentation mode, including --count, --json, and human-readable echo.
-        acts = acts.filter(({ act }) => act.kind === 'say' || act.kind === 'done');
+        // Search only the public activity model rendered by history, but include all
+        // of its user-facing fields rather than coupling matching to rendered text.
+        acts = acts.filter((act) => act.kind === 'say' || act.kind === 'done');
         const re = compileSearchPattern(search.pattern, search.fixed);
-        acts = acts.filter(({ act }) => 'body' in act && typeof act.body === 'string' && re.test(act.body));
+        acts = acts.filter((act) => [
+            actId(act.index),
+            act.actor ?? '',
+            'body' in act && typeof act.body === 'string' ? act.body : '',
+        ].some((field) => re.test(field)));
     }
     if (opts.order === 'desc') {
-        acts = [...acts].sort((a, b) => b.index - a.index || b.act.at - a.act.at);
+        acts = [...acts].sort((a, b) => b.index - a.index || b.at - a.at);
     }
     else {
-        acts = [...acts].sort((a, b) => a.index - b.index || a.act.at - b.act.at);
+        acts = [...acts].sort((a, b) => a.index - b.index || a.at - b.at);
     }
     return acts;
 }
@@ -264,23 +236,18 @@ export function coreCompact(doc, keep) {
     const archived = doc.acts.slice(0, splitAt);
     const retained = doc.acts.slice(splitAt);
     const cutoffIndex = actStableIndex(archived[archived.length - 1]);
-    const unread = rosterNames(doc).filter((participant) => {
-        if (!resolveRosterName(doc, participant) || !currentHold(doc.acts))
-            return false;
-        if (!foldedState(doc).participants.some((entry) => sameName(entry.name, participant) && entry.joined))
-            return false;
-        return readCursor(doc, participant) < cutoffIndex;
-    });
+    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 acts being archived.`);
+        throw new SquareError('conflict', `Refusing to compact: ${unread.join(', ')} ${unread.length === 1 ? 'has' : 'have'} not read through the activities being archived.`);
     }
-    const firstActIndex = retained.length > 0 ? actStableIndex(retained[0]) : doc.runtime.nextActIndex;
     return {
         archived,
         doc: {
             ...doc,
             acts: retained,
-            runtime: { ...doc.runtime, firstActIndex },
+            runtime: doc.runtime,
         },
     };
 }