@astrosheep/square 0.3.11 → 0.3.13

package/dist/automatic-session.d.ts

@@ -0,0 +1,5 @@
+export type AutomaticProvider = 'codex' | 'claude' | 'opencode' | 'pi';
+export declare function publicSquarePath(cwd: string): string;
+export declare function automaticParticipant(provider: AutomaticProvider, sessionId: string, env: NodeJS.ProcessEnv): string;
+export declare function automaticSessionStart(provider: AutomaticProvider, sessionId: string, cwd: string, env?: NodeJS.ProcessEnv): Promise<string | undefined>;
+export declare function automaticSessionEnd(provider: AutomaticProvider, sessionId: string, cwd: string, env?: NodeJS.ProcessEnv): Promise<void>;

package/dist/automatic-session.js

@@ -0,0 +1,86 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { openSquare } from './square-file-adapter.js';
+import { closeOpenSquare } from './open-square.js';
+import { Square } from './square-wiring.js';
+import { entryPresentation } from './views.js';
+import { canonicalSquarePath, lookupSession, lookupSessionBindings, recordSessionDone, recordSessionJoin } from './registry.js';
+import { participantIdentity, renderAmbientEvent } from './presentation.js';
+import { validateName } from './model.js';
+const providerEnv = {
+    codex: 'CODEX_THREAD_ID',
+    claude: 'CLAUDE_CODE_SESSION_ID',
+    opencode: 'OPENCODE_SESSION_ID',
+    pi: 'SQUARE_PI_SESSION_ID',
+};
+export function publicSquarePath(cwd) {
+    return path.join(cwd, '.square', 'PUBLIC.square');
+}
+export function automaticParticipant(provider, sessionId, env) {
+    const configured = env.SQUARE_PARTICIPANT_NAME?.trim();
+    if (configured) {
+        validateName(configured);
+        return configured;
+    }
+    const digest = createHash('sha256').update(sessionId, 'utf8').digest('hex').slice(0, 12);
+    return `${provider}-${digest}`;
+}
+export async function automaticSessionStart(provider, sessionId, cwd, env = process.env) {
+    const squarePath = publicSquarePath(cwd);
+    if (!fs.existsSync(squarePath))
+        return undefined;
+    let reader;
+    try {
+        reader = await openSquare(squarePath);
+    }
+    catch (error) {
+        process.stderr.write(`! PUBLIC.square unreadable: ${error instanceof Error ? error.message : String(error)}\n`);
+        return undefined;
+    }
+    const name = automaticParticipant(provider, sessionId, env);
+    const bindings = lookupSession(sessionId);
+    const before = await entryPresentation(reader, name);
+    if (bindings.some((binding) => canonicalSquarePath(binding.squarePath) === canonicalSquarePath(squarePath) && binding.name === name) && before.joined) {
+        await closeOpenSquare(reader);
+        return undefined;
+    }
+    await closeOpenSquare(reader);
+    const square = await Square.at({ path: squarePath });
+    try {
+        await square.join(name);
+        const channel = provider === 'claude' ? 'claude-code' : provider;
+        recordSessionJoin(sessionId, name, squarePath, channel, { ...env, [providerEnv[provider]]: sessionId });
+        const afterSquare = await openSquare(squarePath);
+        const after = await entryPresentation(afterSquare, name, 10).finally(() => closeOpenSquare(afterSquare));
+        const activity = after.recentActivities.map((event) => renderAmbientEvent(event, name, {
+            now: Date.now(),
+            preview: 200,
+            actNumber: event.kind === 'say' ? after.sayNumbers[event.index] : undefined,
+        })).filter(Boolean).join('\n\n');
+        return [`You joined the public square as ${participantIdentity(name)}.`, after.scene, after.context ? `context\n${after.context}` : '', activity ? `recent activity\n${activity}` : ''].filter(Boolean).join('\n\n');
+    }
+    finally {
+        await square.close();
+    }
+}
+export async function automaticSessionEnd(provider, sessionId, cwd, env = process.env) {
+    const squarePath = publicSquarePath(cwd);
+    const channel = provider === 'claude' ? 'claude-code' : provider;
+    const binding = lookupSessionBindings(sessionId).find((item) => canonicalSquarePath(item.squarePath) === canonicalSquarePath(squarePath) && item.channel === channel);
+    if (binding === undefined || !fs.existsSync(squarePath))
+        return;
+    const reader = await openSquare(squarePath);
+    const joined = await entryPresentation(reader, binding.name).finally(() => closeOpenSquare(reader));
+    if (!joined.joined)
+        return;
+    const square = await Square.at({ path: squarePath });
+    try {
+        const participant = await square.join(binding.name);
+        await participant.done();
+    }
+    finally {
+        await square.close();
+    }
+    recordSessionDone(sessionId, binding.name, squarePath, channel, env);
+}

