@astrosheep/square 0.3.83 → 0.3.84

package/dist/claude-delivery-status.d.ts

@@ -0,0 +1,7 @@
+import type { NativeDeliveryObservation } from './host-ledger.js';
+export interface ClaudeDeliveryStatus extends NativeDeliveryObservation {
+    readonly provider: 'claude';
+    readonly sessionId: string;
+}
+/** This receiver-owned observation is not a model tool and grants no delivery authority. */
+export declare function recordClaudeDeliveryStatus(input: ClaudeDeliveryStatus, env?: NodeJS.ProcessEnv): Promise<boolean>;

package/dist/claude-delivery-status.js

@@ -0,0 +1,24 @@
+import { hostLedgerForEnv } from './registry.js';
+const holdReasons = new Set(['explicit-setting', 'managed-setting', 'repo-setting', 'invalid-setting', 'bypass-default', 'mode-unknown', 'mode-mismatch', 'no-mode-asserted']);
+const dropReasons = new Set(['expired', 'refused', 'dropped', 'discarded']);
+const uuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** This receiver-owned observation is not a model tool and grants no delivery authority. */
+export async function recordClaudeDeliveryStatus(input, env = process.env) {
+    if (!input || input.provider !== 'claude' || typeof input.sessionId !== 'string' || !input.sessionId
+        || typeof input.messageId !== 'string' || !uuid.test(input.messageId)
+        || typeof input.eventId !== 'string' || !uuid.test(input.eventId)
+        || !Number.isFinite(input.observedAt) || input.observedAt < 0
+        || !['held', 'released', 'dropped'].includes(input.state)
+        || (input.state === 'held' ? !holdReasons.has(input.reason ?? '')
+            : input.state === 'dropped' ? !dropReasons.has(input.reason ?? '') : input.reason !== undefined))
+        return false;
+    const ledger = hostLedgerForEnv(env);
+    const rows = await ledger.listEvidence({ kind: 'wake', session: input.sessionId, includeReleased: true });
+    const row = rows.find((row) => row.nativeDelivery?.harness === 'claude' && row.nativeDelivery.messageId === input.messageId);
+    if (!row?.claimToken)
+        return false;
+    const { eventId, messageId, state, reason, observedAt } = input;
+    return ledger.observeNativeDelivery({ ...row, claimToken: row.claimToken }, {
+        eventId, messageId, state, ...(reason === undefined ? {} : { reason }), observedAt,
+    });
+}

package/dist/claude-delivery.js

@@ -1,4 +1,5 @@
 import { stat } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
 import { openSquare } from './open-square.js';
 import { closeOpenSquare } from './open-square.js';
 import { hostLedgerForEnv } from './registry.js';
@@ -7,7 +8,7 @@ import { nativePendingPreview } from './inbox.js';
 import { presentPending } from './presentation-operations.js';
 import { canonicalPath } from './canonical-path.js';
 import { parseActivityId } from './square-core.js';
-import { DeliveryError, connect } from './packages/agent-delivery/src/index.js';
+import { writeClaudeNative } from './packages/agent-delivery/src/claude-native.js';
 const marker = /(?:^|\n)\[square-inbox:([a-zA-Z0-9-]+)\](?:\n|$)/g;
 export function nativeTokens(text) { return [...text.matchAll(marker)].map((match) => match[1]); }
 export function nativePayload(token, preview) { return `[square-inbox:${token}]\n${preview}\n[/square-inbox:${token}]`; }
