@astrosheep/square 0.3.92 → 0.3.94

package/dist/activity-feed.d.ts

@@ -1,6 +1,4 @@
 import type { SquareRead } from './ports.js';
-import type { StoredAct } from './model.js';
-/** Directed suffix includes seen rows beyond an earlier hole, unlike notification pending. */
-export declare function directedSuffix(facts: SquareRead, name: string): Extract<StoredAct, {
-    kind: 'say';
-}>[];
+import type { ExpressContext } from './square-facade.js';
+/** A bounded, nonconsuming glimpse; seen rows beyond a cursor hole must not reappear. */
+export declare function expressionContext(facts: SquareRead, name: string): ExpressContext;

package/dist/activity-feed.js

@@ -1,15 +1,17 @@
-import { readCursor } from './runtime.js';
-/** Directed suffix includes seen rows beyond an earlier hole, unlike notification pending. */
-export function directedSuffix(facts, name) {
-    const result = [];
-    let afterIndex = readCursor(facts, name);
-    while (true) {
-        const page = facts.directed(name, { afterIndex }, { edge: 'oldest', limit: 100 });
-        for (const act of facts.activities(page.items.map((head) => head.index)))
-            if (act.kind === 'say')
-                result.push(act);
-        if (!page.hasMore)
-            return result;
-        afterIndex = page.items.at(-1).index;
-    }
+import { formatActivityId } from './square-core.js';
+const CONTEXT_LIMIT = 5;
+const PREVIEW_CHARS = 400;
+/** A bounded, nonconsuming glimpse; seen rows beyond a cursor hole must not reappear. */
+export function expressionContext(facts, name) {
+    const filter = { afterIndex: facts.participant(name)?.lastJoinIndex ?? -1, unseenOnly: true };
+    const page = facts.directed(name, filter, { edge: 'newest', limit: CONTEXT_LIMIT });
+    const activities = facts.activities(page.items.map(head => head.index)).filter(act => act.kind === 'say')
+        .sort((a, b) => a.index - b.index).map(act => {
+        const body = act.body ?? '(structured activity)';
+        // Keep the boundary between Unicode code points, including non-BMP characters.
+        const chars = Array.from(body.slice(0, PREVIEW_CHARS * 2));
+        const preview = chars.slice(0, PREVIEW_CHARS).join('');
+        return { id: formatActivityId(act.index), actor: act.actor, preview, truncated: preview.length < body.length };
+    });
+    return { activities, remaining: Math.max(0, facts.directedCount(name, filter) - activities.length) };
 }

package/dist/artifact.js

@@ -120,10 +120,10 @@ const readMethods = [
     'header', 'participant', 'roster', 'attention', 'incomingAttention', 'hold',
     'activity', 'activityHeads', 'activities', 'activityCount', 'contextIndexes', 'sayOrdinals', 'recentSayTimes',
     'audience', 'directed', 'directedAt', 'directedCount', 'pendingAudience',
-    'receipt', 'receiptFacts', 'receiptAssignments', 'lease', 'participantCounts', 'seat', 'seatsForBody', 'completedSeatsForBody',
+    'receipt', 'receiptFacts', 'receiptAssignments', 'lease', 'participantCounts', 'seat', 'seatsForOwner',
     'deliveryEvidence', 'deliveryByToken', 'cancelledThrough', 'deliveryDeferrals',
 ];
-const writeMethods = ['applyLanding', 'markSeen', 'putLease', 'removeLease', 'storeSeat', 'removeSeat', 'updateWakeAddress', 'cancelThrough', 'claimDelivery', 'prepareDelivery', 'completeDelivery', 'observeNativeDelivery', 'putDeliveryDeferral', 'renewDeliveryDeferral', 'releaseDeliveryDeferral'];
+const writeMethods = ['applyLanding', 'markSeen', 'putLease', 'removeLease', 'storeSeat', 'removeSeat', 'updateWakeAddress', 'reattachSeat', 'detachSeat', 'cancelThrough', 'claimDelivery', 'prepareDelivery', 'completeDelivery', 'observeNativeDelivery', 'putDeliveryDeferral', 'renewDeliveryDeferral', 'releaseDeliveryDeferral'];
 /** One connection, ordered operations, guarded synchronous transaction capabilities. */
 export function createArtifactPort(location, initial, externalSignal) {
     let database;

package/dist/boundary-presentation.d.ts

@@ -1,5 +1,5 @@
 import { pendingAtBoundary } from './inbox.js';
-import type { Body, PendingMembership } from './model.js';
+import type { Owner, PendingMembership } from './model.js';
 export { pendingAtBoundary };
 export declare function renderPendingAtBoundary(inbox: PendingMembership[]): string;
 /**
@@ -11,4 +11,4 @@ export declare function renderPendingAtBoundary(inbox: PendingMembership[]): str
  * after success, captured-seat commits record only its included items without an eligibility veto.
  * A source that cannot verify its reuse must read the inbox again.
  */
-export declare function presentPendingAtBoundary<T>(identity: Body, present: (context: string) => T | Promise<T>, lookup?: (identity: Body, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<PendingMembership[]> | PendingMembership[], env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<T | undefined>;
+export declare function presentPendingAtBoundary<T>(identity: Owner, present: (context: string) => T | Promise<T>, lookup?: (identity: Owner, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<PendingMembership[]> | PendingMembership[], env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<T | undefined>;

package/dist/catch-decisions.d.ts

@@ -1,19 +1,17 @@
-import { type ActivityId } from './square-core.js';
 import { type StoredAct } from './model.js';
 import type { ActivityIndex, DirectedFilter, SquareRead, SquareWrite } from './ports.js';
-import type { CatchOptions } from './square-facade.js';
+import type { CatchOptions, CatchReason, PerceivedActivity } from './square-facade.js';
 export interface CatchSelection {
     readonly participant: string;
-    readonly activities: readonly StoredAct[];
-    readonly consumedThrough: ActivityId | null;
+    readonly activities: readonly PerceivedActivity[];
     readonly remaining: number;
-    readonly sayNumbers: Readonly<Record<number, number>>;
     readonly standingCount: number;
     readonly held: boolean;
+    readonly deliveryAvailable: boolean;
     readonly now: number;
     readonly ownActivityCount: number;
     readonly hardCap: number | null;
-    readonly terminalStatus: 'capped' | 'quorum' | undefined;
+    readonly terminalStatus: Extract<CatchReason, 'capped' | 'quorum'> | undefined;
     readonly hint?: string;
 }
 /** Capture a selected page (or an empty completion) without opening another resource. */

package/dist/catch-decisions.js

@@ -1,19 +1,19 @@
 import { formatActivityId, parseActivityId } from './square-core.js';
-import { readCursor, terminalStatusFor } from './runtime.js';
+import { terminalStatusFor } from './runtime.js';
 import { SquareError } from './model.js';
 import { resolveKnownName } from './decisions.js';
+import { toPerceivedActivity } from './views.js';
 import { catchHint } from './hints.js';
 /** Capture a selected page (or an empty completion) without opening another resource. */
 export function observeCatchSelection(facts, participant, activities, filter, at) {
     if (typeof at !== 'number' || !Number.isFinite(at))
         throw new SquareError('invalid_args', 'Catch time must be a finite number.');
-    const cursor = readCursor(facts, participant);
     const counts = facts.participantCounts(), header = facts.header(), current = facts.participant(participant);
     return {
-        participant, activities, consumedThrough: cursor < 0 ? null : formatActivityId(cursor),
+        participant, activities: activities.map(activity => toPerceivedActivity(facts, activity, participant)),
         remaining: facts.directedCount(participant, filter),
-        sayNumbers: activities.length === 0 ? {} : facts.sayOrdinals(activities.map((item) => item.index)),
         standingCount: counts.joined, held: facts.hold().active, now: at,
+        deliveryAvailable: facts.seat(participant)?.wakeAddress !== undefined,
         ownActivityCount: current.sayCount, hardCap: header.hardCap,
         terminalStatus: terminalStatusFor(current, header.hardCap, counts),
     };

package/dist/claude-delivery-status.js

@@ -1,4 +1,5 @@
 import { createArtifactPort } from './artifact.js';
+import { decodeHarnessOwner } from './owner.js';
 import { indexedSquareEntries } from './square-index.js';
 const holdReasons = new Set(['explicit-setting', 'managed-setting', 'repo-setting', 'invalid-setting', 'bypass-default', 'mode-unknown', 'mode-mismatch', 'no-mode-asserted']);
 const dropReasons = new Set(['expired', 'refused', 'dropped', 'discarded']);
@@ -13,12 +14,17 @@ export async function recordClaudeDeliveryStatus(input, env = process.env) {
         || (input.state === 'held' ? !holdReasons.has(input.reason ?? '')
             : input.state === 'dropped' ? !dropReasons.has(input.reason ?? '') : input.reason !== undefined))
         return false;
-    for (const entry of await indexedSquareEntries({ channel: 'claude-code', session: input.sessionId }, env)) {
-        const artifact = createArtifactPort(entry.location);
+    const paths = new Set((await indexedSquareEntries({}, env)).filter(entry => {
+        const coordinate = decodeHarnessOwner(entry.owner);
+        return coordinate?.channel === 'claude-code' && coordinate.session === input.sessionId;
+    }).map(entry => entry.location));
+    for (const location of paths) {
+        const artifact = createArtifactPort(location);
         try {
             const { value: match } = await artifact.read((facts) => facts.roster().flatMap((participant) => {
                 const seat = facts.seat(participant.name);
-                if (seat === undefined || seat.body.session !== input.sessionId || seat.body.channel !== 'claude-code')
+                if (seat === undefined || seat.attachment !== 'attached' || seat.wakeAddress?.kind !== 'claude-native'
+                    || seat.wakeAddress.address.sessionId !== input.sessionId)
                     return [];
                 const evidence = facts.deliveryEvidence(seat.participant, seat.generation).find((row) => row.correlation?.harness === 'claude' && row.correlation.messageId === input.messageId && row.claimToken !== undefined);
                 return evidence === undefined ? [] : [{ seat, evidence }];
@@ -26,7 +32,7 @@ export async function recordClaudeDeliveryStatus(input, env = process.env) {
             if (match.length === 0)
                 continue;
             const { seat, evidence } = match[0];
-            const ref = { participant: seat.participant, body: seat.body, generation: seat.generation };
+            const ref = { participant: seat.participant, owner: seat.owner, generation: seat.generation };
             return (await artifact.transactAs({ kind: 'participant', seat: ref }, (facts) => facts.observeNativeDelivery({ seat: ref, claimToken: evidence.claimToken, observation: {
                     eventId: input.eventId, messageId: input.messageId, state: input.state,
                     ...(input.reason === undefined ? {} : { reason: input.reason }), observedAt: input.observedAt,

package/dist/claude-delivery.js

@@ -2,9 +2,10 @@ import { stat } from 'node:fs/promises';
 import { createHash, randomUUID } from 'node:crypto';
 import { createArtifactPort } from './artifact.js';
 import { presentPending } from './presentation-operations.js';
-import { projectSessionCandidates, nativePendingPreview } from './inbox.js';
-import { sameBody } from './model.js';
+import { nativePendingPreview } from './inbox.js';
 import { parseActivityId } from './square-core.js';
+import { decodeHarnessOwner } from './owner.js';
+import { indexedSquareEntries } from './square-index.js';
 import { asSeatRef } from './seats.js';
 import { writeClaudeNative } from './packages/agent-delivery/src/claude-native.js';
 const marker = /(?:^|\n)\[square-inbox:([a-zA-Z0-9-]+)\](?:\n|$)/g;
@@ -22,8 +23,9 @@ function previewFacts(facts, request) {
     const index = parseActivityId(request.activity);
     if (index === undefined || request.route.kind !== 'claude-native' || request.route.address.endpoint === undefined)
         return undefined;
-    return nativePendingPreview(facts, { location: request.location, routeKind: 'claude-native', sessionId: request.route.sessionId,
-        participant: request.participant, actIndex: index, address: { endpoint: request.route.address.endpoint }, now: Date.now() });
+    return nativePendingPreview(facts, { location: request.location, routeKind: 'claude-native', generation: request.seat.generation,
+        address: request.route.address,
+        participant: request.participant, actIndex: index, now: Date.now() });
 }
 async function preview(artifact, request) {
     return (await artifact.read((facts) => previewFacts(facts, request))).value;
@@ -31,7 +33,7 @@ async function preview(artifact, request) {
 async function writeClaudeWake(sessionId, endpoint, messageId, payload, timeoutMs, signal) {
     const result = await writeClaudeNative({ sessionId, endpoint, messageId }, payload, { deadline: Date.now() + timeoutMs, signal });
     if (result.outcome === 'unavailable')
-        return { outcome: 'failed', unavailable: true, retainRoute: true, signature: 'claude_endpoint_unavailable', message: result.message };
+        return { outcome: 'failed', signature: 'claude_endpoint_unavailable', message: result.message };
     return { outcome: 'unknown', signature: 'native_admission_unconfirmed', message: result.outcome === 'written' ? 'Claude accepted the local write; native admission is unconfirmed.' : result.message };
 }
 export function createClaudeWakeTransport(env = process.env) {
@@ -69,13 +71,15 @@ async function dispatchClaude(request, timeoutMs, beforeSend, env = process.env)
         return { outcome: 'not-capable', diagnostic: 'Claude activity changed before native write.' };
     if (signal.aborted || !await beforeSend())
         return { outcome: 'not-capable', diagnostic: 'Claude activity was consumed before native write.' };
-    return writeClaudeWake(request.route.sessionId, request.route.address.endpoint, messageId, payload, timeoutMs, signal);
+    const sessionId = request.route.address.sessionId;
+    if (sessionId === undefined)
+        return { outcome: 'not-capable', diagnostic: 'Claude native route has no session address.' };
+    return writeClaudeWake(sessionId, request.route.address.endpoint, messageId, payload, timeoutMs, signal);
 }
 function currentPayload(facts, request) {
     const seat = facts.seat(request.participant), evidence = facts.deliveryByToken(request.claimToken);
-    if (seat === undefined || evidence === undefined || seat.generation !== evidence.generation
-        || seat.generation !== request.seat.generation || !sameBody(seat.body, request.seat.body)
-        || seat.body.channel !== 'claude-code' || seat.body.session !== request.route.sessionId
+    if (seat === undefined || seat.attachment !== 'attached' || evidence === undefined || seat.generation !== evidence.generation
+        || seat.generation !== request.seat.generation || seat.owner !== request.seat.owner
         || evidence.activity !== request.activity || !['dispatching', 'unknown', 'accepted'].includes(evidence.outcome)
         || seat.wakeAddress?.kind !== 'claude-native' || !sameAddress(seat.wakeAddress.address, request.route.address))
         return undefined;
@@ -87,7 +91,11 @@ function currentPayload(facts, request) {
 }
 async function rowsForSession(sessionId, env, tokens) {
     const rows = [];
-    const paths = new Set((await projectSessionCandidates({ sessionId, channel: 'claude-code', env })).map(candidate => candidate.location));
+    const candidates = (await indexedSquareEntries({}, env)).filter(entry => {
+        const coordinate = decodeHarnessOwner(entry.owner);
+        return coordinate?.channel === 'claude-code' && coordinate.session === sessionId;
+    });
+    const paths = new Set(candidates.map(candidate => candidate.location));
     for (const location of paths) {
         const artifact = createArtifactPort(location);
         try {
@@ -101,7 +109,7 @@ async function rowsForSession(sessionId, env, tokens) {
                 const item = index === undefined ? undefined : facts.activity(index);
                 if (seat === undefined || item?.kind !== 'say')
                     return [row];
-                const route = { location, participant: seat.participant, sessionId, channel: 'claude-code',
+                const route = { location, participant: seat.participant,
                     ...evidence.route, updatedAt: evidence.at };
                 const request = { location, participant: seat.participant, activity: evidence.activity,
                     actor: item.actor, seat: asSeatRef(seat), claimToken: token, attemptN: evidence.attemptN, route, artifact };

package/dist/claude-mod.js

@@ -7,11 +7,13 @@ import { processActNotificationsOnce } from './notifications.js';
 import { sweepPending } from './delivery-operations.js';
 import { beginClaudeMcpCall, endClaudeMcpCall } from './claude-mcp-context.js';
 import { asSeatRef } from './seats.js';
-import { projectSessionSeats, projectSessionCandidates } from './inbox.js';
-import { InternalSquareError, SquareError, sameBody } from './model.js';
+import { projectSessionSeats } from './inbox.js';
+import { restoreSessionSeats } from './session-lifecycle.js';
+import { harnessOwner } from './owner.js';
+import { InternalSquareError, SquareError } from './model.js';
 /** Persisted hook state keeps its wire coordinate; internal consumers keep the located seat. */
-function claudeBinding({ location, seat }) {
-    return { location, participant: seat.participant, session: seat.body.session, generation: seat.generation };
+function claudeBinding({ location, seat }, sessionId) {
+    return { location, participant: seat.participant, session: sessionId, generation: seat.generation };
 }
 /** JSON stdin bridge. Identity is explicit per operation; process.env is never rewritten. */
 export async function runClaudeMod(inputText, env = process.env) {
@@ -33,29 +35,29 @@ export async function runClaudeMod(inputText, env = process.env) {
     }
     const scoped = operationEnv('claude', input.sessionId, env);
     const signal = AbortSignal.timeout(2500);
-    const body = { channel: 'claude-code', session: input.sessionId, ...(input.agentId === undefined ? {} : { agent: input.agentId }) };
+    const owner = harnessOwner({ channel: 'claude-code', session: input.sessionId, ...(input.agentId === undefined ? {} : { agent: input.agentId }) });
     const supported = process.platform === 'darwin' && typeof input.endpoint === 'string' && input.endpoint.startsWith('/');
-    const sessionSeats = () => projectSessionSeats({ body, env }, signal);
+    const sessionSeats = async () => (await projectSessionSeats({ owner, env }, signal)).filter(member => member.seat.attachment === 'attached');
     if (input.operation === 'end') {
         const retired = [];
         const captured = [...input.bindings ?? []];
         // Discover committed late joins at the pinned end boundary, never later owners.
         if (input.endedAt !== undefined)
-            for (const member of await sessionSeats()) {
+            for (const member of await projectSessionSeats({ owner, env }, signal)) {
                 if (member.joinedAt > input.endedAt || captured.some((item) => item.location === member.location
                     && item.participant === member.seat.participant && item.generation === member.seat.generation))
                     continue;
-                captured.push(claudeBinding(member));
+                captured.push(claudeBinding(member, input.sessionId));
             }
         for (const binding of captured) {
             if (binding.session !== input.sessionId)
                 continue;
-            const square = await Square.at({ path: binding.location, env: scoped, body,
-                participant: binding.participant });
+            const square = await Square.at({ path: binding.location, env: scoped });
             try {
-                const ended = await square.endOwnedSession(binding.participant, input.sessionId, binding.generation, body);
-                if (ended?.activity)
-                    retired.push({ ...binding, generation: binding.generation });
+                const detached = binding.generation === undefined ? null
+                    : await square.detach(binding.participant, { owner, generation: binding.generation });
+                if (detached)
+                    retired.push(binding);
             }
             finally {
                 await square.close();
@@ -67,41 +69,10 @@ export async function runClaudeMod(inputText, env = process.env) {
     }
     const recovery = new Set();
     const cancelledBindings = [...input.cancelledBindings ?? []];
-    if (input.operation === 'start' && input.resume) {
-        // Resume is proven by the artifact's latest participant lifecycle, while HOME
-        // contributes only candidate paths. A stale candidate never establishes a seat.
-        const candidates = await projectSessionCandidates({ body, env });
-        const seen = new Set();
-        for (const candidate of candidates) {
-            if (signal.aborted)
-                break;
-            const probe = createArtifactPort(candidate.location, undefined, signal);
-            let names;
-            try {
-                names = (await probe.read(facts => facts.completedSeatsForBody(body).map(seat => seat.participant), signal)).value;
-            }
-            catch (error) {
-                if (error instanceof InternalSquareError && error.code === 'not_found')
-                    throw new SquareError('unavailable', `Square is unavailable at ${candidate.location}`);
-                throw error;
-            }
-            finally {
-                await probe.close();
-            }
-            for (const participant of names) {
-                const key = `${candidate.location}\0${participant}`;
-                if (seen.has(key))
-                    continue;
-                seen.add(key);
-                const square = await Square.at({ path: candidate.location, env: scoped, body, participant });
-                try {
-                    await square.join(participant);
-                }
-                finally {
-                    await square.close();
-                }
-            }
-        }
+    if (input.operation === 'start') {
+        await restoreSessionSeats(owner, scoped, supported ? {
+            kind: 'claude-native', address: { sessionId: input.sessionId, endpoint: input.endpoint, version: input.version, platform: 'darwin', loaded: 'true' },
+        } : undefined, signal);
     }
     if (input.operation === 'start' || input.operation === 'reconcile' || input.operation === 'cancel' || input.cancelAt !== undefined) {
         for (const member of await sessionSeats()) {
@@ -109,21 +80,21 @@ export async function runClaudeMod(inputText, env = process.env) {
                 break;
             const { location, seat: capturedSeat, joinedAt } = member;
             const matches = (item) => item !== undefined
-                && item.location === location && item.participant === capturedSeat.participant && item.session === capturedSeat.body.session
+                && item.location === location && item.participant === capturedSeat.participant && item.session === input.sessionId
                 && (item.generation === undefined || item.generation === capturedSeat.generation);
             const expected = input.bindings?.find(matches);
             const cancelled = input.cancelledBindings?.find(matches) ?? (input.operation === 'cancel' ? expected : undefined);
             const lateCancelledJoin = input.operation === 'cancel' && input.cancelAt !== undefined
                 && joinedAt <= input.cancelAt && expected === undefined;
             if (lateCancelledJoin && !cancelledBindings.some(matches))
-                cancelledBindings.push(claudeBinding(member));
+                cancelledBindings.push(claudeBinding(member, input.sessionId));
             if (input.operation !== 'start' && input.operation !== 'reconcile' && !lateCancelledJoin && expected === undefined)
                 continue;
             const artifact = createArtifactPort(location, undefined, signal);
             try {
                 const { value: currentSeat } = await artifact.read((facts) => facts.seat(capturedSeat.participant), signal);
-                if (currentSeat === undefined || currentSeat.generation !== capturedSeat.generation
-                    || !sameBody(currentSeat.body, capturedSeat.body))
+                if (currentSeat === undefined || currentSeat.attachment !== 'attached' || currentSeat.generation !== capturedSeat.generation
+                    || currentSeat.owner !== capturedSeat.owner)
                     continue;
                 const seat = asSeatRef(currentSeat);
                 const existing = currentSeat.wakeAddress?.kind === 'claude-native' ? currentSeat.wakeAddress : undefined;
@@ -193,7 +164,7 @@ export async function runClaudeMod(inputText, env = process.env) {
                     await processActNotificationsOnce(location, index, { env: { ...env, SQUARE_NOTIFY_DELIVERY_WAIT_MS: '200' } });
                 }
             }
-        return `${JSON.stringify({ available: supported, diagnostic: supported ? undefined : 'Native inbox unavailable: requires macOS Claude with an interactive loaded mod and its real endpoint.', bindings: members.map(claudeBinding), cancelledBindings })}\n`;
+        return `${JSON.stringify({ available: supported, diagnostic: supported ? undefined : 'Native inbox unavailable: requires macOS Claude with an interactive loaded mod and its real endpoint.', bindings: members.map(member => claudeBinding(member, input.sessionId)), cancelledBindings })}\n`;
     }
     if (!['guard', 'admitted', 'stored'].includes(input.operation) || typeof input.text !== 'string')
         throw new Error('Unknown Claude bridge operation.');

package/dist/cli/context.d.ts

@@ -1,13 +1,16 @@
+import { type Owner } from '../square-api.js';
 import { type HardCap } from '../model.js';
 import { Square } from '../square-api.js';
-import type { Body, OperationControl } from '../square-facade.js';
+import type { OperationControl } from '../square-facade.js';
 export interface CommandContext {
     cwd: string;
     env: NodeJS.ProcessEnv;
     squarePath?: string;
     name?: string;
+    owner?: Owner;
     homeDir: string;
     command: string;
+    json?: boolean;
 }
 export interface CommandSpec<Intent = unknown, Result = void> {
     parse(argv: string[], context: CommandContext): Intent;
@@ -30,18 +33,20 @@ export interface ParsedGlobalArgs {
     explicitSquarePath: boolean;
     multipleSquares: boolean;
     name?: string;
+    owner?: Owner;
     args: string[];
 }
 export declare function parseGlobalArgs(rawArgs: string[]): Promise<ParsedGlobalArgs>;
 export declare function locationIsRequired(command: string): boolean;
 export declare function defaultContext(command: string, squarePath?: string, name?: string): CommandContext;
 export declare function squareInput(context: CommandContext): {
-    wakeAddress?: import("../model.js").WakeAddress | undefined;
-    body?: Body | undefined;
     cwd: string;
     env: NodeJS.ProcessEnv;
     path: string | undefined;
-    participant: string | undefined;
+};
+export declare function commandIdentity(env: NodeJS.ProcessEnv, explicit?: Owner): {
+    owner: Owner;
+    wakeAddress?: import('../model.js').WakeAddress;
 };
 /** Adapter lifetime only; each callback uses the actual public resource API. */
 export declare function withSquare<T>(context: CommandContext, run: (square: Square) => Promise<T>, control?: OperationControl): Promise<T>;

package/dist/cli/context.js

@@ -1,9 +1,10 @@
 import os from 'node:os';
+import { harnessOwner, localUserOwner } from '../square-api.js';
+import { harnessSessionSources } from '../participant-identity.js';
 import { codexWakeAddress } from '../codex-address.js';
 import { commandUsageHint } from '../help.js';
 import { parseParticipantList, validateName } from '../model.js';
 import { Square, squareClock } from '../square-api.js';
-import { harnessSessionSources } from '../participant-identity.js';
 export async function readStdin() {
     try {
         let content = '';
@@ -110,12 +111,18 @@ export async function parseGlobalArgs(rawArgs) {
     const args = [...rawArgs];
     let requestedPath;
     let name;
+    let owner;
     for (let index = 0; index < args.length; index++) {
         if (args[index] === '--location') {
             requestedPath = requireValue(args, index, args[index]);
             args.splice(index, 2);
             index -= 1;
         }
+        else if (args[index] === '--owner') {
+            owner = requireValue(args, index, args[index]);
+            args.splice(index, 2);
+            index -= 1;
+        }
         else if (args[index] === '--as') {
             name = requireValue(args, index, args[index]);
             args.splice(index, 2);
@@ -132,39 +139,37 @@ export async function parseGlobalArgs(rawArgs) {
         fail(`✕ ${command} needs a square location\nsquare ls`);
     }
     const squarePath = requestedPath ?? configured;
-    return { squarePath, explicitSquarePath: explicitSquarePath || configured !== undefined, multipleSquares: false, name, args };
+    return { squarePath, explicitSquarePath: explicitSquarePath || configured !== undefined, multipleSquares: false, name, owner, args };
 }
 export function locationIsRequired(command) {
     return LOCATION_REQUIRED_COMMANDS.has(command);
 }
 export function defaultContext(command, squarePath, name) {
-    return { command, cwd: process.cwd(), env: { ...process.env }, squarePath, name, homeDir: os.homedir() };
+    return { command, cwd: process.cwd(), env: { ...process.env }, squarePath, name, owner: undefined, homeDir: os.homedir() };
 }
 export function squareInput(context) {
-    const { body, wakeAddress } = commandIdentity(context.env);
-    return { cwd: context.cwd, env: context.env, path: context.squarePath, participant: context.name,
-        ...(body === undefined ? {} : { body }), ...(wakeAddress === undefined ? {} : { wakeAddress }) };
-}
-function commandIdentity(env) {
-    const coordinates = harnessSessionSources.flatMap(({ variable, channel, provider }) => {
-        const session = env[variable]?.trim();
-        return session === undefined || session === '' ? [] : [{ channel, session, native: provider !== undefined }];
-    });
-    const native = coordinates.filter((coordinate) => coordinate.native);
-    if (native.length > 1)
-        throw new Error('Multiple harness execution coordinates are present; select one explicit body.');
-    const paseo = coordinates.find((coordinate) => coordinate.channel === 'paseo');
-    // A child marker without a reliable agent id must never inherit the parent or Paseo identity.
+    return { cwd: context.cwd, env: context.env, path: context.squarePath };
+}
+export function commandIdentity(env, explicit) {
+    if (explicit !== undefined)
+        return { owner: explicit };
+    const configured = env.SQUARE_OWNER;
+    if (configured !== undefined)
+        return { owner: configured };
+    const selected = harnessSessionSources.flatMap(({ variable, channel }) => env[variable]?.trim() ? [{ channel, session: env[variable].trim() }] : []);
+    const native = selected.filter(source => source.channel !== 'paseo');
     if (env.CLAUDE_CODE_CHILD_SESSION === '1')
-        return {};
-    const selected = native[0] ?? paseo;
-    if (selected === undefined)
-        return {};
-    const body = { channel: selected.channel, session: selected.session };
-    const wakeAddress = selected.channel === 'codex'
-        ? codexWakeAddress(selected.session, env)
+        throw new Error('Harness identity is incomplete; provide --owner explicitly.');
+    if (native.length > 1)
+        throw new Error('Multiple harness execution coordinates are present; select one explicit owner.');
+    const paseo = selected.find(source => source.channel === 'paseo');
+    const coordinate = native[0] ?? paseo;
+    if (coordinate === undefined)
+        return { owner: localUserOwner() };
+    const owner = harnessOwner({ channel: coordinate.channel, session: coordinate.session });
+    const wakeAddress = coordinate.channel === 'codex' ? codexWakeAddress(coordinate.session, env)
         : paseo === undefined ? undefined : { kind: 'paseo', address: { agentId: paseo.session } };
-    return { body, ...(wakeAddress === undefined ? {} : { wakeAddress }) };
+    return { owner, ...(wakeAddress === undefined ? {} : { wakeAddress }) };
 }
 /** Adapter lifetime only; each callback uses the actual public resource API. */
 export async function withSquare(context, run, control) {

package/dist/cli/express-presentation.d.ts

@@ -1,7 +1,9 @@
 import { type Square } from '../square-api.js';
+import type { Owner } from '../square-api.js';
 import type { OperationControl, ExpressOptions } from '../square-facade.js';
 export { renderExpression } from '../operation-presentation.js';
 export interface ActivityOptions extends Omit<ExpressOptions, 'reply'> {
+    readonly recoveryOwner?: Owner;
     readonly reply?: string;
     readonly metadataJson?: string;
     readonly bodyProvided?: boolean;
@@ -10,4 +12,4 @@ export declare function saveActivityDraft(squarePath: string, name: string, body
 /** Retry choices are transport syntax, never a second admission decision. */
 export declare function activityRetryCommand(squarePath: string, name: string, opts: ActivityOptions, force?: boolean): string;
 /** Body adaptation, terminal IO and drafts only; Participant owns every attempt and wait. */
-export declare function executeExpression(open: (control?: OperationControl) => Promise<Square>, squarePath: string, requestedName: string | undefined, rawInput: string | undefined, opts: ActivityOptions): Promise<void>;
+export declare function executeExpression(open: (control?: OperationControl) => Promise<Square>, squarePath: string, requestedName: string | undefined, rawInput: string | undefined, opts: ActivityOptions, json?: boolean, resolveOwner?: Owner | (() => Owner)): Promise<void>;