package/dist/boundary-presentation.d.ts

@@ -0,0 +1,5 @@
+import type { InboxMembership } from './model.js';
+/** A fresh blocking catch owns only the notifications admitted by its filter. */
+export declare function pendingAtBoundary(inbox: InboxMembership[]): InboxMembership[];
+export declare function renderPendingAtBoundary(inbox: InboxMembership[]): string;
+export declare function presentPendingAtBoundary<T>(sessionId: string, present: (context: string) => T, lookup?: (sessionId: string) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv): Promise<T | undefined>;

package/dist/boundary-presentation.js

@@ -1,6 +1,6 @@
 import { leaseOwnsNotification, notificationMessageId } from './delivery.js';
 import { sessionInbox } from './inbox.js';
-import { participantCommandPrefix } from './presentation.js';
+import { participantCommandPrefix, participantIdentity } from './presentation.js';
 import { presentOnce } from './presented.js';
 const BODY_MAX = 200;
 const CONTEXT_MAX = 1200;
@@ -16,7 +16,7 @@ export function pendingAtBoundary(inbox) {
             return membership;
         return {
             ...membership,
-            notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.name })),
+            notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, notification)),
         };
     })
         .filter((membership) => membership.notifications.length > 0);
@@ -43,7 +43,7 @@ export function renderPendingAtBoundary(inbox) {
         const command = `${participantCommandPrefix(membership.squarePath, membership.name)} catch --now`;
         const id = notificationMessageId(membership.squarePath, notification.actIndex);
         const block = [
-            `${id} · ${membership.squarePath}: @${membership.name} from @${notification.actor} (${notification.route})`,
+            `${id} · ${membership.squarePath}: ${participantIdentity(membership.name)} from ${participantIdentity(notification.actor)} (${notification.route})`,
             bodyPreview(notification.body),
             `Ack with: ${command}`,
         ].join('\n');
@@ -72,6 +72,7 @@ export function renderPendingAtBoundary(inbox) {
         ...footer,
     ].join('\n');
 }
