@astrosheep/square 0.3.92 → 0.3.94

package/dist/mcp.js

@@ -6,8 +6,10 @@ import { codexWakeAddress } from './codex-address.js';
 import { readClaudeMcpCall } from './claude-mcp-context.js';
 import { SQUARE_IDENTITY } from './identity.js';
 import { Square, createSquareResourceOwner } from './square-api.js';
+import { harnessOwner } from './square-api.js';
 export function createSquareMcpServer(options) {
-    const baseEnv = { ...(options.env ?? process.env) };
+    const { owner: configuredOwner, wakeAddress, ...resourceOptions } = options;
+    const baseEnv = { ...(resourceOptions.env ?? process.env) };
     const resources = createSquareResourceOwner();
     // Calls to the configured square borrow one server-owned connection.
     const inFlight = new Set();
@@ -19,21 +21,20 @@ export function createSquareMcpServer(options) {
             const call = (async () => {
                 let square;
                 try {
-                    const { as: participant, location } = args;
+                    const { location } = args;
                     const threadId = extra._meta?.threadId;
                     const opencodeSessionId = extra._meta?.['ai.opencode/sessionID'];
                     // Claude's plugin endpoint requires the mod's call-local coordinate, never startup identity.
                     const claude = baseEnv.SQUARE_CLAUDE_MCP_CONTEXT === '1'
                         ? await readClaudeMcpCall(extra._meta?.['claudecode/toolUseId'], baseEnv)
                         : undefined;
-                    const body = claude !== undefined
-                        ? { channel: 'claude-code', session: claude.sessionId,
-                            ...(claude.agentId === undefined ? {} : { agent: claude.agentId }) }
+                    const owner = claude !== undefined
+                        ? harnessOwner({ channel: 'claude-code', session: claude.sessionId, ...(claude.agentId === undefined ? {} : { agent: claude.agentId }) })
                         : typeof threadId === 'string' && threadId.trim()
-                            ? { channel: 'codex', session: threadId }
+                            ? harnessOwner({ channel: 'codex', session: threadId })
                             : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
-                                ? { channel: 'opencode', session: opencodeSessionId }
-                                : options.body;
+                                ? harnessOwner({ channel: 'opencode', session: opencodeSessionId })
+                                : configuredOwner;
                     const env = claude !== undefined
                         ? { ...operationEnv('claude', claude.sessionId, baseEnv),
                             // Preserve Claude's session + child flag semantics; an agent loop ID is not a session ID.
@@ -44,37 +45,35 @@ export function createSquareMcpServer(options) {
                                 ? operationEnv('opencode', opencodeSessionId, baseEnv)
                                 : baseEnv;
                     square = await Square.at({
-                        ...options, env, body, cwd: claude?.cwd ?? options.cwd,
-                        // A call-local Codex thread uses its native queue even when managed by Paseo.
-                        wakeAddress: claude === undefined && typeof threadId === 'string' && threadId.trim()
-                            ? codexWakeAddress(threadId, env) : options.wakeAddress,
+                        ...resourceOptions, env, cwd: claude?.cwd ?? resourceOptions.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 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.
+                    const callWake = wakeAddress !== undefined && (owner === configuredOwner
+                        || wakeAddress.kind === 'paseo' && wakeAddress.address.agentId === baseEnv.PASEO_AGENT_ID
+                        || wakeAddress.kind === 'claude-native' && wakeAddress.address.sessionId === claude?.sessionId
+                        || wakeAddress.kind === 'opencode-server' && wakeAddress.address.sessionId === opencodeSessionId)
+                        ? wakeAddress : undefined;
+                    let text;
                     try {
-                        receipt = await tool.run(square, args, { signal: extra.signal, observe: true });
+                        text = await tool.run(square, args, { signal: extra.signal }, {
+                            owner, wakeAddress: claude === undefined && typeof threadId === 'string' && threadId.trim()
+                                ? codexWakeAddress(threadId, env) : callWake,
+                        });
                     }
                     finally {
                         await square.close();
                     }
-                    // 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 };
+                    return { content: [{ type: 'text', text }] };
                 }
                 catch (error) {
                     const failure = squareToolFailure(error, extra.signal);
                     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 } };
+                                    participant: typeof participant === 'string' ? participant : undefined,
+                                }) }] };
                 }
             })();
             inFlight.add(call);

package/dist/model.d.ts

