@astrosheep/square 0.3.93 → 0.3.95

package/dist/presentation.js

@@ -4,7 +4,6 @@ import path from 'node:path';
 import { participantIdentity } from './participant-identity.js';
 export { participantIdentity } from './participant-identity.js';
 import { formatActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
-import { HELD_WAIT_BUDGET_MS } from './runtime.js';
 import { formatDuration, formatRelativeTime, formatTimestamp } from './time.js';
 import { grepSnippet } from './search.js';
 import { style } from './tty-style.js';
@@ -27,8 +26,7 @@ export function displayPath(squarePath, cwd = process.cwd()) {
 }
 export function withPathOutput(squarePath, body = '', opts = {}) {
     const count = opts.participantCount ?? 0;
-    const heldSuffix = opts.held ? ' — a hand is raised' : '';
-    const line = `· ${displayPath(squarePath)} — ${count} in the square${heldSuffix}`;
+    const line = `· ${displayPath(squarePath)} — ${count} in the square`;
     return [opts.plain === true ? line : style('dim', line), ...(body === '' ? [] : ['', body])].join('\n') + '\n';
 }
 /** The same header/blank/body layout as withPathOutput, for refusal bodies written to stderr. */
@@ -50,18 +48,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 +77,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;
@@ -122,10 +121,6 @@ export function renderRoomChangeText(event) {
             return `${identity} stepped into the square`;
         case 'done':
             return `${identity} stepped out of the square`;
-        case 'hold':
-            return `${identity} raised a hand${event.body ? ` — ${event.body}` : ''}`;
-        case 'resume':
-            return `${identity} lowered the hand`;
         case 'listen':
             return `${identity} turned an ear toward ${participantIdentity(event.target ?? 'someone')}`;
         case 'ignore':
@@ -158,10 +153,6 @@ function renderEventCliFacts(event, opts = {}) {
     switch (event.kind) {
         case 'join':
             return { text: `· ${renderRoomChangeText(event)}`, bodyClipped: false };
-        case 'hold':
-            return { text: `· ${renderRoomChangeText(event)}`, bodyClipped: false };
-        case 'resume':
-            return { text: `${style('release', '✓')} ${renderRoomChangeText(event)}`, bodyClipped: false };
         case 'listen':
         case 'ignore':
         case 'unlisten':
@@ -229,42 +220,31 @@ 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:',
         withDraftInput(opts.retryCommand, opts.draftPath),
-    ].join('\n'), { participantCount: opts.participantCount, held: opts.held });
+    ].join('\n'), { participantCount: opts.participantCount });
 }
 /** An indeterminate or already-committed send only points to inspection, never resend. */
 export function renderActivityUncertain(opts) {
@@ -278,47 +258,22 @@ export function renderActivityUncertain(opts) {
         `${commandPrefix(opts.squarePath)} history${opts.landedId === undefined ? ' --limit 10' : ` --at ${opts.landedId}`} --no-truncate`,
     ], opts);
 }
