@astrosheep/square 0.3.5 → 0.3.7

package/dist/cli/square-commands.js

@@ -1,14 +1,14 @@
 import { cmdActivity } from '../activity.js';
 import { loadSquare } from '../artifact.js';
 import { cmdCompact } from '../compact.js';
-import { SquareError, formatHardCap, validateParticipantName, } from '../model.js';
-import { participantCommandPrefix, quoteShell, renderEventCli, renderPublicTail, withJoinNextOutput, withPathOutput, } from '../presentation.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 };
+    const options = { force: false, hardCap: null };
     for (let index = 0; index < argv.length; index++) {
         const flag = argv[index];
         switch (flag) {
@@ -36,23 +36,21 @@ function parseBuild(argv) {
     if (options.template !== undefined && !/^[a-zA-Z0-9-]+$/.test(options.template)) {
         fail('Invalid template name: only letters, digits, and hyphens allowed.');
     }
-    if (options.hardCap === undefined)
-        fail('Missing required build option: --cap must be a positive integer or -1.');
     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: options, snippet };
+    return { options, snippet };
 }
 export const buildCommand = {
     parse: (argv) => parseBuild(argv),
     async execute(intent, context) {
         await createSquare(context.squarePath, intent.options, intent.snippet);
-        const cap = formatHardCap(intent.options.hardCap);
+        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 === '-1' ? 'unlimited' : cap}`, ...throttle, '  · participants (none seeded — first join adds names)'].join('\n'), { participantCount: 0 });
+        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),
 };
@@ -75,7 +73,7 @@ function parseJoin(argv, context) {
 export const joinCommand = {
     parse: parseJoin,
     async execute(intent, context) {
-        validateParticipantName(intent.name);
+        validateName(intent.name);
         try {
             const committed = await execute(context.squarePath, { type: 'join', name: intent.name, now: nowMs() });
             const joinedName = committed.result.joinedName;
@@ -95,7 +93,7 @@ export const joinCommand = {
                 ...(isRejoin ? [] : ['', `» ${participantCommandPrefix(context.squarePath, joinedName)} warmup`]),
                 ...fallback,
             ].join('\n');
-            return withJoinNextOutput(context.squarePath, output, { participantCount: inSquareCount(after) });
+            return withPathOutput(context.squarePath, output, { participantCount: inSquareCount(after) });
         }
         catch (error) {
             if (!(error instanceof SquareError) || error.code !== 'conflict')
@@ -108,7 +106,7 @@ export const joinCommand = {
             const fallback = hasAutomaticDeliveryIdentity()
                 ? ''
                 : `\n» ${participantCommandPrefix(context.squarePath, joinedName)} catch --idle 30m\n  no session delivery detected — keep this catch open for new activity`;
-            return withJoinNextOutput(context.squarePath, `● ${joinedName} is already in the square${fallback}`, { participantCount: inSquareCount(doc) });
+            return withPathOutput(context.squarePath, `● ${joinedName} is already in the square${fallback}`, { participantCount: inSquareCount(doc) });
         }
     },
     present: (result) => process.stdout.write(result),
@@ -118,6 +116,7 @@ function parseActivity(argv, context) {
     let noWait = false;
     let beside;
     let bell = false;
+    let reply;
     const bodyArgs = [];
     for (let index = 0; index < argv.length; index++) {
         const argument = argv[index];
@@ -131,23 +130,30 @@ function parseActivity(argv, context) {
         }
         else if (argument === '--bell')
             bell = true;
+        else if (argument === '--reply') {
+            const value = requireValue(argv, index, argument).trim().match(/^(?:act_)?(\d+)$/i);
+            if (!value || !Number.isSafeInteger(Number(value[1])))
+                fail('Invalid --reply: expected an activity id like act_12 or 12.');
+            reply = Number(value[1]);
+            index += 1;
+        }
         else
             bodyArgs.push(argument);
     }
     if (bell && beside !== undefined)
-        fail('Invalid act options: --beside and --bell are mutually exclusive.');
+        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 };
+                return { name: requireParticipant(context.name), activity: piped, force, noWait, reach, reply };
         }
-        fail("act requires a body argument (a quoted string or '-' with piped stdin)");
+        fail("express requires a body argument (a quoted string or '-' with piped stdin)");
     }
-    return { name: requireParticipant(context.name), activity: bodyArgs[0], force, noWait, reach };
+    return { name: requireParticipant(context.name), activity: bodyArgs[0], force, noWait, reach, reply };
 }
-export const actCommand = {
+export const expressCommand = {
     parse: parseActivity,
     async execute(intent, context) {
         const reachArg = intent.reach === 'bell' ? ' --bell' : intent.reach === undefined ? '' : ` --beside ${quoteShell(intent.reach.beside)}`;
@@ -155,7 +161,8 @@ export const actCommand = {
             force: intent.force,
             noWait: intent.noWait,
             reach: intent.reach,
-            forceCommand: `${participantCommandPrefix(context.squarePath, intent.name)} act --force${reachArg} -`,
+            reply: intent.reply,
+            forceCommand: `${participantCommandPrefix(context.squarePath, intent.name)} express --force${reachArg}${intent.reply === undefined ? '' : ` --reply act_${intent.reply}`} -`,
         });
     },
     present: () => { },
@@ -170,7 +177,7 @@ export const doneCommand = {
     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].act.actor;
+        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)) });
     },
@@ -186,7 +193,7 @@ export const holdCommand = {
     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].act), { participantCount: inSquareCount(doc), held: true });
+        return withPathOutput(context.squarePath, renderEventCli(committed.acts[0]), { participantCount: inSquareCount(doc), held: true });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -199,7 +206,7 @@ export const resumeCommand = {
     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].act), { participantCount: inSquareCount(doc) });
+        return withPathOutput(context.squarePath, renderEventCli(committed.acts[0]), { participantCount: inSquareCount(doc) });
     },
     present: (result) => process.stdout.write(result),
 };

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/codex-hook.js

@@ -0,0 +1,22 @@
+import { presentPendingAtBoundary } from './boundary-presentation.js';
+import { sessionInbox } from './inbox.js';
+export 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) {
+    let input;
+    try {
+        input = JSON.parse(inputText);
+    }
+    catch {
+        return '';
+    }
+    if (input === null || typeof input !== 'object')
+        return '';
+    const response = codexHookResponse(input, sessionInbox, env);
+    return response === undefined ? '' : `${JSON.stringify(response)}\n`;
+}

package/dist/compact.js

@@ -13,7 +13,7 @@ export async function cmdCompact(squarePath, opts) {
         const result = committed.result;
         archivedCount = result.archived.length;
         keptCount = result.doc.acts.length;
-        const summary = ['✓ compacted', `  · archived ${archivedCount} acts`, `  · kept ${keptCount} acts`, ...(archivedCount > 0 ? [`  · sidecar ${archive}`] : [])].join('\n');
+        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,20 @@ 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 reply = input.reply;
+    if (reply !== undefined) {
+        if (!Number.isSafeInteger(reply) || reply < 0 || reply >= doc.runtime.nextActIndex) {
+            throw new SquareError('invalid_args', `Unknown reply activity: act_${reply}`);
+        }
+    }
     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 });
+    const result = validate(state, { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}), ...(reply !== undefined ? { reply } : {}) }, { 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 +61,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),
         });
     }
@@ -95,7 +101,7 @@ export function decideAct(doc, input) {
     const ownActCount = (current?.activityCount ?? 0) + 1;
     return {
         type: 'sent',
-        act: { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}) },
+        act: { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}), ...(reply !== undefined ? { reply } : {}) },
         confirmation: `● heads turn your way — #${ownActCount}`,
         ownActCount,
         pendingPublic: unreadPublic,
@@ -112,35 +118,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 +164,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 +176,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 +242,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,
         },
     };
 }