@@ -17,18 +18,11 @@ function nativeSupported(route) { return route.address.loaded === 'true' && !!ro
  * owns the payload, the correlation and the evidence. A local write is never proof
  * of native admission.
  */
-async function writeClaudeWake(sessionId, endpoint, payload, timeoutMs, signal) {
-    try {
-        const agent = await connect({ harness: 'claude', sessionId, endpoint, timeoutMs });
-        await agent.steer(payload, { signal });
-        return { outcome: 'unknown', signature: 'native_admission_unconfirmed', message: 'Claude accepted the local write; native admission is unconfirmed.' };
-    }
-    catch (error) {
-        if (error instanceof DeliveryError && !error.maybeDelivered) {
-            return { outcome: 'failed', unavailable: true, retainRoute: true, signature: 'claude_endpoint_unavailable', message: error.message };
-        }
-        return { outcome: 'unknown', signature: 'native_admission_unconfirmed', message: error instanceof Error ? error.message : String(error) };
-    }
+async function writeClaudeWake(sessionId, endpoint, messageId, payload, timeoutMs, signal) {
+    const result = await writeClaudeNative({ sessionId, endpoint, messageId }, payload, { deadline: Date.now() + timeoutMs, signal });
+    if (result.outcome === 'unavailable')
+        return { outcome: 'failed', unavailable: true, retainRoute: true, signature: 'claude_endpoint_unavailable', message: result.message };
+    return { outcome: 'unknown', signature: 'native_admission_unconfirmed', message: result.outcome === 'written' ? 'Claude accepted the local write; native admission is unconfirmed.' : result.message };
 }
 export function createClaudeWakeTransport(hostLedger, env = process.env) {
     return {
@@ -92,13 +86,13 @@ async function dispatchClaude(request, hostLedger, timeoutMs, beforeSend, env =
         }
         if (!await (beforeSend?.() ?? Promise.resolve(true)))
             return { outcome: 'not-capable', diagnostic: 'Native activity was consumed before send.' };
-        const native = { harness: 'claude', payload, epoch: owner.epoch ?? 0, endpoint: request.route.address.endpoint };
+        const native = { harness: 'claude', payload, epoch: owner.epoch ?? 0, endpoint: request.route.address.endpoint, messageId: randomUUID() };
         const row = { location: request.location, participant: request.participant, session: request.route.sessionId, activity: request.activity, kind: 'wake', outcome: 'dispatching', routeKind: 'claude-native', attemptN: request.attemptN, claimToken: request.claimToken, nativeDelivery: native };
         if (!await currentDelivery(row, hostLedger) || !await hostLedger.prepareNativeWake(row))
             return { outcome: 'not-capable', diagnostic: 'Native delivery is no longer current.' };
         if (!await (beforeSend?.() ?? Promise.resolve(true)) || !await currentDelivery(row, hostLedger))
             return { outcome: 'not-capable', diagnostic: 'Catch, cancellation or consumption won before native write.' };
-        return writeClaudeWake(row.session, native.endpoint, payload, timeoutMs, signal);
+        return writeClaudeWake(row.session, native.endpoint, native.messageId, payload, timeoutMs, signal);
     }, signal);
 }
 /** Retired tokens veto a frame; only live correlations and bound memberships confer authority. */

package/dist/claude-mod.js

@@ -8,6 +8,7 @@ import { observeClaudeDelivery } from './claude-delivery.js';
 import { processActNotificationsOnce } from './notifications.js';
 import { sweepPending } from './delivery-operations.js';
 import { beginClaudeMcpCall, endClaudeMcpCall } from './claude-mcp-context.js';
+import { recordClaudeDeliveryStatus } from './claude-delivery-status.js';
 /** JSON stdin bridge. Identity is explicit per operation; process.env is never rewritten. */
 export async function runClaudeMod(inputText, env = process.env) {
     if (inputText.length > 512_000)
@@ -15,6 +16,10 @@ export async function runClaudeMod(inputText, env = process.env) {
     const input = JSON.parse(inputText);
     if (!input || typeof input.sessionId !== 'string' || !input.sessionId || typeof input.cwd !== 'string')
         throw new Error('Claude bridge coordinate missing.');
+    if (input.operation === 'status') {
+        const recorded = input.status?.sessionId === input.sessionId && await recordClaudeDeliveryStatus(input.status, env);
+        return `${JSON.stringify({ recorded })}\n`;
+    }
     if (input.operation === 'tool-begin') {
         return `${JSON.stringify(await beginClaudeMcpCall({ toolUseId: input.toolUseId, sessionId: input.sessionId, cwd: input.cwd, agentId: input.agentId }, env))}\n`;
     }

package/dist/cli/catch-presentation.d.ts

@@ -1,7 +1,3 @@
-import type { CatchResult, CatchOptions, OperationProgress } from '../square-facade.js';
+import type { OperationProgress } from '../square-facade.js';
+export { renderCatchOutcome } from '../operation-presentation.js';
 export declare function renderCatchProgress(squarePath: string, progress: OperationProgress): string | undefined;
-/** Render settled catch facts; no selection, terminal decisions, receipts or wait machinery. */
-export declare function renderCatchOutcome(squarePath: string, data: CatchResult, options?: CatchOptions): {
-    stdout: string;
-    exitCode: number;
-};

package/dist/cli/catch-presentation.js

@@ -1,6 +1,5 @@
-import { parseActivityId } from '../square-api.js';
-import { participantCommandPrefix, renderAmbientEvent, renderWatchAlreadyActive, renderWatchForceTakeover, renderWatchReplaceMissing, renderWatchReplaced, renderWatchStatus, withPathOutput, } from '../presentation.js';
-import { style } from '../tty-style.js';
+import { renderWatchForceTakeover, renderWatchReplaceMissing } from '../presentation.js';
+export { renderCatchOutcome } from '../operation-presentation.js';
 export function renderCatchProgress(squarePath, progress) {
     if (progress.kind !== 'catch-started' || !progress.replacementRequested)
         return undefined;
@@ -8,50 +7,3 @@ export function renderCatchProgress(squarePath, progress) {
     return (progress.replaced
         ? renderWatchForceTakeover(options) : renderWatchReplaceMissing(options)) + '\n';
 }
-function continuationCommand(squarePath, name, options) {
-    const args = ['--now'];
-    if (options.from?.length)
-        args.push('--from', options.from.join(','));
-    if (options.mention)
-        args.push('--mention');
-    if (options.limit !== undefined)
-        args.push('--limit', String(options.limit));
-    return `${participantCommandPrefix(squarePath, name)} catch ${args.join(' ')}`;
-}
-/** Render settled catch facts; no selection, terminal decisions, receipts or wait machinery. */
-export function renderCatchOutcome(squarePath, data, options = {}) {
-    const projection = data.observation;
-    const location = projection.location ?? squarePath;
-    const name = projection.participant;
-    const stop = projection.stop ?? data.status;
-    const header = { participantCount: projection.standingCount, held: projection.held };
-    const statusOptions = {
-        squarePath: location, name, presence: projection.presence,
-        showCatchHint: !projection.automaticDeliveryAvailable,
-        ownActivityCount: projection.ownActivityCount, hardCap: projection.hardCap,
-    };
-    if (stop === 'already-active' || stop === 'replaced') {
-        return {
-            stdout: withPathOutput(location, stop === 'already-active'
-                ? renderWatchAlreadyActive(statusOptions) : renderWatchReplaced(statusOptions), header),
-            exitCode: stop === 'already-active' ? 1 : 0,
-        };
-    }
-    const rendered = data.activities.map((activity) => renderAmbientEvent(activity, name, {
-        now: projection.now, actNumber: projection.sayNumbers[parseActivityId(activity.id)],
-        perception: activity.perception, mention: options.mention ? name : undefined,
-    })).filter(Boolean).join('\n\n');
-    const remaining = data.remaining === 0 ? ''
-        : `○ ${data.remaining} matching ${data.remaining === 1 ? 'activity remains' : 'activities remain'}\n${continuationCommand(location, name, options)}`;
-    const terminal = stop === undefined ? '' : renderWatchStatus({
-        ...statusOptions, status: stop,
-        ...(stop === 'stale' && options.idle !== undefined ? { idleMs: options.idle } : {}),
-    });
-    const fallback = stop === undefined && !projection.automaticDeliveryAvailable && data.remaining === 0
-        ? `${participantCommandPrefix(location, name)} catch --idle 30m\n  stay available for new activity` : '';
-    const hint = data.hint === undefined ? '' : style('dim', `· ${data.hint}`);
-    return {
-        stdout: withPathOutput(location, [terminal, rendered, hint, remaining, fallback].filter(Boolean).join('\n\n'), header),
-        exitCode: stop === 'capped' ? 1 : 0,
-    };
-}

package/dist/cli/express-presentation.d.ts

@@ -1,11 +1,11 @@
 import { type Square } from '../square-api.js';
-import type { OperationControl, ExpressResult, ExpressOptions } from '../square-facade.js';
+import type { OperationControl, ExpressOptions } from '../square-facade.js';
+export { renderExpression } from '../operation-presentation.js';
 export interface ActivityOptions extends Omit<ExpressOptions, 'reply'> {
     readonly reply?: string;
 }
 export declare function saveActivityDraft(squarePath: string, name: string, body: string, now?: number): string;
 /** Retry choices are transport syntax, never a second admission decision. */
 export declare function activityRetryCommand(squarePath: string, name: string, opts: ActivityOptions, force?: boolean): string;
-export declare function renderExpression(squarePath: string, data: ExpressResult): string;
 /** Body adaptation, terminal IO and drafts only; Participant owns every attempt and wait. */
 export declare function executeExpression(open: (control?: OperationControl) => Promise<Square>, squarePath: string, requestedName: string | undefined, rawInput: string, opts: ActivityOptions): Promise<void>;

package/dist/cli/express-presentation.js

@@ -3,9 +3,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { isSquareError } from '../model.js';
 import { formatActivityId, parseActivityId } from '../square-api.js';
-import { formatRefusal, refusalText, renderActivityBlocked, renderActivityLimit, renderActivityUncertain, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, joinRecoveryCommand, participantIdentity, participantsRecoveryCommand, participantCommandPrefix, commandPrefix, quoteShell, takeoverRecoveryLines, withPathOutput, } from '../presentation.js';
+import { formatRefusal, refusalText, renderActivityBlocked, renderActivityLimit, renderActivityUncertain, renderExpressNoWait, renderExpressWaiting, joinRecoveryCommand, participantsRecoveryCommand, participantCommandPrefix, commandPrefix, quoteShell, takeoverRecoveryLines, withPathOutput, } from '../presentation.js';
+import { renderExpression } from '../operation-presentation.js';
 import { formatDuration } from '../time.js';
-import { style } from '../tty-style.js';
+export { renderExpression } from '../operation-presentation.js';
 export function saveActivityDraft(squarePath, name, body, now = Date.now()) {
     const draftDir = path.join(path.dirname(squarePath), 'drafts');
     fs.mkdirSync(draftDir, { recursive: true });
@@ -38,32 +39,6 @@ export function activityRetryCommand(squarePath, name, opts, force = opts.force
         + (opts.noMention === true ? ' --no-mention' : '');
     return `${participantCommandPrefix(squarePath, name)} express${force ? ' --force' : ''}${opts.noWait ? ' --no-wait' : ''}${reach}${replyArgument(opts.reply)} -`;
 }
-function isGestureOnly(body) {
-    return /\*[^*]*\*/.test(body) && body.replace(/\*[^*]*\*/g, '').trim() === '';
-}
-export function renderExpression(squarePath, data) {
-    const projection = data.observation;
-    const name = projection.participant;
-    const pendingSpeaker = projection.pendingPublic[0]?.actor;
-    const pendingLead = pendingSpeaker === undefined ? ''
-        : `▲ while you spoke, ${participantIdentity(pendingSpeaker)} said something behind you\n\n`;
-    const pending = projection.pendingPublic.length === 0 ? ''
-        : `\n\n${pendingLead}${renderPendingFeed(projection.pendingPublic, projection.sayNumbers, projection.perceptions, name)}`;
-    const ownCount = projection.ownActivityCount;
-    const capCount = projection.hardCap === null ? '' : ` · ${ownCount}/${projection.hardCap}`;
-    const activity = data.activity;
-    const confirmation = activity.reach === 'bell'
-        ? `● you ring the bell — everyone turns · ${activity.id}${style('dim', capCount)}`
-        : `● ${activity.mentions.length > 0
-            ? `you walk over to ${activity.mentions.map((target) => participantIdentity(target)).join(', ')}`
-            : isGestureOnly(activity.body ?? '') ? 'your gesture lands' : 'your words land'} — ${activity.id}${style('dim', capCount)}`;
-    const replyNotice = data.replyAuthorNotHere === undefined ? ''
-        : `\n○ ${participantIdentity(data.replyAuthorNotHere)} isn't in the square right now — the reply landed without reaching them`;
-    const unmatchedNotice = data.unmatchedMentions?.length
-        ? `\n  · ${data.unmatchedMentions.map((token) => `@${token} isn't standing here`).join('; ')} — ${activity.mentions.length === 0 && activity.reply === undefined ? 'activity landed bare' : 'left as literal text'}` : '';
-    return withPathOutput(projection.location ?? squarePath, (projection.reentry === undefined ? '' : '● you stepped back into the square\n')
-        + confirmation + (data.hint ? `\n${style('dim', `· ${data.hint}`)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount, held: projection.held });
-}
 /** Body adaptation, terminal IO and drafts only; Participant owns every attempt and wait. */
 export async function executeExpression(open, squarePath, requestedName, rawInput, opts) {
     let square;
@@ -92,7 +67,9 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
         });
         landedId = outcome.activity.id;
         name = outcome.observation.participant;
-        process.stdout.write(renderExpression(squarePath, outcome));
+        const rendered = renderExpression(squarePath, outcome);
+        if (rendered !== undefined)
+            process.stdout.write(rendered);
     }
     catch (error) {
         const detail = error?.operation;

package/dist/cli/observation-commands.js

@@ -2,16 +2,14 @@ import path from 'node:path';
 import { once } from 'node:events';
 import { runClaudeMod } from '../claude-mod.js';
 import { runCodexHookAsync } from '../codex-hook.js';
-import { isSquareError, sameName } from '../model.js';
-import { commandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEventFacts, renderPresenceAnchor, truncateChars, withPathOutput, quoteShell, } from '../presentation.js';
+import { isSquareError } from '../model.js';
+import { commandPrefix, participantIdentity, truncateChars, withPathOutput, quoteShell, } from '../presentation.js';
+import { PARTICIPANTS_DEFAULT_LIMIT, PARTICIPANTS_MAX_LIMIT, renderHistoryResult, renderParticipantsResult, renderStatusResult, } from '../operation-presentation.js';
 import { style } from '../tty-style.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.js';
 import { discover, inbox, 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-api.js';
 import { renderCatchOutcome, renderCatchProgress } from './catch-presentation.js';
 import { withSquare, squareInput, now, fail, parseBoundedLimit, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdin, requireSquarePath, requireValue, usage, } from './context.js';
-const STATUS_PARTICIPANT_PREVIEW_LIMIT = 10;
-const PARTICIPANTS_DEFAULT_LIMIT = 20;
-const PARTICIPANTS_MAX_LIMIT = 100;
 const INBOX_DEFAULT_LIMIT = 20;
 const INBOX_MAX_LIMIT = 100;
 const INBOX_DISPLAY_CHARS = 160;
@@ -414,34 +412,6 @@ function jsonLine(sayNumbers, item) {
         reply: act.kind === 'say' && act.reply !== undefined ? formatActivityId(act.reply) : null,
     });
 }
-function renderHistoryProjection(projection, visible, noTruncate, squarePath) {
-    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.
-    const anchored = [];
-    for (const activity of shown) {
-        const options = {
-            preview,
-            actNumber: activity.kind === 'say' ? projection.sayNumbers[activity.index] : undefined,
-        };
-        const rendered = renderEventCli(activity, options);
-        if (rendered !== '')
-            chunks.push(rendered);
-        for (const participant of projection.presenceAnchors[activity.index] ?? []) {
-            if (!anchored.some((existing) => sameName(existing, participant)))
-                anchored.push(participant);
-        }
-    }
-    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`);
-    }
-    if (anchored.length > 0)
-        chunks.push(renderPresenceAnchor(anchored));
-    return chunks.join('\n\n');
-}
 export const historyCommand = {
     parse(argv, context) { return parseHistory(argv, context); },
     async execute(options, context) {
@@ -463,13 +433,11 @@ export const historyCommand = {
         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 });
+        return renderHistoryResult(squarePath, outcome, {
+            query: options.query,
+            noTruncate: options.noTruncate,
+            continuationArgs: options.continuationArgs,
+        });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -491,26 +459,7 @@ export const participantsCommand = {
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
         const data = await withSquare(context, (square) => square.participants({ observe: true }));
-        const projection = data.observation;
-        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,
-        });
+        return renderParticipantsResult(squarePath, data, intent.limit);
     },
     present: (result) => process.stdout.write(result),
 };
@@ -520,88 +469,7 @@ export const statusCommand = {
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
         const result = await withSquare(context, (square) => square.status({ viewer: context.name, observe: true }));
-        const presentation = result.observation;
-        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 (lingering > 0)
-                people.push(`  ○ … ${lingering} lingering`);
-            if (unshown > 0) {
-                people.push(`${presentation.knownParticipantCount <= PARTICIPANTS_MAX_LIMIT
-                    ? participantsLimitCommand(squarePath, presentation.knownParticipantCount)
-                    : `${commandPrefix(squarePath)} participants`}`);
-            }
-        }
-        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 });
+        return renderStatusResult(squarePath, result);
     },
     present: (result) => process.stdout.write(result),
 };

