@astrosheep/square 0.3.93 → 0.3.95

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 = '';
@@ -98,8 +99,6 @@ const LOCATION_REQUIRED_COMMANDS = new Set([
     'unlisten',
     'listening',
     'done',
-    'hold',
-    'resume',
     'history',
     'status',
     'participants',
@@ -110,12 +109,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 +137,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>;

package/dist/cli/express-presentation.js

@@ -2,10 +2,11 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { isSquareError } from '../model.js';
-import { formatActivityId, parseActivityId } from '../square-api.js';
+import { selectOwnSeat, formatActivityId, parseActivityId } from '../square-api.js';
 import { formatRefusal, refusalText, renderActivityBlocked, renderActivityLimit, renderActivityUncertain, renderExpressNoWait, renderExpressWaiting, joinRecoveryCommand, participantsRecoveryCommand, participantCommandPrefix, commandPrefix, quoteShell, takeoverRecoveryLines, withPathOutput, } from '../presentation.js';
 import { renderExpression } from '../operation-presentation.js';
 import { formatDuration } from '../time.js';
+import { jsonResult } from './json.js';
 export { renderExpression } from '../operation-presentation.js';
 export function saveActivityDraft(squarePath, name, body, now = Date.now()) {
     const draftDir = path.join(/^[A-Za-z][A-Za-z0-9+.-]*:/.test(squarePath) ? process.cwd() : path.dirname(squarePath), 'drafts');
@@ -39,10 +40,11 @@ export function activityRetryCommand(squarePath, name, opts, force = opts.force
         + (opts.noMention === true ? ' --no-mention' : '');
     const metadata = opts.metadataJson === undefined ? '' : ` --metadata ${quoteShell(opts.metadataJson)}`;
     const body = opts.bodyProvided === false ? '' : ' -';
-    return `${participantCommandPrefix(squarePath, name)} express${force ? ' --force' : ''}${opts.noWait ? ' --no-wait' : ''}${reach}${metadata}${replyArgument(opts.reply)}${body}`;
+    return `${participantCommandPrefix(squarePath, name, opts.recoveryOwner)} express${force ? ' --force' : ''}${opts.noWait ? ' --no-wait' : ''}${reach}${metadata}${replyArgument(opts.reply)}${body}`;
 }
 /** Body adaptation, terminal IO and drafts only; Participant owns every attempt and wait. */
-export async function executeExpression(open, squarePath, requestedName, rawInput, opts) {
+export async function executeExpression(open, squarePath, requestedName, rawInput, opts, json = false, resolveOwner) {
+    let owner;
     let square;
     let attempted = false;
     let announcedWait;
@@ -52,25 +54,27 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
     const interrupt = () => controller.abort();
     process.once('SIGINT', interrupt);
     try {
+        owner = typeof resolveOwner === 'function' ? resolveOwner() : resolveOwner;
         square = await open({ signal: controller.signal });
-        const participant = await square.participant(requestedName);
+        const participant = await selectOwnSeat(square, owner, requestedName);
         name = participant.name;
         attempted = true;
-        const { metadataJson: _metadataJson, bodyProvided: _bodyProvided, ...expressOptions } = opts;
+        const { metadataJson: _metadataJson, bodyProvided: _bodyProvided, recoveryOwner: _owner, ...expressOptions } = opts;
         const outcome = await participant.express(rawInput === undefined ? undefined : rawInput.replace(/\r\n/g, '\n').trim(), {
-            ...expressOptions, reply: opts.reply, observe: true,
+            ...expressOptions, reply: opts.reply, ...(json ? {} : { observe: true }),
         }, {
             signal: controller.signal,
             onProgress(progress) {
                 if (progress.kind !== 'waiting' || announcedWait === progress.reason)
                     return;
-                process.stdout.write(renderExpressWaiting(progress) + '\n');
+                (json ? process.stderr : process.stdout).write(renderExpressWaiting(progress) + '\n');
                 announcedWait = progress.reason;
             },
         });
         landedId = outcome.activity.id;
-        name = outcome.observation.participant;
-        const rendered = renderExpression(squarePath, outcome);
+        if (!json)
+            name = outcome.observation.participant;
+        const rendered = json ? jsonResult(outcome) : renderExpression(squarePath, outcome, opts.recoveryOwner);
         if (rendered !== undefined)
             process.stdout.write(rendered);
     }
@@ -81,9 +85,10 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
         const draftPath = saveActivityDraft(squarePath, name, rawInput ?? '');
         if (square === undefined)
             square = await open().catch(() => undefined);
-        const fresh = await square?.recovery(name).catch(() => undefined);
+        const selected = square === undefined ? undefined : await selectOwnSeat(square, owner, name).catch(() => undefined);
+        const fresh = await square?.recovery(selected?.name ?? name).catch(() => undefined);
         name = fresh?.participant ?? name;
-        const output = { squarePath, name, draftPath, participantCount: fresh?.standingCount, held: fresh?.held };
+        const output = { squarePath, name, owner: opts.recoveryOwner, draftPath, participantCount: fresh?.standingCount };
         const confirmedUnsent = landedId === undefined && detail?.landedId === undefined
             && detail?.expressEffect !== 'landed' && detail?.expressEffect !== 'unknown'
             && (!attempted || detail?.expressEffect === 'unsent' || (isSquareError(error) && error.facts?.activityUnsent === true));
@@ -99,7 +104,7 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
         if (isSquareError(error)) {
             if (error.code === 'behind' && fresh?.activitySummaries !== undefined) {
                 process.stdout.write(renderActivityBlocked({ ...output, retryCommand: retryInput,
-                    activitySummaries: fresh.activitySummaries.map((summary) => ({ ...summary, previews: [...summary.previews] })),
+                    activitySummaries: fresh.activitySummaries,
                 }));
                 exitCode(1);
                 return;
@@ -111,9 +116,9 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
                 exitCode(1);
                 return;
             }
-            if (error.code === 'held' || error.code === 'throttled') {
+            if (error.code === 'throttled') {
                 process.stdout.write(renderExpressNoWait({ ...output, reason: error.code, retryCommand: retryInput,
-                    delayMs: error.facts?.retryAfterMs ?? 1, holder: error.facts?.holder, holdReason: error.facts?.holdReason,
+                    delayMs: error.facts?.retryAfterMs ?? 1,
                 }));
                 exitCode(1);
                 return;
@@ -137,13 +142,20 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
                     : 'Invalid --reply: expected an activity id like act/12'
                 : refusalText(error);
         const lines = [message, `· draft kept: ${draftPath}`];
+        if (reason === 'needs_seat') {
+            lines[0] = `✕ ${message}`;
+            lines.push(joinRecoveryCommand(squarePath, name, opts.recoveryOwner));
+            process.stderr.write(formatRefusal(squarePath, lines, output));
+            exitCode(2);
+            return;
+        }
         const repair = reason === 'bell_mention_conflict' || (reason === 'not_standing' && detail?.subject === 'recipient');
         if (isSquareError(error)) {
             if ((reason === 'never_joined' && detail?.subject === 'caller') || error.code === 'unknown_participant' || error.code === 'not_joined') {
-                lines.push(joinRecoveryCommand(squarePath, name));
+                lines.push(joinRecoveryCommand(squarePath, name, opts.recoveryOwner));
             }
             if (error.code === 'already_joined')
-                lines.push(...takeoverRecoveryLines(squarePath, name));
+                lines.push(...takeoverRecoveryLines(squarePath, name, opts.recoveryOwner));
             if (repair) {
                 lines.push(participantsRecoveryCommand(squarePath), reason === 'bell_mention_conflict'
                     ? '  · ring the bell without explicit mentions:'

package/dist/cli/json.d.ts

@@ -0,0 +1,3 @@
+export declare const JSON_COMMANDS: ReadonlySet<string>;
+/** Serialize the SDK receipt, not its optional presentation or live participant handle. */
+export declare function jsonResult(result: object): string;

package/dist/cli/json.js

@@ -0,0 +1,14 @@
+export const JSON_COMMANDS = new Set([
+    'join', 'express', 'catch', 'history', 'listen', 'ignore', 'unlisten', 'listening',
+    'done', 'status', 'participants', 'inbox',
+]);
+/** Serialize the SDK receipt, not its optional presentation or live participant handle. */
+export function jsonResult(result) {
+    const { observation: _observation, ...data } = result;
+    const participant = data.participant;
+    if (participant !== null && typeof participant === 'object' && 'name' in participant
+        && 'express' in participant && typeof participant.express === 'function') {
+        data.participant = { name: participant.name };
+    }
+    return `${JSON.stringify(data)}\n`;
+}

package/dist/cli/mcp-server-command.js

@@ -1,4 +1,4 @@
-import { fail, squareInput } from './context.js';
+import { fail, squareInput, commandIdentity } from './context.js';
 export const mcpServerCommand = {
     parse(argv) {
         if (argv.length > 0)
@@ -7,7 +7,7 @@ export const mcpServerCommand = {
     },
     async execute(_intent, context) {
         const { runSquareMcpStdio } = await import('../mcp.js');
-        await runSquareMcpStdio(squareInput(context));
+        await runSquareMcpStdio({ ...squareInput(context), ...commandIdentity(context.env, context.owner) });
     },
     present() { },
 };

package/dist/cli/observation-commands.d.ts

@@ -4,7 +4,6 @@ interface HistoryCommandOptions {
     query: HistoryQuery;
     noTruncate: boolean;
     format?: string[];
-    json: boolean;
     continuationArgs: string[];
 }
 export declare const listCommand: CommandSpec<DiscoveryOptions, string>;
@@ -22,8 +21,7 @@ interface ParticipantsCommandOptions {
 export declare const participantsCommand: CommandSpec<ParticipantsCommandOptions, string>;
 export declare const statusCommand: CommandSpec<undefined, string>;
 interface InboxIntent {
-    sessionId: string;
-    json: boolean;
+    owner: string;
     limit: number;
 }
 export declare const inboxCommand: CommandSpec<InboxIntent, string>;

package/dist/cli/observation-commands.js

@@ -9,7 +9,9 @@ import { style } from '../tty-style.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.js';
 import { discover, inbox, formatActivityId, parseActivityId, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT } from '../square-api.js';
 import { renderCatchOutcome, renderCatchProgress } from './catch-presentation.js';
-import { withSquare, squareInput, now, fail, parseBoundedLimit, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdin, requireSquarePath, requireValue, usage, } from './context.js';
+import { selectOwnSeat } from '../square-api.js';
+import { jsonResult } from './json.js';
+import { withSquare, squareInput, now, fail, parseBoundedLimit, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdin, requireSquarePath, requireValue, usage, commandIdentity, } from './context.js';
 const INBOX_DEFAULT_LIMIT = 20;
 const INBOX_MAX_LIMIT = 100;
 const INBOX_DISPLAY_CHARS = 160;
@@ -109,7 +111,7 @@ export const streamCommand = {
             else if (argv[index] === '--after') {
                 if (hasLast)
                     fail('Invalid stream options: --last and --after cannot be combined.');
-                after = parseActRef(requireValue(argv, index, argv[index]), '--after');
+                after = formatActivityId(parseActRef(requireValue(argv, index, argv[index]), '--after'));
                 index += 1;
             }
             else
@@ -191,7 +193,7 @@ export const catchCommand = {
                 replace = true;
             else if (argv[index] === '--now')
                 now = true;
-            else
+            else if (argv[index] !== '--json')
                 fail(`✕ catch does not know ${argv[index]}\nsquare catch --help`);
         }
         if (id !== undefined) {
@@ -218,7 +220,7 @@ export const catchCommand = {
         const interrupt = () => controller.abort();
         process.once('SIGINT', interrupt);
         try {
-            const outcome = await withSquare(context, async (square) => (await square.participant(context.name)).catch({ ...intent, observe: true }, {
+            const outcome = await withSquare(context, async (square) => (await selectOwnSeat(square, commandIdentity(context.env, context.owner).owner, context.name)).catch({ ...intent, ...(context.json ? {} : { observe: true }) }, {
                 signal: controller.signal,
                 onProgress(progress) {
                     const line = renderCatchProgress(squarePath, progress);
@@ -226,9 +228,15 @@ export const catchCommand = {
                         process.stderr.write(line);
                 },
             }), { signal: controller.signal });
-            const rendered = renderCatchOutcome(squarePath, outcome, intent);
-            process.stdout.write(rendered.stdout);
-            process.exitCode = rendered.exitCode;
+            if (context.json) {
+                process.stdout.write(jsonResult(outcome));
+                process.exitCode = outcome.reason === 'already-active' || outcome.reason === 'capped' ? 1 : 0;
+            }
+            else {
+                const rendered = renderCatchOutcome(squarePath, outcome, intent, context.owner ?? context.env.SQUARE_OWNER);
+                process.stdout.write(rendered.stdout);
+                process.exitCode = rendered.exitCode;
+            }
         }
         catch (error) {
             if (!controller.signal.aborted)
@@ -288,7 +296,6 @@ function parseHistory(argv, context) {
     let fixed;
     let order;
     let format;
-    let json = false;
     const participants = [];
     for (let index = 0; index < argv.length; index++) {
         const flag = argv[index];
@@ -358,9 +365,7 @@ function parseHistory(argv, context) {
             format = requireValue(argv, index, flag).split(',').map((item) => item.trim()).filter(Boolean);
             index += 1;
         }
-        else if (flag === '--json')
-            json = true;
-        else
+        else if (flag !== '--json')
             fail(`✕ history does not know ${flag}\nsquare history --help`);
     }
     if (grep !== undefined && fixed !== undefined)
@@ -372,7 +377,7 @@ function parseHistory(argv, context) {
     return {
         query: { limit, from: participants, since, after, before, at: at.length === 0 ? undefined : at,
             contextBefore: beforeContext, contextAfter: afterContext, mention, grep, fixed, order },
-        noTruncate, format, json,
+        noTruncate, format,
         continuationArgs: historyContinuationArgs(argv),
     };
 }
@@ -396,30 +401,13 @@ function renderFields(sayNumbers, item, fields) {
         }
     }).join('\t');
 }
-function jsonLine(sayNumbers, item) {
-    const act = item;
-    return JSON.stringify({
-        id: formatActivityId(item.index),
-        index: item.index,
-        kind: act.kind,
-        author: act.actor ?? null,
-        at: act.at,
-        ts: formatTimestamp(act.at),
-        body: 'body' in act && typeof act.body === 'string' ? act.body : '',
-        number: act.kind === 'say' ? sayNumbers[act.index] : null,
-        mentions: act.kind === 'say' ? [...(act.mentions ?? [])] : [],
-        metadata: act.kind === 'say' ? act.metadata ?? null : null,
-        reach: act.kind === 'say' ? act.reach ?? null : null,
-        reply: act.kind === 'say' && act.reply !== undefined ? formatActivityId(act.reply) : null,
-    });
-}
 export const historyCommand = {
     parse(argv, context) { return parseHistory(argv, context); },
     async execute(options, context) {
         const squarePath = requireSquarePath(context);
         let outcome;
         try {
-            outcome = await withSquare(context, (square) => square.history({ ...options.query, observe: true }));
+            outcome = await withSquare(context, (square) => square.history({ ...options.query, ...(context.json ? {} : { observe: true }) }));
         }
         catch (error) {
             const bounds = error?.operation?.historyBounds;
@@ -427,10 +415,10 @@ export const historyCommand = {
                 fail(`✕ history is capped at ${bounds.maxLimit} activities\n${historyContinuationCommand(options, squarePath, ['--limit', String(bounds.maxLimit)])}`);
             throw error;
         }
+        if (context.json)
+            return jsonResult(outcome);
         const projection = outcome.observation;
         const events = projection.activities;
-        if (options.json)
-            return events.map((item) => jsonLine(projection.sayNumbers, item)).join('\n') + (events.length > 0 ? '\n' : '');
         if (options.format !== undefined && options.format.length > 0) {
             return events.map((item) => renderFields(projection.sayNumbers, item, options.format)).join('\n') + (events.length > 0 ? '\n' : '');
         }
@@ -448,6 +436,8 @@ function participantsLimitCommand(squarePath, limit) {
 function parseParticipants(argv, context) {
     let limit = PARTICIPANTS_DEFAULT_LIMIT;
     for (let index = 0; index < argv.length; index++) {
+        if (argv[index] === '--json')
+            continue;
         if (argv[index] !== '--limit')
             usage(context.command);
         limit = parseBoundedLimit(argv[index + 1], '--limit', PARTICIPANTS_MAX_LIMIT, participantsLimitCommand(requireSquarePath(context), PARTICIPANTS_MAX_LIMIT));
@@ -459,35 +449,37 @@ export const participantsCommand = {
     parse(argv, context) { return parseParticipants(argv, context); },
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        const data = await withSquare(context, (square) => square.participants({ observe: true }));
-        return renderParticipantsResult(squarePath, data, intent.limit);
+        const data = await withSquare(context, (square) => square.participants(context.json ? {} : { observe: true }));
+        return context.json ? jsonResult(data) : renderParticipantsResult(squarePath, data, intent.limit);
     },
     present: (result) => process.stdout.write(result),
 };
 export const statusCommand = {
-    parse(argv, context) { if (argv.length > 0)
+    parse(argv, context) { if (argv.some((arg) => arg !== '--json'))
         usage(context.command); return undefined; },
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
-        const result = await withSquare(context, (square) => square.status({ viewer: context.name, observe: true }));
-        return renderStatusResult(squarePath, result);
+        const result = await withSquare(context, async (square) => {
+            const viewer = (await selectOwnSeat(square, commandIdentity(context.env, context.owner).owner, context.name, { optional: true }))?.name;
+            return square.status({ viewer, ...(context.json ? {} : { observe: true }) });
+        });
+        return context.json ? jsonResult(result) : renderStatusResult(squarePath, result);
     },
     present: (result) => process.stdout.write(result),
 };
 export const inboxCommand = {
     parse(argv, context) {
-        let sessionId;
-        let json = false;
+        let owner;
         let limitValue;
         let hasLimit = false;
         let duplicateLimit = false;
         for (let index = 0; index < argv.length; index++) {
-            if (argv[index] === '--for-session') {
-                sessionId = requireValue(argv, index, argv[index]);
+            if (argv[index] === '--for-owner') {
+                owner = requireValue(argv, index, argv[index]);
                 index += 1;
             }
             else if (argv[index] === '--json')
-                json = true;
+                continue;
             else if (argv[index] === '--limit') {
                 if (hasLimit)
                     duplicateLimit = true;
@@ -501,28 +493,23 @@ export const inboxCommand = {
             else
                 usage(context.command);
         }
-        if (!sessionId)
-            fail('inbox requires --for-session <session-id>.');
-        const retry = `square inbox --for-session ${quoteShell(sessionId)} --limit ${INBOX_MAX_LIMIT}${json ? ' --json' : ''}`;
+        if (!owner)
+            fail('inbox requires --for-owner <owner>.');
+        const retry = `square inbox --for-owner ${quoteShell(owner)} --limit ${INBOX_MAX_LIMIT}${context.json ? ' --json' : ''}`;
         if (duplicateLimit)
             fail(`✕ inbox accepts one --limit\n${retry}`);
         const limit = hasLimit
             ? parseBoundedLimit(limitValue, '--limit', INBOX_MAX_LIMIT, retry)
             : INBOX_DEFAULT_LIMIT;
-        return { sessionId, json, limit };
+        return { owner, limit };
     },
     async execute(intent, context) {
-        const data = await inbox(squareInput(context), intent.sessionId, { limit: intent.limit });
-        const rows = data.rows.map((membership) => ({
-            namePreview: inboxDisplay(membership.name),
-            squarePathPreview: inboxDisplay(membership.squarePath),
-            pending: membership.pending,
-        }));
-        if (intent.json)
-            return `${JSON.stringify({ rows, total: data.total })}\n`;
+        const data = await inbox(squareInput(context), intent.owner, { limit: intent.limit });
+        if (context.json)
+            return jsonResult(data);
         return [
-            ...rows.map((row) => `${row.namePreview}\t${row.squarePathPreview}\t${row.pending}\n`),
-            ...(rows.length < data.total ? [`${rows.length} of ${data.total} memberships shown\n`] : []),
+            ...data.rows.map((row) => `${inboxDisplay(row.name)}\t${inboxDisplay(row.squarePath)}\t${row.pending}\n`),
+            ...(data.rows.length < data.total ? [`${data.rows.length} of ${data.total} memberships shown\n`] : []),
         ].join('');
     },
     present: (result) => process.stdout.write(result),

package/dist/cli/program.js

@@ -12,12 +12,12 @@ async function handleSquareError(error, context) {
     const recovery = error.facts?.reason === 'migration_required' || context === undefined || squarePath === undefined ? undefined
         : await withSquare({ ...context, name: detail?.participant ?? context.name }, (square) => square.recovery(detail?.participant ?? context.name)).catch(() => undefined);
     const name = detail?.participant ?? recovery?.participant ?? context?.name;
-    const lines = renderFailureLines(error, { squarePath, name });
+    const lines = renderFailureLines(error, { squarePath, name, owner: context?.owner ?? context?.env.SQUARE_OWNER });
     if (squarePath === undefined)
         process.stderr.write(`${lines.join('\n')}\n`);
     else
         process.stderr.write(formatRefusal(squarePath, lines, {
-            participantCount: recovery?.standingCount, held: recovery?.held,
+            participantCount: recovery?.standingCount,
         }));
     process.exit(error.code === 'not_found' ? 1 : 2);
 }
@@ -32,7 +32,7 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
         }
         const parsed = await parseGlobalArgs(rawArgs);
         const command = parsed.args[0];
-        context = defaultContext(command ?? 'help', parsed.squarePath, parsed.name);
+        context = { ...defaultContext(command ?? 'help', parsed.squarePath, parsed.name), owner: parsed.owner };
         if (command === undefined || command === '--help' || command === '-h') {
             await executeRegisteredCommand('help', [], context);
             return;

package/dist/cli/registry.js

@@ -1,8 +1,9 @@
-import { buildCommand, doneCommand, expressCommand, holdCommand, ignoreCommand, joinCommand, listenCommand, listeningCommand, resumeCommand, unlistenCommand } from './square-commands.js';
+import { buildCommand, doneCommand, expressCommand, ignoreCommand, joinCommand, listenCommand, listeningCommand, unlistenCommand } from './square-commands.js';
 import { doctorCommand, migrateCommand } from './maintenance-commands.js';
 import { harnessCommand, installCommand, uninstallCommand } from './harness-command.js';
 import { helpCommand, versionCommand } from './meta-commands.js';
 import { mcpServerCommand } from './mcp-server-command.js';
+import { JSON_COMMANDS } from './json.js';
 import { catchCommand, claudeModCommand, codexHookCommand, historyCommand, inboxCommand, listCommand, participantsCommand, statusCommand, streamCommand, } from './observation-commands.js';
 /** Every public command is an executable adapter, including aliases and utility commands. */
 export const commandRegistry = [
@@ -20,8 +21,6 @@ export const commandRegistry = [
     { names: ['unlisten'], spec: unlistenCommand },
     { names: ['listening'], spec: listeningCommand },
     { names: ['done'], spec: doneCommand },
-    { names: ['hold'], spec: holdCommand },
-    { names: ['resume'], spec: resumeCommand },
     { names: ['install'], spec: installCommand },
     { names: ['uninstall'], spec: uninstallCommand },
     { names: ['harness'], spec: harnessCommand },
@@ -41,7 +40,9 @@ export async function executeRegisteredCommand(name, argv, context) {
     const command = findCommand(name);
     if (command === undefined)
         throw new Error(`No registered command named ${name}`);
-    const intent = command.spec.parse(argv, context);
-    const result = await command.spec.execute(intent, context);
-    command.spec.present(result, context);
+    const json = JSON_COMMANDS.has(name) && argv.includes('--json');
+    const options = json ? { ...context, json } : context;
+    const intent = command.spec.parse(argv, options);
+    const result = await command.spec.execute(intent, options);
+    command.spec.present(result, options);
 }

package/dist/cli/square-commands.d.ts

@@ -35,6 +35,4 @@ export declare const ignoreCommand: CommandSpec<ListenerIntent, string>;
 export declare const unlistenCommand: CommandSpec<ListenerIntent, string>;
 export declare const listeningCommand: CommandSpec<ListenerIntent, string>;
 export declare const doneCommand: CommandSpec<BodyIntent, string>;
-export declare const holdCommand: CommandSpec<BodyIntent, string>;
-export declare const resumeCommand: CommandSpec<Record<string, never>, string>;
 export {};