@astrosheep/square 0.3.93 → 0.3.95

package/dist/help.js

@@ -1,3 +1,4 @@
+import { JSON_COMMANDS } from './cli/json.js';
 const COMMANDS = [
     { names: ['help'], usage: 'help [command]', summary: 'Show the command index or help for one command.' },
     { names: ['version'], usage: 'version', summary: 'Print the installed version.', hiddenFromIndex: true },
@@ -31,7 +32,7 @@ const COMMANDS = [
             '',
             'Options:',
             '  -f, --force       Express without first catching unread activity or satisfying attention etiquette.',
-            '  --no-wait         If held or throttled, save a draft and return instead of waiting. A held wait gives up on its own after 10 minutes.',
+            '  --no-wait         If throttled, save a draft and return instead of waiting.',
             '  --metadata <json> Attach a bounded JSON object (at most 16 KiB UTF-8 and 256 nesting levels); it may be the only content.',
             '                    Metadata is returned in structured activity results but is not shown in human text or searchable.',
         ],
@@ -52,9 +53,9 @@ const COMMANDS = [
         details: ['Options:', '  --ndjson       Emit one JSON event per line.', '  --for <name>   With --ndjson, emit notifications for one participant.', '  --last <N>     Emit the last N eligible activities first (default 10, maximum 100).', '  --after <id>   Resume after a canonical activity id (act/12).'],
     },
     {
-        names: ['inbox'], usage: 'inbox --for-session <session-id> [--limit <N>] [--json]', hiddenFromIndex: true,
+        names: ['inbox'], usage: 'inbox --for-owner <owner> [--limit <N>]', hiddenFromIndex: true,
         summary: 'Inspect a bounded machine-local notification snapshot for a native session.',
-        details: ['Options:', '  --for-session <id>  Required harness session id.', '  --limit <N>         Snapshot memberships (default 20, maximum 100).', '  --json              Emit the bounded snapshot as structured JSON.'],
+        details: ['Options:', '  --for-owner <id>    Required opaque owner.', '  --limit <N>         Snapshot memberships (default 20, maximum 100).'],
     },
     { names: ['codex-hook'], usage: '{command}', summary: 'Present pending attention at one native agent boundary.', hiddenFromIndex: true },
     { names: ['claude-mod'], usage: '{command}', summary: 'Receive a structured operation from the loaded Claude mod.', hiddenFromIndex: true },
@@ -67,10 +68,8 @@ const COMMANDS = [
     {
         names: ['participants'], usage: 'participants [--limit <count>]', usesSquare: true, group: 'host',
         summary: 'Show the participant roster and current states.',
-        details: ['Options:', '  --limit <count>  Show the first count names in roster order (default 20, maximum 100).'],
+        details: ['Options:', '  --limit <count>  Show the first count names in human text (default 20, maximum 100).'],
     },
-    { names: ['hold'], usage: '--as <name> hold [reason | -]', usesSquare: true, group: 'participant', summary: 'Raise a hand and pause participant activity.' },
-    { names: ['resume'], usage: '--as <name> resume', usesSquare: true, group: 'participant', summary: 'Lower the raised hand and resume activity.' },
     {
         names: ['install'], usage: 'install (--all | <target>...) [-f]', group: 'maintenance',
         summary: 'Install Square support for one or more agent hosts.',
@@ -93,7 +92,7 @@ const COMMANDS = [
     {
         names: ['migrate'], usage: 'migrate', usesSquare: true, group: 'maintenance',
         summary: 'Convert a supported older square to the current format in place.',
-        details: ['For the selected .square artifact only. Stop sessions using this artifact before conversion. Back up the stopped artifact, migrate it, then run square --location <path> doctor before starting updated clients.', 'Versions 2, 3 and 4 are accepted; version 1, unrelated or unsupported artifacts are refused without a write. Names whose own owner and route evidence agrees may share a body; names with missing or conflicting ownership stay standing without write or delivery authority. Migration reports recovered seats, unowned standing names, shared-body seats and skipped evidence. There is no --check, --backup or --force.'],
+        details: ['For the selected .square artifact only. Stop sessions using this artifact before conversion. Back up the stopped artifact, migrate it, then run square --location <path> doctor before starting updated clients.', 'Versions 2–7 migrate explicitly to format 8. Format 7 migration deletes hold/resume activities and their keyed rows, clears replies to those activities, and preserves surviving activity ids with gaps. Format 6 attachment and opaque-owner conversion are preserved; versions 4/5 first gain attached seats, and 4 also gains empty deferrals. Version 1, unrelated or unsupported artifacts refuse without a write. Names whose legacy owner and routes agree may share an owner; ambiguous names stay standing without custody. Rejoin with the same owner after migration to republish discovery. There is no --check, --backup or --force.'],
     },
 ];
 function definitionFor(command) {
@@ -104,7 +103,7 @@ function isHelpFlag(value) {
 }
 export function renderGlobalHelp() {
     const groups = [
-        { key: 'participant', title: 'In the square:', order: ['join', 'express', 'listen', 'unlisten', 'ignore', 'listening', 'catch', 'history', 'status', 'hold', 'resume', 'done'] },
+        { key: 'participant', title: 'In the square:', order: ['join', 'express', 'listen', 'unlisten', 'ignore', 'listening', 'catch', 'history', 'status', 'done'] },
         { key: 'host', title: 'Prepare and manage:', order: ['build', 'list', 'participants'] },
         { key: 'maintenance', title: 'Setup:', order: ['install', 'uninstall', 'doctor', 'migrate'] },
     ];
@@ -117,10 +116,11 @@ export function renderGlobalHelp() {
         '',
     ]);
     return [
-        'Usage: square [--location <square>] [--as <name>] <command> [args...]',
-        'Environment: SQUARE_LOCATION sets the CLI location (local artifact path or stdio://name/key); square-accessing commands require it or --location. Use --as to select a participant.',
-        'Backends: SQUARE_BACKENDS_CONFIG selects {backends:{name:{command,args?,cwd?,env?}}}; default ~/.config/square/backends.json. See guides/backends.md.',
-        'CLI flags override environment values. Participants join explicitly; no square is joined automatically.',
+        'Usage: square [--location <square>] [--as <name>] [--owner <id>] <command> [args...]',
+        'Environment: SQUARE_LOCATION sets the CLI local artifact path; square-accessing commands require it or --location. Use --as to select a participant.',
+        'Identity: --owner overrides SQUARE_OWNER, then a complete harness identity, then user:<OS user>@<host>. Incomplete or ambiguous harness identities refuse. Owners without wake use catch --idle.',
+        'Output: --json on join, express, catch, history, listen, ignore, unlisten, listening, done, status, participants and inbox prints the SDK result without observation; a participant handle becomes {name}.',
+        'History emits one JSON document; stream --ndjson emits one SDK record per line.',
         '',
         ...commandLines,
         "Run 'square <command> --help' for command options.",
@@ -132,7 +132,7 @@ export function renderSubcommandHelp(command) {
     if (definition === undefined)
         return undefined;
     const aliases = definition.names.filter((name) => name !== command);
-    const usage = definition.usage.replace('{command}', command);
+    const usage = definition.usage.replace('{command}', command) + (JSON_COMMANDS.has(command) ? ' [--json]' : '');
     return [
         `Usage: square ${definition.usesSquare ? '[--location <square>] ' : ''}${usage}`,
         ...(aliases.length > 0 ? [`Aliases: ${aliases.join(', ')}`] : []),
@@ -151,7 +151,7 @@ export function helpRequest(rawArgs) {
     const args = [];
     for (let index = 0; index < rawArgs.length; index++) {
         const arg = rawArgs[index];
-        if (arg === '--location' || arg === '--as') {
+        if (arg === '--location' || arg === '--as' || arg === '--owner') {
             const value = rawArgs[index + 1];
             if (value === undefined || value.startsWith('--'))
                 return undefined;

package/dist/http-delivery.d.ts

@@ -0,0 +1,16 @@
+import type { WakeRoute } from './model.js';
+import type { WakeOutcome, WakeRequest, WakeTransportPort } from './ports.js';
+export interface HttpWakeTransportOptions {
+    fetch?: typeof fetch;
+    env?: NodeJS.ProcessEnv;
+}
+/** HTTP accepts wake custody only; it never consumes or presents Square activity. */
+export declare class HttpWakeTransport implements WakeTransportPort {
+    private readonly opts;
+    constructor(opts?: HttpWakeTransportOptions);
+    probe(route: WakeRoute): Promise<boolean | {
+        outcome: 'not-capable';
+        diagnostic: string;
+    }>;
+    attempt(request: WakeRequest, timeoutMs: number, beforeSend: () => Promise<boolean>): Promise<WakeOutcome>;
+}

package/dist/http-delivery.js

@@ -0,0 +1,101 @@
+import { wakePreview } from './delivery.js';
+/** Configuration only: probing never contacts the receiver. */
+function configuration(route, env) {
+    if (route.kind !== 'http')
+        return undefined;
+    try {
+        const url = new URL(route.address.url);
+        if (!['http:', 'https:'].includes(url.protocol) || !url.hostname || url.username || url.password
+            || route.address.url.includes('#'))
+            return undefined;
+        const headers = new Headers({ 'Content-Type': 'application/json' });
+        const tokenEnv = route.address.tokenEnv;
+        if (tokenEnv !== undefined) {
+            const token = tokenEnv.trim() ? env[tokenEnv] : undefined;
+            // RFC 6750 bearer credentials; whitespace/control characters cannot become headers.
+            if (!token || token !== token.trim() || !/^[A-Za-z0-9._~+\/-]+=*$/.test(token))
+                return undefined;
+            headers.set('Authorization', `Bearer ${token}`);
+        }
+        return { url: route.address.url, headers };
+    }
+    catch {
+        return undefined;
+    }
+}
+/** HTTP accepts wake custody only; it never consumes or presents Square activity. */
+export class HttpWakeTransport {
+    opts;
+    constructor(opts = {}) {
+        this.opts = opts;
+    }
+    async probe(route) {
+        return configuration(route, this.opts.env ?? process.env) !== undefined
+            ? true : { outcome: 'not-capable', diagnostic: 'HTTP wake configuration unavailable.' };
+    }
+    async attempt(request, timeoutMs, beforeSend) {
+        const deadline = Date.now() + timeoutMs;
+        if (request.route.kind !== 'http')
+            return { outcome: 'not-capable' };
+        const config = configuration(request.route, this.opts.env ?? process.env);
+        if (config === undefined)
+            return { outcome: 'failed', signature: 'http_config_rejected', message: 'Invalid HTTP wake configuration.' };
+        const controller = new AbortController();
+        let sent = false;
+        const budgetUnavailable = () => sent
+            ? { outcome: 'unknown', signature: 'http_send_timeout', message: 'HTTP wake acceptance is unknown after timeout.' }
+            : { outcome: 'failed', signature: 'http_pre_send_timeout', message: 'HTTP wake budget elapsed before sending.' };
+        if (!Number.isFinite(timeoutMs) || Date.now() >= deadline)
+            return budgetUnavailable();
+        let timer;
+        const timeout = new Promise(resolve => {
+            timer = setTimeout(() => { controller.abort(); resolve(budgetUnavailable()); }, Math.max(0, deadline - Date.now()));
+        });
+        const send = async () => {
+            try {
+                const preview = request.artifact === undefined ? undefined
+                    : (await request.artifact.read(facts => wakePreview(facts, request), controller.signal)).value;
+                if (preview === undefined)
+                    return { outcome: 'not-capable', diagnostic: 'No pending Square activity to preview.' };
+                const body = JSON.stringify({
+                    location: request.location, participant: request.participant, activity: request.activity, actor: request.actor,
+                    ...(request.attemptN === undefined ? {} : { attemptN: request.attemptN }), preview,
+                });
+                if (controller.signal.aborted || Date.now() >= deadline)
+                    return budgetUnavailable();
+                if (!(await beforeSend()))
+                    return { outcome: 'not-capable' };
+                // Preview and the final gate spend the same absolute budget as the request.
+                if (controller.signal.aborted || Date.now() >= deadline)
+                    return budgetUnavailable();
+                sent = true;
+                const response = await (this.opts.fetch ?? fetch)(config.url, {
+                    method: 'POST', headers: config.headers, body, redirect: 'manual', signal: controller.signal,
+                });
+                // Status is the whole acknowledgement; never wait for or buffer a receiver body.
+                void response.body?.cancel().catch(() => undefined);
+                if (response.status >= 200 && response.status < 300)
+                    return { outcome: 'accepted', signature: 'http_accepted' };
+                return {
+                    outcome: 'failed', signature: response.status >= 500 && response.status < 600 ? 'http_status_transient' : 'http_status_rejected',
+                    message: `HTTP wake returned status ${response.status}.`,
+                };
+            }
+            catch {
+                // URLs, query credentials and raw fetch exceptions must never reach evidence.
+                if (controller.signal.aborted)
+                    return budgetUnavailable();
+                return sent
+                    ? { outcome: 'unknown', signature: 'http_send_unknown', message: 'HTTP wake acceptance is unknown after a network error.' }
+                    : { outcome: 'failed', signature: 'http_pre_send_failed', message: 'HTTP wake could not be prepared.' };
+            }
+        };
+        try {
+            return await Promise.race([send(), timeout]);
+        }
+        finally {
+            if (timer !== undefined)
+                clearTimeout(timer);
+        }
+    }
+}

package/dist/inbox.d.ts

@@ -1,4 +1,4 @@
-import { type Body, type LocatedSeat, type PendingMembership } from './model.js';
+import { type Owner, type LocatedSeat, type PendingMembership } from './model.js';
 import type { SquareRead } from './ports.js';
 export interface PendingWaitOptions {
     signal?: AbortSignal;
@@ -14,15 +14,12 @@ export declare function pendingAtBoundary(inbox: readonly PendingMembership[]):
 export declare function projectBoundaryEligibility(inbox: readonly PendingMembership[]): Promise<PendingMembership[]>;
 export interface SessionBindingCandidate {
     readonly location: string;
-    readonly body: Body;
+    readonly owner: Owner;
 }
 /** HOME is a candidate path index; current seats and delivery evidence live in the artifact. */
 export declare function projectSessionCandidates(input: SessionSeatQuery): Promise<readonly SessionBindingCandidate[]>;
 export interface SessionSeatQuery {
-    readonly body?: Body;
-    readonly sessionId?: string;
-    readonly channel?: string;
-    readonly agent?: string;
+    readonly owner?: Owner;
     readonly location?: string;
     readonly env?: NodeJS.ProcessEnv;
 }
@@ -36,31 +33,21 @@ export interface NativePendingPreview {
 }
 export type NativePendingPreviewInput = {
     readonly location: string;
-    readonly sessionId: string;
+    readonly generation: import('./model.js').ActivityId;
     readonly participant: string;
     readonly actIndex: number;
     readonly cancelledThrough?: number;
     readonly now: number;
 } & ({
     readonly routeKind: 'claude-native';
-    readonly address: {
-        readonly endpoint: string;
-    };
+    readonly address: Readonly<Record<string, string>>;
 } | {
     readonly routeKind: 'opencode-server';
-    readonly address: {
-        readonly sessionId: string;
-    };
+    readonly address: Readonly<Record<string, string>>;
 });
-/** First matching current seat, exact body/generation/address and catch ownership. */
+/** Current-generation native attention, owned by its exact wake address and catch state. */
 export declare function nativePendingPreview(facts: SquareRead, input: NativePendingPreviewInput): NativePendingPreview | undefined;
-export interface SessionIdentityQuery {
-    readonly channel: string;
-    readonly session: string;
-    readonly allAgents?: true;
-}
-export type SessionIdentity = Body | SessionIdentityQuery;
-export declare function sessionInbox(identity: SessionIdentity, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<PendingMembership[]>;
+export declare function sessionInbox(owner: Owner, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<PendingMembership[]>;
 export interface SessionPendingObserver {
     /** Read committed revisions before reusing content; filesystem hints are only for waiting. */
     read(options?: Pick<PendingWaitOptions, 'signal' | 'excludeKeys'>): Promise<PendingMembership[]>;
@@ -68,4 +55,4 @@ export interface SessionPendingObserver {
     close(): void;
 }
 /** Session-scoped projection over process-shared storage change detectors. */
-export declare function observeSessionPending(identity: SessionIdentity, suppliedEnv?: NodeJS.ProcessEnv): Promise<SessionPendingObserver>;
+export declare function observeSessionPending(owner: Owner, suppliedEnv?: NodeJS.ProcessEnv): Promise<SessionPendingObserver>;

package/dist/inbox.js

@@ -1,4 +1,3 @@
-import { sameBody } from './model.js';
 import { createArtifactPort, observeSquareDeliveryRevision, observeSquareRevision } from './artifact.js';
 import { indexedSquareEntries, observeSquareIndex } from './square-index.js';
 import { canonicalPath } from './canonical-path.js';
@@ -20,8 +19,8 @@ export function pendingAtBoundary(inbox) {
 }
 function eligibleNotifications(facts, membership, now = Date.now()) {
     const seat = facts.seat(membership.seat.participant);
-    if (seat === undefined || seat.generation !== membership.seat.generation
-        || !sameBody(seat.body, membership.seat.body))
+    if (seat === undefined || seat.attachment !== 'attached' || seat.generation !== membership.seat.generation
+        || seat.owner !== membership.seat.owner)
         return { notifications: [] };
     const cancelledThrough = facts.cancelledThrough(seat.participant, seat.generation);
     let expiry = Infinity;
@@ -68,22 +67,22 @@ export async function projectBoundaryEligibility(inbox) {
 /** HOME is a candidate path index; current seats and delivery evidence live in the artifact. */
 export async function projectSessionCandidates(input) {
     const location = input.location === undefined ? undefined : await canonicalPath(input.location);
-    const entries = await indexedSquareEntries({ body: input.body, session: input.sessionId, channel: input.channel, agent: input.agent }, input.env ?? process.env);
+    const entries = await indexedSquareEntries({ owner: input.owner }, input.env ?? process.env);
     const candidates = new Map();
     for (const entry of entries) {
         if (location !== undefined && location !== entry.location)
             continue;
-        const key = JSON.stringify([entry.location, entry.body.channel, entry.body.session, entry.body.agent ?? null]);
-        candidates.set(key, { location: entry.location, body: entry.body });
+        const key = JSON.stringify([entry.location, entry.owner]);
+        candidates.set(key, { location: entry.location, owner: entry.owner });
     }
     return [...candidates.values()];
 }
 function groupCandidates(candidates) {
     const grouped = new Map();
-    for (const { location, body } of candidates) {
-        const bodies = grouped.get(location) ?? [];
-        bodies.push(body);
-        grouped.set(location, bodies);
+    for (const { location, owner } of candidates) {
+        const owners = grouped.get(location) ?? [];
+        owners.push(owner);
+        grouped.set(location, owners);
     }
     return grouped;
 }
@@ -97,11 +96,11 @@ function locatedSeats(facts, location, seats) {
 /** Lifecycle reads resolve seats and join times, never pending activity bodies. */
 export async function projectSessionSeats(input, signal) {
     const seats = [];
-    for (const [location, bodies] of groupCandidates(await projectSessionCandidates(input))) {
+    for (const [location, owners] of groupCandidates(await projectSessionCandidates(input))) {
         signal?.throwIfAborted();
         const artifact = createArtifactPort(location, undefined, signal);
         try {
-            seats.push(...(await artifact.read(facts => locatedSeats(facts, location, bodies.flatMap(body => facts.seatsForBody(body))), signal)).value);
+            seats.push(...(await artifact.read(facts => locatedSeats(facts, location, owners.flatMap(owner => facts.seatsForOwner(owner))), signal)).value);
         }
         catch (error) {
             if (signal?.aborted)
@@ -116,11 +115,11 @@ export async function projectSessionSeats(input, signal) {
 /** Public count boundary: one coherent read per artifact, without pending body hydration. */
 export async function sessionInboxCounts(input, signal) {
     const rows = [];
-    for (const [location, bodies] of groupCandidates(await projectSessionCandidates(input))) {
+    for (const [location, owners] of groupCandidates(await projectSessionCandidates(input))) {
         signal?.throwIfAborted();
         const artifact = createArtifactPort(location, undefined, signal);
         try {
-            rows.push(...(await artifact.read(facts => locatedSeats(facts, location, bodies.flatMap(body => facts.seatsForBody(body))).map(({ seat }) => ({
+            rows.push(...(await artifact.read(facts => locatedSeats(facts, location, owners.flatMap(owner => facts.seatsForOwner(owner).filter(seat => seat.attachment === 'attached'))).map(({ seat }) => ({
                 name: seat.participant, squarePath: location, pending: facts.directedCount(seat.participant, { unseenOnly: true }),
             })), signal)).value);
         }
@@ -137,13 +136,13 @@ export async function sessionInboxCounts(input, signal) {
 /** One authoritative read per canonical artifact, even when discovery names several bodies. */
 async function projectPending(candidates, cache, signal) {
     const pending = [];
-    for (const [location, bodies] of groupCandidates(candidates)) {
+    for (const [location, owners] of groupCandidates(candidates)) {
         signal?.throwIfAborted();
         const artifact = createArtifactPort(location, undefined, signal);
         try {
             const { value: current } = await artifact.read(facts => {
-                const seats = bodies.flatMap(body => facts.seatsForBody(body));
-                const coordinate = JSON.stringify([bodies, seats.map(seat => [seat.participant, seat.body, seat.generation])]);
+                const seats = owners.flatMap(owner => facts.seatsForOwner(owner).filter(seat => seat.attachment === 'attached'));
+                const coordinate = JSON.stringify([owners, seats.map(seat => [seat.participant, seat.owner, seat.generation])]);
                 const header = facts.header();
                 let cached = cache?.get(location);
                 if (cached?.coordinate !== coordinate || cached.version !== header.revision) {
@@ -177,14 +176,14 @@ async function projectPending(candidates, cache, signal) {
     return pending;
 }
 function sameWakeAddress(address, kind, requested) {
-    if (address?.kind !== kind)
+    if (address?.kind !== kind || Object.keys(address.address).length !== Object.keys(requested).length)
         return false;
     return Object.entries(requested).every(([key, value]) => address.address[key] === value);
 }
-/** First matching current seat, exact body/generation/address and catch ownership. */
+/** Current-generation native attention, owned by its exact wake address and catch state. */
 export function nativePendingPreview(facts, input) {
     const seat = facts.seat(input.participant);
-    if (seat === undefined || seat.body.session !== input.sessionId
+    if (seat === undefined || seat.attachment !== 'attached' || seat.generation !== input.generation
         || !sameWakeAddress(seat.wakeAddress, input.routeKind, input.address))
         return undefined;
     const cancelledThrough = facts.cancelledThrough(seat.participant, seat.generation);
@@ -200,10 +199,8 @@ export function nativePendingPreview(facts, input) {
     return { payload: renderSquareReminder([renderAttentionPreview({ squarePath: input.location, recipient: input.participant, actIndex: item.index,
                 actor: item.actor, route: head.route, body: item.body ?? '(structured activity)' })]), clipped: attentionBodyIsClipped(item.body ?? '(structured activity)') };
 }
-export async function sessionInbox(identity, env = process.env, signal) {
-    const query = 'allAgents' in identity ? { channel: identity.channel, sessionId: identity.session, env }
-        : { body: identity, env };
-    return projectPending(await projectSessionCandidates(query), undefined, signal);
+export async function sessionInbox(owner, env = process.env, signal) {
+    return projectPending(await projectSessionCandidates({ owner, env }), undefined, signal);
 }
 async function capture(observer, kind, signal) {
     const generation = observer.generation;
@@ -234,10 +231,9 @@ async function capture(observer, kind, signal) {
     }
 }
 /** Session-scoped projection over process-shared storage change detectors. */
-export async function observeSessionPending(identity, suppliedEnv = process.env) {
+export async function observeSessionPending(owner, suppliedEnv = process.env) {
     const env = { ...suppliedEnv };
-    const query = 'allAgents' in identity ? { channel: identity.channel, sessionId: identity.session, env }
-        : { body: identity, env };
+    const query = { owner, env };
     const index = await observeSquareIndex(env);
     const artifacts = new Map();
     const cache = new Map();

package/dist/index.d.ts

@@ -1,8 +1,6 @@
 export { Square, squareLocation, squareClock, createSquareResourceOwner, discover, inbox, diagnoseSquare, migrateSquare } from './square-api.js';
 export { SquareError, ACTIVITY_METADATA_MAX_BYTES } from './model.js';
+export { selectOwnSeat, requireOwner, localUserOwner, harnessOwner, decodeHarnessOwner } from './square-api.js';
 export type { WakeTransportPort, WakeRequest, WakeOutcome } from './ports.js';
 export type { WakeTransports } from './notifications.js';
-export { createDefaultWakeTransport } from './notifications.js';
-export type { PresentationSinkPort } from './ports.js';
-export type * from './square-backend.js';
 export type * from './square-facade.js';

package/dist/index.js

@@ -1,3 +1,3 @@
 export { Square, squareLocation, squareClock, createSquareResourceOwner, discover, inbox, diagnoseSquare, migrateSquare } from './square-api.js';
 export { SquareError, ACTIVITY_METADATA_MAX_BYTES } from './model.js';
-export { createDefaultWakeTransport } from './notifications.js';
+export { selectOwnSeat, requireOwner, localUserOwner, harnessOwner, decodeHarnessOwner } from './square-api.js';

package/dist/mcp.d.ts

@@ -1,7 +1,10 @@
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { type Owner } from './square-api.js';
 import type { SquareAtInput } from './square-facade.js';
 /** The server owns its artifact connection lifetime, so callers cannot lend one. */
 export interface SquareMcpOptions extends Omit<SquareAtInput, 'resources'> {
+    readonly owner?: Owner;
+    readonly wakeAddress?: import('./model.js').WakeAddress;
 }
 export type SquareMcpServer = McpServer;
 export declare function createSquareMcpServer(options: SquareMcpOptions): SquareMcpServer;

package/dist/mcp.js

@@ -6,8 +6,10 @@ import { codexWakeAddress } from './codex-address.js';
 import { readClaudeMcpCall } from './claude-mcp-context.js';
 import { SQUARE_IDENTITY } from './identity.js';
 import { Square, createSquareResourceOwner } from './square-api.js';
+import { harnessOwner } from './square-api.js';
 export function createSquareMcpServer(options) {
-    const baseEnv = { ...(options.env ?? process.env) };
+    const { owner: configuredOwner, wakeAddress, ...resourceOptions } = options;
+    const baseEnv = { ...(resourceOptions.env ?? process.env) };
     const resources = createSquareResourceOwner();
     // Calls to the configured square borrow one server-owned connection.
     const inFlight = new Set();
@@ -19,21 +21,20 @@ export function createSquareMcpServer(options) {
             const call = (async () => {
                 let square;
                 try {
-                    const { as: participant, location } = args;
+                    const { location } = args;
                     const threadId = extra._meta?.threadId;
                     const opencodeSessionId = extra._meta?.['ai.opencode/sessionID'];
                     // Claude's plugin endpoint requires the mod's call-local coordinate, never startup identity.
                     const claude = baseEnv.SQUARE_CLAUDE_MCP_CONTEXT === '1'
                         ? await readClaudeMcpCall(extra._meta?.['claudecode/toolUseId'], baseEnv)
                         : undefined;
-                    const body = claude !== undefined
-                        ? { channel: 'claude-code', session: claude.sessionId,
-                            ...(claude.agentId === undefined ? {} : { agent: claude.agentId }) }
+                    const owner = claude !== undefined
+                        ? harnessOwner({ channel: 'claude-code', session: claude.sessionId, ...(claude.agentId === undefined ? {} : { agent: claude.agentId }) })
                         : typeof threadId === 'string' && threadId.trim()
-                            ? { channel: 'codex', session: threadId }
+                            ? harnessOwner({ channel: 'codex', session: threadId })
                             : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
-                                ? { channel: 'opencode', session: opencodeSessionId }
-                                : options.body;
+                                ? harnessOwner({ channel: 'opencode', session: opencodeSessionId })
+                                : configuredOwner;
                     const env = claude !== undefined
                         ? { ...operationEnv('claude', claude.sessionId, baseEnv),
                             // Preserve Claude's session + child flag semantics; an agent loop ID is not a session ID.
@@ -44,37 +45,35 @@ export function createSquareMcpServer(options) {
                                 ? operationEnv('opencode', opencodeSessionId, baseEnv)
                                 : baseEnv;
                     square = await Square.at({
-                        ...options, env, body, cwd: claude?.cwd ?? options.cwd,
-                        // A call-local Codex thread uses its native queue even when managed by Paseo.
-                        wakeAddress: claude === undefined && typeof threadId === 'string' && threadId.trim()
-                            ? codexWakeAddress(threadId, env) : options.wakeAddress,
+                        ...resourceOptions, env, cwd: claude?.cwd ?? resourceOptions.cwd,
                         path: location ?? options.path,
-                        participant: participant ?? options.participant,
                         // The server owner is bound to its configured square; overrides close after each call.
                         resources: location === undefined && claude === undefined ? resources : undefined,
                     }, { signal: extra.signal });
-                    let receipt;
-                    // The transport shows people the square, so it asks for the rendering facts
-                    // the CLI already gathers and keeps that request out of the tool schema.
+                    const callWake = wakeAddress !== undefined && (owner === configuredOwner
+                        || wakeAddress.kind === 'paseo' && wakeAddress.address.agentId === baseEnv.PASEO_AGENT_ID
+                        || wakeAddress.kind === 'claude-native' && wakeAddress.address.sessionId === claude?.sessionId
+                        || wakeAddress.kind === 'opencode-server' && wakeAddress.address.sessionId === opencodeSessionId)
+                        ? wakeAddress : undefined;
+                    let text;
                     try {
-                        receipt = await tool.run(square, args, { signal: extra.signal, observe: true });
+                        text = await tool.run(square, args, { signal: extra.signal }, {
+                            owner, wakeAddress: claude === undefined && typeof threadId === 'string' && threadId.trim()
+                                ? codexWakeAddress(threadId, env) : callWake,
+                        });
                     }
                     finally {
                         await square.close();
                     }
-                    // A missing observation renders as nothing, never as raw JSON for a person to read.
-                    const text = tool.render(receipt, args) ?? '';
-                    // Observation facts are a rendering aid, not part of the receipt machines receive.
-                    const { observation: _observation, ...structuredContent } = receipt;
-                    return { content: [{ type: 'text', text }], structuredContent };
+                    return { content: [{ type: 'text', text }] };
                 }
                 catch (error) {
                     const failure = squareToolFailure(error, extra.signal);
                     const participant = args.as;
                     return { isError: true, content: [{ type: 'text', text: squareToolFailureText(failure, {
                                     location: square?.location ?? options.path,
-                                    participant: typeof participant === 'string' ? participant : options.participant,
-                                }) }], structuredContent: { error: failure } };
+                                    participant: typeof participant === 'string' ? participant : undefined,
+                                }) }] };
                 }
             })();
             inFlight.add(call);