-export function presentPendingAtBoundary(sessionId, present, lookup = sessionInbox, env = process.env) {
-    return presentOnce(sessionId, (id) => pendingAtBoundary(lookup(id)), (inbox) => present(renderPendingAtBoundary(inbox)), env);
+export async function presentPendingAtBoundary(sessionId, present, lookup = sessionInbox, env = process.env) {
+    const inbox = await lookup(sessionId);
+    return presentOnce(sessionId, () => pendingAtBoundary(inbox), (inbox) => present(renderPendingAtBoundary(inbox)), env);
 }

package/dist/claude-hook.d.ts

@@ -0,0 +1,9 @@
+import type { InboxMembership } from './model.js';
+export interface NativeHookInput {
+    session_id?: unknown;
+    hook_event_name?: unknown;
+    cwd?: unknown;
+}
+export declare function runClaudeHookAsync(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;
+export declare function claudeHookResponse(input: NativeHookInput, lookup?: (sessionId: string) => Promise<InboxMembership[]> | InboxMembership[], env?: NodeJS.ProcessEnv): Promise<object | undefined>;
+export declare function runClaudeHook(inputText: string, env?: NodeJS.ProcessEnv): Promise<string>;

package/dist/claude-hook.js

@@ -1,13 +1,45 @@
 import { presentPendingAtBoundary } from './boundary-presentation.js';
 import { sessionInbox } from './inbox.js';
-export function claudeHookResponse(input, lookup = sessionInbox, env = process.env) {
+import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
+export async function runClaudeHookAsync(inputText, env = process.env) {
+    let input;
+    try {
+        input = JSON.parse(inputText);
+    }
+    catch {
+        return '';
+    }
+    if (input === null || typeof input !== 'object')
+        return '';
+    const value = input;
+    if (typeof value.session_id !== 'string' || typeof value.cwd !== 'string')
+        return runClaudeHook(inputText, env);
+    if (value.hook_event_name === 'SessionStart' || value.hook_event_name === 'SessionResume') {
+        try {
+            const context = await automaticSessionStart('claude', value.session_id, value.cwd, env);
+            return context === undefined ? '' : `${JSON.stringify({ hookSpecificOutput: { hookEventName: value.hook_event_name, additionalContext: context } })}\n`;
+        }
+        catch {
+            return '';
+        }
+    }
+    if (value.hook_event_name === 'SessionEnd') {
+        try {
+            await automaticSessionEnd('claude', value.session_id, value.cwd, env);
+        }
+        catch { /* end remains bounded */ }
+        return '';
+    }
+    return runClaudeHook(inputText, env);
+}
+export async function claudeHookResponse(input, lookup = sessionInbox, env = process.env) {
     if (typeof input.session_id !== 'string' || input.session_id === '')
         return undefined;
     if (input.hook_event_name !== 'PostToolBatch')
         return undefined;
     return presentPendingAtBoundary(input.session_id, (context) => ({ hookSpecificOutput: { hookEventName: 'PostToolBatch', additionalContext: context } }), lookup, env);
 }
-export function runClaudeHook(inputText, env = process.env) {
+export async function runClaudeHook(inputText, env = process.env) {
     let input;
     try {
         input = JSON.parse(inputText);
@@ -17,6 +49,6 @@ export function runClaudeHook(inputText, env = process.env) {
     }
     if (input === null || typeof input !== 'object')
         return '';
-    const response = claudeHookResponse(input, sessionInbox, env);
+    const response = await claudeHookResponse(input, sessionInbox, env);
     return response === undefined ? '' : `${JSON.stringify(response)}\n`;
 }

package/dist/cli/context.d.ts

@@ -0,0 +1,35 @@
+import { type HardCap } from '../model.js';
+export declare const DEFAULT_SQUARE_PATH = ".square/SQUARE.square";
+export interface CommandContext {
+    squarePath: string;
+    name?: string;
+    homeDir: string;
+    command: string;
+}
+export interface CommandSpec<Intent = unknown, Result = void> {
+    parse(argv: string[], context: CommandContext): Intent;
+    execute(intent: Intent, context: CommandContext): Promise<Result> | Result;
+    present(result: Result, context: CommandContext): void;
+}
+export declare function readStdinSync(): string;
+export declare function resolveBody(arg: string): string;
+export declare function readPipedBodyFallback(): string | undefined;
+export declare function fail(message: string, exitCode?: number): never;
+export declare function usage(command: string): never;
+export declare function requireValue(args: string[], index: number, flag: string): string;
+export declare function parseDurationMs(value: string, flag: string): number;
+export declare function parsePositiveInteger(value: string, flag: string): number;
+export declare function parseNonNegativeInteger(value: string, flag: string): number;
+export declare function parseHardCap(value: string): HardCap;
+export declare function parseNameList(value: string, flag: string): string[];
+export declare function requireParticipant(name: string | undefined): string;
+export interface ParsedGlobalArgs {
+    squarePath: string;
+    explicitSquarePath: boolean;
+    multipleSquares: boolean;
+    name?: string;
+    args: string[];
+}
+export declare function parseGlobalArgs(rawArgs: string[]): ParsedGlobalArgs;
+export declare function locationIsRequired(command: string): boolean;
+export declare function defaultContext(command: string, squarePath: string, name?: string): CommandContext;

package/dist/cli/context.js

@@ -1,10 +1,9 @@
 import fs from 'node:fs';
 import os from 'node:os';
-import path from 'node:path';
-import { loadSquare } from '../artifact.js';
 import { commandUsageHint } from '../help.js';
 import { parseParticipantList, validateName } from '../model.js';
-export const DEFAULT_SQUARE_PATH = '.square/SQUARE.md';
+import { localParticipantName } from '../registry.js';
+export const DEFAULT_SQUARE_PATH = '.square/SQUARE.square';
 export function readStdinSync() {
     try {
         return fs.readFileSync(0, 'utf8');
@@ -88,30 +87,17 @@ export function requireParticipant(name) {
     validateName(name);
     return name;
 }
-function resolveDefaultSquarePath() {
-    const directory = path.join(process.cwd(), '.square');
-    let entries;
-    try {
-        entries = fs.readdirSync(directory, { withFileTypes: true });
-    }
-    catch {
-        return { path: DEFAULT_SQUARE_PATH, multiple: false };
-    }
-    const candidates = [];
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith('.md'))
-            continue;
-        const fullPath = path.join(directory, entry.name);
-        try {
-            const doc = loadSquare(fullPath);
-            candidates.push({ relPath: path.relative(process.cwd(), fullPath), at: doc.acts.at(-1)?.at ?? fs.statSync(fullPath).mtimeMs });
-        }
-        catch {
-            // Unreadable artifacts are not implicit command targets.
-        }
-    }
-    candidates.sort((a, b) => b.at - a.at);
-    return { path: candidates[0]?.relPath ?? DEFAULT_SQUARE_PATH, multiple: candidates.length > 1 };
+const LOCATION_REQUIRED_COMMANDS = new Set(['join', 'catch', 'express', 'done', 'hold', 'resume']);
+function configuredLocation() {
+    const value = process.env.SQUARE_LOCATION?.trim();
+    return value === '' ? undefined : value;
+}
+function configuredName() {
+    const value = process.env.SQUARE_PARTICIPANT_NAME?.trim();
+    if (!value)
+        return undefined;
+    validateName(value);
+    return value;
 }
 export function parseGlobalArgs(rawArgs) {
     const args = [...rawArgs];
@@ -129,14 +115,23 @@ export function parseGlobalArgs(rawArgs) {
             index -= 1;
         }
     }
+    if (name === undefined)
+        name = configuredName();
     if (name !== undefined)
         validateName(name);
     const explicitSquarePath = requestedPath !== undefined;
     const command = args[0];
-    const resolved = !explicitSquarePath && !['ls', 'list', 'version', 'install', 'uninstall'].includes(command ?? '')
-        ? resolveDefaultSquarePath()
-        : { path: requestedPath ?? DEFAULT_SQUARE_PATH, multiple: false };
-    return { squarePath: resolved.path, explicitSquarePath, multipleSquares: resolved.multiple, name, args };
+    const configured = configuredLocation();
+    if (command !== undefined && !['--help', '-h'].includes(command) && locationIsRequired(command) && requestedPath === undefined && configured === undefined) {
+        fail(`✕ ${command} needs a square location\n» square ls`);
+    }
+    const squarePath = requestedPath ?? configured ?? DEFAULT_SQUARE_PATH;
+    if (name === undefined && command !== undefined && locationIsRequired(command))
+        name = localParticipantName(squarePath);
+    return { squarePath, explicitSquarePath: explicitSquarePath || configured !== undefined, multipleSquares: false, name, args };
+}
+export function locationIsRequired(command) {
+    return LOCATION_REQUIRED_COMMANDS.has(command);
 }
 export function defaultContext(command, squarePath, name) {
     return { command, squarePath, name, homeDir: os.homedir() };

package/dist/cli/harness-command.d.ts

@@ -0,0 +1,28 @@
+import { executeHarnessTarget, type HarnessAction } from '../harness.js';
+import { type CommandSpec } from './context.js';
+export type HarnessCommandAction = HarnessAction;
+export interface ParsedHarnessCommand {
+    target?: string;
+}
+export interface ParsedInstallCommand {
+    targets: string[];
+    all: boolean;
+    force: boolean;
+}
+export interface HarnessCommandResult {
+    lines: string[];
+    notes: string[];
+    failures: string[];
+}
+type HarnessTargetExecutor = typeof executeHarnessTarget;
+export declare function executeTargetBatch(targets: string[], action: 'install' | 'uninstall', context: {
+    homeDir: string;
+    squarePath?: string;
+    force: boolean;
+}, executeTarget?: HarnessTargetExecutor): Promise<HarnessCommandResult>;
+export declare const installCommand: CommandSpec<ParsedInstallCommand, HarnessCommandResult>;
+export declare const uninstallCommand: CommandSpec<ParsedInstallCommand, HarnessCommandResult>;
+export declare const harnessCommand: CommandSpec<ParsedHarnessCommand, HarnessCommandResult>;
+export declare function formatHarnessResult(result: HarnessCommandResult): string;
+export declare function runHarnessCommand(argv: string[], squarePath?: string): Promise<string>;
+export {};

package/dist/cli/harness-command.js

@@ -26,24 +26,38 @@ function parseInstall(argv, action) {
         throw new Error(`Cannot combine ${action} --all with named targets`);
     return { targets, all, force };
 }
+export async function executeTargetBatch(targets, action, context, executeTarget = executeHarnessTarget) {
+    const results = [];
+    const failures = [];
+    for (const target of targets) {
+        try {
+            results.push(await executeTarget(target, action, context));
+        }
+        catch (error) {
+            failures.push(`✕ ${target} ${action} failed: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        notes: results.flatMap((result) => result.notes),
+        lines: results.flatMap((result) => result.lines),
+        failures,
+    };
+}
 function targetCommand(action) {
     return {
         parse(argv) { return parseInstall(argv, action); },
         async execute(intent, context) {
-            const results = [];
-            for (const target of installTargets(intent, action)) {
-                results.push(await executeHarnessTarget(target, action, {
-                    homeDir: context.homeDir,
-                    squarePath: context.squarePath,
-                    force: intent.force,
-                }));
-            }
-            return {
-                notes: results.flatMap((result) => result.notes),
-                lines: results.flatMap((result) => result.lines),
-            };
+            return executeTargetBatch(installTargets(intent, action), action, {
+                homeDir: context.homeDir,
+                squarePath: context.squarePath,
+                force: intent.force,
+            });
+        },
+        present(result) {
+            process.stdout.write(formatHarnessResult(result));
+            if (result.failures.length > 0)
+                process.exitCode = 1;
         },
-        present(result) { process.stdout.write(formatHarnessResult(result)); },
     };
 }
 export const installCommand = targetCommand('install');
@@ -77,6 +91,7 @@ export const harnessCommand = {
         return {
             notes: results.flatMap((result) => result.notes),
             lines: results.flatMap((result) => result.lines),
+            failures: [],
         };
     },
     present(result) {
@@ -84,10 +99,10 @@ export const harnessCommand = {
     },
 };
 export function formatHarnessResult(result) {
-    return `${[...result.notes, ...result.lines].join('\n')}\n`;
+    return `${[...result.notes, ...result.lines, ...result.failures].join('\n')}\n`;
 }
 export function runHarnessCommand(argv, squarePath) {
-    const context = { homeDir: os.homedir(), squarePath: squarePath ?? '.square/SQUARE.md', command: 'harness' };
+    const context = { homeDir: os.homedir(), squarePath: squarePath ?? '.square/SQUARE.square', command: 'harness' };
     const intent = harnessCommand.parse(argv, context);
     return Promise.resolve(harnessCommand.execute(intent, context)).then(formatHarnessResult);
 }

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

@@ -0,0 +1,7 @@
+import { type CommandSpec } from './context.js';
+interface DoctorResult {
+    output: string;
+    exitCode?: number;
+}
+export declare const doctorCommand: CommandSpec<undefined, DoctorResult>;
+export {};

package/dist/cli/maintenance-commands.js

@@ -1,82 +1,25 @@
-import fs from 'node:fs';
-import { diagnoseSquare, loadSquare } from '../artifact.js';
-import { renderDoctorClean, renderDoctorProblems, renderDoctorRepaired, renderDoctorUnfixable, withPathOutput, } from '../presentation.js';
+import { diagnoseSquareFile } from '../square-storage.js';
+import { renderDoctorClean, renderDoctorUnfixable, withPathOutput } from '../presentation.js';
 import { inSquareCount } from '../runtime.js';
-import { repairSquare } from '../square-application.js';
-import { SquareError } from '../model.js';
-import { pruneRegistry } from '../registry.js';
 import { usage } from './context.js';
-function readSquareText(squarePath) {
-    try {
-        return fs.readFileSync(squarePath, 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            throw new SquareError('not_found', `square file not found: ${squarePath}`);
-        throw error;
-    }
-}
-function quarantinePath(squarePath) {
-    return squarePath.replace(/\.md$/, '') + '.quarantine.md';
-}
-function registryActs(squarePath) {
-    if (!fs.existsSync(squarePath))
-        return [];
-    try {
-        return loadSquare(squarePath).acts;
-    }
-    catch {
-        // A temporarily unreadable artifact cannot disprove a cache binding.
-        return undefined;
-    }
-}
 export const doctorCommand = {
     parse(argv, context) {
-        let fix = false;
-        for (let index = 0; index < argv.length; index++) {
-            const argument = argv[index];
-            if (argument === '--fix')
-                fix = true;
-            else if (argument === '--before') {
-                index += 1;
-                if (argv[index] === undefined)
-                    usage(context.command);
-            }
-            else
-                usage(context.command);
-        }
-        return { fix };
+        if (argv.length > 0)
+            usage(context.command);
+        return undefined;
     },
-    async execute(intent, context) {
-        if (!intent.fix) {
-            const diagnosis = diagnoseSquare(readSquareText(context.squarePath));
-            if (diagnosis.unfixable) {
-                return {
-                    output: withPathOutput(context.squarePath, renderDoctorUnfixable(diagnosis.unfixable), { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
-                    exitCode: 2,
-                };
-            }
-            const summary = diagnosis.problems.length === 0 ? renderDoctorClean() : renderDoctorProblems(diagnosis.problems);
+    execute(_intent, context) {
+        const diagnosis = diagnoseSquareFile(context.squarePath);
+        if (diagnosis.unfixable !== undefined || diagnosis.state === undefined) {
             return {
-                output: withPathOutput(context.squarePath, summary, { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
-                exitCode: diagnosis.problems.length === 0 ? 0 : 1,
-            };
-        }
-        const repair = await repairSquare(context.squarePath);
-        if (repair.diagnosis.unfixable) {
-            return {
-                output: withPathOutput(context.squarePath, renderDoctorUnfixable(repair.diagnosis.unfixable), { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
+                output: withPathOutput(context.squarePath, renderDoctorUnfixable(diagnosis.unfixable ?? 'the snapshot could not be decoded')),
                 exitCode: 2,
             };
         }
-        const repaired = repair.repaired;
-        const registry = pruneRegistry(registryActs);
-        if (registry.removed > 0) {
-            repaired.actions.push({ message: `pruned ${registry.removed} obsolete registry membership(s)` });
-        }
-        const sidecar = quarantinePath(context.squarePath);
         return {
-            output: withPathOutput(context.squarePath, renderDoctorRepaired(repaired.actions, repaired.quarantinedBlocks.length, repaired.quarantinedBlocks.length > 0 ? sidecar : undefined), { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
+            output: withPathOutput(context.squarePath, renderDoctorClean(), {
+                participantCount: inSquareCount(diagnosis.state),
+            }),
         };
     },
     present(result) {

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

@@ -0,0 +1,5 @@
+import { type CommandSpec } from './context.js';
+export declare const helpCommand: CommandSpec<{
+    command?: string;
+}, string>;
+export declare const versionCommand: CommandSpec<undefined, string>;

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

@@ -0,0 +1,20 @@
+import { type ActivitiesOptions, type WatchOptions } from '../model.js';
+import { type CommandSpec } from './context.js';
+export declare const listCommand: CommandSpec<string[]>;
+interface StreamIntent {
+    ndjson: boolean;
+    forName?: string;
+}
+export declare const streamCommand: CommandSpec<StreamIntent>;
+export declare const catchCommand: CommandSpec<WatchOptions>;
+export declare const historyCommand: CommandSpec<ActivitiesOptions, string>;
+export declare const participantsCommand: CommandSpec<undefined, string>;
+export declare const statusCommand: CommandSpec<undefined, string>;
+interface InboxIntent {
+    sessionId: string;
+    json: boolean;
+}
+export declare const inboxCommand: CommandSpec<InboxIntent, string>;
+export declare const claudeHookCommand: CommandSpec<undefined, string>;
+export declare const codexHookCommand: CommandSpec<undefined, string>;
+export {};