@astrosheep/square 0.4.6 → 0.4.8

package/dist/card-format.d.ts

@@ -0,0 +1,2 @@
+/** Receiver formatting shared by the Paseo and Pi cards. */
+export { cardReferences, reachLabel, timeLabel } from './plugins/paseo/shared/card-format.js';

package/dist/card-format.js

@@ -0,0 +1,2 @@
+/** Receiver formatting shared by the Paseo and Pi cards. */
+export { cardReferences, reachLabel, timeLabel } from './plugins/paseo/shared/card-format.js';

package/dist/claude-mcp-context.d.ts

@@ -10,6 +10,5 @@ export declare function beginClaudeMcpCall(input: ClaudeMcpCall, env?: NodeJS.Pr
     token: string;
 }>;
 export declare function endClaudeMcpCall(toolUseId: string, token: string, env?: NodeJS.ProcessEnv): Promise<void>;
-export declare function endClaudeMcpCallForSession(toolUseId: string, sessionId: string, env?: NodeJS.ProcessEnv, agentId?: string, signal?: AbortSignal): Promise<void>;
 export declare function readClaudeMcpCall(toolUseId: unknown, env?: NodeJS.ProcessEnv): Promise<ClaudeMcpCall>;
 export {};

package/dist/claude-mcp-context.js

@@ -71,16 +71,6 @@ export async function endClaudeMcpCall(toolUseId, token, env = process.env) {
             await fs.unlink(file);
     });
 }