package/dist/cli/program.js

@@ -1,6 +1,7 @@
 import { helpRequest } from '../help.js';
 import { isSquareError } from '../model.js';
-import { commandPrefix, formatRefusal, refusalText, joinRecoveryCommand, participantIdentity, participantsRecoveryCommand, takeoverRecoveryLines, } from '../presentation.js';
+import { formatRefusal } from '../presentation.js';
+import { renderFailureLines } from '../operation-presentation.js';
 import { withSquare, defaultContext, parseGlobalArgs } from './context.js';
 import { executeRegisteredCommand, findCommand } from './registry.js';
 async function handleSquareError(error, context) {
@@ -11,35 +12,11 @@ async function handleSquareError(error, context) {
     const recovery = error.facts?.reason === 'migration_required' || context === undefined || squarePath === undefined ? undefined
         : await withSquare({ ...context, name: detail?.participant ?? context.name }, (square) => square.recovery(detail?.participant ?? context.name)).catch(() => undefined);
     const name = detail?.participant ?? recovery?.participant ?? context?.name;
-    const existing = [refusalText(error)];
-    if (error.facts?.reason === 'migration_required') {
-        if (error.facts.ledgerRoot !== undefined)
-            existing.push('square ledger migrate', 'square ledger verify');
-        else if (squarePath !== undefined)
-            existing.push(`${commandPrefix(squarePath)} migrate`);
-    }
-    else if (squarePath !== undefined && name !== undefined && error.code === 'already_joined') {
-        existing.splice(0, 1, `✕ ${participantIdentity(name)} shoos you out of the square`, `  · ${participantIdentity(name)} already stands here — another session holds the name`);
-        existing.push(...takeoverRecoveryLines(squarePath, name));
-    }
-    else if (squarePath !== undefined && error.facts?.reason === 'never_joined') {
-        existing.push(detail?.subject !== 'filter' && name !== undefined
-            ? joinRecoveryCommand(squarePath, name) : participantsRecoveryCommand(squarePath));
-    }
-    else if (squarePath !== undefined && error.facts?.reason === 'not_standing') {
-        existing.push(participantsRecoveryCommand(squarePath));
-    }
-    else if (squarePath !== undefined && error.facts?.reason === 'not_addressed' && typeof error.facts.activityId === 'string') {
-        existing.push(error.facts.activityExists === true
-            ? `${commandPrefix(squarePath)} history --at ${error.facts.activityId} -C 2`
-            : `${commandPrefix(squarePath)} history --limit 10`);
-    }
-    if (error.facts?.reason === 'invalid_done_body')
-        existing.push('square done --help');
+    const lines = renderFailureLines(error, { squarePath, name });
     if (squarePath === undefined)
-        process.stderr.write(`${existing.join('\n')}\n`);
+        process.stderr.write(`${lines.join('\n')}\n`);
     else
-        process.stderr.write(formatRefusal(squarePath, existing, {
+        process.stderr.write(formatRefusal(squarePath, lines, {
             participantCount: recovery?.standingCount, held: recovery?.held,
         }));
     process.exit(error.code === 'not_found' ? 1 : 2);

package/dist/cli/square-commands.js

@@ -1,7 +1,7 @@
 import { formatHardCap } from '../model.js';
-import { commandPrefix, participantCommandPrefix, participantIdentity, renderRoomChangeText, renderAmbientEvent, withPathOutput, } from '../presentation.js';
-import { Square, formatActivityId } from '../square-api.js';
-import { style } from '../tty-style.js';
+import { commandPrefix, participantCommandPrefix, withPathOutput, } from '../presentation.js';
+import { renderJoinResult, renderLifecycleResult, renderListenerChange, renderListeningResult, } from '../operation-presentation.js';
+import { Square } from '../square-api.js';
 import { executeExpression } from './express-presentation.js';
 import { squareInput, withSquare, fail, parseBoundedLimit, parseHardCap, parsePositiveInteger, readStdin, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
 const JOIN_DEFAULT_LAST = 10;
@@ -76,33 +76,7 @@ export const joinCommand = {
     },
     async execute(intent, context) {
         const data = await withSquare(context, (square) => square.join(context.name, { takeover: intent.kick, last: intent.lastN, observe: true }));
-        const after = data.observation;
-        const entry = after.entry;
-        const name = data.participant.name;
-        const activities = (entry?.recentActivities ?? []).map((event) => renderAmbientEvent(event, name, {
-            now: after.now, preview: 200,
-            actNumber: event.kind === 'say' ? entry.sayNumbers[event.index] : undefined,
-            perception: entry.perceptions[event.index],
-        })).filter(Boolean).join('\n\n');
-        const fallback = after.automaticDeliveryAvailable ? [] : [
-            '', `${participantCommandPrefix(after.location, name)} catch --idle 30m`,
-            '  the square has no way to call you — keep this catch open and stay within earshot',
-        ];
-        const entryLine = data.kind === 'joined' ? '● you stepped into the square'
-            : data.kind === 'reconnected' ? '● you are already in the square'
-                : `✓ you banished the original ${participantIdentity(name)} — the name is yours`;
-        const isRejoin = data.kind !== 'joined';
-        const entryScene = isRejoin || entry === undefined ? '' : entry.joinedBefore
-            ? '*the flagstones are where you left them. so is your shadow.*' : entry.scene;
-        return withPathOutput(after.location, [
-            entryLine, '',
-            "· carved into the fountain's edge: every word here lands on a real ear — speak when someone needs it.",
-            ...(entryScene === '' ? [] : ['', entryScene]),
-            ...(isRejoin || !entry?.joinContext ? [] : ['', style('dim', 'context'), entry.joinContext]),
-            ...(after.enrichmentUnavailable ? ['  · joined; recent activity and context are unavailable right now'] : []),
-            ...(isRejoin || activities === '' ? [] : ['', style('dim', 'recent activity'), activities]),
-            ...fallback,
-        ].join('\n'), { participantCount: after.standingCount, held: after.held });
+        return renderJoinResult(data);
     },
     present: (result) => process.stdout.write(result),
 };
@@ -166,20 +140,9 @@ function listenerCommand(verb) {
     return {
         parse(argv, context) { return parseListener(argv, context, true); },
         async execute(intent, context) {
+            const squarePath = requireSquarePath(context);
             const data = await withSquare(context, async (square) => (await square.participant(context.name))[verb](intent.target, { observe: true }));
-            const projection = data.observation;
-            const actor = participantIdentity(projection.participant);
-            const target = participantIdentity(projection.target);
-            const action = data.activity !== null
-                ? verb === 'listen' ? `${actor} turns an ear toward ${target}`
-                    : verb === 'ignore' ? `${actor} turns away from ${target}`
-                        : `${actor} stops listening to ${target}`
-                : verb === 'listen' ? `${actor} already turns an ear toward ${target}`
-                    : verb === 'ignore' ? `${actor} is not turned toward ${target}`
-                        : `${actor} is not listening to ${target}`;
-            return withPathOutput(projection.location, `${data.activity === null ? '○' : '·'} ${action}`, {
-                participantCount: projection.standingCount, held: projection.held,
-            });
+            return renderListenerChange(squarePath, verb, data);
         },
         present: (result) => process.stdout.write(result),
     };
@@ -190,12 +153,9 @@ export const unlistenCommand = listenerCommand('unlisten');
 export const listeningCommand = {
     parse(argv, context) { return parseListener(argv, context, false); },
     async execute(_intent, context) {
+        const squarePath = requireSquarePath(context);
         const data = await withSquare(context, async (square) => (await square.participant(context.name)).listening({ observe: true }));
-        const projection = data.observation;
-        const body = data.listening.length === 0
-            ? `○ ${participantIdentity(projection.participant)} is not turned toward anyone`
-            : ['listening', ...data.listening.map((target) => `  · ${participantIdentity(target)}`)].join('\n');
-        return withPathOutput(projection.location, body, { participantCount: projection.standingCount, held: projection.held });
+        return renderListeningResult(squarePath, data);
     },
     present: (result) => process.stdout.write(result),
 };
@@ -208,11 +168,9 @@ export const doneCommand = {
     async execute(intent, context) {
         const body = intent.body === '-' || ((intent.body === undefined || intent.body === '') && !process.stdin.isTTY)
             ? await readStdin() : intent.body;
+        const squarePath = requireSquarePath(context);
         const data = await withSquare(context, async (square) => (await square.participant(context.name)).done(body, { observe: true }));
-        const projection = data.observation;
-        return withPathOutput(projection.location, `○ you stepped out — your footsteps fade · ${data.activity.id}`, {
-            participantCount: projection.standingCount, held: projection.held,
-        });
+        return renderLifecycleResult(squarePath, 'done', data);
     },
     present: (result) => process.stdout.write(result),
 };
@@ -224,9 +182,9 @@ export const holdCommand = {
     },
     async execute(intent, context) {
         const body = (await resolveBody(intent.body ?? '')).replace(/\r\n/g, '\n').trim();
+        const squarePath = requireSquarePath(context);
         const result = await withSquare(context, async (square) => (await square.participant(context.name)).hold(body, { observe: true }));
-        const projection = result.observation;
-        return withPathOutput(projection.location, `· ${renderRoomChangeText(projection.activity)} · ${formatActivityId(projection.activity.index)} · just now`, { participantCount: projection.standingCount, held: projection.held });
+        return renderLifecycleResult(squarePath, 'hold', result);
     },
     present: (result) => process.stdout.write(result),
 };
@@ -237,9 +195,9 @@ export const resumeCommand = {
         return {};
     },
     async execute(_intent, context) {
+        const squarePath = requireSquarePath(context);
         const result = await withSquare(context, async (square) => (await square.participant(context.name)).resume({ observe: true }));
-        const projection = result.observation;
-        return withPathOutput(projection.location, `✓ ${renderRoomChangeText(projection.activity)} · ${formatActivityId(projection.activity.index)} · just now`, { participantCount: projection.standingCount, held: projection.held });
+        return renderLifecycleResult(squarePath, 'resume', result);
     },
     present: (result) => process.stdout.write(result),
 };

package/dist/delivery-health.d.ts

@@ -1,5 +1,5 @@
 import { type DirectedNotificationRoute } from './delivery.js';
-import type { WakeAttempt, WakeReleaseDiagnostic } from './wake-evidence.js';
+import { type WakeAttempt, type WakeReleaseDiagnostic } from './wake-evidence.js';
 export type DeliveryHealthKind = 'awaiting' | 'wake-accepted' | 'wake-unknown' | 'presented-not-delivered' | 'unreachable';
 export interface DeliveryHealthItem {
     squarePath: string;
@@ -18,5 +18,5 @@ export declare function classifyDeliveryHealth(squarePath: string, opts: {
     now?: number;
     env?: NodeJS.ProcessEnv;
 }): Promise<DeliveryHealthItem[]>;
-export declare function renderDeliveryHealth(items: readonly DeliveryHealthItem[], releases?: readonly WakeReleaseDiagnostic[], now?: number): string[];
+export declare function renderDeliveryHealth(items: readonly DeliveryHealthItem[], releases?: readonly WakeReleaseDiagnostic[], now?: number, nativeAttempts?: readonly WakeAttempt[]): string[];
 export declare function doctorDeliveryHealth(squarePath: string, graceMs: number, now?: number, env?: NodeJS.ProcessEnv): Promise<string[]>;