@astrosheep/square 0.3.92 → 0.3.94

package/dist/paseo-delivery.js

@@ -17,28 +17,30 @@ function diagnostic(phase, address, code) {
 }
 export class PaseoWakeTransport {
     opts;
+    discovering;
     constructor(opts = {}) {
         this.opts = opts;
     }
+    /** Coalesce overlapping inventory reads only; a later send must rediscover current status. */
+    discover(timeoutMs) {
+        return this.discovering ??= Promise.resolve().then(() => (this.opts.discover ?? discoverPaseoAgents)(timeoutMs))
+            .finally(() => { this.discovering = undefined; });
+    }
     async attempt(request, timeoutMs, beforeSend) {
         const address = request.route.address;
         const deadline = Date.now() + timeoutMs;
         const remainingMs = () => Math.max(0, deadline - Date.now());
         const budgetUnavailable = () => ({
             outcome: 'failed',
-            unavailable: true,
             signature: 'dispatch_budget_exhausted',
             message: 'The wake dispatch budget elapsed before Paseo accepted the wake.',
-            retainRoute: true,
         });
         const agentId = address.agentId?.trim();
         if (!agentId) {
             return {
                 outcome: 'failed',
-                unavailable: true,
                 signature: 'invalid_address',
                 message: 'Paseo route has no agent id.',
-                routeStale: true,
                 diagnostic: diagnostic('selection', address, 'invalid_address'),
             };
         }
@@ -49,30 +51,25 @@ export class PaseoWakeTransport {
         let remaining = remainingMs();
         if (remaining === 0)
             return budgetUnavailable();
-        const discovery = (this.opts.discover ?? discoverPaseoAgents)(remaining);
+        const discovery = await this.discover(remaining);
         if (discovery.error && discovery.agents.length === 0) {
             return {
                 outcome: 'failed',
-                unavailable: true,
                 // A credential or authorization refusal is proven; anything else may be transient.
                 signature: /password|auth|unauthori[sz]ed/i.test(discovery.error) ? 'discovery_rejected'
                     : /DAEMON_NOT_RUNNING|ECONNREFUSED|ENOENT|not found.*executable|ETIMEDOUT|timed out|timeout/i.test(discovery.error)
                         ? 'discovery_transient' : 'discovery_rejected',
                 message: `Paseo unavailable: ${discovery.error}`,
                 diagnostic: diagnostic('discovery', address, 'unavailable'),
-                retainRoute: true,
             };
         }
         const agent = discovery.agents.find((candidate) => candidate.id === agentId);
         if (agent === undefined || agent.status !== 'idle') {
             return {
                 outcome: 'failed',
-                unavailable: true,
                 signature: agent === undefined ? 'address_not_found' : 'agent_not_idle',
                 message: agent === undefined ? 'The registered Paseo agent was not found.' : 'The registered Paseo agent is not idle.',
                 diagnostic: diagnostic('selection', address, agent === undefined ? 'not_found' : 'not_idle'),
-                ...(agent === undefined ? {} : { retainRoute: true }),
-                ...(agent === undefined ? { routeStale: true } : {}),
             };
         }
         remaining = remainingMs();
@@ -81,11 +78,9 @@ export class PaseoWakeTransport {
         if (!(await (this.opts.waitForBoundary ?? waitForPaseoWakeBoundary)(agent, remaining))) {
             return {
                 outcome: 'failed',
-                unavailable: true,
                 signature: 'boundary_unavailable',
                 message: 'Paseo did not reach the current tool boundary before the wake timeout.',
                 diagnostic: diagnostic('boundary', address, 'unavailable'),
-                retainRoute: true,
             };
         }
         if (!(await beforeSend()))

package/dist/paseo-state.d.ts

@@ -7,8 +7,8 @@ export interface PaseoAgent {
 export declare function discoverPaseoAgents(timeoutMs?: number, opts?: {
     args?: string[];
     bin?: string;
-}): {
+}): Promise<{
     agents: PaseoAgent[];
     error?: string;
-};
+}>;
 export declare function waitForPaseoWakeBoundary(agent: Pick<PaseoAgent, 'id' | 'status'>, timeoutMs?: number): Promise<boolean>;

package/dist/paseo-state.js

@@ -1,11 +1,13 @@
-import { execFileSync } from 'node:child_process';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
 import { waitForPaseoToolBoundary } from './paseo-timeline.js';
-export function discoverPaseoAgents(timeoutMs = 5000, opts = {}) {
+const execFileAsync = promisify(execFile);
+export async function discoverPaseoAgents(timeoutMs = 5000, opts = {}) {
     try {
-        const raw = execFileSync(opts.bin ?? process.env.SQUARE_PASEO_BIN ?? 'paseo', [...(opts.args ?? []), 'ls', '--global', '--json'], {
+        const { stdout: raw } = await execFileAsync(opts.bin ?? process.env.SQUARE_PASEO_BIN ?? 'paseo', [...(opts.args ?? []), 'ls', '--global', '--json'], {
             encoding: 'utf8',
             timeout: timeoutMs,
-            stdio: ['ignore', 'pipe', 'pipe'],
+            maxBuffer: 1024 * 1024,
         });
         const parsed = JSON.parse(raw);
         const agents = Array.isArray(parsed) ? parsed : parsed?.agents;

package/dist/plugins/opencode/delivery.js

@@ -3,39 +3,48 @@ import { createArtifactPort } from '../../artifact.js';
 import { deliverPending } from '../../delivery-operations.js';
 import { nativePendingPreview, observeSessionPending, projectSessionSeats } from '../../inbox.js';
 import { automaticWakeEligible, presentationBlocksWake } from '../../delivery.js';
-import { sameBody } from '../../model.js';
+import { harnessOwner, decodeHarnessOwner } from '../../owner.js';
 import { formatActivityId, parseActivityId } from '../../square-core.js';
 import { indexedSquareEntries } from '../../square-index.js';
 import { asSeatRef } from '../../seats.js';
+import { restoreSessionSeats } from '../../session-lifecycle.js';
 import { presentPending } from '../../presentation-operations.js';
 import { createNativeInputId, sendNativeText } from '../../packages/agent-delivery/src/opencode-native.js';
 const routeKind = 'opencode-server';
-const bodyFor = (sessionId) => ({ channel: 'opencode', session: sessionId });
+const ownerFor = (sessionId) => harnessOwner({ channel: 'opencode', session: sessionId });
 const payloadHash = (payload) => createHash('sha256').update(payload).digest('hex');
-function preview(facts, location, seat, index) {
+function preview(facts, location, captured, index) {
+    const seat = facts.seat(captured.participant);
+    if (seat === undefined || seat.attachment !== 'attached' || seat.generation !== captured.generation || seat.owner !== captured.owner)
+        return undefined;
+    const wake = seat.wakeAddress;
+    if (wake?.kind !== routeKind)
+        return undefined;
     return nativePendingPreview(facts, {
-        location, routeKind, sessionId: seat.body.session, participant: seat.participant,
-        actIndex: index, address: { sessionId: seat.body.session }, now: Date.now(),
+        location, routeKind, generation: seat.generation, participant: seat.participant,
+        actIndex: index, address: wake.address, now: Date.now(),
     });
 }
 export async function indexedOpenCodeSessions(env) {
-    return [...new Set((await indexedSquareEntries({ channel: 'opencode' }, env)).map((entry) => entry.body.session))];
+    return [...new Set((await indexedSquareEntries({}, env)).flatMap((entry) => {
+            const coordinate = decodeHarnessOwner(entry.owner);
+            return coordinate?.channel === 'opencode' ? [coordinate.session] : [];
+        }))];
 }
 export async function discoverOpenCodeSeats(sessionId, env, signal) {
-    return projectSessionSeats({ body: bodyFor(sessionId), env }, signal);
+    return projectSessionSeats({ owner: ownerFor(sessionId), env }, signal);
 }
 function sameSeat(left, right) {
-    return left !== undefined && left.generation === right.generation && sameBody(left.body, right.body);
+    return left !== undefined && left.attachment === 'attached' && left.generation === right.generation && left.owner === right.owner;
 }
 function createOpenCodeWakeTransport(target, lifetime) {
     return {
         probe: async (route) => !lifetime.aborted && route.kind === routeKind
-            && route.sessionId === target.sessionId && route.address.sessionId === target.sessionId,
+            && route.address.sessionId === target.sessionId,
         async attempt(request, timeoutMs, beforeSend) {
             const index = parseActivityId(request.activity);
             const artifact = request.artifact;
             if (artifact === undefined || request.claimToken === undefined || index === undefined
-                || !sameBody(request.seat.body, bodyFor(target.sessionId))
                 || request.route.kind !== routeKind || request.route.address.sessionId !== target.sessionId) {
                 return { outcome: 'not-capable', diagnostic: 'OpenCode attention has no matching artifact claim or session.' };
             }
@@ -61,7 +70,7 @@ function createOpenCodeWakeTransport(target, lifetime) {
             if (result.state === 'accepted')
                 return { outcome: 'accepted' };
             if (result.state === 'unavailable')
-                return { outcome: 'failed', unavailable: true, retainRoute: true, signature: result.code };
+                return { outcome: 'failed', signature: result.code };
             return { outcome: 'unknown', signature: result.code };
         },
     };
@@ -126,7 +135,7 @@ export async function observeOpenCodeContext(sessionId, messages, env, signal) {
 }
 /** The native receiver owns no claims outside the artifact; HOME is used only for discovery. */
 export async function receiveOpenCodePending(target, env, signal) {
-    const observer = await observeSessionPending(bodyFor(target.sessionId), env);
+    const observer = await observeSessionPending(ownerFor(target.sessionId), env);
     const transport = createOpenCodeWakeTransport(target, signal);
     let waiting;
     try {
@@ -181,7 +190,8 @@ export async function receiveOpenCodePending(target, env, signal) {
 }
 /** Publish the native address into current artifact seats; the legacy route projection is not read. */
 export async function publishOpenCodeAddress(sessionId, env, signal) {
-    const seats = await discoverOpenCodeSeats(sessionId, env, signal);
+    await restoreSessionSeats(ownerFor(sessionId), env, { kind: routeKind, address: { sessionId } }, signal);
+    const seats = (await discoverOpenCodeSeats(sessionId, env, signal)).filter(({ seat }) => seat.attachment === 'attached');
     for (const { location, seat } of seats) {
         if (signal.aborted)
             return false;
@@ -199,6 +209,8 @@ export async function cancelOpenCodeDeliveries(sessionId, env, signal) {
     for (const { location, seat } of await discoverOpenCodeSeats(sessionId, env, signal)) {
         if (signal.aborted)
             return;
+        if (seat.attachment !== 'attached')
+            continue;
         const artifact = createArtifactPort(location, undefined, signal);
         try {
             const { value: through } = await artifact.read((facts) => facts.header().lastActIndex, signal);
@@ -215,9 +227,9 @@ export async function endOpenCodeSession(sessionId, env, signal) {
         if (signal.aborted)
             return;
         const { Square } = await import('../../square-api.js');
-        const square = await Square.at({ path: location, env, body: seat.body, participant: seat.participant });
+        const square = await Square.at({ path: location, env });
         try {
-            await square.endOwnedSession(seat.participant, sessionId, seat.generation, seat.body);
+            await square.endHeld(seat.participant, { owner: seat.owner, generation: seat.generation });
         }
         finally {
             await square.close();

package/dist/ports.d.ts

@@ -1,4 +1,4 @@
-import type { Act, ActivityId, Body, HardCap, Seat, StoredAct, WakeAddress, WakeRoute, WatchLease } from './model.js';
+import type { Act, ActivityId, Owner, HardCap, Seat, StoredAct, WakeAddress, WakeRoute, WatchLease } from './model.js';
 import type { MetadataMatch, DeliveryDeferralFact } from './delivery-deferral.js';
 export type ActivityIndex = number;
 export interface SquareHeader {
@@ -85,22 +85,22 @@ export interface ReceiptAssignment {
     readonly owner: string;
     readonly index: ActivityIndex;
 }
-export type JsonValue = null | boolean | number | string | readonly JsonValue[] | {
-    readonly [key: string]: JsonValue;
-};
-export type SeatRef = Omit<Seat, 'wakeAddress'>;
+export type SeatRef = Pick<Seat, 'participant' | 'owner' | 'generation'>;
 export type ArtifactWriteAuthority = {
     readonly kind: 'participant';
     readonly seat: SeatRef;
+} | {
+    readonly kind: 'host-cleanup';
+    readonly seat: SeatRef;
 } | {
     readonly kind: 'join';
     readonly participant: string;
-    readonly body: Body;
+    readonly owner: Owner;
     readonly wakeAddress?: WakeAddress;
 } | {
     readonly kind: 'takeover';
     readonly participant: string;
-    readonly body: Body;
+    readonly owner: Owner;
     readonly expectedGeneration: ActivityId;
     readonly wakeAddress?: WakeAddress;
 };
@@ -168,9 +168,7 @@ export interface DeliveryCompletion {
 /** Domain facts exist only during a synchronous artifact callback. Values are detached. */
 export interface SquareRead {
     seat(requestedName: string): Seat | undefined;
-    seatsForBody(body: Body): readonly Seat[];
-    /** Latest completed coordinates only; never participant write authority. */
-    completedSeatsForBody(body: Body): readonly Seat[];
+    seatsForOwner(owner: Owner): readonly Seat[];
     deliveryEvidence(participant: string, generation: ActivityId, activity?: ActivityId): readonly DeliveryEvidence[];
     deliveryByToken(claimToken: string): DeliveryEvidence | undefined;
     cancelledThrough(participant: string, generation: ActivityId): number | undefined;
@@ -219,6 +217,10 @@ export interface SquareWrite extends SquareRead {
         readonly at: number;
     }): StoredAct;
     updateWakeAddress(seat: SeatRef, wakeAddress?: WakeAddress): boolean;
+    /** Join authority only; preserves membership and its establishing generation. */
+    reattachSeat(seat: SeatRef, wakeAddress?: WakeAddress): boolean;
+    /** Host-cleanup authority only; stale/already-detached coordinates are a no-op. */
+    detachSeat(seat: SeatRef): boolean;
     cancelThrough(seat: SeatRef, through: ActivityIndex): boolean;
     claimDelivery(input: DeliveryClaimInput): DeliveryClaimResult;
     prepareDelivery(input: DeliveryPreparation): boolean;
@@ -245,7 +247,7 @@ export interface SquareCommitResult<R> extends SquareReadResult<R> {
 /** Atomic artifact access; no framing, SQL or lazy transaction capability escapes. */
 export interface SquareArtifactPort {
     read<R>(select: (facts: SquareRead) => R, signal?: AbortSignal): Promise<SquareReadResult<R>>;
-    /** Participant/domain writes must carry an explicit authority; no body-less mutation path exists. */
+    /** Participant/domain writes must carry an explicit owner; no owner-less mutation path exists. */
     transactAs<R>(authority: ArtifactWriteAuthority, change: (facts: SquareWrite) => R, signal?: AbortSignal): Promise<SquareCommitResult<R>>;
     /** Bounded cleanup/evidence settlement on this same connection after custody was acquired.
      * Independent of request/lifetime cancellation; explicit close and authority fences still apply. */
@@ -295,28 +297,14 @@ export interface WakeRequest {
 export interface PresentationSinkPort {
     present(activity: StoredAct): void | Promise<void>;
 }
-/** Read-only presentation evidence projection for diagnostics and migration callers. */
-export interface PresentationEvidenceProjection {
-    readonly location: string;
-    readonly participant: string;
-    readonly sessionId: string;
-    readonly activity: string;
-    readonly outcome: string;
-    readonly at?: number;
-}
 export type WakeOutcome = {
     readonly outcome: 'accepted';
     readonly signature?: string;
-    readonly attemptN?: number;
 } | {
     readonly outcome: 'failed';
     readonly message?: string;
     readonly signature?: string;
     readonly diagnostic?: unknown;
-    readonly attemptN?: number;
-    readonly unavailable?: boolean;
-    readonly retainRoute?: boolean;
-    readonly routeStale?: boolean;
 } | {
     readonly outcome: 'not-capable';
     readonly diagnostic?: string;
@@ -325,15 +313,7 @@ export type WakeOutcome = {
     readonly signature?: string;
     readonly message?: string;
     readonly diagnostic?: unknown;
-    readonly attemptN?: number;
 };
-export interface DeliveryResult {
-    readonly attempted: number;
-    readonly accepted: number;
-    readonly failed: number;
-    readonly unknown: number;
-    readonly notCapable: number;
-}
 export interface DeliverPendingInput {
     readonly artifact: SquareArtifactPort;
     readonly transport: WakeTransportPort;

package/dist/presentation-operations.js

@@ -1,6 +1,6 @@
 import { randomUUID } from 'node:crypto';
 import { formatActivityId, parseActivityId } from './square-core.js';
-import { isSquareError, sameBody } from './model.js';
+import { isSquareError } from './model.js';
 import { pendingHead, sameJoin } from './delivery.js';
 import { deliveryDeferralExpiry } from './delivery-deferral.js';
 import { asSeatRef } from './seats.js';
@@ -12,8 +12,8 @@ export async function preparePendingPresentation(input) {
     const initial = await input.artifact.read((facts) => {
         const participant = facts.participant(input.participant);
         const seat = facts.seat(input.participant);
-        if (!participant?.joined || seat === undefined || input.generation !== undefined && input.generation !== seat.generation
-            || input.seat !== undefined && (input.seat.generation !== seat.generation || !sameBody(input.seat.body, seat.body))
+        if (!participant?.joined || seat === undefined || seat.attachment !== 'attached' || input.generation !== undefined && input.generation !== seat.generation
+            || input.seat !== undefined && (input.seat.generation !== seat.generation || input.seat.owner !== seat.owner)
             || input.current?.(facts) === false || !pendingHead(facts, participant.name, index)
             || deliveryDeferralExpiry(facts, seat, index, input.now ?? Date.now()) !== undefined)
             return undefined;
@@ -26,7 +26,7 @@ export async function preparePendingPresentation(input) {
     const ref = asSeatRef(seat);
     const owns = (facts) => {
         const current = facts.seat(seat.participant);
-        return current !== undefined && sameBody(current.body, seat.body) && current.generation === seat.generation
+        return current !== undefined && current.attachment === 'attached' && current.owner === seat.owner && current.generation === seat.generation
             && sameJoin(facts, participant);
     };
     const claimToken = randomUUID();

package/dist/presentation.d.ts

@@ -2,7 +2,7 @@ import { type StoredAct, type RoomChangeAct } from './model.js';
 export { participantIdentity } from './participant-identity.js';
 import { type Perception } from './square-core.js';
 import type { Activity, UnreadActivitySummary, ParticipantSummary } from './square-facade.js';
-export type WatchStatus = 'stale' | 'empty-now' | 'quorum' | 'capped';
+export type WatchStatus = 'idle' | 'drained' | 'quorum' | 'capped';
 interface HeaderOptions {
     participantCount?: number;
     held?: boolean;
@@ -10,6 +10,7 @@ interface HeaderOptions {
     plain?: boolean;
 }
 interface ParticipantOutputOptions {
+    owner?: string;
     squarePath: string;
     name: string;
     participantCount?: number;
@@ -60,11 +61,11 @@ export declare function formatRefusal(squarePath: string, bodyLines: string[], o
 export declare function refusalText(error: unknown): string;
 export declare function quoteShell(value: string): string;
 export declare function commandPrefix(squarePath: string): string;
-export declare function participantCommandPrefix(squarePath: string, name: string): string;
+export declare function participantCommandPrefix(squarePath: string, name: string, owner?: string): string;
 /** Blocked actions end with a full copy-pasteable recovery command. */
-export declare function joinRecoveryCommand(squarePath: string, name: string): string;
+export declare function joinRecoveryCommand(squarePath: string, name: string, owner?: string): string;
 /** Taking a name is an explicit recovery choice, never an automatic retry. */
-export declare function takeoverRecoveryLines(squarePath: string, name: string): string[];
+export declare function takeoverRecoveryLines(squarePath: string, name: string, owner?: string): string[];
 export declare function participantsRecoveryCommand(squarePath: string): string;
 export declare function renderPresenceLines(recent: readonly ParticipantSummary[], now: number, limit?: number): string[];
 export declare function truncateChars(body: string, maxChars: number): {
@@ -81,14 +82,12 @@ interface RenderedEvent {
 export declare function renderEventCli(event: StoredAct | Activity, opts?: {
     now?: number;
     preview?: number;
-    actNumber?: number;
     mention?: string;
 }): string;
 export declare function renderAmbientEventFacts(event: StoredAct | Activity, viewer: string, opts?: {
     now?: number;
     preview?: number;
     presencePreview?: number;
-    actNumber?: number;
     mention?: string;
     perception?: Perception;
 }): RenderedEvent;
@@ -96,11 +95,9 @@ export declare function renderAmbientEvent(event: StoredAct | Activity, viewer:
     now?: number;
     preview?: number;
     presencePreview?: number;
-    actNumber?: number;
     mention?: string;
     perception?: Perception;
 }): string;
-export declare function renderPendingFeed(publicItems: readonly StoredAct[], sayNumbers: Readonly<Record<number, number>>, perceptions: Readonly<Record<number, Perception>>, viewer: string): string;
 export declare function renderActivityBlocked(opts: ActivityBlockedOptions): string;
 /** An indeterminate or already-committed send only points to inspection, never resend. */
 export declare function renderActivityUncertain(opts: ParticipantOutputOptions & {

package/dist/presentation.js

@@ -50,18 +50,18 @@ export function quoteShell(value) {
 export function commandPrefix(squarePath) {
     return `square --location ${quoteShell(squarePath)}`;
 }
-export function participantCommandPrefix(squarePath, name) {
-    return `square --location ${quoteShell(/^[A-Za-z][A-Za-z0-9+.-]*:/.test(squarePath) ? squarePath : path.resolve(squarePath))} --as ${quoteShell(name)}`;
+export function participantCommandPrefix(squarePath, name, owner) {
+    return `square --location ${quoteShell(/^[A-Za-z][A-Za-z0-9+.-]*:/.test(squarePath) ? squarePath : path.resolve(squarePath))} --as ${quoteShell(name)}${owner === undefined ? '' : ` --owner ${quoteShell(owner)}`}`;
 }
 /** Blocked actions end with a full copy-pasteable recovery command. */
-export function joinRecoveryCommand(squarePath, name) {
-    return `${participantCommandPrefix(squarePath, name)} join`;
+export function joinRecoveryCommand(squarePath, name, owner) {
+    return `${participantCommandPrefix(squarePath, name, owner)} join`;
 }
 /** Taking a name is an explicit recovery choice, never an automatic retry. */
-export function takeoverRecoveryLines(squarePath, name) {
+export function takeoverRecoveryLines(squarePath, name, owner) {
     return [
         'If this is your name to reclaim, --kick banishes the one standing here so you can step in:',
-        `${participantCommandPrefix(squarePath, name)} join --kick`,
+        `${participantCommandPrefix(squarePath, name, owner)} join --kick`,
     ];
 }
 export function participantsRecoveryCommand(squarePath) {
@@ -79,13 +79,14 @@ export function renderPresenceLines(recent, now, limit = 5) {
     if (shown.length === 0)
         return [style('dim', '  ○ nobody nearby')];
     const lines = shown.map((p) => {
-        const glyph = p.state === 'done' ? '○' : p.presence === 'watching' ? '◎' : p.lastActiveAt !== undefined ? '●' : '○';
-        const text = p.state === 'done'
+        const glyph = p.presence === 'done' || p.presence === 'away' ? '○' : p.presence === 'watching' ? '◎' : p.lastActiveAt !== undefined ? '●' : '○';
+        const text = p.presence === 'done'
             ? (p.lastActiveAt === undefined ? 'stepped out of the square' : `stepped out of the square · ${formatRelativeTime(p.lastActiveAt, now)}`)
-            : p.presence === 'watching'
-                ? (p.lastActiveAt === undefined ? 'is nearby · catching' : `is nearby · catching · ${formatRelativeTime(p.lastActiveAt, now)}`)
-                : p.lastActiveAt === undefined ? 'is nearby · quiet'
-                    : p.activityCount > 0 ? `is nearby · ${formatRelativeTime(p.lastActiveAt, now)}` : `is nearby · quiet · ${formatRelativeTime(p.lastActiveAt, now)}`;
+            : p.presence === 'away' ? 'is away'
+                : p.presence === 'watching'
+                    ? (p.lastActiveAt === undefined ? 'is nearby · catching' : `is nearby · catching · ${formatRelativeTime(p.lastActiveAt, now)}`)
+                    : p.lastActiveAt === undefined ? 'is nearby · quiet'
+                        : p.activityCount > 0 ? `is nearby · ${formatRelativeTime(p.lastActiveAt, now)}` : `is nearby · quiet · ${formatRelativeTime(p.lastActiveAt, now)}`;
         return `  ${glyph === '○' ? style('dim', glyph) : glyph} ${participantIdentity(p.name)}${style('dim', ` ${text}`)}`;
     });
     const remaining = recent.length - shown.length;
@@ -229,37 +230,26 @@ function draftSavedLines(draftPath) {
 function withDraftInput(command, draftPath) {
     return draftPath === undefined ? command : `${command} < ${quoteShell(draftPath)}`;
 }
-function renderUnreadSummary(opts) {
-    const visibleSummaries = opts.activitySummaries.slice(0, MAX_IDENTITY_SET_SIZE);
-    const remainingSummaries = opts.activitySummaries.length - visibleSummaries.length;
+function renderUnreadSummary(activitySummaries) {
+    const visibleSummaries = activitySummaries.slice(0, MAX_IDENTITY_SET_SIZE);
+    const remainingSummaries = activitySummaries.length - visibleSummaries.length;
     return [
-        ...visibleSummaries.flatMap((item) => [
-            ...item.previews.slice(-1).map((preview) => {
-                const rendered = renderAmbientEvent(preview.act, opts.viewer, { actNumber: preview.number, perception: preview.perception });
-                if (rendered === '')
-                    return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago`);
-                if (preview.perception === 'presence') {
-                    return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago · ${rendered.replace(/\n/g, ' ')}`);
-                }
-                const compact = (preview.act.body ?? '').replace(/\s+/g, ' ').trim();
-                const bodyPreview = compact === ''
-                    ? { text: preview.act.metadata === undefined ? '(empty)' : '(structured activity)', remaining: 0 }
-                    : truncateChars(compact, UNREAD_PREVIEW_CHARS);
-                const bodyText = bodyPreview.remaining === 0 ? bodyPreview.text : `${bodyPreview.text}${style('dim', `… (+${bodyPreview.remaining} chars)`)}`;
-                return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago · "${bodyText}"`);
-            }),
-        ]),
+        ...visibleSummaries.map((item) => {
+            const compact = (item.preview.body ?? '').replace(/\s+/g, ' ').trim();
+            const bodyPreview = compact === ''
+                ? { text: item.preview.metadata === undefined ? '(empty)' : '(structured activity)', remaining: 0 }
+                : truncateChars(compact, UNREAD_PREVIEW_CHARS);
+            const bodyText = bodyPreview.remaining === 0 ? bodyPreview.text : `${bodyPreview.text}${style('dim', `… (+${bodyPreview.remaining} chars)`)}`;
+            return style('dim', `  · ${participantIdentity(item.name)} spoke — ${formatAge(item.latestActivityAgeMs)} ago · "${bodyText}"`);
+        }),
         ...(remainingSummaries === 0 ? [] : [style('dim', `  · ${remainingSummaries} more participants have unread activity`)]),
     ];
 }
-export function renderPendingFeed(publicItems, sayNumbers, perceptions, viewer) {
-    return publicItems.map((act) => renderAmbientEvent(act, viewer, { actNumber: sayNumbers[act.index], perception: perceptions[act.index] })).filter(Boolean).join('\n\n');
-}
 export function renderActivityBlocked(opts) {
-    const readNowCommand = `${participantCommandPrefix(opts.squarePath, opts.name)} catch`;
+    const readNowCommand = `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} catch`;
     return withPathOutput(opts.squarePath, [
         `${style('blocked', '✕')} your activity hasn't landed — someone spoke while you were away`,
-        ...renderUnreadSummary({ activitySummaries: opts.activitySummaries, viewer: opts.name }),
+        ...renderUnreadSummary(opts.activitySummaries),
         ...draftSavedLines(opts.draftPath),
         `${readNowCommand}`,
         '  · take it in, then retry:',
@@ -373,7 +363,7 @@ export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squa
 export function renderActivityLimit(opts) {
     // The cap wording lives inside the count: the speaker is simply spent.
     const spoken = opts.count !== undefined && opts.hardCap !== undefined ? ` — ${opts.count}/${opts.hardCap} spoken` : '';
-    const doneCommand = `${participantCommandPrefix(opts.squarePath, opts.name)} done`;
+    const doneCommand = `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} done`;
     return withPathOutput(opts.squarePath, [
         `${style('blocked', '✕')} you’ve reached your speaking cap${spoken}`,
         ...draftSavedLines(opts.draftPath),
@@ -386,7 +376,7 @@ export function renderWatchAlreadyActive(opts) {
         `${style('blocked', '✕')} you are already catching`,
         `  · an active catch is already running for ${participantIdentity(opts.name)}`,
         '  · --replace lets a new catch take over',
-        `${participantCommandPrefix(opts.squarePath, opts.name)} catch --idle 30m --replace`,
+        `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} catch --idle 30m --replace`,
     ].join('\n');
 }
 export function renderWatchForceTakeover(_opts) {
@@ -406,9 +396,9 @@ export function renderWatchStatus(opts) {
         ? ['', 'around the square', ...renderPresenceLines(others, opts.presence.now)]
         : [];
     switch (opts.status) {
-        case 'stale':
-        case 'empty-now': {
-            const prefix = participantCommandPrefix(opts.squarePath, opts.name);
+        case 'idle':
+        case 'drained': {
+            const prefix = participantCommandPrefix(opts.squarePath, opts.name, opts.owner);
             // Quiet graduates with the idle length; an empty catch has no idle budget to report.
             const idleMs = opts.idleMs;
             const quiet = idleMs !== undefined && idleMs >= 60 * 60 * 1000
@@ -425,12 +415,12 @@ export function renderWatchStatus(opts) {
             ].join('\n');
         }
         case 'quorum':
-            return [`${style('release', '✓')} everyone else has left — the square is yours alone`, `${participantCommandPrefix(opts.squarePath, opts.name)} done`].join('\n');
+            return [`${style('release', '✓')} everyone else has left — the square is yours alone`, `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} done`].join('\n');
         case 'capped': {
             const spoken = opts.hardCap === undefined || opts.hardCap === null
                 ? ''
                 : ` — ${opts.ownActivityCount ?? 0}/${opts.hardCap} spoken`;
-            return [`${style('blocked', '✕')} you’ve reached your speaking cap${spoken}`, `${participantCommandPrefix(opts.squarePath, opts.name)} done`].join('\n');
+            return [`${style('blocked', '✕')} you’ve reached your speaking cap${spoken}`, `${participantCommandPrefix(opts.squarePath, opts.name, opts.owner)} done`].join('\n');
         }
     }
 }

package/dist/runtime.d.ts

@@ -1,18 +1,12 @@
-import { type ActivityId } from './square-core.js';
-import { type StoredAct, type WatchLease } from './model.js';
+import { type WatchLease } from './model.js';
 import type { ParticipantCounts, ParticipantFact, SquareRead } from './ports.js';
 export declare const WATCH_HEARTBEAT_MS: number;
-export declare const SLEEP_MS: number;
-export declare const STALE_MS: number;
 export declare const WATCH_STALE_MS: number;
 export declare const THROTTLE_WINDOW_MS: number;
 export declare const UNREAD_BLOCK_GRACE_MS: number;
 export declare const HELD_WAIT_BUDGET_MS: number;
 export declare const FACT_PAGE_SIZE = 100;
-export declare function nowMs(): number;
-export declare function rosterNames(facts: SquareRead): string[];
 export declare function inSquareCount(facts: SquareRead): number;
-export declare function actId(actOrIndex: StoredAct | number): ActivityId;
 export declare function terminalStatusFor(current: ParticipantFact | undefined, hardCap: number | null, counts: ParticipantCounts): 'capped' | 'quorum' | undefined;
 export declare function watchTerminalStatus(facts: SquareRead, name: string): 'capped' | 'quorum' | undefined;
 /** A continuous prefix stops at the first unseen historical audience edge after join. */

package/dist/runtime.js

@@ -1,4 +1,3 @@
-import { formatActivityId } from './square-core.js';
 import { SquareError } from './model.js';
 function parseIntegerEnv(name, fallback) {
     const raw = process.env[name];
@@ -10,25 +9,12 @@ function parseIntegerEnv(name, fallback) {
     return value;
 }
 export const WATCH_HEARTBEAT_MS = parseIntegerEnv('SQUARE_WATCH_HEARTBEAT_MS', 60000);
-export const SLEEP_MS = parseIntegerEnv('SQUARE_WATCH_POLL_MS', 10000);
-export const STALE_MS = parseIntegerEnv('SQUARE_WATCH_QUIET_MS', 300000);
 export const WATCH_STALE_MS = parseIntegerEnv('SQUARE_WATCH_STALE_MS', 180000);
 export const THROTTLE_WINDOW_MS = parseIntegerEnv('SQUARE_THROTTLE_WINDOW_MS', 60000);
 export const UNREAD_BLOCK_GRACE_MS = parseIntegerEnv('SQUARE_UNREAD_BLOCK_GRACE_MS', 90000);
 export const HELD_WAIT_BUDGET_MS = parseIntegerEnv('SQUARE_HELD_WAIT_BUDGET_MS', 10 * 60 * 1000);
 export const FACT_PAGE_SIZE = 100;
-export function nowMs() {
-    const override = process.env.SQUARE_NOW_MS;
-    if (override === undefined)
-        return Date.now();
-    const value = parseInt(override, 10);
-    if (!Number.isFinite(value))
-        throw new SquareError('invalid_args', 'Invalid SQUARE_NOW_MS: expected integer milliseconds.');
-    return value;
-}
-export function rosterNames(facts) { return facts.roster().map((participant) => participant.name); }
 export function inSquareCount(facts) { return facts.participantCounts().joined; }
-export function actId(actOrIndex) { return formatActivityId(typeof actOrIndex === 'number' ? actOrIndex : actOrIndex.index); }
 export function terminalStatusFor(current, hardCap, counts) {
     if (hardCap !== null && (current?.sayCount ?? 0) >= hardCap)
         return 'capped';

package/dist/seats.d.ts

@@ -1,7 +1,6 @@
-import { type Body, type Seat } from './model.js';
+import { type Owner, type Seat } from './model.js';
 import type { ArtifactWriteAuthority, SeatRef } from './ports.js';
-export declare function requireBody(body: Body | undefined): Body;
+export declare function requireOwner(owner: Owner | undefined): Owner;
 export declare function requireJoinName(name: string | undefined): string;
 export declare function asSeatRef(seat: Seat): SeatRef;
 export declare function participantAuthority(seat: Seat): ArtifactWriteAuthority;
-export declare function requireSeat(seat: Seat | undefined, body: Body | undefined, participant: string): Seat;