-export async function endClaudeMcpCallForSession(toolUseId, sessionId, env = process.env, agentId, signal) {
-    if (!text.safeParse(toolUseId).success || !text.safeParse(sessionId).success)
-        throw unavailable();
-    await mutate(env, async (root) => {
-        const file = callFile(root, toolUseId);
-        const stored = await readRecord(file);
-        if (stored?.toolUseId === toolUseId && stored.sessionId === sessionId && stored.agentId === agentId)
-            await fs.unlink(file);
-    }, signal);
-}
 export async function readClaudeMcpCall(toolUseId, env = process.env) {
     if (!text.safeParse(toolUseId).success)
         throw unavailable();

package/dist/claude-mod.d.ts

@@ -0,0 +1,2 @@
+/** One mod-owned helper. Only this process touches Node/SQLite; no producer socket or inbox. */
+export declare function runClaudeMod(input: string, env?: NodeJS.ProcessEnv, signal?: AbortSignal, output?: (line: string) => void | Promise<void>): Promise<string>;

package/dist/claude-mod.js

@@ -0,0 +1,211 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { createServer } from 'node:http';
+import { once } from 'node:events';
+import { z } from 'zod/v4';
+import { DeliveryLedger, deliveryLedgerLocation } from './delivery-ledger.js';
+import { retainDeliveryLedger } from './delivery-lifetime.js';
+import { harnessOwner } from './owner.js';
+import { attachDeliverySession, detachDeliverySession } from './session-lifecycle.js';
+import { beginClaudeMcpCall, endClaudeMcpCall } from './claude-mcp-context.js';
+import { renderDeliveryReminder } from './delivery-frame.js';
+const routeKind = 'claude-mod';
+const nativeId = z.string().min(1).max(4096).regex(/^[^\x00-\x1f\x7f]+$/u);
+const coordinate = z.object({ agentId: nativeId.optional() });
+const request = z.discriminatedUnion('op', [
+    coordinate.extend({ op: z.literal('state'), mode: z.enum(['busy', 'idle', 'stopped', 'ended']) }),
+    z.object({ op: z.literal('guard'), token: z.string().uuid() }),
+    z.object({ op: z.literal('settle'), token: z.string().uuid(), kind: z.enum(['append', 'submit', 'failed', 'unknown', 'released']),
+        text: z.string().optional(), uuid: nativeId.optional() }),
+    coordinate.extend({ op: z.literal('mcp-begin'), toolUseId: nativeId, cwd: z.string().min(1) }),
+    z.object({ op: z.literal('mcp-end'), toolUseId: nativeId, token: nativeId }),
+    z.object({ op: z.literal('close') }),
+]);
+/** One mod-owned helper. Only this process touches Node/SQLite; no producer socket or inbox. */
+export async function runClaudeMod(input, env = process.env, signal, output = line => new Promise((resolve, reject) => {
+    process.stdout.write(line, error => error ? reject(error) : resolve());
+})) {
+    const { sessionId } = z.object({ sessionId: nativeId }).parse(JSON.parse(input));
+    const stop = new AbortController();
+    const abort = () => stop.abort();
+    const lifetimeSignal = signal ? AbortSignal.any([signal, stop.signal]) : stop.signal;
+    const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env), signal: AbortSignal.any([lifetimeSignal, AbortSignal.timeout(5000)]) });
+    process.once('SIGTERM', abort);
+    process.once('SIGINT', abort);
+    const lifetime = retainDeliveryLedger(ledger);
+    const receivers = new Map();
+    const offers = new Map();
+    const secret = `/${randomBytes(32).toString('hex')}`;
+    let revision = 0;
+    const ownerFor = (agentId) => harnessOwner({ channel: 'claude-code', session: sessionId, ...(agentId === undefined ? {} : { agent: agentId }) });
+    async function state(agentId, mode, signal = lifetimeSignal) {
+        const key = agentId ?? '';
+        let receiver = receivers.get(key);
+        if ((!receiver || receiver.mode === 'ended') && (mode === 'busy' || mode === 'idle')) {
+            const owner = ownerFor(agentId);
+            const attached = await attachDeliverySession(owner, env, [{ kind: routeKind, address: { sessionId, ...(agentId === undefined ? {} : { agentId }) } }], signal);
+            if (!attached)
+                return false;
+            receiver = { agentId, owner, generation: attached.generation, mode, attempted: new Set() };
+            receivers.set(key, receiver);
+        }
+        if (!receiver)
+            return false;
+        if (mode === 'busy' && receiver.mode === 'stopped')
+            receiver.attempted.clear();
+        receiver.mode = mode;
+        revision++;
+        if (mode === 'stopped')
+            await ledger.cancel({ owner: receiver.owner, generation: receiver.generation }, signal);
+        if (mode === 'ended')
+            await detachDeliverySession(receiver.owner, receiver.generation, env, signal);
+        if (mode === 'stopped' || mode === 'ended')
+            for (const offer of offers.values()) {
+                if (offer.receiver === receiver)
+                    offer.finish(offer.invoked ? 'unknown' : 'not-capable');
+            }
+        return true;
+    }
+    async function rpc(data) {
+        switch (data.op) {
+            case 'state': return { ok: await state(data.agentId, data.mode) };
+            case 'guard': {
+                const offer = offers.get(data.token);
+                if (!offer || !['busy', 'idle'].includes(offer.receiver.mode) || !await offer.guard())
+                    return { ok: false };
+                // Crossing this fence may invoke a native effect. Cancellation thereafter is uncertain.
+                offer.invoked = true;
+                return { ok: true };
+            }
+            case 'settle': {
+                const offer = offers.get(data.token);
+                if (!offer)
+                    return { ok: false };
+                const exact = data.text === offer.text;
+                const outcome = data.kind === 'append' ? exact && data.uuid ? 'presented' : 'unknown'
+                    : data.kind === 'submit' ? exact ? 'presented' : 'accepted'
+                        : data.kind === 'released' ? 'not-capable' : data.kind;
+                offer.finish(outcome);
+                return { ok: true };
+            }
+            case 'mcp-begin': {
+                const receiver = receivers.get(data.agentId ?? '');
+                if (!receiver || receiver.mode !== 'busy') {
+                    // Some native child starts are nested under another mod's event. The
+                    // actual tool event is still authoritative, never its model arguments.
+                    if (receiver?.mode === 'stopped' || !await state(data.agentId, 'busy'))
+                        throw new Error('Square MCP call identity unavailable');
+                }
+                return beginClaudeMcpCall({ toolUseId: data.toolUseId, sessionId, cwd: data.cwd, agentId: data.agentId }, env, lifetimeSignal);
+            }
+            case 'mcp-end':
+                await endClaudeMcpCall(data.toolUseId, data.token, env);
+                return { ok: true };
+            case 'close':
+                // The mod may kill its process stream as soon as this RPC returns.
+                // Commit detach before acknowledging, not only in process teardown.
+                for (const receiver of receivers.values())
+                    await state(receiver.agentId, 'ended');
+                stop.abort();
+                return { ok: true };
+        }
+    }
+    const server = createServer(async (req, res) => {
+        if (req.method !== 'POST' || req.url !== secret) {
+            res.writeHead(404).end();
+            return;
+        }
+        try {
+            let body = '';
+            for await (const chunk of req) {
+                body += chunk.toString();
+                if (body.length > 1_048_576)
+                    throw new Error('Request too large');
+            }
+            const result = await rpc(request.parse(JSON.parse(body)));
+            res.writeHead(200, { 'content-type': 'application/json' }).end(JSON.stringify(result));
+        }
+        catch {
+            res.writeHead(400, { 'content-type': 'application/json' }).end(JSON.stringify({ error: 'Square Claude mod request failed' }));
+        }
+    });
+    let observer;
+    try {
+        server.listen(0, '127.0.0.1');
+        await once(server, 'listening', { signal: lifetimeSignal });
+        const address = server.address();
+        if (!address || typeof address === 'string')
+            throw new Error('Claude helper address unavailable');
+        if (!await state(undefined, 'idle', AbortSignal.any([lifetimeSignal, AbortSignal.timeout(5000)])))
+            throw new Error('Claude helper attachment unavailable');
+        observer = await ledger.observe(ownerFor());
+        await output(`${JSON.stringify({ type: 'ready', url: `http://127.0.0.1:${address.port}${secret}` })}\n`);
+        while (!lifetimeSignal.aborted) {
+            let version = await observer.read(lifetimeSignal);
+            const previousRevision = revision;
+            for (const receiver of receivers.values()) {
+                if (!['busy', 'idle'].includes(receiver.mode))
+                    continue;
+                const current = await ledger.session(receiver.owner, lifetimeSignal);
+                if (current?.state !== 'attached' || current.generation !== receiver.generation) {
+                    if (receiver.agentId === undefined)
+                        return '';
+                    receiver.mode = 'ended';
+                    continue;
+                }
+                const held = new Set((await ledger.handoffs(receiver.owner, { generation: receiver.generation }, lifetimeSignal))
+                    .filter(attempt => !['failed', 'released'].includes(attempt.outcome)).map(attempt => attempt.seq));
+                for (const card of await ledger.pending(receiver.owner, { generation: receiver.generation }, lifetimeSignal)) {
+                    if (lifetimeSignal.aborted || !['busy', 'idle'].includes(receiver.mode))
+                        break;
+                    if (held.has(card.seq) || receiver.attempted.has(card.key))
+                        continue;
+                    // An idle child cannot be woken with the main session's prompt.submit.
+                    if (receiver.agentId !== undefined && receiver.mode !== 'busy')
+                        continue;
+                    receiver.attempted.add(card.key);
+                    const transport = {
+                        kind: routeKind,
+                        async send(deliveryCard, _address, context) {
+                            const text = renderDeliveryReminder([`[square-delivery:${context.token}]\n${deliveryCard.text}\n[/square-delivery:${context.token}]`], { tagged: false });
+                            if (!await context.prepare({ token: context.token, messageId: context.token, payloadHash: createHash('sha256').update(text).digest('hex') })
+                                || !await context.beforeSend() || !['busy', 'idle'].includes(receiver.mode))
+                                return 'not-capable';
+                            const completion = Promise.withResolvers();
+                            offers.set(context.token, { receiver, text, invoked: false, guard: context.beforeSend, finish: completion.resolve });
+                            try {
+                                await output(`${JSON.stringify({ type: 'delivery', token: context.token, agentId: receiver.agentId, text, display: deliveryCard.text })}\n`);
+                                return await completion.promise;
+                            }
+                            finally {
+                                offers.delete(context.token);
+                            }
+                        },
+                    };
+                    lifetime.track(await ledger.dispatchHandoff(receiver.owner, card.key, transport, { generation: receiver.generation, timeoutMs: 5000, signal: lifetimeSignal }));
+                    // Settlement changes are our own; drain them rather than busy-retrying.
+                    version = await observer.read(lifetimeSignal);
+                }
+            }
+            if (!lifetimeSignal.aborted && previousRevision === revision)
+                await observer.changed(version, 1000, lifetimeSignal);
+        }
+    }
+    catch (error) {
+        if (!lifetimeSignal.aborted)
+            throw error;
+    }
+    finally {
+        stop.abort();
+        for (const offer of offers.values())
+            offer.finish(offer.invoked ? 'unknown' : 'not-capable');
+        server.closeAllConnections();
+        await new Promise(resolve => server.close(() => resolve()));
+        observer?.close();
+        for (const receiver of receivers.values())
+            await detachDeliverySession(receiver.owner, receiver.generation, env, AbortSignal.timeout(1500)).catch(() => undefined);
+        await lifetime.close();
+        process.off('SIGTERM', abort);
+        process.off('SIGINT', abort);
+    }
+    return '';
+}

