@astrosheep/square 0.3.70 → 0.3.72

package/dist/cli/observation-commands.js

@@ -1,27 +1,15 @@
+import path from 'node:path';
+import { once } from 'node:events';
 import { runClaudeMod } from '../claude-mod.js';
 import { runCodexHookAsync } from '../codex-hook.js';
-import { sessionInbox } from '../inbox.js';
-import { sweepPendingNotifications } from '../notifications.js';
-import { cmdListSquares } from '../list.js';
-import { nameKey, parseActivityId, sameName } from '../model.js';
+import { isSquareError, sameName } from '../model.js';
 import { commandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEventFacts, renderPresenceAnchor, truncateChars, withPathOutput, quoteShell, } from '../presentation.js';
-import { actId, nowMs } from '../runtime.js';
 import { style } from '../tty-style.js';
-import { cmdStream, cmdStreamNdjson } from '../stream.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.js';
-import { cmdWatch } from '../watch.js';
-import { openSquare } from '../square-file-adapter.js';
-import { closeOpenSquare } from '../open-square.js';
-import { createSquareApplication } from '../square-application.js';
-import { historyPresentation } from '../views.js';
-import { hostLedgerForEnv } from '../registry.js';
-import { fail, parseBoundedLimit, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdin, requireParticipant, requireSquarePath, requireValue, usage, } from './context.js';
-import { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from '../catch-decisions.js';
+import { formatActivityId, parseActivityId, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT } from '../square-application.js';
+import { renderCatchOutcome, renderCatchProgress } from './catch-presentation.js';
+import { applicationFor as application, fail, parseBoundedLimit, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdin, requireSquarePath, requireValue, usage, } from './context.js';
 const STATUS_PARTICIPANT_PREVIEW_LIMIT = 10;
-/** A participant counts as here when their last sign of life sits inside this window. */
-const STATUS_HERE_WINDOW_MS = 30 * 60_000;
-const HISTORY_DEFAULT_LIMIT = 10;
-const HISTORY_MAX_LIMIT = 100;
 const PARTICIPANTS_DEFAULT_LIMIT = 20;
 const PARTICIPANTS_MAX_LIMIT = 100;
 const INBOX_DEFAULT_LIMIT = 20;
@@ -31,12 +19,71 @@ function inboxDisplay(value) {
     const truncated = truncateChars(value, INBOX_DISPLAY_CHARS - 1);
     return truncated.remaining === 0 ? truncated.text : `${truncated.text}…`;
 }
+function renderSquareList(data, projection) {
+    const { items, stopped, remaining, next } = data;
+    if (data.total === 0) {
+        return ['(no squares found)', ...(stopped ? [style('dim', '○ the walk stopped early — deeper squares may still be hiding')] : [])].join('\n') + '\n';
+    }
+    const lines = ['squares'];
+    for (const item of items) {
+        const glyph = item.activities > 0 ? '●' : style('dim', '○');
+        lines.push(`${glyph} ${inboxDisplay(item.path)}${style('dim', ` · ${formatRelativeTime(item.lastActiveAt, projection.now)} · ${item.participants.length} in the square · ${item.activities} ${item.activities === 1 ? 'activity' : 'activities'}`)}`);
+        const context = item.context.slice(0, 2);
+        if (context.length === 0)
+            lines.push(`  ${style('dim', 'context')} · (none)`);
+        else {
+            context.forEach((line, index) => lines.push(`  ${index === 0 ? style('dim', 'context') : '       '} · ${inboxDisplay(line)}`));
+            const hidden = item.context.length - context.length;
+            if (hidden > 0)
+                lines.push(style('dim', `          · … ${hidden} more ${hidden === 1 ? 'line' : 'lines'}`));
+        }
+        const participants = item.participants.slice(0, 3);
+        const hidden = item.participants.length - participants.length;
+        const names = participants.length === 0 ? 'nobody' : participants.map((name) => participantIdentity(inboxDisplay(name))).join(' · ');
+        lines.push(`  ${style('dim', 'participants')} · ${names}${hidden > 0 ? style('dim', ` · … ${hidden} more`) : ''}`);
+    }
+    if (remaining > 0) {
+        lines.push(style('dim', stopped ? '  … more squares' : `  … ${remaining} more ${remaining === 1 ? 'square' : 'squares'}`));
+        if (next !== undefined)
+            lines.push(`square list --depth ${projection.depth} --limit ${projection.limit} --after ${quoteShell(next)}`);
+    }
+    if (stopped)
+        lines.push(style('dim', '○ the walk stopped early — deeper squares may still be hiding'));
+    return lines.join('\n') + '\n';
+}
 export const listCommand = {
-    parse: (argv) => argv,
-    async execute(argv, context) {
-        await cmdListSquares(argv, () => usage(context.command));
+    parse(argv, context) {
+        let depth = DEFAULT_LIST_DEPTH;
+        let limit = DEFAULT_LIST_LIMIT;
+        let after;
+        for (let index = 0; index < argv.length; index += 2) {
+            const flag = argv[index], value = argv[index + 1];
+            if (value === undefined || !['--depth', '--limit', '--after'].includes(flag))
+                usage(context.command);
+            if (flag === '--after') {
+                if (after !== undefined || value.length === 0 || path.isAbsolute(value))
+                    usage(context.command);
+                after = value;
+            }
+            else {
+                if (!/^\d+$/.test(value))
+                    usage(context.command);
+                const number = Number(value);
+                if (!Number.isSafeInteger(number) || (flag === '--depth' ? number > MAX_LIST_DEPTH : number === 0 || number > MAX_LIST_LIMIT))
+                    usage(context.command);
+                if (flag === '--depth')
+                    depth = number;
+                else
+                    limit = number;
+            }
+        }
+        return { depth, limit, after };
     },
-    present: () => { },
+    async execute(intent, context) {
+        const outcome = await application(context).discover(intent);
+        return renderSquareList(outcome.data, outcome.projection);
+    },
+    present: (result) => process.stdout.write(result),
 };
 export const streamCommand = {
     parse(argv, context) {
@@ -76,17 +123,39 @@ export const streamCommand = {
     },
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        if (intent.ndjson)
-            await cmdStreamNdjson(squarePath, intent.forName, intent.start);
-        else
-            await cmdStream(squarePath);
+        if (!intent.ndjson) {
+            process.stderr.write(`✕ interactive stream was removed\nsquare --location ${quoteShell(path.resolve(context.cwd, squarePath))} stream --ndjson\n`);
+            process.exitCode = 2;
+            return;
+        }
+        const controller = new AbortController();
+        const interrupt = () => controller.abort();
+        process.once('SIGINT', interrupt);
+        try {
+            for await (const record of application(context).stream({ recipient: intent.forName, start: intent.start }, { signal: controller.signal })) {
+                if (!process.stdout.write(`${JSON.stringify(record)}\n`))
+                    await once(process.stdout, 'drain', { signal: controller.signal });
+            }
+        }
+        catch (error) {
+            if (controller.signal.aborted)
+                process.exitCode = 130;
+            else if (isSquareError(error) && error.code === 'unavailable') {
+                process.stderr.write(`square not found: ${squarePath}\n`);
+                process.exitCode = 2;
+            }
+            else
+                throw error;
+        }
+        finally {
+            process.off('SIGINT', interrupt);
+        }
     },
     present: () => { },
 };
 export const catchCommand = {
     parse(argv, context) {
-        const name = requireParticipant(context.name);
-        let idleMs;
+        let idle;
         let mention;
         let limit;
         let id;
@@ -108,11 +177,11 @@ export const catchCommand = {
                 index += 1;
             }
             else if (argv[index] === '--idle') {
-                idleMs = parseDurationMs(requireValue(argv, index, argv[index]), argv[index]);
+                idle = parseDurationMs(requireValue(argv, index, argv[index]), argv[index]);
                 index += 1;
             }
             else if (argv[index] === '--mention') {
-                mention = name;
+                mention = true;
             }
             else if (argv[index] === '--limit') {
                 limit = parseBoundedLimit(argv[index + 1], '--limit', CATCH_MAX_LIMIT, `${commandPrefix(requireSquarePath(context))} catch --limit ${CATCH_MAX_LIMIT}`);
@@ -129,29 +198,47 @@ export const catchCommand = {
             if (argv.some((flag) => ['--idle', '--from', '--mention', '--limit', '--replace'].includes(flag))) {
                 fail('✕ --id cannot be combined with --idle, --from, --mention, --limit or --replace\nsquare catch --help');
             }
-            return { id, now: true };
+            return { id };
         }
-        if (idleMs !== undefined && now)
+        if (idle !== undefined && now)
             fail('catch accepts --now or --idle, not both.');
-        // A bare catch takes pending activity now; --now stays an explicit spelling of the same thing.
-        if (idleMs === undefined)
-            now = true;
-        if (replace && now)
+        if (replace && idle === undefined)
             fail('--replace can only be used with --idle.');
         return {
-            ...(participants.length > 0 ? { participants } : {}),
+            ...(participants.length > 0 ? { from: participants } : {}),
             ...(mention === undefined ? {} : { mention }),
             limit: limit ?? CATCH_DEFAULT_LIMIT,
-            ...(idleMs === undefined ? {} : { idleMs }),
+            ...(idle === undefined ? {} : { idle }),
             ...(replace ? { replace } : {}),
-            ...(now ? { now } : {}),
         };
     },
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        const caught = await cmdWatch(squarePath, requireParticipant(context.name), intent, { cwd: context.cwd, env: context.env });
-        if (caught !== false)
-            await sweepPendingNotifications(squarePath);
+        const controller = new AbortController();
+        const interrupt = () => controller.abort();
+        process.once('SIGINT', interrupt);
+        try {
+            const outcome = await application(context).catch(intent, {
+                signal: controller.signal,
+                onProgress(progress) {
+                    const line = renderCatchProgress(squarePath, progress);
+                    if (line !== undefined)
+                        process.stderr.write(line);
+                },
+            });
+            const rendered = renderCatchOutcome(squarePath, outcome, intent);
+            process.stdout.write(rendered.stdout);
+            process.exitCode = rendered.exitCode;
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                throw error;
+            process.stdout.write(withPathOutput(squarePath, '○ you step back — catch stopped'));
+            process.exitCode = 130;
+        }
+        finally {
+            process.off('SIGINT', interrupt);
+        }
     },
     present: () => { },
 };
@@ -161,8 +248,8 @@ function parseActRef(value, flag) {
         fail(`Invalid ${flag}: expected an activity id like act/12`);
     return index;
 }
-function parseTimestamp(value, flag) {
-    const timestamp = parseTimeOrRelative(value, nowMs());
+function parseTimestamp(value, flag, now) {
+    const timestamp = parseTimeOrRelative(value, now);
     if (!Number.isFinite(timestamp))
         fail(`Invalid ${flag} timestamp: ${value}`);
     return timestamp;
@@ -188,12 +275,11 @@ function historyContinuationArgs(argv) {
 }
 function parseHistory(argv, context) {
     const squarePath = requireSquarePath(context);
-    let lastN = HISTORY_DEFAULT_LIMIT;
-    let lastNExplicit = false;
+    let limit;
+    let since;
     let after;
-    let afterIndex;
-    let beforeIndex;
-    const atIndexes = [];
+    let before;
+    const at = [];
     let beforeContext;
     let afterContext;
     let mention;
@@ -207,8 +293,7 @@ function parseHistory(argv, context) {
     for (let index = 0; index < argv.length; index++) {
         const flag = argv[index];
         if (flag === '--limit') {
-            lastN = parseBoundedLimit(argv[index + 1], '--limit', HISTORY_MAX_LIMIT, `${commandPrefix(squarePath)} history --limit ${HISTORY_MAX_LIMIT}`);
-            lastNExplicit = true;
+            limit = parseBoundedLimit(argv[index + 1], '--limit', HISTORY_MAX_LIMIT, `${commandPrefix(squarePath)} history --limit ${HISTORY_MAX_LIMIT}`);
             index += 1;
         }
         else if (flag === '--from') {
@@ -216,22 +301,22 @@ function parseHistory(argv, context) {
             index += 1;
         }
         else if (flag === '--since') {
-            after = parseTimestamp(requireValue(argv, index, flag), flag);
+            since = parseTimestamp(requireValue(argv, index, flag), flag, application(context).now());
             index += 1;
         }
         else if (flag === '--after') {
-            afterIndex = parseActRef(requireValue(argv, index, flag), flag);
+            after = formatActivityId(parseActRef(requireValue(argv, index, flag), flag));
             index += 1;
         }
         else if (flag === '--before') {
-            beforeIndex = parseActRef(requireValue(argv, index, flag), flag);
+            before = formatActivityId(parseActRef(requireValue(argv, index, flag), flag));
             index += 1;
         }
         else if (flag === '--at') {
             const values = requireValue(argv, index, flag).split(',');
             if (values.some((value) => value === ''))
                 fail(`Invalid ${flag}: expected an activity id like act/12`);
-            atIndexes.push(...values.map((value) => parseActRef(value, flag)));
+            at.push(...values.map((value) => formatActivityId(parseActRef(value, flag))));
             index += 1;
         }
         else if (flag === '-B') {
@@ -282,26 +367,12 @@ function parseHistory(argv, context) {
         fail('--grep and --fixed cannot be combined.');
     if (grep === '' || fixed === '')
         fail('--grep and --fixed require non-empty text.');
-    if (beforeIndex !== undefined && afterIndex !== undefined)
+    if (before !== undefined && after !== undefined)
         fail('--before and --after cannot be combined.');
-    if (!lastNExplicit && atIndexes.length > 0)
-        lastN = null;
     return {
-        lastN,
-        participants,
-        after,
-        afterIndex,
-        beforeIndex,
-        atIndexes: atIndexes.length === 0 ? undefined : atIndexes,
-        beforeContext,
-        afterContext,
-        mention,
-        noTruncate,
-        grep,
-        fixed,
-        order,
-        format,
-        json,
+        query: { limit, from: participants, since, after, before, at: at.length === 0 ? undefined : at,
+            contextBefore: beforeContext, contextAfter: afterContext, mention, grep, fixed, order },
+        noTruncate, format, json,
         continuationArgs: historyContinuationArgs(argv),
     };
 }
@@ -309,14 +380,10 @@ function historyContinuationCommand(options, squarePath, args) {
     const full = [...(options.continuationArgs ?? []), ...args];
     return `${commandPrefix(squarePath)} history ${full.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
 }
-/** The archive-visible activity model: content plus the lifecycle moves that keep its story honest — a raised hand pairs with its lowering, and a departure pairs with the return. */
-function isArchiveActivity(item) {
-    return item.kind === 'say' || item.kind === 'done' || item.kind === 'hold' || item.kind === 'resume' || item.kind === 'join';
-}
 function renderFields(sayNumbers, item, fields) {
     return fields.map((field) => {
         switch (field) {
-            case 'id': return actId(item.index);
+            case 'id': return formatActivityId(item.index);
             case 'author':
             case 'actor': return item.actor ?? '';
             case 'ts':
@@ -324,7 +391,7 @@ function renderFields(sayNumbers, item, fields) {
             case 'kind': return item.kind;
             case 'body': return 'body' in item && typeof item.body === 'string' ? item.body.replace(/\s+/g, ' ').trim() : '';
             case 'number': return item.kind === 'say' ? String(sayNumbers[item.index]) : '';
-            case 'reply': return item.kind === 'say' && item.reply !== undefined ? actId(item.reply) : '';
+            case 'reply': return item.kind === 'say' && item.reply !== undefined ? formatActivityId(item.reply) : '';
             default: return '';
         }
     }).join('\t');
@@ -332,7 +399,7 @@ function renderFields(sayNumbers, item, fields) {
 function jsonLine(sayNumbers, item) {
     const act = item;
     return JSON.stringify({
-        id: actId(item.index),
+        id: formatActivityId(item.index),
         index: item.index,
         kind: act.kind,
         author: act.actor ?? null,
@@ -342,11 +409,11 @@ function jsonLine(sayNumbers, item) {
         number: act.kind === 'say' ? sayNumbers[act.index] : null,
         mentions: act.kind === 'say' ? [...(act.mentions ?? [])] : [],
         reach: act.kind === 'say' ? act.reach ?? null : null,
-        reply: act.kind === 'say' && act.reply !== undefined ? actId(act.reply) : null,
+        reply: act.kind === 'say' && act.reply !== undefined ? formatActivityId(act.reply) : null,
     });
 }
 function renderHistoryProjection(projection, visible, noTruncate, squarePath) {
-    const shown = visible.filter(isArchiveActivity);
+    const shown = visible;
     const preview = noTruncate || shown.length <= 1 ? undefined : 200;
     const chunks = [];
     // Presence anchors collect into one closing line instead of interrupting the page.
@@ -377,51 +444,30 @@ export const historyCommand = {
     parse(argv, context) { return parseHistory(argv, context); },
     async execute(options, context) {
         const squarePath = requireSquarePath(context);
-        const square = await openSquare(squarePath, { clock: nowMs, env: context.env, hostLedger: hostLedgerForEnv(context.env) });
+        let outcome;
         try {
-            // Keep the projection chronological; pagination chooses a stable edge,
-            // then --order only changes how the selected page is displayed. The
-            // plain archive hides `read` bookkeeping, while --at/-C/--since windows
-            // render the raw activity stream around their coordinates.
-            const projection = await historyPresentation(square, { ...options, order: 'asc' });
-            const hideReadActs = options.atIndexes === undefined && options.beforeContext === undefined && options.afterContext === undefined && options.after === undefined;
-            let events = hideReadActs ? projection.activities.filter((activity) => activity.kind !== 'read') : [...projection.activities];
-            if (options.lastN === null && events.length > HISTORY_MAX_LIMIT) {
-                fail(`✕ history is capped at ${HISTORY_MAX_LIMIT} activities\n${historyContinuationCommand(options, squarePath, ['--limit', String(HISTORY_MAX_LIMIT)])}`);
-            }
-            const searching = options.grep !== undefined || options.fixed !== undefined;
-            const totalMatches = searching ? events.length : 0;
-            if (options.lastN != null) {
-                events = options.afterIndex !== undefined
-                    ? events.slice(0, options.lastN)
-                    : events.slice(-options.lastN);
-            }
-            if (options.order === 'desc')
-                events.reverse();
-            if (options.json)
-                return events.map((item) => jsonLine(projection.sayNumbers, item)).join('\n') + (events.length > 0 ? '\n' : '');
-            if (options.format !== undefined && options.format.length > 0) {
-                return events.map((item) => renderFields(projection.sayNumbers, item, options.format)).join('\n') + (events.length > 0 ? '\n' : '');
-            }
-            const pattern = options.grep ?? options.fixed;
-            const output = pattern === undefined || pattern === ''
-                ? renderHistoryProjection(projection, events, options.noTruncate === true, squarePath)
-                : renderGrepActivitiesView(events, totalMatches, options.noTruncate, squarePath, pattern, options.fixed !== undefined, () => 'full');
-            const publicEvents = events.filter(isArchiveActivity);
-            const allPublic = projection.activities.filter(isArchiveActivity);
-            const pageMin = publicEvents.length === 0 ? undefined : Math.min(...publicEvents.map((item) => item.index));
-            const pageMax = publicEvents.length === 0 ? undefined : Math.max(...publicEvents.map((item) => item.index));
-            const hasMore = options.lastN != null && publicEvents.length > 0 && (options.afterIndex !== undefined
-                ? allPublic.some((item) => item.index > (pageMax ?? options.afterIndex))
-                : allPublic.some((item) => item.index < (pageMin ?? Infinity)));
-            const cursorDirection = options.afterIndex !== undefined ? '--after' : '--before';
-            const cursorIndex = cursorDirection === '--after' ? Math.max(...publicEvents.map((item) => item.index)) : Math.min(...publicEvents.map((item) => item.index));
-            const continuation = hasMore ? `\n\n${historyContinuationCommand(options, squarePath, [cursorDirection, actId(cursorIndex), '--limit', String(options.lastN ?? HISTORY_DEFAULT_LIMIT)])}` : '';
-            return withPathOutput(squarePath, output + continuation, { participantCount: projection.participantCount });
+            outcome = await application(context).history(options.query);
         }
-        finally {
-            await closeOpenSquare(square);
+        catch (error) {
+            const bounds = error?.operation?.historyBounds;
+            if (bounds !== undefined)
+                fail(`✕ history is capped at ${bounds.maxLimit} activities\n${historyContinuationCommand(options, squarePath, ['--limit', String(bounds.maxLimit)])}`);
+            throw error;
         }
+        const projection = outcome.projection;
+        const events = projection.activities;
+        if (options.json)
+            return events.map((item) => jsonLine(projection.sayNumbers, item)).join('\n') + (events.length > 0 ? '\n' : '');
+        if (options.format !== undefined && options.format.length > 0) {
+            return events.map((item) => renderFields(projection.sayNumbers, item, options.format)).join('\n') + (events.length > 0 ? '\n' : '');
+        }
+        const pattern = options.query.grep ?? options.query.fixed;
+        const output = pattern === undefined || pattern === ''
+            ? renderHistoryProjection(projection, projection.visibleActivities, options.noTruncate, squarePath)
+            : renderGrepActivitiesView(projection.visibleActivities, projection.totalMatches, options.noTruncate, squarePath, pattern, options.query.fixed !== undefined, () => 'full');
+        const next = projection.continuation;
+        const continuation = next === undefined ? '' : `\n\n${historyContinuationCommand(options, squarePath, [`--${next.direction}`, next.cursor, '--limit', String(next.limit)])}`;
+        return withPathOutput(squarePath, output + continuation, { participantCount: projection.standingCount });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -442,30 +488,26 @@ export const participantsCommand = {
     parse(argv, context) { return parseParticipants(argv, context); },
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        const application = createSquareApplication({ cwd: context.cwd, env: context.env, squarePath, clock: nowMs });
-        {
-            const now = nowMs();
-            const participants = await application.participants();
-            const lines = participants.slice(0, intent.limit).map((participant) => {
-                const recent = participant.lastActiveAt !== undefined && now - participant.lastActiveAt <= STATUS_HERE_WINDOW_MS;
-                const glyph = participant.state === 'done' ? '○' : participant.presence === 'watching' ? '◎' : participant.activityCount > 0 && recent ? '●' : '○';
-                const state = participant.state === 'done' ? 'done' : participant.presence === 'watching' ? 'catching' : participant.state;
-                const last = participant.lastActiveAt === undefined ? '—' : formatRelativeTime(participant.lastActiveAt, now);
-                return `  ${glyph} ${participant.name}${style('dim', ` · ${state} · ${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${last}`)}`;
-            });
-            const participantCount = participants.filter((participant) => participant.state === 'active').length;
-            const tail = participants.length <= intent.limit
-                ? []
-                : [
-                    style('dim', `  ○ ${lines.length} of ${participants.length} participants shown`),
-                    ...(participants.length <= PARTICIPANTS_MAX_LIMIT ? [
-                        `${participantsLimitCommand(squarePath, participants.length)}`,
-                    ] : []),
-                ];
-            return withPathOutput(squarePath, ['participants', ...lines, ...tail].join('\n'), {
-                participantCount,
-            });
-        }
+        const { data, projection } = await application(context).participants();
+        const now = projection.now;
+        const participants = data.participants;
+        const lines = participants.slice(0, intent.limit).map((participant) => {
+            const glyph = participant.state === 'done' ? '○' : participant.presence === 'watching' ? '◎' : participant.activityCount > 0 && projection.classificationByName[participant.name] === 'here' ? '●' : '○';
+            const state = participant.state === 'done' ? 'done' : participant.presence === 'watching' ? 'catching' : participant.state;
+            const last = participant.lastActiveAt === undefined ? '—' : formatRelativeTime(participant.lastActiveAt, now);
+            return `  ${glyph} ${participant.name}${style('dim', ` · ${state} · ${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${last}`)}`;
+        });
+        const tail = participants.length <= intent.limit
+            ? []
+            : [
+                style('dim', `  ○ ${lines.length} of ${participants.length} participants shown`),
+                ...(participants.length <= PARTICIPANTS_MAX_LIMIT ? [
+                    `${participantsLimitCommand(squarePath, participants.length)}`,
+                ] : []),
+            ];
+        return withPathOutput(squarePath, ['participants', ...lines, ...tail].join('\n'), {
+            participantCount: projection.standingCount,
+        });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -474,100 +516,88 @@ export const statusCommand = {
         usage(context.command); return undefined; },
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
-        const application = createSquareApplication({ cwd: context.cwd, env: context.env, squarePath, clock: nowMs });
-        {
-            const presentation = await application.status();
-            const result = presentation.status;
-            const active = result.participants.filter((participant) => participant.state === 'active');
-            const here = active.filter((participant) => participant.presence === 'watching'
-                || (participant.lastActiveAt !== undefined && result.now - participant.lastActiveAt <= STATUS_HERE_WINDOW_MS));
-            const lingering = active.length - here.length;
-            const orderedHere = [
-                ...here.filter((participant) => participant.presence === 'watching'),
-                ...here.filter((participant) => participant.presence !== 'watching'),
-            ];
-            const people = [];
-            if (active.length === 0) {
-                people.push('  ○ nobody in the square');
-            }
-            else {
-                if (orderedHere.length === 0)
-                    people.push('  ○ nobody here right now');
-                people.push(...orderedHere.slice(0, STATUS_PARTICIPANT_PREVIEW_LIMIT).map((participant) => {
-                    const glyph = participant.presence === 'watching'
-                        ? '◎'
-                        : participant.activityCount > 0 ? '●' : '○';
-                    const summary = participant.presence === 'watching'
-                        ? 'is nearby · catching'
-                        : participant.activityCount > 0
-                            ? `is nearby · ${formatRelativeTime(participant.lastActiveAt ?? result.now, result.now)}`
-                            : `is nearby · quiet · ${participant.lastActiveAt === undefined ? 'just now' : formatRelativeTime(participant.lastActiveAt, result.now)}`;
-                    const showAttention = context.name === undefined || sameName(participant.name, context.name);
-                    const attention = !showAttention
-                        ? ''
-                        : participant.pendingMentionCount > 0
-                            ? `${participant.pendingMentionCount} ${participant.pendingMentionCount === 1 ? 'mention' : 'mentions'} waiting`
-                            : participant.unreadActivityCount > 0
-                                ? `${participant.unreadActivityCount} change${participant.unreadActivityCount === 1 ? '' : 's'} waiting`
-                                : 'caught up';
-                    return `  ${glyph} ${participantIdentity(participant.name)}${style('dim', ` ${summary}${attention === '' ? '' : ` · ${attention}`}`)}`;
-                }));
-                const unshown = Math.max(0, orderedHere.length - STATUS_PARTICIPANT_PREVIEW_LIMIT) + lingering;
-                if (orderedHere.length > STATUS_PARTICIPANT_PREVIEW_LIMIT) {
-                    people.push(`  ○ … ${orderedHere.length - STATUS_PARTICIPANT_PREVIEW_LIMIT} more here`);
-                }
-                if (lingering > 0)
-                    people.push(`  ○ … ${lingering} lingering`);
-                if (unshown > 0) {
-                    people.push(`${result.participants.length <= PARTICIPANTS_MAX_LIMIT
-                        ? participantsLimitCommand(squarePath, result.participants.length)
-                        : `${commandPrefix(squarePath)} participants`}`);
-                }
-            }
-            const cap = result.hardCap === null ? 'unlimited' : `${result.hardCap} each`;
-            const holdTime = result.holdAt === undefined ? 'just now' : formatRelativeTime(result.holdAt, result.now);
-            const hold = result.holdActive
-                ? `· ${result.holdActor === undefined ? 'someone' : participantIdentity(result.holdActor)} raised a hand${result.holdReason ? ` — ${result.holdReason}` : ''}${style('dim', ` · ${holdTime}`)}`
-                : undefined;
-            const visible = result.latestAct === undefined
-                ? { text: '', bodyClipped: false }
-                : renderAmbientEventFacts(result.latestAct, context.name ?? '', {
-                    now: result.now,
-                    preview: 200,
-                    actNumber: presentation.latestActNumber,
-                    squareState: presentation.state,
-                });
-            const latest = visible.text === ''
-                ? [result.latestAct === undefined
-                        ? '  ○ no public activity yet'
-                        : '  · the latest words were meant for other ears']
-                : [`  ${visible.text.replace(/\n/g, '\n  ')}`];
-            // Presence events after the latest public act: otherwise the roster can say someone is
-            // here while the latest line shows them leaving, with nothing to reconcile the two.
-            const latestIndex = result.latestAct?.index ?? -1;
-            const stepsIn = presentation.state.acts.filter((act) => act.kind === 'join' && act.index > latestIndex);
-            for (const act of stepsIn.slice(-3)) {
-                const rejoined = presentation.state.acts.some((other) => other.kind === 'done' && other.actor === act.actor && other.index < act.index);
-                latest.push(style('dim', `  → ${participantIdentity(act.actor)} ${rejoined ? 'stepped back in' : 'stepped in'} · ${formatRelativeTime(act.at, result.now)}`));
+        const { data: result, projection: presentation } = await application(context).status(context.name);
+        const participantsByName = new Map(result.participants.map((participant) => [participant.name, participant]));
+        const orderedHere = presentation.orderedHereNames.map((name) => participantsByName.get(name));
+        const lingering = presentation.lingeringCount;
+        const people = [];
+        if (result.activeCount === 0) {
+            people.push('  ○ nobody in the square');
+        }
+        else {
+            if (orderedHere.length === 0)
+                people.push('  ○ nobody here right now');
+            people.push(...orderedHere.slice(0, STATUS_PARTICIPANT_PREVIEW_LIMIT).map((participant) => {
+                const glyph = participant.presence === 'watching'
+                    ? '◎'
+                    : participant.activityCount > 0 ? '●' : '○';
+                const summary = participant.presence === 'watching'
+                    ? 'is nearby · catching'
+                    : participant.activityCount > 0
+                        ? `is nearby · ${formatRelativeTime(participant.lastActiveAt ?? result.now, result.now)}`
+                        : `is nearby · quiet · ${participant.lastActiveAt === undefined ? 'just now' : formatRelativeTime(participant.lastActiveAt, result.now)}`;
+                const showAttention = presentation.attentionNames.includes(participant.name);
+                const attention = !showAttention
+                    ? ''
+                    : participant.pendingMentionCount > 0
+                        ? `${participant.pendingMentionCount} ${participant.pendingMentionCount === 1 ? 'mention' : 'mentions'} waiting`
+                        : participant.unreadActivityCount > 0
+                            ? `${participant.unreadActivityCount} change${participant.unreadActivityCount === 1 ? '' : 's'} waiting`
+                            : 'caught up';
+                return `  ${glyph} ${participantIdentity(participant.name)}${style('dim', ` ${summary}${attention === '' ? '' : ` · ${attention}`}`)}`;
+            }));
+            const unshown = Math.max(0, orderedHere.length - STATUS_PARTICIPANT_PREVIEW_LIMIT) + lingering;
+            if (orderedHere.length > STATUS_PARTICIPANT_PREVIEW_LIMIT) {
+                people.push(`  ○ … ${orderedHere.length - STATUS_PARTICIPANT_PREVIEW_LIMIT} more here`);
             }
-            if (stepsIn.length > 3)
-                latest.push(style('dim', `  → … ${stepsIn.length - 3} more stepped in`));
-            if (visible.bodyClipped && result.latestAct !== undefined) {
-                latest.push(`${commandPrefix(squarePath)} history --at ${actId(result.latestAct)} -C 2 --no-truncate`);
+            if (lingering > 0)
+                people.push(`  ○ … ${lingering} lingering`);
+            if (unshown > 0) {
+                people.push(`${presentation.knownParticipantCount <= PARTICIPANTS_MAX_LIMIT
+                    ? participantsLimitCommand(squarePath, presentation.knownParticipantCount)
+                    : `${commandPrefix(squarePath)} participants`}`);
             }
-            const counts = [
-                `${here.length} here`,
-                ...(lingering > 0 ? [`${lingering} lingering`] : []),
-                `${result.doneCount} done`,
-                `cap ${cap}`,
-                `throttle ${result.throttlePerMinute === undefined ? 'none' : `${result.throttlePerMinute}/min`}`,
-            ].join(' · ');
-            const output = [
-                style('dim', counts),
-                ...(hold === undefined ? [] : ['', hold]), '', style('dim', 'around the square'), ...people, '', style('dim', 'latest'), ...latest,
-            ].join('\n');
-            return withPathOutput(squarePath, output, { participantCount: result.activeCount, held: result.holdActive });
         }
+        const cap = result.hardCap === null ? 'unlimited' : `${result.hardCap} each`;
+        const holdTime = result.hold?.at === undefined ? 'just now' : formatRelativeTime(result.hold.at, result.now);
+        const hold = result.hold !== null
+            ? `· ${result.hold.by === undefined ? 'someone' : participantIdentity(result.hold.by)} raised a hand${result.hold.reason ? ` — ${result.hold.reason}` : ''}${style('dim', ` · ${holdTime}`)}`
+            : undefined;
+        const visible = result.latestActivity === undefined
+            ? { text: '', bodyClipped: false }
+            : renderAmbientEventFacts(result.latestActivity, presentation.viewer, {
+                now: result.now,
+                preview: 200,
+                actNumber: presentation.latestActNumber,
+                perception: presentation.latestPerception,
+            });
+        const latest = visible.text === ''
+            ? [result.latestActivity === undefined
+                    ? '  ○ no public activity yet'
+                    : '  · the latest words were meant for other ears']
+            : [`  ${visible.text.replace(/\n/g, '\n  ')}`];
+        // Presence events after the latest public act: otherwise the roster can say someone is
+        // here while the latest line shows them leaving, with nothing to reconcile the two.
+        for (const { activity, rejoined } of presentation.joins) {
+            latest.push(style('dim', `  → ${participantIdentity(activity.actor)} ${rejoined ? 'stepped back in' : 'stepped in'} · ${formatRelativeTime(activity.at, result.now)}`));
+        }
+        if (presentation.joinCount > 3)
+            latest.push(style('dim', `  → … ${presentation.joinCount - 3} more stepped in`));
+        if (visible.bodyClipped && result.latestActivity !== undefined) {
+            latest.push(`${commandPrefix(squarePath)} history --at ${result.latestActivity.id} -C 2 --no-truncate`);
+        }
+        const counts = [
+            `${orderedHere.length} here`,
+            ...(lingering > 0 ? [`${lingering} lingering`] : []),
+            `${result.doneCount} done`,
+            `cap ${cap}`,
+            `throttle ${result.throttlePerMinute === undefined ? 'none' : `${result.throttlePerMinute}/min`}`,
+        ].join(' · ');
+        const output = [
+            style('dim', counts),
+            ...(hold === undefined ? [] : ['', hold]), '', style('dim', 'around the square'), ...people, '', style('dim', 'latest'), ...latest,
+        ].join('\n');
+        return withPathOutput(squarePath, output, { participantCount: presentation.standingCount, held: presentation.held });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -608,35 +638,18 @@ export const inboxCommand = {
             : INBOX_DEFAULT_LIMIT;
         return { sessionId, json, limit };
     },
-    async execute(intent) {
-        const inbox = await sessionInbox(intent.sessionId);
-        const ordered = [...inbox].sort((left, right) => {
-            if (left.squarePath < right.squarePath)
-                return -1;
-            if (left.squarePath > right.squarePath)
-                return 1;
-            const leftName = nameKey(left.name);
-            const rightName = nameKey(right.name);
-            if (leftName < rightName)
-                return -1;
-            if (leftName > rightName)
-                return 1;
-            if (left.name < right.name)
-                return -1;
-            if (left.name > right.name)
-                return 1;
-            return 0;
-        });
-        const rows = ordered.slice(0, intent.limit).map((membership) => ({
+    async execute(intent, context) {
+        const { data } = await application(context).inbox(intent.sessionId, { limit: intent.limit });
+        const rows = data.rows.map((membership) => ({
             namePreview: inboxDisplay(membership.name),
             squarePathPreview: inboxDisplay(membership.squarePath),
-            pending: membership.notifications.length,
+            pending: membership.pending,
         }));
         if (intent.json)
-            return `${JSON.stringify({ rows, total: ordered.length })}\n`;
+            return `${JSON.stringify({ rows, total: data.total })}\n`;
         return [
             ...rows.map((row) => `${row.namePreview}\t${row.squarePathPreview}\t${row.pending}\n`),
-            ...(rows.length < ordered.length ? [`${rows.length} of ${ordered.length} memberships shown\n`] : []),
+            ...(rows.length < data.total ? [`${rows.length} of ${data.total} memberships shown\n`] : []),
         ].join('');
     },
     present: (result) => process.stdout.write(result),