@astrosheep/square 0.3.93 → 0.3.94

package/dist/operation-presentation.js

@@ -1,26 +1,24 @@
 // Human-facing text for one settled operation. The CLI and the MCP transport both
 // render through these functions, so a person sees the same square either way.
 import { sameName } from './model.js';
-import { formatActivityId, parseActivityId } from './square-core.js';
-import { commandPrefix, joinRecoveryCommand, participantCommandPrefix, participantIdentity, participantsRecoveryCommand, quoteShell, renderAmbientEvent, renderAmbientEventFacts, renderEventCli, renderGrepActivitiesView, renderPendingFeed, renderPresenceAnchor, renderRoomChangeText, renderWatchAlreadyActive, renderWatchReplaced, renderWatchStatus, takeoverRecoveryLines, withPathOutput, } from './presentation.js';
+import { formatActivityId } from './square-core.js';
+import { commandPrefix, joinRecoveryCommand, participantCommandPrefix, participantIdentity, participantsRecoveryCommand, quoteShell, renderAmbientEvent, renderAmbientEventFacts, renderEventCli, renderGrepActivitiesView, renderPresenceAnchor, renderRoomChangeText, renderWatchAlreadyActive, renderWatchReplaced, renderWatchStatus, takeoverRecoveryLines, withPathOutput, } from './presentation.js';
 import { formatRelativeTime, formatTimestamp } from './time.js';
 import { style } from './tty-style.js';
 export const PARTICIPANTS_DEFAULT_LIMIT = 20;
 export const PARTICIPANTS_MAX_LIMIT = 100;
 const STATUS_PARTICIPANT_PREVIEW_LIMIT = 10;