-/** A blank or whitespace hold reason is absent, never an empty sensory line. */
-function holdReasonLines(reason) {
-    const text = reason?.trim() ?? '';
-    return text === '' ? [] : [style('dim', `  · ${text}`)];
-}
-function heldMainLine(holder, styled) {
-    const glyph = styled ? style('blocked', '✕') : '·';
-    const who = holder === undefined ? 'a hand is raised' : `${participantIdentity(holder)} has a hand raised`;
-    return `${glyph} ${who} — voices drop, yours too`;
-}
 export function renderExpressWaiting(opts) {
-    if (opts.reason === 'throttled') {
-        return [
-            '· the square is packed — your activity is waiting',
-            `  · a lull opens in ${formatDuration(opts.delayMs)}`,
-            '  · --no-wait saves a draft and returns now',
-        ].join('\n');
-    }
     return [
-        heldMainLine(opts.holder, false),
-        ...holdReasonLines(opts.holdReason),
-        `  · your activity is waiting — after ${formatDuration(HELD_WAIT_BUDGET_MS)} it saves a draft and stops`,
+        '· the square is packed — your activity is waiting',
+        `  · a lull opens in ${formatDuration(opts.delayMs)}`,
         '  · --no-wait saves a draft and returns now',
     ].join('\n');
 }
 export function renderExpressNoWait(opts) {
     const retryCommand = opts.retryCommand;
-    const lines = opts.reason === 'throttled'
-        ? [
-            `${style('blocked', '✕')} the square is packed — shoulder to shoulder`,
-            `  · a lull opens in ${formatDuration(opts.delayMs)}`,
-            ...draftSavedLines(opts.draftPath),
-            `${withDraftInput(retryCommand, opts.draftPath)}`,
-        ]
-        : [
-            heldMainLine(opts.holder, true),
-            ...holdReasonLines(opts.holdReason),
-            ...draftSavedLines(opts.draftPath),
-            `${withDraftInput(retryCommand, opts.draftPath)}`,
-        ];
-    return withPathOutput(opts.squarePath, lines.join('\n'), { participantCount: opts.participantCount, held: opts.held });
+    const lines = [
+        `${style('blocked', '✕')} the square is packed — shoulder to shoulder`,
+        `  · a lull opens in ${formatDuration(opts.delayMs)}`,
+        ...draftSavedLines(opts.draftPath),
+        `${withDraftInput(retryCommand, opts.draftPath)}`,
+    ];
+    return withPathOutput(opts.squarePath, lines.join('\n'), { participantCount: opts.participantCount });
 }
 export function renderPresenceAnchor(names) {
     const visibleNames = names.slice(0, MAX_IDENTITY_SET_SIZE);
@@ -337,7 +292,7 @@ export function renderGrepActivitiesView(visible, totalMatches, noTruncate, squa
     let truncated = false;
     for (const act of publicVisible) {
         const rawBody = act.body ?? '';
-        const header = `${style('dim', formatActivityId(act.index))} · ${act.actor === undefined ? 'unknown' : participantIdentity(act.actor)} · ${style('dim', formatTimestamp(act.at))}`;
+        const header = `${style('dim', formatActivityId(act.index))} · ${participantIdentity(act.actor)} · ${style('dim', formatTimestamp(act.at))}`;
         if (perception?.(act) === 'presence') {
             chunks.push(header);
             continue;
@@ -373,20 +328,20 @@ 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),
         '  · your draft stays unsent; done only steps out',
         doneCommand,
-    ].join('\n'), { participantCount: opts.participantCount, held: opts.held });
+    ].join('\n'), { participantCount: opts.participantCount });
 }
 export function renderWatchAlreadyActive(opts) {
     return [
         `${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 +361,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 +380,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/receive.d.ts

@@ -0,0 +1,66 @@
+/** Synchronous capabilities borrowed from one caller-owned transaction. */
+export interface Item<K extends string | number, D> {
+    readonly key: K;
+    readonly data: D;
+}
+export interface Address<V> {
+    readonly recipient: string;
+    readonly via: V;
+}
+export interface ReceivedHead<K extends string | number, V> {
+    readonly key: K;
+    readonly via: V;
+}
+export interface ReceiptRef<K extends string | number> {
+    readonly recipient: string;
+    readonly item: K;
+}
+export type Selection<K extends string | number, Q> = {
+    readonly kind: 'page';
+    readonly query: Q;
+    readonly limit: number;
+} | {
+    readonly kind: 'exact';
+    readonly key: K;
+    readonly remainingQuery: Q;
+};
+export interface ReceiveRead<K extends string | number, D, V, Q> {
+    heads(recipient: string, query: Q, options: {
+        readonly unconsumed: boolean;
+        readonly limit: number;
+    }): readonly ReceivedHead<K, V>[];
+    addressed(recipient: string, item: K): ReceivedHead<K, V> | undefined;
+    load(keys: readonly K[]): ReadonlyMap<K, D>;
+    count(recipient: string, query: Q, unconsumed: boolean): number;
+    receipt(ref: ReceiptRef<K>): {
+        readonly at: number;
+    } | undefined;
+}
+export interface ReceiveWrite<K extends string | number, D, V, Q> extends ReceiveRead<K, D, V, Q> {
+    insertItem(item: Item<K, D>): void;
+    insertAddress(item: K, address: Address<V>, order: number): void;
+    /** True only for a new coordinate; an existing receipt retains its first timestamp. */
+    insertReceipt(ref: ReceiptRef<K>, at: number): boolean;
+}
+export declare class ReceiveError<K extends string | number = string | number> extends Error {
+    readonly code: 'not_addressed' | 'missing_item';
+    readonly key: K;
+    constructor(code: 'not_addressed' | 'missing_item', key: K);
+}
+/** Storage rejects duplicate items/addresses; the caller rolls back the whole admission. */
+export declare function receive<K extends string | number, D, V>(tx: Pick<ReceiveWrite<K, D, V, unknown>, 'insertItem' | 'insertAddress'>, input: {
+    readonly item: Item<K, D>;
+    readonly audience: readonly Address<V>[];
+}): void;
+/** Queries filter before limiting. Exact selection ignores consumption, not addressing. */
+export declare function selectReceivedHeads<K extends string | number, V, Q>(tx: Pick<ReceiveRead<K, unknown, V, Q>, 'heads' | 'addressed'>, recipient: string, selection: Selection<K, Q>): readonly ReceivedHead<K, V>[];
+/** Record captured coordinates without reselecting or checking their current eligibility. */
+export declare function recordConsumed<K extends string | number>(tx: Pick<ReceiveWrite<K, unknown, unknown, unknown>, 'insertReceipt'>, refs: readonly ReceiptRef<K>[], at: number): number;
+/** Selection, hydration, receipts and remaining count must share the caller's transaction. */
+export declare function consumeReceived<K extends string | number, D, V, Q>(tx: Pick<ReceiveWrite<K, D, V, Q>, 'heads' | 'addressed' | 'load' | 'insertReceipt' | 'count'>, recipient: string, selection: Selection<K, Q>, at: number): {
+    readonly items: readonly (Item<K, D> & {
+        readonly via: V;
+    })[];
+    readonly newlyConsumed: number;
+    readonly remaining: number;
+};

package/dist/receive.js

@@ -0,0 +1,54 @@
+export class ReceiveError extends Error {
+    code;
+    key;
+    constructor(code, key) {
+        super(`${code}: ${String(key)}`);
+        this.code = code;
+        this.key = key;
+        this.name = 'ReceiveError';
+    }
+}
+/** Storage rejects duplicate items/addresses; the caller rolls back the whole admission. */
+export function receive(tx, input) {
+    tx.insertItem(input.item);
+    input.audience.forEach((address, order) => tx.insertAddress(input.item.key, address, order));
+}
+/** Queries filter before limiting. Exact selection ignores consumption, not addressing. */
+export function selectReceivedHeads(tx, recipient, selection) {
+    if (selection.kind === 'page') {
+        if (typeof selection.limit !== 'number')
+            throw new TypeError('Receive limit must be a number.');
+        if (!Number.isSafeInteger(selection.limit) || selection.limit < 1)
+            throw new RangeError('Receive limit must be a positive safe integer.');
+        return tx.heads(recipient, selection.query, { unconsumed: true, limit: selection.limit });
+    }
+    const head = tx.addressed(recipient, selection.key);
+    if (head === undefined)
+        throw new ReceiveError('not_addressed', selection.key);
+    return [head];
+}
+/** Record captured coordinates without reselecting or checking their current eligibility. */
+export function recordConsumed(tx, refs, at) {
+    if (typeof at !== 'number')
+        throw new TypeError('Receipt time must be a number.');
+    if (!Number.isFinite(at))
+        throw new RangeError('Receipt time must be finite.');
+    let count = 0;
+    for (const ref of refs)
+        if (tx.insertReceipt(ref, at))
+            count++;
+    return count;
+}
+/** Selection, hydration, receipts and remaining count must share the caller's transaction. */
+export function consumeReceived(tx, recipient, selection, at) {
+    const heads = selectReceivedHeads(tx, recipient, selection);
+    const data = tx.load(heads.map(head => head.key));
+    const items = heads.map(head => {
+        if (!data.has(head.key))
+            throw new ReceiveError('missing_item', head.key);
+        return { key: head.key, data: data.get(head.key), via: head.via };
+    });
+    const newlyConsumed = recordConsumed(tx, heads.map(head => ({ recipient, item: head.key })), at);
+    const remaining = tx.count(recipient, selection.kind === 'page' ? selection.query : selection.remainingQuery, true);
+    return { items, newlyConsumed, remaining };
+}

package/dist/runtime.d.ts

@@ -1,18 +1,11 @@
-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,11 @@ 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';
@@ -47,8 +32,8 @@ export function readCursor(facts, name) {
     const boundary = facts.participant(name)?.lastJoinIndex ?? -1;
     const block = facts.directed(name, { afterIndex: boundary, unseenOnly: true }, { edge: 'oldest', limit: 1 }).items[0]?.index;
     const last = facts.activityHeads({
-        afterIndex: boundary, ...(block === undefined ? {} : { beforeIndex: block }), actorRequired: true,
-        kinds: ['join', 'done', 'say', 'hold', 'resume', 'listen', 'ignore', 'unlisten'],
+        afterIndex: boundary, ...(block === undefined ? {} : { beforeIndex: block }),
+        kinds: ['join', 'done', 'say', 'listen', 'ignore', 'unlisten'],
     }, { edge: 'newest', limit: 1 }).items[0]?.index;
     return Math.max(boundary, last ?? boundary);
 }

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;

package/dist/seats.js

@@ -1,9 +1,9 @@
-import { SquareError, sameBody, sameName, validateBody, validateName } from './model.js';
-export function requireBody(body) {
-    if (body === undefined)
-        throw new SquareError('invalid_args', 'Participant writes require an explicit body: channel and session.');
-    validateBody(body);
-    return body;
+import { SquareError, validateOwner, validateName } from './model.js';
+export function requireOwner(owner) {
+    if (owner === undefined)
+        throw new SquareError('invalid_args', 'Participant writes require an explicit owner.');
+    validateOwner(owner);
+    return owner;
 }
 export function requireJoinName(name) {
     if (name === undefined)
@@ -12,16 +12,8 @@ export function requireJoinName(name) {
     return name;
 }
 export function asSeatRef(seat) {
-    const { wakeAddress: _wakeAddress, ...ref } = seat;
-    return ref;
+    return { participant: seat.participant, owner: seat.owner, generation: seat.generation };
 }
 export function participantAuthority(seat) {
     return { kind: 'participant', seat: asSeatRef(seat) };
 }
-export function requireSeat(seat, body, participant) {
-    if (seat === undefined || !sameName(seat.participant, participant))
-        throw new SquareError('already_joined', `${participant} needs a current participant handle; join first`);
-    if (!sameBody(seat.body, requireBody(body)))
-        throw new SquareError('already_joined', `${participant} is not held by this body`);
-    return seat;
-}

package/dist/session-lifecycle.d.ts

@@ -1,3 +1,7 @@
+import { type Owner } from './owner.js';
 import type { AutomaticProvider } from './participant-identity.js';
-/** Retire only seats held by this exact body, discovered through the rebuildable index. */
-export declare function endSessionMemberships(provider: AutomaticProvider, sessionId: string, env?: NodeJS.ProcessEnv): Promise<void>;
+import type { WakeAddress } from './model.js';
+/** Host shutdown suspends execution, not membership. Discovery never grants custody. */
+export declare function detachSessionSeats(provider: AutomaticProvider, sessionId: string, env?: NodeJS.ProcessEnv): Promise<void>;
+/** Restore only detached, standing seats of this exact owner before starting a receiver. */
+export declare function restoreSessionSeats(owner: Owner, env?: NodeJS.ProcessEnv, wakeAddress?: WakeAddress, signal?: AbortSignal): Promise<void>;

package/dist/session-lifecycle.js

@@ -1,19 +1,47 @@
 import { Square } from './square-api.js';
-import { projectSessionSeats } from './inbox.js';
-function bodyFor(provider, sessionId) {
-    return { channel: provider === 'claude' ? 'claude-code' : provider, session: sessionId };
+import { harnessOwner } from './owner.js';
+import { projectSessionCandidates, projectSessionSeats } from './inbox.js';
+function ownerFor(provider, sessionId) {
+    return harnessOwner({ channel: provider === 'claude' ? 'claude-code' : provider, session: sessionId });
 }
-/** Retire only seats held by this exact body, discovered through the rebuildable index. */
-export async function endSessionMemberships(provider, sessionId, env = process.env) {
-    const body = bodyFor(provider, sessionId);
-    const seats = await projectSessionSeats({ body, env });
-    for (const { location, seat } of seats) {
-        const square = await Square.at({ path: location, env, body, participant: seat.participant });
+/** Host shutdown suspends execution, not membership. Discovery never grants custody. */
+export async function detachSessionSeats(provider, sessionId, env = process.env) {
+    const owner = ownerFor(provider, sessionId);
+    for (const { location, seat } of await projectSessionSeats({ owner, env })) {
+        let square;
         try {
-            await square.endOwnedSession(seat.participant, sessionId, seat.generation, body);
+            square = await Square.at({ path: location, env });
+            await square.detach(seat.participant, { owner, generation: seat.generation });
         }
+        catch { /* One unavailable or replaced seat must not block cleanup of the others. */ }
         finally {
-            await square.close();
+            await square?.close();
+        }
+    }
+}
+/** Restore only detached, standing seats of this exact owner before starting a receiver. */
+export async function restoreSessionSeats(owner, env = process.env, wakeAddress, signal) {
+    const locations = new Set((await projectSessionCandidates({ owner, env })).map(candidate => candidate.location));
+    for (const location of locations) {
+        if (signal?.aborted)
+            return;
+        let square;
+        try {
+            square = await Square.at({ path: location, env }, { signal });
+            for (const seat of await square.seatsOf(owner)) {
+                if (signal?.aborted)
+                    return;
+                if (seat.attachment !== 'detached')
+                    continue;
+                try {
+                    await square.reattach(seat.name, { owner, wakeAddress }, { signal });
+                }
+                catch { /* A replacement or one failed seat does not block its peers. */ }
+            }
+        }
+        catch { /* An indexed location is only a candidate, not a promise of availability. */ }
+        finally {
+            await square?.close();
         }
     }
 }