@@ -12,11 +12,8 @@ export declare const ACTIVITY_METADATA_MAX_DEPTH = 256;
 /** Validate the bounded, lossless JSON object carried by a say. */
 export declare function validateActivityMetadata(value: unknown): ActivityMetadata | undefined;
 export declare function activityMetadataHasContent(metadata: ActivityMetadata | undefined): boolean;
-export interface Body {
-    readonly channel: string;
-    readonly session: string;
-    readonly agent?: string;
-}
+/** Opaque custody identity. Harness coordinates are adapter-owned. */
+export type Owner = string;
 export interface WakeAddress {
     readonly kind: WakeRouteKind;
     readonly address: Readonly<Record<string, string>>;
@@ -24,24 +21,22 @@ export interface WakeAddress {
 /** Artifact-owned custody binding. Generation is the join activity that established it. */
 export interface Seat {
     readonly participant: string;
-    readonly body: Body;
+    readonly owner: Owner;
     readonly generation: ActivityId;
+    readonly attachment: 'attached' | 'detached';
     readonly wakeAddress?: WakeAddress;
 }
 export interface SeatWatchLease {
     readonly generation: ActivityId;
     readonly lease: WatchLease;
 }
-export declare function sameBody(left: Body, right: Body): boolean;
-export declare function validateBody(body: Body): void;
+export declare function validateOwner(owner: Owner): Owner;
 export declare function isWakeRouteKind(value: unknown): value is WakeRouteKind;
 export interface WakeRoute {
     /** Ownership generation, when the receiver publishes a fenced route. */
     epoch?: number;
     location: string;
     participant: string;
-    sessionId: string;
-    channel: string;
     kind: WakeRouteKind;
     address: Record<string, string>;
     updatedAt: number;
@@ -49,10 +44,12 @@ export interface WakeRoute {
 export type SquareErrorCode = 'invalid_name' | 'invalid_args' | 'unknown_participant' | 'not_joined' | 'already_joined' | 'already_done' | 'held' | 'capped' | 'throttled' | 'bell_quota' | 'behind' | 'io' | 'unavailable';
 export type InternalSquareErrorCode = SquareErrorCode | 'not_found' | 'cap_reached' | 'conflict' | 'pending_peer';
 export interface SquareErrorFacts {
+    /** Copyable recovery for a missing, detached or foreign seat. */
+    join?: string;
     /** Express admission rejected before any activity was committed. */
     activityUnsent?: true;
     /** Refusal reason, including absent participants, conflicting reach, and inaccessible activities. */
-    reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'migration_required' | 'invalid_reply' | 'invalid_done_body';
+    reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'migration_required' | 'invalid_reply' | 'invalid_done_body' | 'needs_seat';
     /** The activity id a `catch --id` refusal named. */
     activityId?: string;
     /** The host ledger requiring offline migration, rather than the selected artifact. */
@@ -122,13 +119,9 @@ export interface PendingMembership extends LocatedSeat {
     readonly deliveryDeferralExpiry?: number;
 }
 export interface WatchOptions {
-    id?: ActivityId;
     participants?: string[];
     mention?: string;
-    limit?: number;
-    idleMs?: number;
     replace?: boolean;
-    now?: boolean;
 }
 export type PublicAct = Extract<StoredAct, {
     kind: 'say' | 'done';

package/dist/model.js

@@ -76,14 +76,11 @@ export function validateActivityMetadata(value) {
 export function activityMetadataHasContent(metadata) {
     return metadata !== undefined && Object.keys(metadata).length > 0;
 }
-export function sameBody(left, right) {
-    return left.channel === right.channel && left.session === right.session && left.agent === right.agent;
-}
-export function validateBody(body) {
-    if (!body || typeof body.channel !== 'string' || !body.channel || typeof body.session !== 'string' || !body.session
-        || (body.agent !== undefined && (typeof body.agent !== 'string' || !body.agent))) {
-        throw new SquareError('invalid_args', 'A participant write requires an explicit channel and session body.');
+export function validateOwner(owner) {
+    if (typeof owner !== 'string' || !owner || Buffer.byteLength(owner, 'utf8') > 512 || /[\u0000-\u001f\u007f-\u009f]/u.test(owner)) {
+        throw new SquareError('invalid_args', 'A participant write requires a non-empty owner without control characters (at most 512 UTF-8 bytes).');
     }
+    return owner;
 }
 export function isWakeRouteKind(value) {
     return typeof value === 'string' && WAKE_ROUTE_KINDS.includes(value);

package/dist/notifications.d.ts

@@ -13,7 +13,7 @@ interface ProcessNotificationOptions {
 export declare function createDefaultWakeTransport(env?: NodeJS.ProcessEnv, suppliedTransports?: WakeTransports): Promise<WakeTransportPort>;
 /** Route selection only: all implementations receive the same request and final gate. */
 export declare function createWakeTransport(transports: WakeTransports): WakeTransportPort;
-export declare function processActNotificationsOnce(squarePath: string, actIndex: number, opts?: ProcessNotificationOptions): Promise<import("./ports.js").DeliveryResult>;
+export declare function processActNotificationsOnce(squarePath: string, actIndex: number, opts?: ProcessNotificationOptions): Promise<void>;
 /** Privileged hook fallback: sweep indexed squares plus the current cwd's local squares within one boundary budget. */
 export declare function sweepPrivilegedPending(cwd: string, env?: NodeJS.ProcessEnv, suppliedTransports?: WakeTransports, deadline?: number, signal?: AbortSignal): Promise<void>;
 export interface SweepPendingNotificationsOptions {

package/dist/notifications.js

@@ -1,4 +1,5 @@
 import path from 'node:path';
+import { canonicalPath } from './canonical-path.js';
 import fs from 'node:fs';
 import { indexedSquareEntries } from './square-index.js';
 import { InternalSquareError, SquareError } from './model.js';
@@ -55,16 +56,15 @@ export function createWakeTransport(transports) {
 export async function processActNotificationsOnce(squarePath, actIndex, opts = {}) {
     const env = opts.env ?? process.env;
     const now = opts.now ?? Date.now;
+    squarePath = await canonicalPath(squarePath);
     const artifact = createArtifactPort(squarePath);
     try {
         await artifact.read(facts => facts.header());
         const transport = await createDefaultWakeTransport(env, opts.transports);
         try {
-            return await deliverPending({ artifact, transport, location: squarePath, activity: actIndex, timeoutMs: Number(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? 5000), now: now() });
-        }
-        catch {
-            return { attempted: 0, accepted: 0, failed: 0, unknown: 0, notCapable: 1 };
+            await deliverPending({ artifact, transport, location: squarePath, activity: actIndex, timeoutMs: Number(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? 5000), now: now() });
         }
+        catch { /* Delivery failure does not undo the activity. */ }
     }
     catch (error) {
         if (error instanceof InternalSquareError && error.code === 'not_found')
@@ -92,10 +92,11 @@ export async function sweepPrivilegedPending(cwd, env = process.env, suppliedTra
     if (remainingMs() === 0 || signal?.aborted)
         return;
     const transport = await createDefaultWakeTransport(env, suppliedTransports);
-    for (const squarePath of paths) {
+    for (const candidate of paths) {
         if (remainingMs() === 0 || signal?.aborted)
             break;
         try {
+            const squarePath = await canonicalPath(candidate);
             const artifact = createArtifactPort(squarePath, undefined, signal);
             try {
                 await artifact.read(facts => facts.header(), signal);

package/dist/operation-presentation.d.ts

@@ -7,10 +7,10 @@ export type JoinPresentation = Omit<JoinResult, 'participant'> & {
         readonly name: string;
     } | string;
 };
-export declare function renderJoinResult(data: JoinPresentation): string | undefined;
-export declare function renderExpression(squarePath: string, data: ExpressResult): string | undefined;
+export declare function renderJoinResult(data: JoinPresentation, owner?: string): string | undefined;
+export declare function renderExpression(squarePath: string, data: ExpressResult, owner?: string): string | undefined;
 /** Render settled catch facts; no selection, terminal decisions, receipts or wait machinery. */
-export declare function renderCatchOutcome(squarePath: string, data: CatchResult, options?: CatchOptions): {
+export declare function renderCatchOutcome(squarePath: string, data: CatchResult, options?: CatchOptions, owner?: string): {
     stdout: string;
     exitCode: number;
 };
@@ -31,7 +31,7 @@ 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 reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'migration_required' | 'invalid_reply' | 'invalid_done_body' | 'needs_seat';
         readonly activityId?: string;
         readonly ledgerRoot?: string;
         readonly activityExists?: boolean;
@@ -42,4 +42,5 @@ export interface FailureReport {
 export declare function renderFailureLines(failure: FailureReport, options?: {
     squarePath?: string;
     name?: string;
+    owner?: string;
 }): string[];

package/dist/operation-presentation.js

@@ -1,26 +1,24 @@
 // 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 { formatActivityId } from './square-core.js';
+import { commandPrefix, joinRecoveryCommand, participantCommandPrefix, participantIdentity, participantsRecoveryCommand, quoteShell, renderAmbientEvent, renderAmbientEventFacts, renderEventCli, renderGrepActivitiesView, 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) {
+export function renderJoinResult(data, owner) {
     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],
+        now: after.now, preview: 200, perception: event.perception,
     })).filter(Boolean).join('\n\n');
-    const fallback = after.automaticDeliveryAvailable ? ['', '· when someone calls you, you’ll hear them here'] : [
-        '', `${participantCommandPrefix(after.location, name)} catch --idle 30m`,
+    const fallback = after.deliveryAvailable ? ['', '· when someone calls you, you’ll hear them here'] : [
+        '', `${participantCommandPrefix(after.location, name, owner)} catch --idle 30m`,
         '  · stay within earshot — keep this catch open for new activity',
     ];
     const entryLine = data.kind === 'joined' ? '● you stepped into the square'
@@ -41,16 +39,18 @@ export function renderJoinResult(data) {
 function isGestureOnly(body) {
     return /\*[^*]*\*/.test(body) && body.replace(/\*[^*]*\*/g, '').trim() === '';
 }
-export function renderExpression(squarePath, data) {
+export function renderExpression(squarePath, data, owner) {
     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 context = projection.context;
+    const pending = context.activities.length === 0 ? '' : '\n\n' + [
+        'Unread context · preview only, not consumed',
+        ...context.activities.map(item => `· ${participantIdentity(item.actor)} · ${item.id}\n  ${item.preview}${item.truncated ? '… (truncated)' : ''}`),
+        ...(context.remaining === 0 ? [] : [`· ${context.remaining} more unread activities`]),
+        `${participantCommandPrefix(projection.location, name, owner)} catch`,
+    ].join('\n');
     const ownCount = projection.ownActivityCount;
     const capCount = projection.hardCap === null ? '' : ` · ${ownCount}/${projection.hardCap}`;
     const activity = data.activity;
@@ -65,7 +65,7 @@ export function renderExpression(squarePath, data) {
         ? `\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, confirmation + (data.hint ? `\n${style('dim', `· ${data.hint}`)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount, held: projection.held });
 }
-function continuationCommand(squarePath, name, options) {
+function continuationCommand(squarePath, name, options, owner) {
     const args = ['--now'];
     if (options.from?.length)
         args.push('--from', options.from.join(','));
@@ -73,20 +73,20 @@ function continuationCommand(squarePath, name, options) {
         args.push('--mention');
     if (options.limit !== undefined)
         args.push('--limit', String(options.limit));
-    return `${participantCommandPrefix(squarePath, name)} catch ${args.join(' ')}`;
+    return `${participantCommandPrefix(squarePath, name, owner)} catch ${args.join(' ')}`;
 }
 /** Render settled catch facts; no selection, terminal decisions, receipts or wait machinery. */
-export function renderCatchOutcome(squarePath, data, options = {}) {
+export function renderCatchOutcome(squarePath, data, options = {}, owner) {
     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 stop = data.reason === 'drained' && data.activities.length > 0 ? undefined : data.reason;
     const header = { participantCount: projection.standingCount, held: projection.held };
     const statusOptions = {
-        squarePath: location, name, presence: projection.presence,
-        showCatchHint: !projection.automaticDeliveryAvailable,
+        squarePath: location, name, owner, presence: projection.presence,
+        showCatchHint: !projection.deliveryAvailable,
         ownActivityCount: projection.ownActivityCount, hardCap: projection.hardCap,
     };
     if (stop === 'already-active' || stop === 'replaced') {
@@ -97,17 +97,16 @@ export function renderCatchOutcome(squarePath, data, options = {}) {
         };
     }
     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,
+        now: projection.now, 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)}`;
+        : `· ${data.remaining} matching ${data.remaining === 1 ? 'activity remains' : 'activities remain'}\n${continuationCommand(location, name, options, owner)}`;
     const terminal = stop === undefined ? '' : renderWatchStatus({
         ...statusOptions, status: stop,
-        ...(stop === 'stale' && options.idle !== undefined ? { idleMs: options.idle } : {}),
+        ...(stop === 'idle' && 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 fallback = stop === undefined && !projection.deliveryAvailable && data.remaining === 0
+        ? `${participantCommandPrefix(location, name, owner)} 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),
@@ -121,11 +120,7 @@ function renderHistoryProjection(projection, visible, noTruncate, squarePath) {
     // 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);
+        const rendered = renderEventCli(activity, { preview });
         if (rendered !== '')
             chunks.push(rendered);
         for (const participant of projection.presenceAnchors[activity.index] ?? []) {
@@ -193,8 +188,8 @@ export function renderParticipantsResult(squarePath, data, limit = PARTICIPANTS_
     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 glyph = participant.presence === 'done' ? '○' : participant.presence === 'watching' ? '◎' : participant.activityCount > 0 && projection.classificationByName[participant.name] === 'here' ? '●' : '○';
+        const state = participant.presence === 'watching' ? 'catching' : participant.presence === 'never-joined' ? 'not joined' : participant.presence;
         const last = participant.lastActiveAt === undefined ? '—' : formatRelativeTime(participant.lastActiveAt, now);
         return `  ${glyph} ${participant.name}${style('dim', ` · ${state} · ${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${last}`)}`;
     });
@@ -217,8 +212,9 @@ export function renderStatusResult(squarePath, data) {
     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 away = data.participants.filter(participant => participant.presence === 'away');
     const people = [];
-    if (data.activeCount === 0) {
+    if (presentation.standingCount === 0) {
         people.push('  ○ nobody in the square');
     }
     else {
@@ -243,7 +239,11 @@ export function renderStatusResult(squarePath, data) {
                         : 'caught up';
             return `  ${glyph} ${participantIdentity(participant.name)}${style('dim', ` ${summary}${attention === '' ? '' : ` · ${attention}`}`)}`;
         }));
-        const unshown = Math.max(0, orderedHere.length - STATUS_PARTICIPANT_PREVIEW_LIMIT) + lingering;
+        people.push(...away.slice(0, STATUS_PARTICIPANT_PREVIEW_LIMIT).map(participant => `  ○ ${participantIdentity(participant.name)}${style('dim', ' · away')}`));
+        if (away.length > STATUS_PARTICIPANT_PREVIEW_LIMIT)
+            people.push(`  ○ … ${away.length - STATUS_PARTICIPANT_PREVIEW_LIMIT} more away`);
+        const unshown = Math.max(0, orderedHere.length - STATUS_PARTICIPANT_PREVIEW_LIMIT)
+            + Math.max(0, away.length - STATUS_PARTICIPANT_PREVIEW_LIMIT) + lingering;
         if (orderedHere.length > STATUS_PARTICIPANT_PREVIEW_LIMIT) {
             people.push(`  ○ … ${orderedHere.length - STATUS_PARTICIPANT_PREVIEW_LIMIT} more here`);
         }
@@ -256,16 +256,16 @@ export function renderStatusResult(squarePath, data) {
         }
     }
     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}`)}`
+    const held = data.held;
+    const holdTime = held?.at === undefined ? 'just now' : formatRelativeTime(held.at, data.now);
+    const hold = held !== null
+        ? `· ${held.by === undefined ? 'someone' : participantIdentity(held.by)} raised a hand${held.reason ? ` — ${held.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 === ''
@@ -285,8 +285,9 @@ export function renderStatusResult(squarePath, data) {
     }
     const counts = [
         `${orderedHere.length} here`,
+        ...(away.length > 0 ? [`${away.length} away`] : []),
         ...(lingering > 0 ? [`${lingering} lingering`] : []),
-        `${data.doneCount} done`,
+        `${data.participants.filter((participant) => participant.presence === 'done').length} done`,
         `cap ${cap}`,
         `throttle ${data.throttlePerMinute === undefined ? 'none' : `${data.throttlePerMinute}/min`}`,
     ].join(' · ');
@@ -298,7 +299,7 @@ export function renderStatusResult(squarePath, data) {
             ...(data.listening.length === 0 ? ['  ○ not turned toward anyone'] : data.listening.map((name) => `  · ${participantIdentity(name)}`)),
         ]),
     ].join('\n');
-    return withPathOutput(squarePath, output, { participantCount: presentation.standingCount, held: presentation.held });
+    return withPathOutput(squarePath, output, { participantCount: presentation.standingCount, held: data.held !== null });
 }
 export function renderListeningResult(squarePath, data) {
     const projection = data.observation;
@@ -334,12 +335,12 @@ export function renderLifecycleResult(squarePath, verb, data) {
     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`;
+    const line = `${renderRoomChangeText(data.activity)} · ${data.activity.id} · 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 { squarePath, name, owner } = options;
     const facts = failure.facts;
     const reason = facts?.reason;
     const marked = reason === 'never_joined' || reason === 'not_standing';
@@ -350,13 +351,17 @@ export function renderFailureLines(failure, options = {}) {
         else if (squarePath !== undefined)
             lines.push(`${commandPrefix(squarePath)} migrate`);
     }
+    else if (squarePath !== undefined && name !== undefined && reason === 'needs_seat') {
+        lines.splice(0, 1, `✕ ${failure.message}`);
+        lines.push(joinRecoveryCommand(squarePath, name, owner));
+    }
     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));
+        lines.push(...takeoverRecoveryLines(squarePath, name, owner));
     }
     else if (squarePath !== undefined && reason === 'never_joined') {
         lines.push(failure.operation?.subject !== 'filter' && name !== undefined
-            ? joinRecoveryCommand(squarePath, name) : participantsRecoveryCommand(squarePath));
+            ? joinRecoveryCommand(squarePath, name, owner) : participantsRecoveryCommand(squarePath));
     }
     else if (squarePath !== undefined && reason === 'not_standing') {
         lines.push(participantsRecoveryCommand(squarePath));

package/dist/owner.d.ts

@@ -0,0 +1,11 @@
+import { type Owner } from './model.js';
+export type { Owner } from './model.js';
+export interface HarnessCoordinate {
+    readonly channel: string;
+    readonly session: string;
+    readonly agent?: string;
+}
+export declare function harnessOwner(coordinate: HarnessCoordinate): Owner;
+/** Decode only at harness adapter boundaries; core never consumes the coordinate. */
+export declare function decodeHarnessOwner(owner: Owner): HarnessCoordinate | undefined;
+export declare function localUserOwner(): Owner;

package/dist/owner.js

@@ -0,0 +1,32 @@
+import os from 'node:os';
+import { validateOwner } from './model.js';
+export function harnessOwner(coordinate) {
+    const channel = nonempty(coordinate.channel, 'channel');
+    const session = nonempty(coordinate.session, 'session');
+    const agent = coordinate.agent === undefined ? undefined : nonempty(coordinate.agent, 'agent');
+    return validateOwner([channel, session, ...(agent === undefined ? [] : ['agent', agent])].map(encodeURIComponent).join(':'));
+}
+/** Decode only at harness adapter boundaries; core never consumes the coordinate. */
+export function decodeHarnessOwner(owner) {
+    const parts = owner.split(':');
+    if ((parts.length !== 2 && parts.length !== 4) || (parts.length === 4 && parts[2] !== 'agent'))
+        return undefined;
+    try {
+        const [channel, session] = parts;
+        const decoded = { channel: decodeURIComponent(channel), session: decodeURIComponent(session) };
+        if (parts.length === 4)
+            return { ...decoded, agent: decodeURIComponent(parts[3]) };
+        return decoded;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function localUserOwner() {
+    return validateOwner(`user:${os.userInfo().username}@${os.hostname()}`);
+}
+function nonempty(value, label) {
+    if (typeof value !== 'string' || value.length === 0)
+        throw new Error(`Harness ${label} must be non-empty.`);
+    return value;
+}

package/dist/paseo-delivery.d.ts

@@ -2,12 +2,15 @@ import type { WakeRequest, WakeOutcome, WakeTransportPort } from './ports.js';
 import { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';
 import { sendPaseoWake } from './wake-sink.js';
 export interface PaseoWakeTransportOptions {
-    discover?: typeof discoverPaseoAgents;
+    discover?: (timeoutMs: number) => ReturnType<typeof discoverPaseoAgents> | Awaited<ReturnType<typeof discoverPaseoAgents>>;
     waitForBoundary?: typeof waitForPaseoWakeBoundary;
     sendWake?: typeof sendPaseoWake;
 }
 export declare class PaseoWakeTransport implements WakeTransportPort {
     private readonly opts;
+    private discovering?;
     constructor(opts?: PaseoWakeTransportOptions);
+    /** Coalesce overlapping inventory reads only; a later send must rediscover current status. */
+    private discover;
     attempt(request: WakeRequest, timeoutMs: number, beforeSend: () => Promise<boolean>): Promise<WakeOutcome>;
 }