-export function renderJoinResult(data) {
+export function renderJoinResult(data, owner) {
     const after = data.observation;
     if (after === undefined)
         return undefined;
     const entry = after.entry;
     const name = typeof data.participant === 'string' ? data.participant : data.participant.name;
     const activities = (entry?.recentActivities ?? []).map((event) => renderAmbientEvent(event, name, {
-        now: after.now, preview: 200,
-        actNumber: event.kind === 'say' ? entry.sayNumbers[event.index] : undefined,
-        perception: entry.perceptions[event.index],
+        now: after.now, preview: 200, perception: event.perception,
     })).filter(Boolean).join('\n\n');
-    const fallback = after.automaticDeliveryAvailable ? ['', '· when someone calls you, you’ll hear them here'] : [
-        '', `${participantCommandPrefix(after.location, name)} catch --idle 30m`,
+    const fallback = after.deliveryAvailable ? ['', '· when someone calls you, you’ll hear them here'] : [
+        '', `${participantCommandPrefix(after.location, name, owner)} catch --idle 30m`,
         '  · stay within earshot — keep this catch open for new activity',
     ];
     const entryLine = data.kind === 'joined' ? '● you stepped into the square'
@@ -41,16 +39,18 @@ export function renderJoinResult(data) {
 function isGestureOnly(body) {
     return /\*[^*]*\*/.test(body) && body.replace(/\*[^*]*\*/g, '').trim() === '';
 }
-export function renderExpression(squarePath, data) {
+export function renderExpression(squarePath, data, owner) {
     const projection = data.observation;
     if (projection === undefined)
         return undefined;
     const name = projection.participant;
-    const pendingSpeaker = projection.pendingPublic[0]?.actor;
-    const pendingLead = pendingSpeaker === undefined ? ''
-        : `▲ while you spoke, ${participantIdentity(pendingSpeaker)} said something behind you\n\n`;
-    const pending = projection.pendingPublic.length === 0 ? ''
-        : `\n\n${pendingLead}${renderPendingFeed(projection.pendingPublic, projection.sayNumbers, projection.perceptions, name)}`;
+    const context = projection.context;
+    const pending = context.activities.length === 0 ? '' : '\n\n' + [
+        'Unread context · preview only, not consumed',
+        ...context.activities.map(item => `· ${participantIdentity(item.actor)} · ${item.id}\n  ${item.preview}${item.truncated ? '… (truncated)' : ''}`),
+        ...(context.remaining === 0 ? [] : [`· ${context.remaining} more unread activities`]),
+        `${participantCommandPrefix(projection.location, name, owner)} catch`,
+    ].join('\n');
     const ownCount = projection.ownActivityCount;
     const capCount = projection.hardCap === null ? '' : ` · ${ownCount}/${projection.hardCap}`;
     const activity = data.activity;
@@ -65,7 +65,7 @@ export function renderExpression(squarePath, data) {
         ? `\n  · ${data.unmatchedMentions.map((token) => `@${token} isn't standing here`).join('; ')} — ${activity.mentions.length === 0 && activity.reply === undefined ? 'activity landed bare' : 'left as literal text'}` : '';
     return withPathOutput(projection.location ?? squarePath, confirmation + (data.hint ? `\n${style('dim', `· ${data.hint}`)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount, held: projection.held });
 }
-function continuationCommand(squarePath, name, options) {
+function continuationCommand(squarePath, name, options, owner) {
     const args = ['--now'];
     if (options.from?.length)
         args.push('--from', options.from.join(','));
@@ -73,20 +73,20 @@ function continuationCommand(squarePath, name, options) {
         args.push('--mention');
     if (options.limit !== undefined)
         args.push('--limit', String(options.limit));
-    return `${participantCommandPrefix(squarePath, name)} catch ${args.join(' ')}`;
+    return `${participantCommandPrefix(squarePath, name, owner)} catch ${args.join(' ')}`;
 }
 /** Render settled catch facts; no selection, terminal decisions, receipts or wait machinery. */
-export function renderCatchOutcome(squarePath, data, options = {}) {
+export function renderCatchOutcome(squarePath, data, options = {}, owner) {
     const projection = data.observation;
     if (projection === undefined)
         return { stdout: '', exitCode: 0 };
     const location = projection.location ?? squarePath;
     const name = projection.participant;
-    const stop = projection.stop ?? data.status;
+    const stop = data.reason === 'drained' && data.activities.length > 0 ? undefined : data.reason;
     const header = { participantCount: projection.standingCount, held: projection.held };
     const statusOptions = {
-        squarePath: location, name, presence: projection.presence,
-        showCatchHint: !projection.automaticDeliveryAvailable,
+        squarePath: location, name, owner, presence: projection.presence,
+        showCatchHint: !projection.deliveryAvailable,
         ownActivityCount: projection.ownActivityCount, hardCap: projection.hardCap,
     };
     if (stop === 'already-active' || stop === 'replaced') {
@@ -97,17 +97,16 @@ export function renderCatchOutcome(squarePath, data, options = {}) {
         };
     }
     const rendered = data.activities.map((activity) => renderAmbientEvent(activity, name, {
-        now: projection.now, actNumber: projection.sayNumbers[parseActivityId(activity.id)],
-        perception: activity.perception, mention: options.mention ? name : undefined,
+        now: projection.now, perception: activity.perception, mention: options.mention ? name : undefined,
     })).filter(Boolean).join('\n\n');
     const remaining = data.remaining === 0 ? ''
-        : `· ${data.remaining} matching ${data.remaining === 1 ? 'activity remains' : 'activities remain'}\n${continuationCommand(location, name, options)}`;
+        : `· ${data.remaining} matching ${data.remaining === 1 ? 'activity remains' : 'activities remain'}\n${continuationCommand(location, name, options, owner)}`;
     const terminal = stop === undefined ? '' : renderWatchStatus({
         ...statusOptions, status: stop,
-        ...(stop === 'stale' && options.idle !== undefined ? { idleMs: options.idle } : {}),
+        ...(stop === 'idle' && options.idle !== undefined ? { idleMs: options.idle } : {}),
     });
-    const fallback = stop === undefined && !projection.automaticDeliveryAvailable && data.remaining === 0
-        ? `${participantCommandPrefix(location, name)} catch --idle 30m\n  stay available for new activity` : '';
+    const fallback = stop === undefined && !projection.deliveryAvailable && data.remaining === 0
+        ? `${participantCommandPrefix(location, name, owner)} catch --idle 30m\n  stay available for new activity` : '';
     const hint = data.hint === undefined ? '' : style('dim', `· ${data.hint}`);
     return {
         stdout: withPathOutput(location, [terminal, rendered, hint, remaining, fallback].filter(Boolean).join('\n\n'), header),
@@ -121,11 +120,7 @@ function renderHistoryProjection(projection, visible, noTruncate, squarePath) {
     // Presence anchors collect into one closing line instead of interrupting the page.
     const anchored = [];
     for (const activity of shown) {
-        const options = {
-            preview,
-            actNumber: activity.kind === 'say' ? projection.sayNumbers[activity.index] : undefined,
-        };
-        const rendered = renderEventCli(activity, options);
+        const rendered = renderEventCli(activity, { preview });
         if (rendered !== '')
             chunks.push(rendered);
         for (const participant of projection.presenceAnchors[activity.index] ?? []) {
@@ -193,8 +188,8 @@ export function renderParticipantsResult(squarePath, data, limit = PARTICIPANTS_
     const now = projection.now;
     const participants = data.participants;
     const lines = participants.slice(0, limit).map((participant) => {
-        const glyph = participant.state === 'done' ? '○' : participant.presence === 'watching' ? '◎' : participant.activityCount > 0 && projection.classificationByName[participant.name] === 'here' ? '●' : '○';
-        const state = participant.state === 'done' ? 'done' : participant.presence === 'watching' ? 'catching' : participant.state;
+        const glyph = participant.presence === 'done' ? '○' : participant.presence === 'watching' ? '◎' : participant.activityCount > 0 && projection.classificationByName[participant.name] === 'here' ? '●' : '○';
+        const state = participant.presence === 'watching' ? 'catching' : participant.presence === 'never-joined' ? 'not joined' : participant.presence;
         const last = participant.lastActiveAt === undefined ? '—' : formatRelativeTime(participant.lastActiveAt, now);
         return `  ${glyph} ${participant.name}${style('dim', ` · ${state} · ${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${last}`)}`;
     });
@@ -217,8 +212,9 @@ export function renderStatusResult(squarePath, data) {
     const participantsByName = new Map(data.participants.map((participant) => [participant.name, participant]));
     const orderedHere = presentation.orderedHereNames.map((name) => participantsByName.get(name));
     const lingering = presentation.lingeringCount;
+    const away = data.participants.filter(participant => participant.presence === 'away');
     const people = [];
-    if (data.activeCount === 0) {
+    if (presentation.standingCount === 0) {
         people.push('  ○ nobody in the square');
     }
     else {
@@ -243,7 +239,11 @@ export function renderStatusResult(squarePath, data) {
                         : 'caught up';
             return `  ${glyph} ${participantIdentity(participant.name)}${style('dim', ` ${summary}${attention === '' ? '' : ` · ${attention}`}`)}`;
         }));
-        const unshown = Math.max(0, orderedHere.length - STATUS_PARTICIPANT_PREVIEW_LIMIT) + lingering;
+        people.push(...away.slice(0, STATUS_PARTICIPANT_PREVIEW_LIMIT).map(participant => `  ○ ${participantIdentity(participant.name)}${style('dim', ' · away')}`));
+        if (away.length > STATUS_PARTICIPANT_PREVIEW_LIMIT)
+            people.push(`  ○ … ${away.length - STATUS_PARTICIPANT_PREVIEW_LIMIT} more away`);
+        const unshown = Math.max(0, orderedHere.length - STATUS_PARTICIPANT_PREVIEW_LIMIT)
+            + Math.max(0, away.length - STATUS_PARTICIPANT_PREVIEW_LIMIT) + lingering;
         if (orderedHere.length > STATUS_PARTICIPANT_PREVIEW_LIMIT) {
             people.push(`  ○ … ${orderedHere.length - STATUS_PARTICIPANT_PREVIEW_LIMIT} more here`);
         }
@@ -256,16 +256,16 @@ export function renderStatusResult(squarePath, data) {
         }
     }
     const cap = data.hardCap === null ? 'unlimited' : `${data.hardCap} each`;
-    const holdTime = data.hold?.at === undefined ? 'just now' : formatRelativeTime(data.hold.at, data.now);
-    const hold = data.hold !== null
-        ? `· ${data.hold.by === undefined ? 'someone' : participantIdentity(data.hold.by)} raised a hand${data.hold.reason ? ` — ${data.hold.reason}` : ''}${style('dim', ` · ${holdTime}`)}`
+    const held = data.held;
+    const holdTime = held?.at === undefined ? 'just now' : formatRelativeTime(held.at, data.now);
+    const hold = held !== null
+        ? `· ${held.by === undefined ? 'someone' : participantIdentity(held.by)} raised a hand${held.reason ? ` — ${held.reason}` : ''}${style('dim', ` · ${holdTime}`)}`
         : undefined;
     const visible = data.latestActivity === undefined
         ? { text: '', bodyClipped: false }
         : renderAmbientEventFacts(data.latestActivity, presentation.viewer, {
             now: data.now,
             preview: 200,
-            actNumber: presentation.latestActNumber,
             perception: presentation.latestPerception,
         });
     const latest = visible.text === ''
@@ -285,8 +285,9 @@ export function renderStatusResult(squarePath, data) {
     }
     const counts = [
         `${orderedHere.length} here`,
+        ...(away.length > 0 ? [`${away.length} away`] : []),
         ...(lingering > 0 ? [`${lingering} lingering`] : []),
-        `${data.doneCount} done`,
+        `${data.participants.filter((participant) => participant.presence === 'done').length} done`,
         `cap ${cap}`,
         `throttle ${data.throttlePerMinute === undefined ? 'none' : `${data.throttlePerMinute}/min`}`,
     ].join(' · ');
@@ -298,7 +299,7 @@ export function renderStatusResult(squarePath, data) {
             ...(data.listening.length === 0 ? ['  ○ not turned toward anyone'] : data.listening.map((name) => `  · ${participantIdentity(name)}`)),
         ]),
     ].join('\n');
-    return withPathOutput(squarePath, output, { participantCount: presentation.standingCount, held: presentation.held });
+    return withPathOutput(squarePath, output, { participantCount: presentation.standingCount, held: data.held !== null });
 }
 export function renderListeningResult(squarePath, data) {
     const projection = data.observation;
@@ -334,12 +335,12 @@ export function renderLifecycleResult(squarePath, verb, data) {
     if (verb === 'done') {
         return withPathOutput(projection.location ?? squarePath, `○ you stepped out — your footsteps fade · ${data.activity.id}`, header);
     }
-    const line = `${renderRoomChangeText(projection.activity)} · ${formatActivityId(projection.activity.index)} · just now`;
+    const line = `${renderRoomChangeText(data.activity)} · ${data.activity.id} · just now`;
     return withPathOutput(projection.location ?? squarePath, verb === 'hold' ? `· ${line}` : `✓ ${line}`, header);
 }
 /** Refusal lines with the same recovery commands the CLI prints. */
 export function renderFailureLines(failure, options = {}) {
-    const { squarePath, name } = options;
+    const { squarePath, name, owner } = options;
     const facts = failure.facts;
     const reason = facts?.reason;
     const marked = reason === 'never_joined' || reason === 'not_standing';
@@ -350,13 +351,17 @@ export function renderFailureLines(failure, options = {}) {
         else if (squarePath !== undefined)
             lines.push(`${commandPrefix(squarePath)} migrate`);
     }
+    else if (squarePath !== undefined && name !== undefined && reason === 'needs_seat') {
+        lines.splice(0, 1, `✕ ${failure.message}`);
+        lines.push(joinRecoveryCommand(squarePath, name, owner));
+    }
     else if (squarePath !== undefined && name !== undefined && failure.code === 'already_joined') {
         lines.splice(0, 1, `✕ ${participantIdentity(name)} shoos you out of the square`, `  · ${participantIdentity(name)} already stands here — another session holds the name`);
-        lines.push(...takeoverRecoveryLines(squarePath, name));
+        lines.push(...takeoverRecoveryLines(squarePath, name, owner));
     }
     else if (squarePath !== undefined && reason === 'never_joined') {
         lines.push(failure.operation?.subject !== 'filter' && name !== undefined
-            ? joinRecoveryCommand(squarePath, name) : participantsRecoveryCommand(squarePath));
+            ? joinRecoveryCommand(squarePath, name, owner) : participantsRecoveryCommand(squarePath));
     }
     else if (squarePath !== undefined && reason === 'not_standing') {
         lines.push(participantsRecoveryCommand(squarePath));

package/dist/owner.d.ts

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

package/dist/owner.js

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

package/dist/paseo-delivery.d.ts

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

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;