@astrosheep/square 0.3.93 → 0.3.94

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, held: fresh?.held };
         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;
@@ -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',
+    'hold', 'resume', '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,7 +12,7 @@ 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
@@ -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

@@ -3,6 +3,7 @@ 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 = [
@@ -41,7 +42,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

@@ -36,5 +36,5 @@ 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 declare const resumeCommand: CommandSpec<BodyIntent, string>;
 export {};

package/dist/cli/square-commands.js

@@ -1,9 +1,10 @@
 import { formatHardCap } from '../model.js';
 import { commandPrefix, participantCommandPrefix, withPathOutput, } from '../presentation.js';
 import { renderJoinResult, renderLifecycleResult, renderListenerChange, renderListeningResult, } from '../operation-presentation.js';
-import { Square } from '../square-api.js';
+import { Square, requireOwner, requireJoinName, selectOwnSeat } from '../square-api.js';
 import { executeExpression } from './express-presentation.js';
-import { squareInput, withSquare, fail, parseBoundedLimit, parseHardCap, parsePositiveInteger, readStdin, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
+import { jsonResult } from './json.js';
+import { squareInput, withSquare, fail, parseBoundedLimit, parseHardCap, parsePositiveInteger, readStdin, requireSquarePath, requireValue, resolveBody, usage, commandIdentity, } from './context.js';
 const JOIN_DEFAULT_LAST = 10;
 const JOIN_MAX_LAST = 100;
 export const buildCommand = {
@@ -69,14 +70,17 @@ export const joinCommand = {
             }
             else if (argv[index] === '--kick')
                 kick = true;
-            else
+            else if (argv[index] !== '--json')
                 usage(context.command);
         }
         return { lastN, kick };
     },
     async execute(intent, context) {
-        const data = await withSquare(context, (square) => square.join(context.name, { takeover: intent.kick, last: intent.lastN, observe: true }));
-        return renderJoinResult(data);
+        const { owner, wakeAddress } = commandIdentity(context.env, context.owner);
+        const data = await withSquare(context, (square) => square.join(requireJoinName(context.name), {
+            owner: requireOwner(owner), wakeAddress, takeover: intent.kick, last: intent.lastN, ...(context.json ? {} : { observe: true }),
+        }));
+        return context.json ? jsonResult(data) : renderJoinResult(data, context.owner ?? context.env.SQUARE_OWNER);
     },
     present: (result) => process.stdout.write(result),
 };
