@astrosheep/square 0.4.7 → 0.4.9

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;

package/dist/cli/context.js

@@ -44,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`);
@@ -107,7 +97,6 @@ const LOCATION_REQUIRED_COMMANDS = new Set([
     'listen',
     'ignore',
     'unlisten',
-    'listening',
     'done',
     'history',
     'status',

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, renderActivityBlocked, renderActivityLimit, renderActivityUncertain, renderExpressNoWait, renderExpressWaiting, participantCommandPrefix, commandPrefix, quoteShell, withPathOutput, } from '../presentation.js';
-import { renderExpression, renderFailureLines } 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,36 +100,10 @@ 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;
@@ -142,10 +115,10 @@ export async function executeExpression(open, squarePath, requestedName, rawInpu
             exitCode(2);
             return;
         }
-        const repair = reason === 'bell_mention_conflict' || (reason === 'not_standing' && detail?.subject === 'recipient');
+        const repair = reason === 'bell_mention_conflict';
         if (isSquareError(error)) {
             if (repair) {
-                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)}`}`);
+                lines.push('  · ring the bell without explicit mentions:', `${activityRetryCommand(squarePath, name, { ...opts, mentions: [] })}${opts.bodyProvided === false ? '' : ` < ${quoteShell(draftPath)}`}`);
             }
             else if (error.code === 'invalid_args' || error.code === 'invalid_name') {
                 if (opts.mentions?.length)

package/dist/cli/json.js

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

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[];
 }
@@ -21,8 +21,7 @@ interface InboxIntent {
     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>;

package/dist/cli/observation-commands.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { once } from 'node:events';
-import { runClaudeHook, runClaudeWatch } from '../claude-hook.js';
+import { runClaudeMod } from '../claude-mod.js';
 import { runCodexHook, runCodexInterrupt } from '../codex-hook.js';
 import { runCodexWatch } from '../codex-watch.js';
 import { isSquareError } from '../model.js';
@@ -135,7 +135,6 @@ export const perceiveCommand = {
         let limit;
         let id;
         let takeover = false;
-        let now = false;
         const participants = [];
         for (let index = 0; index < argv.length; index++) {
             if (argv[index] === '--id') {
@@ -164,8 +163,6 @@ export const perceiveCommand = {
             }
             else if (argv[index] === '--takeover')
                 takeover = true;
-            else if (argv[index] === '--now')
-                now = true;
             else if (argv[index] !== '--json')
                 fail(`✕ perceive does not know ${argv[index]}\nsquare perceive --help`);
         }
@@ -175,8 +172,6 @@ export const perceiveCommand = {
             }
             return { id };
         }
-        if (idle !== undefined && now)
-            fail('perceive accepts --now or --idle, not both.');
         if (takeover && idle === undefined)
             fail('--takeover can only be used with --idle.');
         return {
@@ -244,7 +239,7 @@ function historyContinuationArgs(argv) {
             continue;
         }
         result.push(flag);
-        if (flag === '--from' || flag === '--since' || flag === '--at' || flag === '-B' || flag === '-A' || flag === '-C' || flag === '--mention' || flag === '--grep' || flag === '--fixed' || flag === '--order' || flag === '--format') {
+        if (flag === '--from' || flag === '--since' || flag === '--at' || flag === '-C' || flag === '--mention' || flag === '--search' || flag === '--order' || flag === '--format') {
             const value = argv[index + 1];
             if (value !== undefined) {
                 result.push(value);
@@ -261,12 +256,11 @@ function parseHistory(argv, context) {
     let after;
     let before;
     const at = [];
-    let beforeContext;
-    let afterContext;
+    let historyContext;
     let mention;
-    let noTruncate = false;
-    let grep;
-    let fixed;
+    let full = false;
+    let search;
+    let regex = false;
     let order;
     let format;
     const participants = [];
@@ -299,32 +293,20 @@ function parseHistory(argv, context) {
             at.push(...values.map((value) => formatActivityId(parseActRef(value, flag))));
             index += 1;
         }
-        else if (flag === '-B') {
-            beforeContext = parseNonNegativeInteger(requireValue(argv, index, flag), flag);
-            index += 1;
-        }
-        else if (flag === '-A') {
-            afterContext = parseNonNegativeInteger(requireValue(argv, index, flag), flag);
-            index += 1;
-        }
         else if (flag === '-C') {
-            const context = parseNonNegativeInteger(requireValue(argv, index, flag), flag);
-            beforeContext = context;
-            afterContext = context;
+            historyContext = parseNonNegativeInteger(requireValue(argv, index, flag), flag);
             index += 1;
         }
-        else if (flag === '--no-truncate')
-            noTruncate = true;
+        else if (flag === '--full')
+            full = true;
         else if (flag === '--mention') {
             mention = requireValue(argv, index, flag);
             index += 1;
         }
-        else if (flag === '--grep') {
-            grep = requireValue(argv, index, flag);
-            index += 1;
-        }
-        else if (flag === '--fixed') {
-            fixed = requireValue(argv, index, flag);
+        else if (flag === '--regex')
+            regex = true;
+        else if (flag === '--search') {
+            search = requireValue(argv, index, flag);
             index += 1;
         }
         else if (flag === '--order') {
@@ -341,19 +323,17 @@ function parseHistory(argv, context) {
         else if (flag !== '--json')
             fail(`✕ history does not know ${flag}\nsquare history --help`);
     }
-    if (grep !== undefined && fixed !== undefined)
-        fail('--grep and --fixed cannot be combined.');
-    if (grep === '' || fixed === '')
-        fail('--grep and --fixed require non-empty text.');
+    if (search === '')
+        fail('--search requires non-empty text.');
     if (before !== undefined && after !== undefined)
         fail('--before and --after cannot be combined.');
     return {
         query: { limit, from: participants.length === 0 ? undefined : participants, since,
             cursor: after !== undefined ? { id: after, direction: 'after' } : before === undefined ? undefined : { id: before, direction: 'before' },
             at: at.length === 0 ? undefined : at,
-            contextBefore: beforeContext, contextAfter: afterContext, mention, order,
-            search: grep !== undefined ? { text: grep, mode: 'regex' } : fixed === undefined ? undefined : { text: fixed, mode: 'literal' } },
-        noTruncate, format,
+            context: historyContext, mention, order,
+            search: search === undefined ? undefined : { text: search, mode: regex ? 'regex' : 'literal' } },
+        full, format,
         continuationArgs: historyContinuationArgs(argv),
     };
 }
@@ -396,7 +376,7 @@ export const historyCommand = {
         }
         return renderHistoryResult(squarePath, outcome, {
             query: options.query,
-            noTruncate: options.noTruncate,
+            full: options.full,
             continuationArgs: options.continuationArgs,
         });
     },
@@ -470,28 +450,10 @@ function hookCommand(runHook) {
         present: (result) => process.stdout.write(result),
     };
 }
-export const claudeHookCommand = {
-    parse(argv, context) { if (argv.length > 0)
-        usage(context.command); return undefined; },
-    execute: async () => {
-        try {
-            return await runClaudeHook(await readStdin(), process.env, text => new Promise((resolve, reject) => {
-                process.stdout.write(text, error => { if (error)
-                    reject(error);
-                else
-                    resolve(); });
-            }));
-        }
-        catch {
-            return '';
-        }
-    },
-    present: () => { },
-};
-export const claudeWatchCommand = {
+export const claudeModCommand = {
     parse(argv, context) { if (argv.length > 0)
         usage(context.command); return undefined; },
-    execute: async () => runClaudeWatch(await readStdin(), process.env),
+    execute: async () => runClaudeMod(await readStdin(), process.env),
     present: () => { },
 };
 export const codexHookCommand = {

package/dist/cli/registry.js

@@ -1,10 +1,10 @@
-import { buildCommand, doneCommand, expressCommand, ignoreCommand, joinCommand, listenCommand, listeningCommand, unlistenCommand } from './square-commands.js';
+import { buildCommand, doneCommand, expressCommand, ignoreCommand, joinCommand, listenCommand, unlistenCommand } from './square-commands.js';
 import { doctorCommand } 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 { perceiveCommand, claudeHookCommand, claudeWatchCommand, codexHookCommand, codexWatchCommand, codexInterruptCommand, historyCommand, inboxCommand, listCommand, statusCommand, streamCommand, } from './observation-commands.js';
+import { perceiveCommand, claudeModCommand, codexHookCommand, codexWatchCommand, codexInterruptCommand, historyCommand, inboxCommand, listCommand, statusCommand, streamCommand, } from './observation-commands.js';
 /** Every public command is an executable adapter, including aliases and utility commands. */
 export const commandRegistry = [
     { names: ['build'], spec: buildCommand },
@@ -12,8 +12,7 @@ export const commandRegistry = [
     { names: ['join'], spec: joinCommand },
     { names: ['stream'], spec: streamCommand },
     { names: ['inbox'], spec: inboxCommand },
-    { names: ['claude-hook'], spec: claudeHookCommand },
-    { names: ['claude-watch'], spec: claudeWatchCommand },
+    { names: ['claude-mod'], spec: claudeModCommand },
     { names: ['codex-hook'], spec: codexHookCommand },
     { names: ['codex-watch'], spec: codexWatchCommand },
     { names: ['codex-interrupt'], spec: codexInterruptCommand },
@@ -22,7 +21,6 @@ export const commandRegistry = [
     { names: ['listen'], spec: listenCommand },
     { names: ['ignore'], spec: ignoreCommand },
     { names: ['unlisten'], spec: unlistenCommand },
-    { names: ['listening'], spec: listeningCommand },
     { names: ['done'], spec: doneCommand },
     { names: ['install'], spec: installCommand },
     { names: ['uninstall'], spec: uninstallCommand },

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

@@ -25,7 +25,7 @@ interface BodyIntent {
     body?: string;
 }
 interface ListenerIntent {
-    target?: string;
+    target: string;
 }
 export declare const buildCommand: CommandSpec<BuildIntent, string>;
 export declare const joinCommand: CommandSpec<JoinIntent, string>;
@@ -33,6 +33,5 @@ export declare const expressCommand: CommandSpec<ActivityIntent>;
 export declare const listenCommand: CommandSpec<ListenerIntent, string>;
 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 {};

package/dist/cli/square-commands.js

@@ -1,6 +1,6 @@
 import { formatHardCap } from '../model.js';
 import { commandPrefix, participantCommandPrefix, withPathOutput, } from '../presentation.js';
-import { renderJoinResult, renderLifecycleResult, renderListenerChange, renderListeningResult, } from '../operation-presentation.js';
+import { renderJoinResult, renderLifecycleResult, renderListenerChange, } from '../operation-presentation.js';
 import { Square, requireOwner, requireJoinName, selectOwnSeat } from '../square-api.js';
 import { executeExpression } from './express-presentation.js';
 import { jsonResult } from './json.js';
@@ -153,15 +153,14 @@ export const expressCommand = {
     },
     present: () => { },
 };
-function parseListener(argv, context, targetRequired) {
-    const args = argv.filter((arg) => arg !== '--json');
-    if (targetRequired ? args.length !== 1 : args.length !== 0)
-        usage(context.command);
-    return targetRequired ? { target: args[0] } : {};
-}
 function listenerCommand(verb) {
     return {
-        parse(argv, context) { return parseListener(argv, context, true); },
+        parse(argv, context) {
+            const args = argv.filter((arg) => arg !== '--json');
+            if (args.length !== 1)
+                usage(context.command);
+            return { target: args[0] };
+        },
         async execute(intent, context) {
             const squarePath = requireSquarePath(context);
             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 }));
@@ -173,15 +172,6 @@ function listenerCommand(verb) {
 export const listenCommand = listenerCommand('listen');
 export const ignoreCommand = listenerCommand('ignore');
 export const unlistenCommand = listenerCommand('unlisten');
-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 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),
-};
 export const doneCommand = {
     parse(argv, context) {
         const args = argv.filter((arg) => arg !== '--json');