@astrosheep/square 0.3.57 → 0.3.61

package/claude-plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.57",
+  "version": "0.3.61",
   "description": "Native Claude Code turn-boundary delivery for Square participants",
   "author": {
     "name": "Square"

package/codex-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.57",
+  "version": "0.3.61",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/dist/activity.js

@@ -3,14 +3,16 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { SquareError, isSquareError, validateName } from './model.js';
-import { expressHintLine, renderActivityBlocked, renderActivityLimit, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, joinRecoveryCommand, withPathOutput, } from './presentation.js';
-import { nowMs, SLEEP_MS } from './runtime.js';
+import { expressHintLine, formatRefusal, renderActivityBlocked, renderActivityLimit, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, joinRecoveryCommand, withPathOutput, } from './presentation.js';
+import { nowMs, inSquareCount, SLEEP_MS } from './runtime.js';
+import { unreadActivitySummaries } from './decisions.js';
 import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
 import { Square } from './square-wiring.js';
 import { activityPresentation, resolveParticipant } from './views.js';
 import { formatActivityId } from './square-core.js';
-import { formatTimestamp } from './time.js';
+import { formatDuration } from './time.js';
+import { style } from './tty-style.js';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 import { createDefaultWakeTransport } from './notifications.js';
 function draftDirFor(squarePath) {
@@ -49,14 +51,15 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
         knownName = (await resolveParticipant(reader, name)).name;
     }
     catch (err) {
+        const participantCount = inSquareCount((await reader.artifact.read()).state);
         await closeOpenSquare(reader);
         if (isSquareError(err)) {
             if (err.code === 'unknown_participant' || err.code === 'invalid_args') {
                 const draftPath = saveActivityDraft(squarePath, name, rawInput);
-                process.stderr.write(err.message + '\n');
-                process.stderr.write(`draft kept: ${draftPath}\n`);
-                if (/^Unknown participant/.test(err.message))
-                    process.stderr.write(`${joinRecoveryCommand(squarePath, name)}\n`);
+                const bodyLines = [err.message, `· draft kept: ${draftPath}`];
+                if (/^✕ .* has never stepped into/.test(err.message))
+                    bodyLines.push(joinRecoveryCommand(squarePath, name));
+                process.stderr.write(formatRefusal(squarePath, bodyLines, { participantCount }));
                 process.exit(2);
             }
             process.stderr.write(err.message + '\n');
@@ -81,7 +84,7 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
             const pendingPublic = before.pendingPublic;
             const pendingRoomChanges = before.pendingRoomChanges;
             try {
-                await participant.express(body, {
+                const landed = await participant.express(body, {
                     force,
                     ...(opts.mentions === undefined ? {} : { mentions: opts.mentions }),
                     ...(reach === undefined ? {} : { reach }),
@@ -95,8 +98,8 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
                 const hasPending = pendingPublic.length > 0 || pendingRoomChanges.length > 0;
                 const pending = hasPending ? `\n\n${renderPendingFeed([...fresh.activities], [...pendingPublic], [...pendingRoomChanges], knownName, fresh.state)}` : '';
                 const hint = expressHintLine(ownActCount);
-                const confirmation = `● heads turn your way — #${ownActCount}`;
-                const withHint = hint ? `${confirmation}\n${hint}` : confirmation;
+                const confirmation = `● your activity lands${style('dim', ` — #${ownActCount} · ${landed.activity.id}`)}`;
+                const withHint = hint ? `${confirmation}\n${style('dim', hint)}` : confirmation;
                 process.stdout.write(withPathOutput(squarePath, withHint + pending, { participantCount: headerCount, held }));
                 return;
             }
@@ -113,8 +116,8 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
                         squarePath,
                         name: knownName,
                         forceCommand: opts.forceCommand,
-                        activitySummaries: [],
-                        unreadRoomChanges: [...pendingRoomChanges],
+                        activitySummaries: unreadActivitySummaries(fresh.state, knownName, nowMs()),
+                        unreadRoomChanges: [],
                         draftPath,
                         participantCount: headerCount,
                         held,
@@ -164,8 +167,7 @@ export async function cmdActivity(squarePath, name, activity, resolveBody, opts)
                     continue;
                 }
                 if (error.code === 'bell_quota') {
-                    const nextAt = nowMs() + (error.facts?.retryAfterMs ?? 1);
-                    process.stdout.write(withPathOutput(squarePath, [`✕ the bell stays quiet for now`, `  · you can ring it again at ${formatTimestamp(nextAt)}`].join('\n'), { participantCount: headerCount, held }));
+                    process.stdout.write(withPathOutput(squarePath, [`✕ the bell stays quiet for now`, `  · you can ring it again in ${formatDuration(error.facts?.retryAfterMs ?? 1)}`].join('\n'), { participantCount: headerCount, held }));
                     process.exit(1);
                     return;
                 }

package/dist/attention-presentation.js

@@ -17,29 +17,29 @@ export function displayAttentionPath(squarePath) {
         : squarePath;
 }
 export function renderAttentionPreview(attention) {
-    const attentionKind = attention.route === 'bell' ? 'bell' : 'attention';
-    const attributes = {
-        location: displayAttentionPath(attention.squarePath),
-        id: formatActivityId(attention.actIndex),
-        from: attention.actor,
-        to: attention.recipient,
-        kind: attentionKind,
-    };
-    const entries = Object.entries(attributes);
-    const [lastKey, lastValue] = entries[entries.length - 1];
+    // A boundary preview only ever reaches the recipient's own session, so the
+    // recipient is always "you"; the name follows in parens for recognition.
+    const route = attention.route === 'bell'
+        ? `${attention.actor} rang the bell for you (${attention.recipient})`
+        : `${attention.actor} called your name (${attention.recipient})`;
+    // The fence is what keeps the body from being re-rendered by Markdown. It grows past any
+    // backtick run in the body so a body containing a fence cannot break out of this one.
+    // Everything outside the fence is the system's voice, which participant bodies cannot fake.
+    const fence = '`'.repeat(Math.max(3, longestBacktickRun(attention.body) + 1));
     return [
-        '<square-activity',
-        // The opening tag must never emit a standalone `>` line: Markdown renders it as a blockquote.
-        ...entries.slice(0, -1).map(([key, value]) => `  ${key}="${escapeAttribute(value)}"`),
-        `  ${lastKey}="${escapeAttribute(lastValue)}">`,
+        `${fence}square-activity`,
+        `· ${displayAttentionPath(attention.squarePath)} · ${formatActivityId(attention.actIndex)}`,
+        `● ${route}`,
+        '',
         previewAttentionBody(attention.body),
-        '</square-activity>',
+        fence,
+        // A clipped body ends with the full command to read it all: a labeled caption, then the
+        // command bare on its own line so it can be copied and run as it is.
         ...(attentionBodyIsClipped(attention.body)
-            ? [`» ${participantCommandPrefix(attention.squarePath, attention.recipient)} catch --id ${formatActivityId(attention.actIndex)}`]
+            ? ['· clipped — read it all:', `${participantCommandPrefix(attention.squarePath, attention.recipient)} catch --id ${formatActivityId(attention.actIndex)}`]
             : []),
     ].join('\n');
 }
-function escapeAttribute(value) {
-    return value.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;')
-        .replace(/\r/g, '&#13;').replace(/\n/g, '&#10;').replace(/\t/g, '&#9;');
+function longestBacktickRun(value) {
+    return value.match(/`+/g)?.reduce((longest, run) => Math.max(longest, run.length), 0) ?? 0;
 }

package/dist/automatic-session.js

@@ -71,10 +71,10 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
         await closeOpenSquare(reader);
     }
     if (bindings.some((binding) => binding.session !== sessionId)) {
-        throw new SquareError('already_joined', `${name} is already bound to another session`);
+        throw new SquareError('already_joined', `✕ ${name} already stands here — another session holds the name`);
     }
     if (entry.joined && !bindings.some((binding) => binding.session === sessionId)) {
-        throw new SquareError('already_joined', `${name} is already joined by another session`);
+        throw new SquareError('already_joined', `✕ ${name} already stands here — another session holds the name`);
     }
     const scopedEnv = operationEnv(provider, sessionId, env);
     const claim = await claimSessionParticipant(squarePath, name, scopedEnv);

package/dist/catch-decisions.js

@@ -17,7 +17,7 @@ function resolveCatchName(state, requestedName) {
     validateName(requestedName);
     const known = resolveRosterName(state, requestedName);
     if (known === undefined) {
-        throw new SquareError('invalid_args', `Unknown participant "${participantIdentity(requestedName)}".`);
+        throw new SquareError('invalid_args', `✕ ${participantIdentity(requestedName)} has never stepped into this square`);
     }
     return known;
 }

package/dist/cli/context.js

@@ -35,66 +35,66 @@ export function usage(command) {
 export function requireValue(args, index, flag) {
     const value = args[index + 1];
     if (value === undefined || value.startsWith('--'))
-        fail(`Missing value for ${flag}.`);
+        fail(`✕ missing value for ${flag}`);
     return value;
 }
 export function parseDurationMs(value, flag) {
     const match = value.match(/^([1-9]\d*)(ms|s|m|h)$/);
     if (!match)
-        fail(`Invalid ${flag}: expected a positive duration with unit ms, s, m, or h (for example 500ms, 30s, 3m, 1h).`);
+        fail(`✕ invalid ${flag}: expected a positive duration with unit ms, s, m, or h (for example 500ms, 30s, 3m, 1h)`);
     const amount = Number.parseInt(match[1], 10);
     const multiplier = { ms: 1, s: 1000, m: 60000, h: 3600000 };
     const milliseconds = amount * multiplier[match[2]];
     if (!Number.isSafeInteger(milliseconds))
-        fail(`Invalid ${flag}: duration is too large.`);
+        fail(`✕ invalid ${flag}: duration is too large`);
     return milliseconds;
 }
 export function parsePositiveInteger(value, flag) {
     if (!/^[1-9]\d*$/.test(value))
-        fail(`Invalid ${flag}: expected a positive integer.`);
+        fail(`✕ invalid ${flag}: expected a positive integer`);
     const parsed = Number(value);
     if (!Number.isSafeInteger(parsed))
-        fail(`Invalid ${flag}: value is too large.`);
+        fail(`✕ invalid ${flag}: value is too large`);
     return parsed;
 }
 export function parseBoundedLimit(value, flag, max, retry) {
     if (value === undefined || value.startsWith('--') || !/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value))) {
-        fail(`✕ ${flag} needs a positive integer\n» ${retry}`);
+        fail(`✕ ${flag} needs a positive integer\n${retry}`);
     }
     const parsed = Number(value);
     if (parsed > max)
-        fail(`✕ ${flag} is capped at ${max}\n» ${retry}`);
+        fail(`✕ ${flag} is capped at ${max}\n${retry}`);
     return parsed;
 }
 export function parseNonNegativeInteger(value, flag) {
     if (!/^\d+$/.test(value))
-        fail(`Invalid ${flag}: expected a non-negative integer.`);
+        fail(`✕ invalid ${flag}: expected a non-negative integer`);
     const parsed = Number(value);
     if (!Number.isSafeInteger(parsed))
-        fail(`Invalid ${flag}: value is too large.`);
+        fail(`✕ invalid ${flag}: value is too large`);
     return parsed;
 }
 export function parseHardCap(value) {
     if (value === 'unlimited')
         return null;
     if (!/^[1-9]\d*$/.test(value))
-        fail('Invalid build option: --cap must be a positive integer or unlimited.');
+        fail('✕ invalid build option: --cap must be a positive integer or unlimited');
     const parsed = Number(value);
     if (!Number.isSafeInteger(parsed))
-        fail('Invalid build option: --cap must be a positive integer or unlimited.');
+        fail('✕ invalid build option: --cap must be a positive integer or unlimited');
     return parsed;
 }
 export function parseNameList(value, flag) {
     const names = parseParticipantList(value);
     if (names.length === 0)
-        fail(`Invalid ${flag}: expected at least one participant name.`);
+        fail(`✕ invalid ${flag}: expected at least one participant name`);
     for (const name of names)
         validateName(name);
     return names;
 }
 export function requireParticipant(name) {
     if (!name)
-        fail('Missing required option: --as <name>.');
+        fail('✕ missing required option: --as <name>');
     validateName(name);
     return name;
 }
@@ -157,7 +157,7 @@ export async function parseGlobalArgs(rawArgs) {
     }
     const command = args[0];
     if (command === 'history' && hasExplicitName) {
-        fail(`✕ history is an archive and does not use --as\n» ${withoutAsCommand(rawArgs)}`);
+        fail(`✕ history is an archive and does not use --as\n${withoutAsCommand(rawArgs)}`);
     }
     if (name === undefined)
         name = configuredName();
@@ -166,7 +166,7 @@ export async function parseGlobalArgs(rawArgs) {
     const explicitSquarePath = requestedPath !== undefined;
     const configured = configuredLocation();
     if (command !== undefined && !['--help', '-h'].includes(command) && locationIsRequired(command) && requestedPath === undefined && configured === undefined) {
-        fail(`✕ ${command} needs a square location\n» square ls`);
+        fail(`✕ ${command} needs a square location\nsquare ls`);
     }
     const squarePath = requestedPath ?? configured;
     if (name === undefined && squarePath !== undefined && command !== undefined && locationIsRequired(command)) {
@@ -189,6 +189,6 @@ export function defaultContext(command, squarePath, name) {
 }
 export function requireSquarePath(context) {
     if (context.squarePath === undefined)
-        fail(`✕ ${context.command} needs a square location\n» square ls`);
+        fail(`✕ ${context.command} needs a square location\nsquare ls`);
     return context.squarePath;
 }

package/dist/cli/observation-commands.js

@@ -6,6 +6,7 @@ import { cmdListSquares } from '../list.js';
 import { nameKey, parseActivityId, sameName } from '../model.js';
 import { commandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEvent, 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';
@@ -15,6 +16,8 @@ import { historyPresentation, participantsPresentation, statusPresentation } fro
 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';
 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;
@@ -94,10 +97,10 @@ export const catchCommand = {
         for (let index = 0; index < argv.length; index++) {
             if (argv[index] === '--id') {
                 if (id !== undefined)
-                    fail('✕ catch accepts one --id\n» square catch --help');
+                    fail('✕ catch accepts one --id\nsquare catch --help');
                 const value = requireValue(argv, index, '--id');
                 if (parseActivityId(value) === undefined)
-                    fail('✕ invalid --id: expected an activity id like act/12\n» square catch --help');
+                    fail('✕ invalid --id: expected an activity id like act/12\nsquare catch --help');
                 id = value;
                 index += 1;
             }
@@ -121,11 +124,11 @@ export const catchCommand = {
             else if (argv[index] === '--now')
                 now = true;
             else
-                fail(`✕ catch does not know ${argv[index]}\n» square catch --help`);
+                fail(`✕ catch does not know ${argv[index]}\nsquare catch --help`);
         }
         if (id !== undefined) {
             if (argv.some((flag) => ['--idle', '--from', '--mention', '--limit', '--replace'].includes(flag))) {
-                fail('✕ --id cannot be combined with --idle, --from, --mention, --limit or --replace\n» square catch --help');
+                fail('✕ --id cannot be combined with --idle, --from, --mention, --limit or --replace\nsquare catch --help');
             }
             return { id, now: true };
         }
@@ -271,7 +274,7 @@ function parseHistory(argv, context) {
         else if (flag === '--json')
             json = true;
         else
-            fail(`✕ history does not know ${flag}\n» square history --help`);
+            fail(`✕ history does not know ${flag}\nsquare history --help`);
     }
     if (grep !== undefined && fixed !== undefined)
         fail('--grep and --fixed cannot be combined.');
@@ -359,7 +362,7 @@ function renderHistoryProjection(projection, visible, noTruncate, squarePath) {
     if (chunks.length === 0)
         return 'latest\n  ○ no public activity in this view';
     if (preview !== undefined && shown.some((activity) => activity.kind === 'say' && activity.body.length > preview)) {
-        chunks.push(`» ${commandPrefix(squarePath)} history --no-truncate`);
+        chunks.push(`${commandPrefix(squarePath)} history --no-truncate`);
     }
     return chunks.join('\n\n');
 }
@@ -374,7 +377,7 @@ export const historyCommand = {
             const projection = await historyPresentation(square, { ...options, order: 'asc' });
             let events = [...projection.activities];
             if (options.lastN === null && events.length > HISTORY_MAX_LIMIT) {
-                fail(`✕ history is capped at ${HISTORY_MAX_LIMIT} activities\n» ${boundedHistoryCommand(options, squarePath)}`);
+                fail(`✕ history is capped at ${HISTORY_MAX_LIMIT} activities\n${boundedHistoryCommand(options, squarePath)}`);
             }
             const searching = options.grep !== undefined || options.fixed !== undefined;
             const totalMatches = searching ? events.length : 0;
@@ -403,7 +406,7 @@ export const historyCommand = {
                 : 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, cursorIndex)}` : '';
+            const continuation = hasMore ? `\n\n${historyContinuationCommand(options, squarePath, cursorDirection, cursorIndex)}` : '';
             return withPathOutput(squarePath, output + continuation, { participantCount: projection.participantCount });
         }
         finally {
@@ -434,18 +437,19 @@ export const participantsCommand = {
             const now = nowMs();
             const participants = await participantsPresentation(square);
             const lines = participants.slice(0, intent.limit).map((participant) => {
-                const glyph = participant.state === 'done' ? '○' : participant.presence === 'watching' ? '◎' : participant.activityCount > 0 ? '●' : '○';
+                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} · ${state} · ${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${last}`;
+                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
                 ? []
                 : [
-                    `  ○ ${lines.length} of ${participants.length} participants shown`,
+                    style('dim', `  ○ ${lines.length} of ${participants.length} participants shown`),
                     ...(participants.length <= PARTICIPANTS_MAX_LIMIT ? [
-                        `» ${participantsLimitCommand(squarePath, participants.length)}`,
+                        `${participantsLimitCommand(squarePath, participants.length)}`,
                     ] : []),
                 ];
             return withPathOutput(squarePath, ['participants', ...lines, ...tail].join('\n'), {
@@ -468,36 +472,55 @@ export const statusCommand = {
             const presentation = await statusPresentation(square);
             const result = presentation.status;
             const active = result.participants.filter((participant) => participant.state === 'active');
-            const people = active.length === 0 ? ['  ○ nobody in the square'] : active.slice(0, STATUS_PARTICIPANT_PREVIEW_LIMIT).map((participant) => {
-                const glyph = participant.presence === 'watching'
-                    ? '◎'
-                    : participant.activityCount > 0 ? '●' : '○';
-                const summary = participant.activityCount > 0
-                    ? `${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${participant.lastActiveAt === undefined
-                        ? 'just now'
-                        : formatRelativeTime(participant.lastActiveAt, result.now)}`
-                    : `quiet · ${participant.lastActiveAt === undefined ? '—' : formatRelativeTime(participant.lastActiveAt, result.now)}`;
-                const showAttention = context.name === undefined || sameName(participant.name, context.name);
-                const attention = !showAttention
-                    ? ''
-                    : participant.pendingMentionCount > 0
-                        ? `${participant.pendingMentionCount} attention${participant.pendingMentionCount === 1 ? '' : 's'} waiting`
-                        : participant.unreadActivityCount > 0
-                            ? `${participant.unreadActivityCount} change${participant.unreadActivityCount === 1 ? '' : 's'} waiting`
-                            : 'caught up';
-                return `  ${glyph} ${participantIdentity(participant.name)} · ${summary}${attention === '' ? '' : ` · ${attention}`}`;
-            });
-            if (active.length > STATUS_PARTICIPANT_PREVIEW_LIMIT) {
-                people.push(`  ○ … ${active.length - STATUS_PARTICIPANT_PREVIEW_LIMIT} more participants`);
-                people.push(`» ${result.participants.length <= PARTICIPANTS_MAX_LIMIT
-                    ? participantsLimitCommand(squarePath, result.participants.length)
-                    : `${commandPrefix(squarePath)} participants`}`);
+            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');
             }
-            const cap = result.hardCap === null ? 'unlimited' : String(result.hardCap);
+            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'
+                        ? 'catching'
+                        : participant.activityCount > 0
+                            ? formatRelativeTime(participant.lastActiveAt ?? result.now, result.now)
+                            : `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}` : ''} · ${result.holdAt === undefined
-                    ? 'just now'
-                    : formatRelativeTime(result.holdAt, result.now)}`
+                ? `· ${result.holdActor === undefined ? 'someone' : participantIdentity(result.holdActor)} raised a hand${result.holdReason ? ` — ${result.holdReason}` : ''}${style('dim', ` · ${holdTime}`)}`
                 : undefined;
             const visible = result.latestAct === undefined
                 ? ''
@@ -510,14 +533,31 @@ export const statusCommand = {
             const latest = visible === ''
                 ? [result.latestAct === undefined
                         ? '  ○ no public activity yet'
-                        : '  · latest activity is private to another participant']
+                        : '  · the latest words were meant for other ears']
                 : [`  ${visible.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)}`));
+            }
+            if (stepsIn.length > 3)
+                latest.push(style('dim', `  → … ${stepsIn.length - 3} more stepped in`));
             if (visible.includes('more chars') && result.latestAct !== undefined) {
-                latest.push(`» ${commandPrefix(squarePath)} history --at ${actId(result.latestAct)} -C 2 --no-truncate`);
+                latest.push(`${commandPrefix(squarePath)} history --at ${actId(result.latestAct)} -C 2 --no-truncate`);
             }
+            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 = [
-                `${result.activeCount} active · ${result.doneCount} done · cap ${cap} · throttle ${result.throttlePerMinute === undefined ? 'none' : `${result.throttlePerMinute}/min`}`,
-                ...(hold === undefined ? [] : ['', hold]), '', 'around the square', ...people, '', 'latest', ...latest,
+                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 });
         }
@@ -558,7 +598,7 @@ export const inboxCommand = {
             fail('inbox requires --for-session <session-id>.');
         const retry = inboxLimitCommand(sessionId, json);
         if (duplicateLimit)
-            fail(`✕ inbox accepts one --limit\n» ${retry}`);
+            fail(`✕ inbox accepts one --limit\n${retry}`);
         const limit = hasLimit
             ? parseBoundedLimit(limitValue, '--limit', INBOX_MAX_LIMIT, retry)
             : INBOX_DEFAULT_LIMIT;

package/dist/cli/program.js

@@ -1,20 +1,44 @@
 import { helpRequest } from '../help.js';
 import { isSquareError } from '../model.js';
-import { joinRecoveryCommand, participantsRecoveryCommand } from '../presentation.js';
+import { formatRefusal, joinRecoveryCommand, participantsRecoveryCommand } from '../presentation.js';
+import { inSquareCount, nowMs } from '../runtime.js';
+import { openSquare } from '../square-file-adapter.js';
+import { closeOpenSquare } from '../open-square.js';
 import { defaultContext, parseGlobalArgs } from './context.js';
 import { executeRegisteredCommand, findCommand } from './registry.js';
-function handleSquareError(error, squarePath, name) {
+async function participantCountFor(squarePath) {
+    try {
+        const square = await openSquare(squarePath, { clock: nowMs });
+        try {
+            return inSquareCount((await square.artifact.read()).state);
+        }
+        finally {
+            await closeOpenSquare(square);
+        }
+    }
+    catch {
+        return undefined;
+    }
+}
+async function handleSquareError(error, squarePath, name) {
     if (isSquareError(error)) {
-        process.stderr.write(`${error.message}\n`);
-        if (squarePath !== undefined && /^Unknown participant/.test(error.message)) {
+        const existing = [error.message];
+        if (squarePath !== undefined && /^✕ .* has never stepped into/.test(error.message)) {
             // The caller's name has never joined this square; only a join admits it.
             if (name !== undefined)
-                process.stderr.write(`${joinRecoveryCommand(squarePath, name)}\n`);
+                existing.push(joinRecoveryCommand(squarePath, name));
             else
-                process.stderr.write(`${participantsRecoveryCommand(squarePath)}\n`);
+                existing.push(participantsRecoveryCommand(squarePath));
+        }
+        else if (squarePath !== undefined && /^✕ .* is not standing in this square/.test(error.message)) {
+            existing.push(participantsRecoveryCommand(squarePath));
+        }
+        if (squarePath === undefined) {
+            process.stderr.write(`${existing.join('\n')}\n`);
         }
-        else if (squarePath !== undefined && /^Unknown mention target/.test(error.message)) {
-            process.stderr.write(`${participantsRecoveryCommand(squarePath)}\n`);
+        else {
+            const participantCount = await participantCountFor(squarePath);
+            process.stderr.write(formatRefusal(squarePath, existing, participantCount === undefined ? {} : { participantCount }));
         }
         process.exit(error.code === 'not_found' ? 1 : 2);
     }
@@ -45,6 +69,6 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
         await executeRegisteredCommand(command, parsed.args.slice(1), defaultContext(command, parsed.squarePath, parsed.name));
     }
     catch (error) {
-        handleSquareError(error, squarePath, requestedName);
+        await handleSquareError(error, squarePath, requestedName);
     }
 }