@@ -92,6 +96,8 @@ function parseActivity(argv, context) {
     const bodyArgs = [];
     for (let index = 0; index < argv.length; index++) {
         const argument = argv[index];
+        if (argument === '--json')
+            continue;
         if (argument === '-f' || argument === '--force')
             force = true;
         else if (argument === '--no-wait')
@@ -141,23 +147,25 @@ export const expressCommand = {
         await executeExpression((control) => Square.at(squareInput(context), control), requireSquarePath(context), context.name, rawInput, {
             force: intent.force, noWait: intent.noWait, noMention: intent.noMention,
             mentions: intent.mentions, reach: intent.reach, reply: intent.reply, metadata: intent.metadata,
+            recoveryOwner: context.owner ?? context.env.SQUARE_OWNER,
             metadataJson: intent.metadataJson, bodyProvided: intent.activity !== undefined,
-        });
+        }, context.json, () => commandIdentity(context.env, context.owner).owner);
     },
     present: () => { },
 };
 function parseListener(argv, context, targetRequired) {
-    if (targetRequired ? argv.length !== 1 : argv.length !== 0)
+    const args = argv.filter((arg) => arg !== '--json');
+    if (targetRequired ? args.length !== 1 : args.length !== 0)
         usage(context.command);
-    return targetRequired ? { target: argv[0] } : {};
+    return targetRequired ? { target: args[0] } : {};
 }
 function listenerCommand(verb) {
     return {
         parse(argv, context) { return parseListener(argv, context, true); },
         async execute(intent, context) {
             const squarePath = requireSquarePath(context);
-            const data = await withSquare(context, async (square) => (await square.participant(context.name))[verb](intent.target, { observe: true }));
-            return renderListenerChange(squarePath, verb, data);
+            const data = await withSquare(context, async (square) => (await selectOwnSeat(square, commandIdentity(context.env, context.owner).owner, context.name))[verb](intent.target, context.json ? {} : { observe: true }));
+            return context.json ? jsonResult(data) : renderListenerChange(squarePath, verb, data);
         },
         present: (result) => process.stdout.write(result),
     };
@@ -169,50 +177,34 @@ export const listeningCommand = {
     parse(argv, context) { return parseListener(argv, context, false); },
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
-        const data = await withSquare(context, async (square) => (await square.participant(context.name)).listening({ observe: true }));
-        return renderListeningResult(squarePath, data);
-    },
-    present: (result) => process.stdout.write(result),
-};
-export const doneCommand = {
-    parse(argv, context) {
-        if (argv.length > 1)
-            usage(context.command);
-        return { body: argv[0] };
-    },
-    async execute(intent, context) {
-        const body = intent.body === '-' || ((intent.body === undefined || intent.body === '') && !process.stdin.isTTY)
-            ? await readStdin() : intent.body;
-        const squarePath = requireSquarePath(context);
-        const data = await withSquare(context, async (square) => (await square.participant(context.name)).done(body, { observe: true }));
-        return renderLifecycleResult(squarePath, 'done', data);
-    },
-    present: (result) => process.stdout.write(result),
-};
-export const holdCommand = {
-    parse(argv, context) {
-        if (argv.length > 1)
-            usage(context.command);
-        return { body: argv[0] };
-    },
-    async execute(intent, context) {
-        const body = (await resolveBody(intent.body ?? '')).replace(/\r\n/g, '\n').trim();
-        const squarePath = requireSquarePath(context);
-        const result = await withSquare(context, async (square) => (await square.participant(context.name)).hold(body, { observe: true }));
-        return renderLifecycleResult(squarePath, 'hold', result);
-    },
-    present: (result) => process.stdout.write(result),
-};
-export const resumeCommand = {
-    parse(argv, context) {
-        if (argv.length !== 0)
-            usage(context.command);
-        return {};
-    },
-    async execute(_intent, context) {
-        const squarePath = requireSquarePath(context);
-        const result = await withSquare(context, async (square) => (await square.participant(context.name)).resume({ observe: true }));
-        return renderLifecycleResult(squarePath, 'resume', result);
+        const data = await withSquare(context, async (square) => (await selectOwnSeat(square, commandIdentity(context.env, context.owner).owner, context.name)).listening(context.json ? {} : { observe: true }));
+        return context.json ? jsonResult(data) : renderListeningResult(squarePath, data);
     },
     present: (result) => process.stdout.write(result),
 };
+function lifecycleCommand(verb) {
+    return {
+        parse(argv, context) {
+            const args = argv.filter((arg) => arg !== '--json');
+            if (args.length > (verb === 'resume' ? 0 : 1))
+                usage(context.command);
+            return { body: args[0] };
+        },
+        async execute(intent, context) {
+            const body = verb === 'hold' ? (await resolveBody(intent.body ?? '')).replace(/\r\n/g, '\n').trim()
+                : verb === 'done' && (intent.body === '-' || ((intent.body === undefined || intent.body === '') && !process.stdin.isTTY))
+                    ? await readStdin() : intent.body;
+            const squarePath = requireSquarePath(context);
+            const result = await withSquare(context, async (square) => {
+                const participant = await selectOwnSeat(square, commandIdentity(context.env, context.owner).owner, context.name);
+                const options = context.json ? {} : { observe: true };
+                return verb === 'resume' ? participant.resume(options) : participant[verb](body, options);
+            });
+            return context.json ? jsonResult(result) : renderLifecycleResult(squarePath, verb, result);
+        },
+        present: (result) => process.stdout.write(result),
+    };
+}
+export const doneCommand = lifecycleCommand('done');
+export const holdCommand = lifecycleCommand('hold');
+export const resumeCommand = lifecycleCommand('resume');