package/dist/cli/context.d.ts

@@ -22,7 +22,7 @@ export declare function resolveBody(arg: string): Promise<string>;
 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 { parseDurationMs } from '../time.js';
 export declare function parsePositiveInteger(value: string, flag: string): number;
 export declare function parseBoundedLimit(value: string | undefined, flag: string, max: number, retry: string): number;
 export declare function parseNonNegativeInteger(value: string, flag: string): number;
@@ -41,8 +41,8 @@ export declare function locationIsRequired(command: string): boolean;
 export declare function defaultContext(command: string, squarePath?: string, name?: string): CommandContext;
 export declare function squareInput(context: CommandContext): {
     cwd: string;
-    env: NodeJS.ProcessEnv;
     path: string | undefined;
+    clock: () => number;
 };
 export declare function commandIdentity(env: NodeJS.ProcessEnv, explicit?: Owner): {
     owner: Owner;

package/dist/cli/context.js

@@ -3,8 +3,18 @@ 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 { SquareError, parseParticipantList, validateName } from '../model.js';
+import { Square } from '../square-api.js';
+function squareClock(env, clock) {
+    if (clock !== undefined)
+        return clock;
+    if (env.SQUARE_NOW_MS === undefined)
+        return Date.now;
+    const value = Number.parseInt(env.SQUARE_NOW_MS, 10);
+    if (!Number.isFinite(value))
+        throw new SquareError('invalid_args', 'Invalid SQUARE_NOW_MS: expected integer milliseconds.');
+    return () => value;
+}
 export async function readStdin() {
     try {
         let content = '';
@@ -34,17 +44,7 @@ export function requireValue(args, index, flag) {
         fail(`✕ missing value for ${flag}`);
     return value;
 }
-export function parseDurationMs(value, flag) {
-    const match = value.match(/^([1-9]\d*)(ms|s|m|h)$/);
-    if (!match)
-        fail(`✕ invalid ${flag}: expected a positive duration with unit ms, s, m, or h (for example 500ms, 30s, 3m, 1h)`);
-    const amount = Number.parseInt(match[1], 10);
-    const multiplier = { ms: 1, s: 1000, m: 60000, h: 3600000 };
-    const milliseconds = amount * multiplier[match[2]];
-    if (!Number.isSafeInteger(milliseconds))
-        fail(`✕ invalid ${flag}: duration is too large`);
-    return milliseconds;
-}
+export { parseDurationMs } from '../time.js';
 export function parsePositiveInteger(value, flag) {
     if (!/^[1-9]\d*$/.test(value))
         fail(`✕ invalid ${flag}: expected a positive integer`);
@@ -97,11 +97,9 @@ const LOCATION_REQUIRED_COMMANDS = new Set([
     'listen',
     'ignore',
     'unlisten',
-    'listening',
     'done',
     'history',
     'status',
-    'participants',
     'doctor',
 ]);
 export async function parseGlobalArgs(rawArgs) {
@@ -142,7 +140,7 @@ export function defaultContext(command, squarePath, name) {
     return { command, cwd: process.cwd(), env: { ...process.env }, squarePath, name, owner: undefined, homeDir: os.homedir() };
 }
 export function squareInput(context) {
-    return { cwd: context.cwd, env: context.env, path: context.squarePath };
+    return { cwd: context.cwd, path: context.squarePath, clock: squareClock(context.env) };
 }
 export function commandIdentity(env, explicit) {
     if (explicit !== undefined)

package/dist/cli/express-presentation.js

@@ -3,9 +3,8 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { isSquareError } from '../model.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 { formatRefusal, renderActivityUncertain, renderExpressWaiting, participantCommandPrefix, commandPrefix, quoteShell, withPathOutput, } from '../presentation.js';
+import { isExpressGate, renderExpression, renderFailureLines } from '../operation-presentation.js';
 import { jsonResult } from './json.js';
 export { renderExpression } from '../operation-presentation.js';
 export function saveActivityDraft(squarePath, name, body, now = Date.now()) {
@@ -101,76 +100,36 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
             exitCode(1);
             return;
         }
-        if (isSquareError(error)) {
-            if (error.code === 'behind' && fresh?.activitySummaries !== undefined) {
-                process.stdout.write(renderActivityBlocked({ ...output, retryCommand: retryInput,
-                    activitySummaries: fresh.activitySummaries,
-                }));
-                exitCode(1);
-                return;
-            }
-            if (error.code === 'capped') {
-                process.stdout.write(renderActivityLimit({ ...output, count: fresh?.ownActivityCount,
-                    ...(fresh?.hardCap == null ? {} : { hardCap: fresh.hardCap }),
-                }));
-                exitCode(1);
-                return;
-            }
-            if (error.code === 'throttled') {
-                process.stdout.write(renderExpressNoWait({ ...output, reason: error.code, retryCommand: retryInput,
-                    delayMs: error.facts?.retryAfterMs ?? 1,
-                }));
-                exitCode(1);
-                return;
-            }
-            if (error.code === 'bell_quota') {
-                process.stdout.write(withPathOutput(squarePath, [
-                    '✕ the bell stays quiet for now', `  · you can ring it again in ${formatDuration(error.facts?.retryAfterMs ?? 1)}`,
-                    `· draft kept: ${draftPath}`, '  · retry when the bell is ready:', retryInput,
-                ].join('\n'), output));
-                exitCode(1);
-                return;
-            }
+        if (isSquareError(error) && isExpressGate(error.code)) {
+            process.stdout.write(withPathOutput(squarePath, renderFailureLines({ code: error.code, message: error.message, facts: error.facts }, { squarePath, name, owner: opts.recoveryOwner, draftPath, retry: retryInput }).join('\n'), output));
+            exitCode(1);
+            return;
         }
         const facts = isSquareError(error) ? error.facts : undefined;
         const reason = facts?.reason;
-        const message = reason === 'bell_mention_conflict'
-            ? '✕ a bell cannot be combined with a mention'
-            : reason === 'invalid_reply'
-                ? facts?.activityExists === false
-                    ? `Invalid --reply: ${facts.activityId ?? opts.reply ?? 'that activity'} is not in this square's history`
-                    : 'Invalid --reply: expected an activity id like act/12'
-                : refusalText(error);
-        const lines = [message, `· draft kept: ${draftPath}`];
+        const lines = renderFailureLines({ code: isSquareError(error) ? error.code : '', message: error instanceof Error ? error.message : String(error), facts, operation: detail }, { squarePath, name, owner: opts.recoveryOwner, reply: opts.reply });
+        const headlineLines = reason !== 'needs_seat' && isSquareError(error) && error.code === 'already_joined' ? 2 : (reason === 'never_joined' || reason === 'not_standing') ? (error instanceof Error ? error.message : String(error)).split('\n').length : 1;
+        lines.splice(headlineLines, 0, `· 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, opts.recoveryOwner));
-            }
-            if (error.code === 'already_joined')
-                lines.push(...takeoverRecoveryLines(squarePath, name, opts.recoveryOwner));
             if (repair) {
-                lines.push(participantsRecoveryCommand(squarePath), reason === 'bell_mention_conflict'
-                    ? '  · ring the bell without explicit mentions:'
-                    : '  · retry without explicit recipients:', `${activityRetryCommand(squarePath, name, { ...opts, mentions: [] })}${opts.bodyProvided === false ? '' : ` < ${quoteShell(draftPath)}`}`);
+                lines.push(reason === 'bell_mention_conflict' ? '  · ring the bell without explicit mentions:' : '  · retry without explicit recipients:', `${activityRetryCommand(squarePath, name, { ...opts, mentions: [] })}${opts.bodyProvided === false ? '' : ` < ${quoteShell(draftPath)}`}`);
             }
             else if (error.code === 'invalid_args' || error.code === 'invalid_name') {
                 if (opts.mentions?.length)
-                    lines.push(participantsRecoveryCommand(squarePath));
+                    lines.push(`${commandPrefix(squarePath)} status`);
                 if (opts.reply !== undefined && reason !== 'invalid_reply')
                     lines.push(`${commandPrefix(squarePath)} history --limit 10`);
             }
         }
         if (reason === 'invalid_reply') {
             const withoutReply = { ...opts, reply: undefined };
-            lines.push(`${commandPrefix(squarePath)} history --limit 10`, '  · choose a valid --reply from history, or send without a reply using this repair:', `${activityRetryCommand(squarePath, name, withoutReply)}${withoutReply.bodyProvided === false ? '' : ` < ${quoteShell(draftPath)}`}`);
+            lines.push('  · choose a valid --reply from history, or send without a reply using this repair:', `${activityRetryCommand(squarePath, name, withoutReply)}${withoutReply.bodyProvided === false ? '' : ` < ${quoteShell(draftPath)}`}`);
         }
         else if (!repair) {
             lines.push('  · correct the problem above before retrying; keep your intended recipients and reply:', `${retryInput}`);

package/dist/cli/json.js

@@ -1,6 +1,6 @@
 export const JSON_COMMANDS = new Set([
-    'join', 'express', 'perceive', 'history', 'listen', 'ignore', 'unlisten', 'listening',
-    'done', 'status', 'participants', 'inbox',
+    'join', 'express', 'perceive', 'history', 'listen', 'ignore', 'unlisten',
+    'done', 'status', 'inbox',
 ]);
 /** Serialize the SDK receipt, not its optional presentation or live participant handle. */
 export function jsonResult(result) {

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

@@ -2,7 +2,7 @@ import type { PerceiveOptions, DiscoveryOptions, HistoryQuery, StreamStart } fro
 import { type CommandSpec } from './context.js';
 interface HistoryCommandOptions {
     query: HistoryQuery;
-    noTruncate: boolean;
+    full: boolean;
     format?: string[];
     continuationArgs: string[];
 }
@@ -15,18 +15,13 @@ interface StreamIntent {
 export declare const streamCommand: CommandSpec<StreamIntent>;
 export declare const perceiveCommand: CommandSpec<PerceiveOptions>;
 export declare const historyCommand: CommandSpec<HistoryCommandOptions, string>;
-interface ParticipantsCommandOptions {
-    limit: number;
-}
-export declare const participantsCommand: CommandSpec<ParticipantsCommandOptions, string>;
 export declare const statusCommand: CommandSpec<undefined, string>;
 interface InboxIntent {
     owner: string;
     limit: number;
 }
 export declare const inboxCommand: CommandSpec<InboxIntent, string>;
-export declare const claudeHookCommand: CommandSpec<undefined, string>;
-export declare const claudeWatchCommand: CommandSpec<undefined, string>;
+export declare const claudeModCommand: CommandSpec<undefined, string>;
 export declare const codexHookCommand: CommandSpec<undefined, string>;
 export declare const codexWatchCommand: CommandSpec<undefined, string>;
 export declare const codexInterruptCommand: CommandSpec<undefined, string>;