@astrosheep/square 0.3.2

package/dist/paseo-timeline.js

@@ -0,0 +1,206 @@
+import { randomUUID } from 'node:crypto';
+import { setTimeout as sleep } from 'node:timers/promises';
+const DEFAULT_POLL_INTERVAL_MS = 100;
+const DEFAULT_REQUEST_TIMEOUT_MS = 3000;
+function paseoWebSocketUrl() {
+    const override = process.env['SQUARE_PASEO_WS_URL']?.trim();
+    if (override)
+        return override;
+    const listen = process.env['PASEO_LISTEN']?.trim();
+    if (!listen)
+        return 'ws://127.0.0.1:6767/ws';
+    if (/^wss?:\/\//i.test(listen)) {
+        const url = new URL(listen);
+        if (url.pathname === '/' || url.pathname === '')
+            url.pathname = '/ws';
+        return url.toString();
+    }
+    if (/^tcp:\/\//i.test(listen)) {
+        const url = new URL(listen);
+        const secure = url.searchParams.get('ssl') === 'true';
+        url.protocol = secure ? 'wss:' : 'ws:';
+        url.pathname = '/ws';
+        return url.toString();
+    }
+    if (/^\d+$/.test(listen))
+        return `ws://127.0.0.1:${listen}/ws`;
+    return `ws://${listen.replace(/\/$/, '')}/ws`;
+}
+function parseSnapshot(payload) {
+    if (payload === null || typeof payload !== 'object') {
+        throw new Error('Invalid Paseo timeline response.');
+    }
+    const response = payload;
+    if (typeof response.error === 'string' && response.error) {
+        throw new Error(response.error);
+    }
+    const latestTools = new Map();
+    for (const entry of response.entries ?? []) {
+        const item = entry.item;
+        if (item?.['type'] !== 'tool_call' ||
+            typeof item['callId'] !== 'string' ||
+            (item['status'] !== 'running' && item['status'] !== 'completed' && item['status'] !== 'failed')) {
+            continue;
+        }
+        latestTools.set(item['callId'], item['status']);
+    }
+    return {
+        agentStatus: typeof response.agent?.status === 'string' ? response.agent.status : 'unknown',
+        toolCalls: Array.from(latestTools, ([callId, status]) => ({ callId, status })),
+    };
+}
+class PaseoTimelineProbe {
+    socket;
+    pending = new Map();
+    constructor(socket) {
+        this.socket = socket;
+        socket.addEventListener('message', (event) => {
+            let envelope;
+            try {
+                envelope = JSON.parse(String(event.data));
+            }
+            catch {
+                return;
+            }
+            if (envelope === null || typeof envelope !== 'object')
+                return;
+            const outer = envelope;
+            if (outer.type !== 'session' || outer.message === null || typeof outer.message !== 'object') {
+                return;
+            }
+            const message = outer.message;
+            if (message.type !== 'fetch_agent_timeline_response' ||
+                message.payload === null ||
+                typeof message.payload !== 'object') {
+                return;
+            }
+            const requestId = message.payload.requestId;
+            if (typeof requestId !== 'string')
+                return;
+            const request = this.pending.get(requestId);
+            if (!request)
+                return;
+            clearTimeout(request.timer);
+            this.pending.delete(requestId);
+            try {
+                request.resolve(parseSnapshot(message.payload));
+            }
+            catch (error) {
+                request.reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+        const rejectPending = () => {
+            for (const [requestId, request] of this.pending) {
+                clearTimeout(request.timer);
+                request.reject(new Error('Paseo timeline connection closed.'));
+                this.pending.delete(requestId);
+            }
+        };
+        socket.addEventListener('close', rejectPending);
+        socket.addEventListener('error', rejectPending);
+    }
+    static async connect(timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+        const socket = new WebSocket(paseoWebSocketUrl());
+        await new Promise((resolvePromise, reject) => {
+            const timer = setTimeout(() => {
+                socket.close();
+                reject(new Error('Timed out connecting to Paseo.'));
+            }, timeoutMs);
+            socket.addEventListener('open', () => {
+                clearTimeout(timer);
+                resolvePromise();
+            }, { once: true });
+            socket.addEventListener('error', () => {
+                clearTimeout(timer);
+                reject(new Error('Could not connect to Paseo.'));
+            }, { once: true });
+        });
+        const probe = new PaseoTimelineProbe(socket);
+        socket.send(JSON.stringify({
+            type: 'hello',
+            clientId: `square-wake-${process.pid}-${randomUUID()}`,
+            clientType: 'cli',
+            protocolVersion: 1,
+        }));
+        return probe;
+    }
+    snapshot(agentId, timeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+        const requestId = randomUUID();
+        return new Promise((resolvePromise, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(requestId);
+                reject(new Error('Timed out reading Paseo timeline.'));
+            }, timeoutMs);
+            this.pending.set(requestId, { resolve: resolvePromise, reject, timer });
+            this.socket.send(JSON.stringify({
+                type: 'session',
+                message: {
+                    type: 'fetch_agent_timeline_request',
+                    agentId,
+                    requestId,
+                    direction: 'tail',
+                    limit: 200,
+                    projection: 'projected',
+                },
+            }));
+        });
+    }
+    close() {
+        this.socket.close();
+    }
+}
+async function waitWithSnapshots(agentId, readSnapshot, options) {
+    const initial = await readSnapshot(agentId);
+    if (initial.agentStatus === 'idle')
+        return true;
+    if (initial.agentStatus !== 'running')
+        return false;
+    const currentCalls = new Set(initial.toolCalls.filter((tool) => tool.status === 'running').map((tool) => tool.callId));
+    if (currentCalls.size === 0)
+        return true;
+    const pollIntervalMs = options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    const delay = options.delay ?? ((ms) => sleep(ms));
+    const deadline = options.timeoutMs === undefined ? null : Date.now() + options.timeoutMs;
+    while (deadline === null || Date.now() < deadline) {
+        await delay(pollIntervalMs);
+        const snapshot = await readSnapshot(agentId);
+        if (snapshot.agentStatus === 'idle')
+            return true;
+        if (snapshot.agentStatus !== 'running')
+            return false;
+        const latest = new Map(snapshot.toolCalls.map((tool) => [tool.callId, tool.status]));
+        const allTerminal = Array.from(currentCalls).every((callId) => {
+            const status = latest.get(callId);
+            return status === 'completed' || status === 'failed';
+        });
+        if (allTerminal)
+            return true;
+    }
+    return false;
+}
+/**
+ * Wait until the tool calls that were running at the initial snapshot finish.
+ * Tool calls that start later are intentionally ignored: the subsequent
+ * `paseo send` may replace the next tool call under the transitional policy.
+ */
+export async function waitForPaseoToolBoundary(agentId, options = {}) {
+    if (options.readSnapshot) {
+        try {
+            return await waitWithSnapshots(agentId, options.readSnapshot, options);
+        }
+        catch {
+            return false;
+        }
+    }
+    let probe = null;
+    try {
+        probe = await PaseoTimelineProbe.connect();
+        return await waitWithSnapshots(agentId, (id) => probe.snapshot(id), options);
+    }
+    catch {
+        return false;
+    }
+    finally {
+        probe?.close();
+    }
+}

package/dist/presentation.js

@@ -0,0 +1,468 @@
+import { sameName } from './model.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fold, perceive } from './square-core.js';
+import { actId, actStableIndex, extractMentions, publicActs, readCursor, rosterNames, sayNumberFor } from './runtime.js';
+import { formatDuration, formatRelativeTime, formatTimestamp } from './time.js';
+import { grepSnippet } from './search.js';
+function headerLine(squarePath, opts = {}) {
+    const count = opts.participantCount ?? 0;
+    const heldSuffix = opts.held ? ' — a hand is raised' : '';
+    return `· the square at ${displayPath(squarePath)} — ${count} in the square${heldSuffix}`;
+}
+export function displayPath(squarePath, cwd = process.cwd()) {
+    if (!path.isAbsolute(squarePath))
+        return squarePath;
+    const comparableCwd = fs.realpathSync.native(cwd);
+    let comparableSquarePath = squarePath;
+    try {
+        comparableSquarePath = fs.realpathSync.native(squarePath);
+    }
+    catch {
+        // Some error outputs name a path before it exists; lexical comparison remains useful there.
+    }
+    const relative = path.relative(comparableCwd, comparableSquarePath);
+    return relative !== '' && relative !== '..' && !relative.startsWith(`..${path.sep}`) ? relative : squarePath;
+}
+export function withPathOutput(squarePath, body = '', opts = {}) {
+    return [headerLine(squarePath, opts), ...(body === '' ? [] : ['', body])].join('\n') + '\n';
+}
+export function quoteShell(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+export function commandPrefix(squarePath) {
+    return `square --square-path ${quoteShell(squarePath)}`;
+}
+export function participantCommandPrefix(squarePath, name) {
+    return `square --square-path ${quoteShell(path.resolve(squarePath))} --as ${quoteShell(name)}`;
+}
+function formatAge(ms) {
+    if (ms === undefined)
+        return '(none)';
+    if (ms < 1000)
+        return `${Math.max(0, ms)}ms`;
+    return `${Math.floor(ms / 1000)}s`;
+}
+function pluralize(count, singular, plural = `${singular}s`) {
+    return count === 1 ? singular : plural;
+}
+const PRESENCE_WINDOW_MS = 8 * 60 * 60 * 1000;
+function presenceGlyph(participant) {
+    if (participant.state === 'done')
+        return '×';
+    if (participant.presence === 'watching')
+        return '◎';
+    if (participant.presenceAt !== undefined)
+        return '●';
+    return '○';
+}
+function presenceText(participant, now) {
+    if (participant.state === 'done') {
+        return participant.lastActiveAt === undefined ? 'stepped out of the square' : `stepped out of the square · ${formatRelativeTime(participant.lastActiveAt, now)}`;
+    }
+    if (participant.presence === 'watching') {
+        const at = participant.presenceAt ?? participant.lastActiveAt;
+        return at === undefined ? 'catching' : `catching · ${formatRelativeTime(at, now)}`;
+    }
+    if (participant.presenceAt === undefined)
+        return 'quiet';
+    return participant.activityCount > 0 ? `${formatRelativeTime(participant.presenceAt, now)}` : `quiet · ${formatRelativeTime(participant.presenceAt, now)}`;
+}
+export function renderPresenceLines(participants, now, limit = 5) {
+    const recent = participants
+        .map((p) => ({ p, at: p.presenceAt ?? p.lastActiveAt ?? -Infinity }))
+        .filter(({ p, at }) => p.state === 'done' || p.presence === 'watching' || (at !== -Infinity && now - at <= PRESENCE_WINDOW_MS))
+        .sort((a, b) => b.at - a.at || a.p.name.localeCompare(b.p.name))
+        .map(({ p }) => p);
+    const shown = recent.slice(0, limit);
+    if (shown.length === 0)
+        return ['  ○ nobody nearby'];
+    const lines = shown.map((p) => `  ${presenceGlyph(p)} ${p.name} · ${presenceText(p, now)}`);
+    const remaining = recent.length - shown.length;
+    if (remaining > 0)
+        lines.push(`  ○ …and ${remaining} more`);
+    return lines;
+}
+const ACT_HINTS = [
+    '*asterisks* are your body — *slams table*, *sketches in the air*, *shrugs*',
+    "you're standing in a square, not posting to a feed",
+    'half-shaped is welcome — a sketch, an objection, a joke, a fragment',
+    '@ only who you need — step back with catch --mention',
+];
+export function actHintLine(ownActCount) {
+    if (ownActCount !== 1 && ownActCount % 5 !== 0)
+        return undefined;
+    const hint = ACT_HINTS[Math.floor(ownActCount / 5) % ACT_HINTS.length];
+    return `· ${hint}`;
+}
+const BODY_PREVIEW_LENGTH = 200;
+export function truncateChars(body, maxChars) {
+    const chars = [...body];
+    if (chars.length <= maxChars)
+        return { text: body, remaining: 0 };
+    return { text: chars.slice(0, maxChars).join('').trimEnd(), remaining: chars.length - maxChars };
+}
+function previewBody(body, maxLen = BODY_PREVIEW_LENGTH) {
+    const preview = truncateChars(body, maxLen);
+    return preview.remaining === 0 ? preview.text : `${preview.text}\n… ${preview.remaining} more chars`;
+}
+const UNREAD_PREVIEW_CHARS = 120;
+export function previewActivityBody(body) {
+    const compact = body.replace(/\s+/g, ' ').trim();
+    if (compact === '')
+        return '(empty)';
+    const preview = truncateChars(compact, UNREAD_PREVIEW_CHARS);
+    return preview.remaining === 0 ? preview.text : `${preview.text}… (+${preview.remaining} chars)`;
+}
+export function renderRoomChangeText(event) {
+    const actor = event.actor ?? 'someone';
+    switch (event.kind) {
+        case 'join':
+            return `${actor} stepped into the square`;
+        case 'done':
+            return `${actor} stepped out of the square`;
+        case 'hold':
+            return `${actor} raised a hand${event.body ? ` — ${event.body}` : ''}`;
+        case 'resume':
+            return `${actor} lowered the hand`;
+    }
+}
+function renderedBody(body, maxChars) {
+    if (!body)
+        return '';
+    return maxChars === undefined ? body : previewBody(body, maxChars);
+}
+function bodySuffix(body) {
+    if (body === '')
+        return '';
+    return `\n${body.split('\n').map((line) => `  ${line}`).join('\n')}`;
+}
+export function renderEventCli(event, opts = {}) {
+    const now = opts.now;
+    const maxBody = opts.preview;
+    switch (event.kind) {
+        case 'join':
+            return `· ${renderRoomChangeText(event)}`;
+        case 'hold':
+            return `· ${renderRoomChangeText(event)}`;
+        case 'resume':
+            return `✓ ${renderRoomChangeText(event)}`;
+        case 'say': {
+            const body = renderedBody(event.body, maxBody);
+            const mention = opts.mention;
+            const mentionSuffix = mention !== undefined && extractMentions(event.body).some((name) => sameName(name, mention))
+                ? ` · calls your name across the square — @${mention}`
+                : '';
+            return `● ${event.actor} #${opts.actNumber ?? 1} · ${actId(event)} · ${formatRelativeTime(event.at, now)}${mentionSuffix}${bodySuffix(body)}`;
+        }
+        case 'done': {
+            const body = renderedBody(event.body, maxBody);
+            return `× ${event.actor} stepped out of the square — done · ${actId(event)} · ${formatRelativeTime(event.at, now)}${bodySuffix(body)}`;
+        }
+        case 'read':
+            return '';
+    }
+}
+function renderPresenceOnlySay(event) {
+    if (event.kind !== 'say' || event.reach === undefined || event.reach === 'bell')
+        return '';
+    return `*walks over to @${event.reach.beside}*`;
+}
+function perceptionFor(history, event, viewer) {
+    const cutoff = history.findIndex((item) => actStableIndex(item) === actStableIndex(event));
+    const acts = cutoff >= 0 ? history.slice(0, cutoff) : history;
+    return perceive(fold(acts), event, viewer);
+}
+export function renderVisibleEvent(history, event, viewer, opts = {}) {
+    if (event.kind !== 'say')
+        return renderEventCli(event, opts);
+    const seen = perceptionFor(history, event, viewer);
+    if (seen === 'none')
+        return '';
+    if (seen === 'presence')
+        return renderPresenceOnlySay(event);
+    return renderEventCli(event, opts);
+}
+function draftSavedLines(draftPath) {
+    return draftPath === undefined ? [] : [`· draft kept: ${draftPath}`];
+}
+function withDraftInput(command, draftPath) {
+    return draftPath === undefined ? command : `${command} < ${quoteShell(draftPath)}`;
+}
+function renderUnreadSummary(opts) {
+    return [
+        ...opts.activitySummaries.flatMap((item) => [
+            ...item.previews.slice(-1).map((preview) => {
+                const rendered = renderVisibleEvent([preview.act], preview.act, opts.viewer, { actNumber: preview.number });
+                if (rendered === '')
+                    return `  · ${item.name} spoke — ${formatAge(item.latestActivityAgeMs)} ago`;
+                if (rendered.startsWith('*'))
+                    return `  · ${item.name} spoke — ${formatAge(item.latestActivityAgeMs)} ago · ${rendered}`;
+                return `  · ${item.name} spoke — ${formatAge(item.latestActivityAgeMs)} ago · "${previewActivityBody(preview.act.body)}"`;
+            }),
+        ]),
+        ...opts.roomChanges.map(({ act }) => `  · ${renderRoomChangeText(act)}`),
+    ];
+}
+export function renderPendingFeed(publicItems, roomChanges, viewer = '') {
+    const lines = [];
+    for (const item of publicItems) {
+        if (item.act.kind === 'say' && item.number !== undefined && item.act.at) {
+            const rendered = renderVisibleEvent(publicItems
+                .filter((entry) => (entry.act.kind === 'say' || entry.act.kind === 'done') && entry.act.at !== undefined)
+                .map((entry, index) => ({ ...entry.act, index })), { kind: 'say', actor: item.act.actor, at: item.act.at, body: item.act.body ?? '', index: item.index }, viewer, { actNumber: item.number });
+            if (rendered !== '')
+                lines.push(rendered);
+        }
+        else if (item.act.kind === 'done' && item.act.at) {
+            lines.push(renderEventCli({ kind: 'done', actor: item.act.actor, at: item.act.at, body: item.act.body ?? '', index: item.index }));
+        }
+    }
+    const publicIndexes = new Set(publicItems.map((item) => item.index));
+    for (const { act, index } of roomChanges) {
+        if (publicIndexes.has(index))
+            continue;
+        lines.push(`· ${renderRoomChangeText(act)}`);
+    }
+    return lines.join('\n\n');
+}
+export function renderActivityBlocked(opts) {
+    const readNowCommand = `${participantCommandPrefix(opts.squarePath, opts.name)} catch --now`;
+    return withPathOutput(opts.squarePath, [
+        "✕ your act doesn't land — the square moved behind your back",
+        ...renderUnreadSummary({ activitySummaries: opts.activitySummaries, roomChanges: opts.unreadRoomChanges, viewer: opts.name }),
+        ...draftSavedLines(opts.draftPath),
+        `» ${readNowCommand}`,
+        '  read, then act again',
+        `» ${withDraftInput(opts.forceCommand, opts.draftPath)}`,
+        '  only if you truly mean to speak over them',
+    ].join('\n'), { participantCount: opts.participantCount, held: opts.held });
+}
+export function withJoinNextOutput(squarePath, body, opts = {}) {
+    return withPathOutput(squarePath, body.trimEnd(), opts);
+}
+export function withActivityNextOutput(squarePath, body = '', opts = {}) {
+    return withPathOutput(squarePath, body.trimEnd(), opts);
+}
+export function withWatchNextOutput(squarePath, body, opts = {}) {
+    return withPathOutput(squarePath, body.trimEnd(), opts);
+}
+export function renderActWaiting(opts) {
+    if (opts.reason === 'throttled') {
+        return ['✕ the square is packed', `  · your act is waiting · next opening in ${formatDuration(opts.delayMs)}`].join('\n');
+    }
+    return ["✕ your act doesn't land — a hand is raised", '  · your act is waiting'].join('\n');
+}
+export function renderActNoWait(opts) {
+    const retryCommand = `${participantCommandPrefix(opts.squarePath, opts.name)} act -`;
+    const lines = opts.reason === 'throttled'
+        ? [
+            '✕ the square is packed',
+            `  · next opening in ${formatDuration(opts.delayMs)}`,
+            ...draftSavedLines(opts.draftPath),
+            `» ${withDraftInput(retryCommand, opts.draftPath)}`,
+        ]
+        : [
+            "✕ your act doesn't land — a hand is raised",
+            `  · ${opts.holdReason ?? 'the square holds its breath'}`,
+            ...draftSavedLines(opts.draftPath),
+            `» ${withDraftInput(retryCommand, opts.draftPath)}`,
+        ];
+    return withPathOutput(opts.squarePath, lines.join('\n'), { participantCount: opts.participantCount, held: opts.held });
+}
+export function renderPublicTail(events, lastN, now, viewer = '') {
+    const publicItems = publicActs(events);
+    const selected = lastN == null ? publicItems : publicItems.slice(-lastN);
+    const preview = lastN == null ? undefined : BODY_PREVIEW_LENGTH;
+    return selected
+        .map((event) => renderVisibleEvent(events, event, viewer, { now, preview, actNumber: event.kind === 'say' ? sayNumberFor(events, event) : undefined }))
+        .filter(Boolean)
+        .join('\n\n');
+}
+function lastPresenceAnchor(doc, name) {
+    const cursor = readCursor(doc, name);
+    for (let i = doc.acts.length - 1; i >= 0; i--) {
+        const event = doc.acts[i];
+        const index = actStableIndex(event);
+        if (index > cursor)
+            continue;
+        if (event.kind === 'say' || event.kind === 'done')
+            return index;
+    }
+    return -1;
+}
+function renderLastPresenceMarker(name) {
+    return `· ${name}'s footprints reach here`;
+}
+export function renderActivitiesView(doc, visible, lastN, full, squarePath, viewer = '') {
+    const publicVisible = visible.filter((item) => item.act.kind === 'say' || item.act.kind === 'done');
+    const shown = lastN == null ? publicVisible : publicVisible.slice(-lastN);
+    const previewLen = full ? undefined : BODY_PREVIEW_LENGTH;
+    const markers = new Map();
+    for (const participant of rosterNames(doc)) {
+        const anchor = lastPresenceAnchor(doc, participant);
+        if (anchor >= 0)
+            markers.set(anchor, [...(markers.get(anchor) ?? []), participant]);
+    }
+    const chunks = [];
+    for (const item of shown) {
+        const rendered = renderVisibleEvent(doc.acts, item.act, viewer, {
+            preview: previewLen,
+            actNumber: item.act.kind === 'say' ? sayNumberFor(doc.acts, item.act) : undefined,
+        });
+        if (rendered !== '')
+            chunks.push(rendered);
+        for (const participant of markers.get(item.index) ?? []) {
+            chunks.push(renderLastPresenceMarker(participant));
+        }
+    }
+    if (chunks.length === 0)
+        return 'latest\n  ○ no public activity in this view';
+    if (previewLen !== undefined) {
+        const truncated = shown.some((item) => item.act.kind === 'say' && item.act.body.length > previewLen);
+        if (truncated)
+            chunks.push(`» ${commandPrefix(squarePath)} echo --full`);
+    }
+    return chunks.join('\n\n');
+}
+const GREP_PREVIEW_CHARS = 160;
+function highlightGrepMatch(text) {
+    if (!process.stdout.isTTY || process.env.NO_COLOR !== undefined || text === '')
+        return text;
+    return `\x1b[38;5;222m\x1b[1m${text}\x1b[0m`;
+}
+export function renderGrepActivitiesView(visible, totalMatches, full, squarePath, pattern, fixed = false) {
+    const publicVisible = visible.filter((item) => item.act.kind === 'say' || item.act.kind === 'done');
+    if (totalMatches === 0)
+        return `○ no activity matched ${quoteShell(pattern)}`;
+    const matchLabel = totalMatches === 1 ? 'match' : 'matches';
+    const chunks = [publicVisible.length === totalMatches ? `${totalMatches} ${matchLabel}` : `${publicVisible.length} of ${totalMatches} ${matchLabel}`];
+    let truncated = false;
+    for (const item of publicVisible) {
+        const rawBody = item.act.body ?? '';
+        if (full === true) {
+            const body = rawBody.split('\n').map((line) => `  ${line}`).join('\n');
+            chunks.push(`${actId(item.index)} · ${item.act.actor ?? 'unknown'} · ${formatTimestamp(item.act.at)}\n${body}`);
+            continue;
+        }
+        const snippet = grepSnippet(rawBody, pattern, GREP_PREVIEW_CHARS, fixed);
+        if (snippet === undefined)
+            continue;
+        const clippedBefore = snippet.beforeOmitted > 0;
+        const clippedAfter = snippet.afterOmitted > 0;
+        truncated ||= clippedBefore || clippedAfter;
+        const text = `${clippedBefore ? '… ' : ''}${snippet.before}${highlightGrepMatch(snippet.match)}${snippet.after}${clippedAfter ? ' …' : ''}`;
+        const omitted = clippedBefore || clippedAfter
+            ? `\n  · ${snippet.beforeOmitted} chars before · ${snippet.afterOmitted} chars after`
+            : '';
+        chunks.push(`${actId(item.index)} · ${item.act.actor ?? 'unknown'} · ${formatTimestamp(item.act.at)}\n  ${text.trim()}${omitted}`);
+    }
+    if (publicVisible.length === 1) {
+        chunks.push(`» ${commandPrefix(squarePath)} echo --at ${actId(publicVisible[0].index)} -C 2${truncated ? ' --full' : ''}`);
+    }
+    else if (truncated && publicVisible.length > 1) {
+        chunks.push(`» ${commandPrefix(squarePath)} echo --at ${actId(publicVisible[0].index)} -C 2 --full`);
+    }
+    return chunks.join('\n\n');
+}
+function renderActivityLimitBody(opts) {
+    const countText = opts.count !== undefined && opts.hardCap !== undefined ? ` (${opts.count}/${opts.hardCap})` : '';
+    const doneCommand = `${participantCommandPrefix(opts.squarePath, opts.name)} done -`;
+    return [
+        `✕ your act doesn't land — the cap is reached${countText}`,
+        ...draftSavedLines(opts.draftPath),
+        `» ${withDraftInput(doneCommand, opts.draftPath)}`,
+    ].join('\n');
+}
+export function renderActivityLimit(opts) {
+    return withPathOutput(opts.squarePath, renderActivityLimitBody(opts), { participantCount: opts.participantCount, held: opts.held });
+}
+export function renderWatchInterrupted(_opts) {
+    return '✕ catch stopped';
+}
+export function renderWatchAlreadyActive(opts) {
+    return ['✕ you are already catching', `» ${participantCommandPrefix(opts.squarePath, opts.name)} catch --force`].join('\n');
+}
+export function renderWatchForceTakeover(_opts) {
+    return '✓ your new catch takes over';
+}
+export function renderWatchReplaced(_opts) {
+    return '✕ a newer catch took over';
+}
+export function renderWatchStatus(opts) {
+    const others = opts.presence === undefined
+        ? undefined
+        : opts.presence.participants.filter((participant) => !sameName(participant.name, opts.name));
+    const presenceLines = opts.presence !== undefined && others !== undefined
+        ? ['', 'around the square', ...renderPresenceLines(others, opts.presence.now)]
+        : [];
+    switch (opts.status) {
+        case 'stale':
+        case 'empty-now': {
+            const prefix = participantCommandPrefix(opts.squarePath, opts.name);
+            return [
+                '○ only footsteps in the square — nothing new for you',
+                ...(opts.showCatchHint === false
+                    ? []
+                    : [`» ${prefix} catch --idle 30m`, `  glance: ${prefix} catch --now`]),
+                ...presenceLines,
+            ].join('\n');
+        }
+        case 'quorum':
+            return ['✓ everyone else has left — the square is yours alone', `» ${participantCommandPrefix(opts.squarePath, opts.name)} done -`].join('\n');
+        case 'capped':
+            return ['✕ nothing left in you — the cap is reached', `» ${participantCommandPrefix(opts.squarePath, opts.name)} done -`].join('\n');
+    }
+}
+function renderRoomChanges(changes) {
+    if (changes.length === 0)
+        return '';
+    return ['▲ while your back was turned', ...changes.map(({ act }) => `  · ${renderRoomChangeText(act)}`)].join('\n');
+}
+export function renderDoctorClean() {
+    return '✓ no problems found';
+}
+export function renderDoctorProblems(problems) {
+    return [`✕ ${problems.length} ${pluralize(problems.length, 'problem')} found`, ...problems.map((problem) => `  · ${problem.kind}: ${problem.message}`)].join('\n');
+}
+export function renderDoctorUnfixable(reason) {
+    return ['✕ cannot repair', `  · ${reason}`].join('\n');
+}
+export function renderDoctorRepaired(actions, quarantinedCount, sidecarPath) {
+    if (actions.length === 0)
+        return '✓ no problems found';
+    return [
+        '✓ repaired',
+        ...actions.map((action) => `  · ${action.message}`),
+        ...(quarantinedCount > 0 && sidecarPath !== undefined ? [`  · quarantined ${quarantinedCount} act block(s)`, `  · sidecar ${sidecarPath}`] : []),
+    ].join('\n');
+}
+export function renderWatchOutput(history, publicItems, roomChanges, opts) {
+    const sections = [];
+    if (opts.stalePartial) {
+        const prefix = participantCommandPrefix(opts.squarePath, opts.viewer);
+        sections.push([
+            '○ only footsteps in the square — nothing new for you',
+            ...(opts.showCatchHint === false
+                ? []
+                : [`» ${prefix} catch --idle 30m`, `  glance: ${prefix} catch --now`]),
+        ].join('\n'));
+    }
+    const publicIndexes = new Set(publicItems.map((item) => item.index));
+    const presenceChanges = roomChanges.filter(({ index }) => !publicIndexes.has(index));
+    const room = renderRoomChanges(presenceChanges);
+    if (room !== '')
+        sections.push(room);
+    if (publicItems.length > 0) {
+        const rendered = publicItems
+            .map((item) => renderVisibleEvent(history, item.act, opts.viewer, {
+            actNumber: item.act.kind === 'say' ? sayNumberFor(history, item.act) : undefined,
+            mention: opts.mention,
+        }))
+            .filter(Boolean)
+            .join('\n\n');
+        if (rendered !== '')
+            sections.push(rendered);
+    }
+    return sections.join('\n\n') + '\n';
+}