package/dist/codex-hook.d.ts

@@ -1,4 +1,5 @@
-import type { Body, PendingMembership } from './model.js';
+import { type Owner } from './owner.js';
+import type { PendingMembership } from './model.js';
 import type { WakeTransports } from './notifications.js';
 export interface CodexHookInput {
     session_id?: unknown;
@@ -8,6 +9,6 @@ export interface CodexHookInput {
 }
 export type HookTrace = (line: string) => void;
 export declare const CODEX_HOOK_BUDGET_MS = 4500;
-export declare function codexHookResponse(input: CodexHookInput, lookup?: (identity: Body, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<PendingMembership[]> | PendingMembership[], env?: NodeJS.ProcessEnv, deliveryTransports?: WakeTransports, trace?: HookTrace): Promise<object | undefined>;
+export declare function codexHookResponse(input: CodexHookInput, lookup?: (identity: Owner, env?: NodeJS.ProcessEnv, signal?: AbortSignal) => Promise<PendingMembership[]> | PendingMembership[], env?: NodeJS.ProcessEnv, deliveryTransports?: WakeTransports, trace?: HookTrace): Promise<object | undefined>;
 export declare function runCodexHook(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;
 export declare const runCodexHookAsync: typeof runCodexHook;

package/dist/codex-hook.js

@@ -1,8 +1,10 @@
 import { handleCodexHook } from './packages/agent-delivery/src/codex-hook.js';
 import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
-import { endSessionMemberships } from './session-lifecycle.js';
+import { harnessOwner } from './owner.js';
+import { detachSessionSeats, restoreSessionSeats } from './session-lifecycle.js';
 import { codexBoundaryStore } from './codex-boundary-state.js';
+import { codexWakeAddress } from './codex-address.js';
 import { PRIVILEGED_HOOK_BUDGET_MS, sweepPrivilegedPending } from './notifications.js';
 export const CODEX_HOOK_BUDGET_MS = 4500;
 const defaultTrace = (line) => { process.stderr.write(`${line}\n`); };
@@ -10,13 +12,20 @@ export async function codexHookResponse(input, lookup = sessionInbox, env = proc
     const configured = Number(env.SQUARE_CODEX_HOOK_BUDGET_MS ?? CODEX_HOOK_BUDGET_MS);
     const startedAt = Date.now();
     let mark = startedAt;
+    const timeoutMs = Number.isFinite(configured) && configured > 0 ? configured : CODEX_HOOK_BUDGET_MS;
+    const signal = AbortSignal.timeout(timeoutMs);
+    if ((input.hook_event_name === 'SessionStart' || input.hook_event_name === 'SessionResume')
+        && typeof input.session_id === 'string' && input.session_id.trim()) {
+        await restoreSessionSeats(harnessOwner({ channel: 'codex', session: input.session_id }), env, codexWakeAddress(input.session_id, env), signal);
+    }
     return handleCodexHook(input, {
         boundaries: codexBoundaryStore(env),
-        timeoutMs: Number.isFinite(configured) && configured > 0 ? configured : CODEX_HOOK_BUDGET_MS,
+        timeoutMs,
+        signal,
         sweepTimeoutMs: PRIVILEGED_HOOK_BUDGET_MS,
-        pull: (id, signal) => presentPendingAtBoundary({ channel: 'codex', session: id }, (context) => context, lookup, env, signal),
+        pull: (id, signal) => presentPendingAtBoundary(harnessOwner({ channel: 'codex', session: id }), (context) => context, lookup, env, signal),
         sweep: (cwd, deadline, signal) => sweepPrivilegedPending(cwd ?? process.cwd(), env, deliveryTransports, deadline, signal),
-        end: async (id) => { await endSessionMemberships('codex', id, env); },
+        end: async (id) => { await detachSessionSeats('codex', id, env); },
         trace: (name, detail = '') => {
             const now = Date.now();
             const durationMs = now - mark;