@astrosheep/square 0.3.83 → 0.3.84

package/dist/delivery-health.js

@@ -3,6 +3,8 @@ import { formatActivityId } from './square-core.js';
 import { participantIdentity, truncateChars } from './presentation.js';
 import { formatDuration } from './time.js';
 import { projectWakeEvidence } from './wake-eligibility.js';
+import { decodeWakeEvidence } from './wake-evidence.js';
+import { hostLedgerForEnv } from './registry.js';
 import { openSquare } from './open-square.js';
 import { closeOpenSquare } from './open-square.js';
 import { readWakeReleaseDiagnostics } from './wake-attempts.js';
@@ -62,7 +64,7 @@ function displayField(value) {
     const truncated = truncateChars(value, DISPLAY_FIELD_LIMIT - 1);
     return truncated.remaining === 0 ? truncated.text : `${truncated.text}…`;
 }
-export function renderDeliveryHealth(items, releases = [], now = Date.now()) {
+export function renderDeliveryHealth(items, releases = [], now = Date.now(), nativeAttempts = []) {
     const out = items.length === 0 ? ['✓ no pending delivery attention'] : [`· delivery attention · ${items.length} pending`];
     if (items.length > 0) {
         let displayed = 0;
@@ -81,6 +83,17 @@ export function renderDeliveryHealth(items, releases = [], now = Date.now()) {
         if (items.length > DETAIL_LIMIT)
             out.push(`${DETAIL_LIMIT} of ${items.length} pending details shown`);
     }
+    if (nativeAttempts.length > 0) {
+        out.push(`· Claude native custody · ${nativeAttempts.length}`);
+        out.push(...nativeAttempts.slice(0, DETAIL_LIMIT).map((attempt) => {
+            const observations = [...attempt.nativeObservations ?? []].sort((a, b) => a.observedAt - b.observedAt);
+            const last = observations.at(-1);
+            const states = observations.map((observation) => `${observation.state}${observation.reason ? ` (${observation.reason})` : ''}`).join(' → ');
+            return `  · ${formatActivityId(attempt.attention.actIndex)} → ${displayField(participantIdentity(attempt.attention.recipient))} · ${attempt.outcome} · native ${displayField(states)} · ${formatDuration(Math.max(0, now - last.observedAt))} · message ${displayField(last.messageId)}`;
+        }));
+        if (nativeAttempts.length > DETAIL_LIMIT)
+            out.push(`${DETAIL_LIMIT} of ${nativeAttempts.length} native custody details shown`);
+    }
     if (releases.length > 0) {
         out.push(`· recent wake releases · ${releases.length}`);
         out.push(...releases.slice(0, DETAIL_LIMIT).map((release) => formatRelease(release, now)));
@@ -100,5 +113,10 @@ function formatRelease(release, now) {
 export async function doctorDeliveryHealth(squarePath, graceMs, now = Date.now(), env = process.env) {
     const items = await classifyDeliveryHealth(squarePath, { graceMs, now, env });
     const releases = await readWakeReleaseDiagnostics({ location: squarePath, now, env });
-    return renderDeliveryHealth(items, releases, now);
+    const rows = await hostLedgerForEnv(env).listEvidence({ location: squarePath, kind: 'wake', includeReleased: true, now });
+    const nativeAttempts = rows.flatMap((row) => {
+        const decoded = decodeWakeEvidence(row, now);
+        return decoded?.kind === 'attempt' && decoded.value.nativeObservations?.length ? [decoded.value] : [];
+    }).sort((a, b) => Math.max(...b.nativeObservations.map((row) => row.observedAt)) - Math.max(...a.nativeObservations.map((row) => row.observedAt)));
+    return renderDeliveryHealth(items, releases, now, nativeAttempts);
 }

package/dist/host-ledger-file-adapter.d.ts

@@ -32,6 +32,9 @@ export declare class FileHostLedgerPort implements HostLedgerPort {
     confirmWakeAdmission(i: EvidenceRecord & {
         readonly claimToken: string;
     }): Promise<boolean>;
+    observeNativeDelivery(i: EvidenceRecord & {
+        readonly claimToken: string;
+    }, observation: import('./host-ledger.js').NativeDeliveryObservation): Promise<boolean>;
     claimEvidence(i: EvidenceClaim): Promise<ClaimResult>;
     releaseEvidence(i: EvidenceRelease): Promise<void>;
     appendEvidence(i: EvidenceRecord & {

package/dist/host-ledger-file-adapter.js

@@ -279,6 +279,18 @@ export class FileHostLedgerPort {
             return current.outcome === 'accepted' ? current : finishWake(current, 'accepted', { signature: 'native_queue_confirmed', message: undefined, diagnostic: undefined });
         });
     }
+    async observeNativeDelivery(i, observation) {
+        return this.updateWake(i, (current) => {
+            const native = current.nativeDelivery;
+            if (native?.harness !== 'claude' || native.messageId !== observation.messageId)
+                return undefined;
+            const observations = current.nativeObservations ?? [];
+            if (observations.some((prior) => prior.eventId === observation.eventId))
+                return current;
+            // Native custody is diagnostic evidence, never permission to retry or a queue receipt.
+            return { ...current, nativeObservations: [...observations, observation] };
+        });
+    }
     async claimEvidence(i) {
         if (i.kind === 'wake')
             return { status: 'degraded', error: new Error('wake attempts are claimed with claimWakeAttempt') };

package/dist/host-ledger.d.ts

@@ -42,11 +42,20 @@ export type NativeDeliveryEvidence = {
 } & ({
     readonly harness: 'claude';
     readonly endpoint: string;
+    readonly messageId?: string;
 } | {
     readonly harness: 'opencode';
     readonly inputId: string;
 });
+export interface NativeDeliveryObservation {
+    readonly eventId: string;
+    readonly messageId: string;
+    readonly state: 'held' | 'released' | 'dropped';
+    readonly reason?: string;
+    readonly observedAt: number;
+}
 export interface EvidenceRecord {
+    readonly nativeObservations?: readonly NativeDeliveryObservation[];
     readonly bindingEpoch?: number;
     readonly nativeDelivery?: NativeDeliveryEvidence;
     readonly location: string;
@@ -179,5 +188,8 @@ export interface HostLedgerPort {
     confirmWakeAdmission(input: EvidenceRecord & {
         readonly claimToken: string;
     }): Promise<boolean>;
+    observeNativeDelivery(input: EvidenceRecord & {
+        readonly claimToken: string;
+    }, observation: NativeDeliveryObservation): Promise<boolean>;
     claimWakeAttempt(input: WakeAttemptClaimInput): Promise<WakeAttemptClaim>;
 }

package/dist/mcp.js

@@ -1,6 +1,6 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, squareToolFailure } from './square-tools.js';
+import { SQUARE_TOOLS, SQUARE_TOOL_INSTRUCTIONS, squareToolFailure, squareToolFailureText } from './square-tools.js';
 import { operationEnv } from './participant-identity.js';
 import { readClaudeMcpCall } from './claude-mcp-context.js';
 import { SQUARE_IDENTITY } from './identity.js';
@@ -16,6 +16,7 @@ export function createSquareMcpServer(options) {
     for (const tool of SQUARE_TOOLS) {
         server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, (args, extra) => {
             const call = (async () => {
+                let square;
                 try {
                     const { as: participant, location } = args;
                     const threadId = extra._meta?.threadId;
@@ -33,25 +34,35 @@ export function createSquareMcpServer(options) {
                             : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
                                 ? operationEnv('opencode', opencodeSessionId, baseEnv)
                                 : baseEnv;
-                    const square = await Square.at({
+                    square = await Square.at({
                         ...options, env, cwd: claude?.cwd ?? options.cwd,
                         path: location ?? options.path,
                         participant: participant ?? options.participant,
                         // The server owner is bound to its configured square; overrides close after each call.
                         resources: location === undefined && claude === undefined ? resources : undefined,
                     }, { signal: extra.signal });
-                    let structuredContent;
+                    let receipt;
+                    // The transport shows people the square, so it asks for the rendering facts
+                    // the CLI already gathers and keeps that request out of the tool schema.
                     try {
-                        structuredContent = await tool.run(square, args, { signal: extra.signal });
+                        receipt = await tool.run(square, args, { signal: extra.signal, observe: true });
                     }
                     finally {
                         await square.close();
                     }
-                    return { content: [{ type: 'text', text: JSON.stringify(structuredContent) }], structuredContent };
+                    // A missing observation renders as nothing, never as raw JSON for a person to read.
+                    const text = tool.render(receipt, args) ?? '';
+                    // Observation facts are a rendering aid, not part of the receipt machines receive.
+                    const { observation: _observation, ...structuredContent } = receipt;
+                    return { content: [{ type: 'text', text }], structuredContent };
                 }
                 catch (error) {
                     const failure = squareToolFailure(error, extra.signal);
-                    return { isError: true, content: [{ type: 'text', text: JSON.stringify(failure) }], structuredContent: { error: failure } };
+                    const participant = args.as;
+                    return { isError: true, content: [{ type: 'text', text: squareToolFailureText(failure, {
+                                    location: square?.location ?? options.path,
+                                    participant: typeof participant === 'string' ? participant : options.participant,
+                                }) }], structuredContent: { error: failure } };
                 }
             })();
             inFlight.add(call);

package/dist/operation-presentation.d.ts

@@ -0,0 +1,45 @@
+import type { CatchOptions, CatchResult, ExpressResult, HistoryQuery, HistoryResult, JoinResult, LifecycleResult, ListenerChangeResult, ListeningResult, OperationFailureDetail, ParticipantsResult, StatusResult } from './square-facade.js';
+export declare const PARTICIPANTS_DEFAULT_LIMIT = 20;
+export declare const PARTICIPANTS_MAX_LIMIT = 100;
+/** A join receipt whose participant is already reduced to its serializable name. */
+export type JoinPresentation = Omit<JoinResult, 'participant'> & {
+    readonly participant: {
+        readonly name: string;
+    } | string;
+};
+export declare function renderJoinResult(data: JoinPresentation): string | undefined;
+export declare function renderExpression(squarePath: string, data: ExpressResult): 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;
+};
+export declare function renderHistoryResult(squarePath: string, data: HistoryResult, options?: {
+    query?: HistoryQuery;
+    noTruncate?: boolean;
+    continuationArgs?: readonly string[];
+}): string | undefined;
+export declare function renderParticipantsResult(squarePath: string, data: ParticipantsResult, limit?: number): string | undefined;
+export declare function renderStatusResult(squarePath: string, data: StatusResult): string | undefined;
+export declare function renderListeningResult(squarePath: string, data: ListeningResult): string | undefined;
+export type ListenerVerb = 'listen' | 'ignore' | 'unlisten';
+export declare function renderListenerChange(squarePath: string, verb: ListenerVerb, data: ListenerChangeResult): string | undefined;
+export type LifecycleVerb = 'hold' | 'resume' | 'done';
+export declare function renderLifecycleResult(squarePath: string, verb: LifecycleVerb, data: LifecycleResult): string | undefined;
+/** The refusal facts a transport has after normalizing a failure, without the live error. */
+export interface FailureReport {
+    readonly code: string;
+    readonly message: string;
+    readonly facts?: {
+        readonly reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'migration_required' | 'invalid_reply' | 'invalid_done_body';
+        readonly activityId?: string;
+        readonly ledgerRoot?: string;
+        readonly activityExists?: boolean;
+    };
+    readonly operation?: OperationFailureDetail;
+}
+/** Refusal lines with the same recovery commands the CLI prints. */
+export declare function renderFailureLines(failure: FailureReport, options?: {
+    squarePath?: string;
+    name?: string;
+}): string[];

package/dist/operation-presentation.js

@@ -0,0 +1,370 @@
+// Human-facing text for one settled operation. The CLI and the MCP transport both
+// render through these functions, so a person sees the same square either way.
+import { sameName } from './model.js';
+import { formatActivityId, parseActivityId } from './square-core.js';
+import { commandPrefix, joinRecoveryCommand, participantCommandPrefix, participantIdentity, participantsRecoveryCommand, quoteShell, renderAmbientEvent, renderAmbientEventFacts, renderEventCli, renderGrepActivitiesView, renderPendingFeed, renderPresenceAnchor, renderRoomChangeText, renderWatchAlreadyActive, renderWatchReplaced, renderWatchStatus, takeoverRecoveryLines, withPathOutput, } from './presentation.js';
+import { formatRelativeTime, formatTimestamp } from './time.js';
+import { style } from './tty-style.js';
+export const PARTICIPANTS_DEFAULT_LIMIT = 20;
+export const PARTICIPANTS_MAX_LIMIT = 100;
+const STATUS_PARTICIPANT_PREVIEW_LIMIT = 10;
+export function renderJoinResult(data) {
+    const after = data.observation;
+    if (after === undefined)
+        return undefined;
+    const entry = after.entry;
+    const name = typeof data.participant === 'string' ? data.participant : 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 });
+}
+function isGestureOnly(body) {
+    return /\*[^*]*\*/.test(body) && body.replace(/\*[^*]*\*/g, '').trim() === '';
+}
+export function renderExpression(squarePath, data) {
+    const projection = data.observation;
+    if (projection === undefined)
+        return undefined;
+    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 });
+}
+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;
+    if (projection === undefined)
+        return { stdout: '', exitCode: 0 };
+    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,
+    };
+}
+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');
+}
+function historyContinuationCommand(squarePath, args) {
+    return `${commandPrefix(squarePath)} history ${args.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
+}
+/** The same query spelled as CLI arguments, for a continuation someone can actually run. */
+function historyQueryArgs(query) {
+    const args = [];
+    if (query.from?.length)
+        args.push('--from', query.from.join(','));
+    if (query.since !== undefined)
+        args.push('--since', formatTimestamp(query.since));
+    if (query.at?.length)
+        args.push('--at', query.at.join(','));
+    if (query.contextBefore !== undefined)
+        args.push('-B', String(query.contextBefore));
+    if (query.contextAfter !== undefined)
+        args.push('-A', String(query.contextAfter));
+    if (query.mention !== undefined)
+        args.push('--mention', query.mention);
+    if (query.grep !== undefined)
+        args.push('--grep', query.grep);
+    if (query.fixed !== undefined)
+        args.push('--fixed', query.fixed);
+    if (query.order !== undefined)
+        args.push('--order', query.order);
+    return args;
+}
+export function renderHistoryResult(squarePath, data, options = {}) {
+    const projection = data.observation;
+    if (projection === undefined)
+        return undefined;
+    const query = options.query ?? {};
+    const noTruncate = options.noTruncate === true;
+    const pattern = query.grep ?? query.fixed;
+    const output = pattern === undefined || pattern === ''
+        ? renderHistoryProjection(projection, projection.visibleActivities, noTruncate, squarePath)
+        : renderGrepActivitiesView(projection.visibleActivities, projection.totalMatches, noTruncate, squarePath, pattern, query.fixed !== undefined, () => 'full');
+    const next = projection.continuation;
+    const base = options.continuationArgs ?? historyQueryArgs(query);
+    const continuation = next === undefined ? '' : `\n\n${historyContinuationCommand(squarePath, [...base, `--${next.direction}`, next.cursor, '--limit', String(next.limit)])}`;
+    return withPathOutput(squarePath, output + continuation, { participantCount: projection.standingCount });
+}
+function participantsLimitCommand(squarePath, limit) {
+    return `${commandPrefix(squarePath)} participants --limit ${limit}`;
+}
+export function renderParticipantsResult(squarePath, data, limit = PARTICIPANTS_DEFAULT_LIMIT) {
+    const projection = data.observation;
+    if (projection === undefined)
+        return undefined;
+    const now = projection.now;
+    const participants = data.participants;
+    const lines = participants.slice(0, 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 <= 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,
+    });
+}
+export function renderStatusResult(squarePath, data) {
+    const presentation = data.observation;
+    if (presentation === undefined)
+        return undefined;
+    const participantsByName = new Map(data.participants.map((participant) => [participant.name, participant]));
+    const orderedHere = presentation.orderedHereNames.map((name) => participantsByName.get(name));
+    const lingering = presentation.lingeringCount;
+    const people = [];
+    if (data.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 ?? data.now, data.now)}`
+                    : `is nearby · quiet · ${participant.lastActiveAt === undefined ? 'just now' : formatRelativeTime(participant.lastActiveAt, data.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 = data.hardCap === null ? 'unlimited' : `${data.hardCap} each`;
+    const holdTime = data.hold?.at === undefined ? 'just now' : formatRelativeTime(data.hold.at, data.now);
+    const hold = data.hold !== null
+        ? `· ${data.hold.by === undefined ? 'someone' : participantIdentity(data.hold.by)} raised a hand${data.hold.reason ? ` — ${data.hold.reason}` : ''}${style('dim', ` · ${holdTime}`)}`
+        : undefined;
+    const visible = data.latestActivity === undefined
+        ? { text: '', bodyClipped: false }
+        : renderAmbientEventFacts(data.latestActivity, presentation.viewer, {
+            now: data.now,
+            preview: 200,
+            actNumber: presentation.latestActNumber,
+            perception: presentation.latestPerception,
+        });
+    const latest = visible.text === ''
+        ? [data.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, data.now)}`));
+    }
+    if (presentation.joinCount > 3)
+        latest.push(style('dim', `  → … ${presentation.joinCount - 3} more stepped in`));
+    if (visible.bodyClipped && data.latestActivity !== undefined) {
+        latest.push(`${commandPrefix(squarePath)} history --at ${data.latestActivity.id} -C 2 --no-truncate`);
+    }
+    const counts = [
+        `${orderedHere.length} here`,
+        ...(lingering > 0 ? [`${lingering} lingering`] : []),
+        `${data.doneCount} done`,
+        `cap ${cap}`,
+        `throttle ${data.throttlePerMinute === undefined ? 'none' : `${data.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 });
+}
+export function renderListeningResult(squarePath, data) {
+    const projection = data.observation;
+    if (projection?.participant === undefined)
+        return undefined;
+    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(squarePath, body, { participantCount: projection.standingCount, held: projection.held });
+}
+export function renderListenerChange(squarePath, verb, data) {
+    const projection = data.observation;
+    if (projection?.participant === undefined)
+        return undefined;
+    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(squarePath, `${data.activity === null ? '○' : '·'} ${action}`, {
+        participantCount: projection.standingCount, held: projection.held,
+    });
+}
+export function renderLifecycleResult(squarePath, verb, data) {
+    const projection = data.observation;
+    if (projection === undefined)
+        return undefined;
+    const header = { participantCount: projection.standingCount, held: projection.held };
+    if (verb === 'done') {
+        return withPathOutput(projection.location ?? squarePath, `○ you stepped out — your footsteps fade · ${data.activity.id}`, header);
+    }
+    const line = `${renderRoomChangeText(projection.activity)} · ${formatActivityId(projection.activity.index)} · just now`;
+    return withPathOutput(projection.location ?? squarePath, verb === 'hold' ? `· ${line}` : `✓ ${line}`, header);
+}
+/** Refusal lines with the same recovery commands the CLI prints. */
+export function renderFailureLines(failure, options = {}) {
+    const { squarePath, name } = options;
+    const facts = failure.facts;
+    const reason = facts?.reason;
+    const marked = reason === 'never_joined' || reason === 'not_standing';
+    const lines = marked ? failure.message.split('\n').map((line) => `✕ ${line}`) : [failure.message];
+    if (reason === 'migration_required') {
+        if (facts?.ledgerRoot !== undefined)
+            lines.push('square ledger migrate', 'square ledger verify');
+        else if (squarePath !== undefined)
+            lines.push(`${commandPrefix(squarePath)} migrate`);
+    }
+    else if (squarePath !== undefined && name !== undefined && failure.code === 'already_joined') {
+        lines.splice(0, 1, `✕ ${participantIdentity(name)} shoos you out of the square`, `  · ${participantIdentity(name)} already stands here — another session holds the name`);
+        lines.push(...takeoverRecoveryLines(squarePath, name));
+    }
+    else if (squarePath !== undefined && reason === 'never_joined') {
+        lines.push(failure.operation?.subject !== 'filter' && name !== undefined
+            ? joinRecoveryCommand(squarePath, name) : participantsRecoveryCommand(squarePath));
+    }
+    else if (squarePath !== undefined && reason === 'not_standing') {
+        lines.push(participantsRecoveryCommand(squarePath));
+    }
+    else if (squarePath !== undefined && reason === 'not_addressed' && facts?.activityId !== undefined) {
+        lines.push(facts.activityExists === true
+            ? `${commandPrefix(squarePath)} history --at ${facts.activityId} -C 2`
+            : `${commandPrefix(squarePath)} history --limit 10`);
+    }
+    if (reason === 'invalid_done_body')
+        lines.push('square done --help');
+    return lines;
+}

package/dist/packages/agent-delivery/src/claude-native.js

@@ -32,9 +32,11 @@ export async function writeClaudeNative(target, text, control) {
     try {
         scope.check();
         const token = await scope.wait(resolveClaudeToken({ endpoint, token: target.token, claudeHome: target.claudeHome, env: target.env, platform: target.platform }, scope.signal));
+        const messageId = target.messageId ?? randomUUID();
         const frames = [
             ...(token === undefined ? [] : [{ type: 'auth', token }]),
-            { msgV: 1, msg_id: target.messageId ?? randomUUID(), type: 'user', session_id: target.sessionId, message: { role: 'user', content: text }, priority: 'next' },
+            // Claude's SDK custody events echo uuid, not the peer-protocol msg_id.
+            { msgV: 1, msg_id: messageId, uuid: messageId, type: 'user', session_id: target.sessionId, message: { role: 'user', content: text }, priority: 'next' },
         ];
         scope.check();
         if (Date.now() >= control.deadline)

package/dist/routes.js

@@ -19,10 +19,10 @@ export async function defaultWakeRouteCapabilities(hostLedger) {
 export function resolvePrimaryWakeRoute(boundary, env, capabilities) {
     const paseoAgentId = env.PASEO_AGENT_ID?.trim();
     const candidates = [];
-    if (paseoAgentId)
-        candidates.push({ kind: 'paseo', address: { agentId: paseoAgentId } });
     if (boundary.provider === 'codex')
         candidates.push({ kind: 'codex-queue', address: { threadId: boundary.sessionId } });
+    if (paseoAgentId)
+        candidates.push({ kind: 'paseo', address: { agentId: paseoAgentId } });
     const chosen = candidates.find((candidate) => Object.values(candidate.address).every((value) => value.trim() !== '') && capabilities.canUse(candidate.kind, candidate.address));
     return chosen === undefined ? undefined : { location: boundary.location, participant: boundary.participant, sessionId: boundary.sessionId, channel: boundary.provider === 'paseo' ? 'paseo' : boundary.provider === 'claude' ? 'claude-code' : boundary.provider, ...chosen };
 }
@@ -80,6 +80,11 @@ export async function publishWakeRoute(artifact, route, opts = {}) {
             return;
         const identity = routeIdentityKey(route, location);
         const matching = routes.filter((item) => routeIdentityKey(item, canonicalPathSync(item.location)) === identity);
+        // A receiver's fresh native registration outranks a generic Paseo proposal.
+        // Arbitrate in the write transaction so tool publication and mod reconciliation cannot flip it back.
+        if (route.kind === 'paseo' && matching.some((item) => item.kind !== 'paseo' && item.channel === route.channel
+            && item.epoch === route.epoch && item.updatedAt <= at && item.updatedAt > at - ROUTE_FRESH_MS))
+            return;
         const existing = matching[0];
         if (matching.length === 1 && existing.updatedAt > at - ROUTE_FRESH_MS && existing.kind === route.kind
             && existing.channel === route.channel && sameRouteAddress(existing.address, route.address) && existing.epoch === route.epoch)