@astrosheep/square 0.3.93 → 0.3.95

package/dist/model.d.ts

@@ -1,7 +1,7 @@
 import type { Act, ActivityId } from './square-core.js';
 export { formatActivityId, parseActivityId } from './square-core.js';
 export type { Act, ActivityId, Audience, Reach } from './square-core.js';
-export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue", "claude-native", "paseo"];
+export declare const WAKE_ROUTE_KINDS: readonly ["opencode-server", "codex-queue", "claude-native", "paseo", "http"];
 export type WakeRouteKind = typeof WAKE_ROUTE_KINDS[number];
 export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
     readonly [key: string]: JsonValue;
@@ -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,35 +21,35 @@ 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;
 }
-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 SquareErrorCode = 'invalid_name' | 'invalid_args' | 'unknown_participant' | 'not_joined' | 'already_joined' | 'already_done' | '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. */
@@ -62,8 +59,6 @@ export interface SquareErrorFacts {
     /** Whether the artifact holds that activity at all; an unknown id needs an ordinary page. */
     activityExists?: boolean;
     pending?: number;
-    holder?: string;
-    holdReason?: string;
     retryAfterMs?: number;
 }
 declare class SquareErrorBase<Code extends string> extends Error {
@@ -103,7 +98,7 @@ export interface WatchLease {
     expiresAt: number;
     filter?: WatchLeaseFilter;
 }
-export type DirectedNotificationRoute = 'mention' | 'reply' | 'attention' | 'bell';
+export type DirectedNotificationRoute = import('./attention.js').AudienceRoute;
 export interface InboxNotification {
     actIndex: number;
     actor: string;
@@ -122,19 +117,15 @@ 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';
 }>;
 export type RoomChangeAct = Extract<StoredAct, {
-    kind: 'join' | 'done' | 'hold' | 'resume' | 'listen' | 'ignore' | 'unlisten';
+    kind: 'join' | 'done' | 'listen' | 'ignore' | 'unlisten';
 }>;
 export declare function formatHardCap(hardCap: HardCap): string;
 export declare function parseParticipantList(value: string): string[];

package/dist/model.js

@@ -1,6 +1,6 @@
 // Shared model and constants for Square.
 export { formatActivityId, parseActivityId } from './square-core.js';
-export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-queue', 'claude-native', 'paseo'];
+export const WAKE_ROUTE_KINDS = ['opencode-server', 'codex-queue', 'claude-native', 'paseo', 'http'];
 export const ACTIVITY_METADATA_MAX_BYTES = 16 * 1024;
 export const ACTIVITY_METADATA_MAX_DEPTH = 256;
 /** Validate the bounded, lossless JSON object carried by a say. */
@@ -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';
@@ -31,6 +32,8 @@ export async function createDefaultWakeTransport(env = process.env, suppliedTran
     }
     const { createClaudeWakeTransport } = await import('./claude-delivery.js');
     transports['claude-native'] = createClaudeWakeTransport(env);
+    const { HttpWakeTransport } = await import('./http-delivery.js');
+    transports.http = new HttpWakeTransport({ env });
     return createWakeTransport(transports);
 }
 /** Route selection only: all implementations receive the same request and final gate. */
@@ -55,16 +58,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 +94,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;
 };
@@ -24,14 +24,13 @@ export declare function renderStatusResult(squarePath: string, data: StatusResul
 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;
+export declare function renderLifecycleResult(squarePath: string, 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 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 +41,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, 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'
@@ -36,21 +34,23 @@ export function renderJoinResult(data) {
         ...(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 });
+    ].join('\n'), { participantCount: after.standingCount });
 }
 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;
@@ -63,9 +63,9 @@ export function renderExpression(squarePath, data) {
         : `\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, confirmation + (data.hint ? `\n${style('dim', `· ${data.hint}`)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount, held: projection.held });
+    return withPathOutput(projection.location ?? squarePath, confirmation + (data.hint ? `\n${style('dim', `· ${data.hint}`)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount });
 }
-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 header = { participantCount: projection.standingCount, held: projection.held };
+    const stop = data.reason === 'drained' && data.activities.length > 0 ? undefined : data.reason;
+    const header = { participantCount: projection.standingCount };
     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,11 @@ 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}`)}`
-        : 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,20 +280,21 @@ 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(' · ');
     const output = [
         style('dim', counts),
-        ...(hold === undefined ? [] : ['', hold]), '', style('dim', 'around the square'), ...people, '', style('dim', 'latest'), ...latest,
+        '', style('dim', 'around the square'), ...people, '', style('dim', 'latest'), ...latest,
         ...(data.listening === undefined ? [] : [
             '', style('dim', 'you listen to'),
             ...(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 });
 }
 export function renderListeningResult(squarePath, data) {
     const projection = data.observation;
@@ -307,7 +303,7 @@ export function renderListeningResult(squarePath, data) {
     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 });
+    return withPathOutput(squarePath, body, { participantCount: projection.standingCount });
 }
 export function renderListenerChange(squarePath, verb, data) {
     const projection = data.observation;
@@ -323,23 +319,20 @@ export function renderListenerChange(squarePath, verb, data) {
             : verb === 'ignore' ? `${actor} already ignores ${target} — only bells will reach you from them`
                 : `${actor} is not listening to ${target}`;
     return withPathOutput(squarePath, `${data.activity === null ? '○' : '·'} ${action}`, {
-        participantCount: projection.standingCount, held: projection.held,
+        participantCount: projection.standingCount,
     });
 }
-export function renderLifecycleResult(squarePath, verb, data) {
+export function renderLifecycleResult(squarePath, 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);
+    return withPathOutput(projection.location ?? squarePath, `○ you stepped out — your footsteps fade · ${data.activity.id}`, {
+        participantCount: projection.standingCount,
+    });
 }
 /** 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 +343,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>;
 }