@astrosheep/square 0.3.11 → 0.3.13

package/dist/cli/observation-commands.js

@@ -1,21 +1,22 @@
-import { loadSquare } from '../artifact.js';
-import { runClaudeHook } from '../claude-hook.js';
-import { runCodexHook } from '../codex-hook.js';
-import { coreActivities, coreParticipants, coreStatus } from '../decisions.js';
+import { runClaudeHookAsync } from '../claude-hook.js';
+import { runCodexHookAsync } from '../codex-hook.js';
 import { sessionInbox } from '../inbox.js';
 import { sweepPendingNotifications } from '../notifications.js';
 import { cmdListSquares } from '../list.js';
-import { sameName } from '../model.js';
-import { commandPrefix, participantCommandPrefix, renderActivitiesView, renderGrepActivitiesView, renderVisibleEvent, withPathOutput, } from '../presentation.js';
-import { actId, inSquareCount, nowMs, sayNumberFor } from '../runtime.js';
+import { parseActivityId, sameName } from '../model.js';
+import { commandPrefix, participantCommandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEvent, withPathOutput, } from '../presentation.js';
+import { actId, nowMs } from '../runtime.js';
 import { cmdStream, cmdStreamNdjson } from '../stream.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.js';
 import { cmdWatch } from '../watch.js';
+import { openSquare } from '../square-file-adapter.js';
+import { closeOpenSquare } from '../open-square.js';
+import { historyPresentation, participantsPresentation, statusPresentation } from '../views.js';
 import { fail, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdinSync, requireParticipant, requireValue, usage, } from './context.js';
 export const listCommand = {
     parse: (argv) => argv,
-    execute(argv, context) {
-        cmdListSquares(argv, () => usage(context.command));
+    async execute(argv, context) {
+        await cmdListSquares(argv, () => usage(context.command));
     },
     present: () => { },
 };
@@ -98,10 +99,10 @@ export const catchCommand = {
     present: () => { },
 };
 function parseActRef(value, flag) {
-    const match = value.trim().match(/^(?:act_)?(\d+)$/i);
-    if (!match)
-        fail(`Invalid ${flag}: expected an activity id like act_12 or 12.`);
-    return Number(match[1]);
+    const index = parseActivityId(value);
+    if (index === undefined)
+        fail(`Invalid ${flag}: expected an activity id like act/12`);
+    return index;
 }
 function parseTimestamp(value, flag) {
     const timestamp = parseTimeOrRelative(value, nowMs());
@@ -116,7 +117,7 @@ function parseHistory(argv, context) {
     let before;
     let after;
     let afterIndex;
-    let atIndex;
+    const atIndexes = [];
     let beforeContext;
     let afterContext;
     let mention;
@@ -124,10 +125,8 @@ function parseHistory(argv, context) {
     let full = false;
     let grep;
     let fixed;
-    let ids;
     let order;
     let format;
-    let countOnly = false;
     let json = false;
     const participants = [];
     for (let index = 0; index < argv.length; index++) {
@@ -165,7 +164,10 @@ function parseHistory(argv, context) {
             index += 1;
         }
         else if (flag === '--at') {
-            atIndex = parseActRef(requireValue(argv, index, flag), flag);
+            const values = requireValue(argv, index, flag).split(',');
+            if (values.some((value) => value === ''))
+                fail(`Invalid ${flag}: expected an activity id like act/12`);
+            atIndexes.push(...values.map((value) => parseActRef(value, flag)));
             index += 1;
         }
         else if (flag === '-B') {
@@ -198,14 +200,6 @@ function parseHistory(argv, context) {
             fixed = requireValue(argv, index, flag);
             index += 1;
         }
-        else if (flag === '--ids') {
-            ids = requireValue(argv, index, flag)
-                .split(',')
-                .map((item) => item.trim())
-                .filter(Boolean)
-                .map((item) => parseActRef(item, flag));
-            index += 1;
-        }
         else if (flag === '--order') {
             const value = requireValue(argv, index, flag);
             if (value !== 'asc' && value !== 'desc')
@@ -217,8 +211,6 @@ function parseHistory(argv, context) {
             format = requireValue(argv, index, flag).split(',').map((item) => item.trim()).filter(Boolean);
             index += 1;
         }
-        else if (flag === '--count')
-            countOnly = true;
         else if (flag === '--json')
             json = true;
         else
@@ -230,7 +222,7 @@ function parseHistory(argv, context) {
         fail('--grep and --fixed cannot be combined.');
     if (grep === '' || fixed === '')
         fail('--grep and --fixed require non-empty text.');
-    if (!lastNExplicit && (atIndex !== undefined || ids !== undefined || pending))
+    if (!lastNExplicit && (atIndexes.length > 0 || pending))
         lastN = null;
     return {
         lastN,
@@ -238,7 +230,7 @@ function parseHistory(argv, context) {
         before,
         after,
         afterIndex,
-        atIndex,
+        atIndexes: atIndexes.length === 0 ? undefined : atIndexes,
         beforeContext,
         afterContext,
         mention,
@@ -247,14 +239,12 @@ function parseHistory(argv, context) {
         full,
         grep,
         fixed,
-        ids,
         order,
         format,
-        countOnly,
         json,
     };
 }
-function renderFields(doc, item, fields) {
+function renderFields(sayNumbers, item, fields) {
     return fields.map((field) => {
         switch (field) {
             case 'id': return actId(item.index);
@@ -264,13 +254,13 @@ function renderFields(doc, item, fields) {
             case 'at': return formatTimestamp(item.at);
             case 'kind': return item.kind;
             case 'body': return 'body' in item && typeof item.body === 'string' ? item.body.replace(/\s+/g, ' ').trim() : '';
-            case 'number': return item.kind === 'say' ? String(sayNumberFor(doc.acts, item)) : '';
+            case 'number': return item.kind === 'say' ? String(sayNumbers[item.index]) : '';
             case 'reply': return item.kind === 'say' && item.reply !== undefined ? actId(item.reply) : '';
             default: return '';
         }
     }).join('\t');
 }
-function jsonLine(doc, item) {
+function jsonLine(sayNumbers, item) {
     const act = item;
     return JSON.stringify({
         id: actId(item.index),
@@ -280,130 +270,160 @@ function jsonLine(doc, item) {
         at: act.at,
         ts: formatTimestamp(act.at),
         body: 'body' in act && typeof act.body === 'string' ? act.body : '',
-        number: act.kind === 'say' ? sayNumberFor(doc.acts, act) : null,
+        number: act.kind === 'say' ? sayNumbers[act.index] : null,
         reach: act.kind === 'say' ? act.reach ?? null : null,
         reply: act.kind === 'say' && act.reply !== undefined ? actId(act.reply) : null,
     });
 }
+function renderHistoryProjection(projection, visible, full, squarePath, viewer, mode) {
+    const shown = visible.filter((activity) => activity.kind === 'say' || activity.kind === 'done');
+    const preview = full ? undefined : 200;
+    const chunks = [];
+    for (const activity of shown) {
+        const options = {
+            preview,
+            actNumber: activity.kind === 'say' ? projection.sayNumbers[activity.index] : undefined,
+        };
+        const rendered = mode === 'archive'
+            ? renderEventCli(activity, options)
+            : renderAmbientEvent(activity, viewer, options);
+        if (rendered !== '')
+            chunks.push(rendered);
+        for (const name of projection.presenceAnchors[activity.index] ?? [])
+            chunks.push(`→ ${participantIdentity(name)} was here`);
+    }
+    if (chunks.length === 0)
+        return 'latest\n  ○ no public activity in this view';
+    if (preview !== undefined && shown.some((activity) => activity.kind === 'say' && activity.body.length > preview && (mode === 'archive' || activity.perception === 'full'))) {
+        chunks.push(`» ${commandPrefix(squarePath)} history --full`);
+    }
+    return chunks.join('\n\n');
+}
 export const historyCommand = {
     parse(argv, context) { return parseHistory(argv, context); },
-    execute(options, context) {
-        const doc = loadSquare(context.squarePath);
-        let events = coreActivities(doc, options);
-        const searching = options.grep !== undefined || options.fixed !== undefined;
-        const totalMatches = searching ? events.length : 0;
-        if (options.lastN != null) {
-            events = options.order === 'desc'
-                ? events.slice(0, options.lastN)
-                : events.slice(-options.lastN);
+    async execute(options, context) {
+        const square = await openSquare(context.squarePath, { clock: nowMs });
+        try {
+            const projection = await historyPresentation(square, options);
+            let events = [...projection.activities];
+            const searching = options.grep !== undefined || options.fixed !== undefined;
+            const totalMatches = searching ? events.length : 0;
+            if (options.lastN != null) {
+                events = options.order === 'desc'
+                    ? events.slice(0, options.lastN)
+                    : events.slice(-options.lastN);
+            }
+            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' : '');
+            }
+            const pattern = options.grep ?? options.fixed;
+            const anonymous = options.viewer === undefined;
+            const archive = (options.atIndexes !== undefined && options.atIndexes.length > 0)
+                || (options.lastN == null && options.full === true)
+                || anonymous;
+            const output = pattern === undefined || pattern === ''
+                ? renderHistoryProjection(projection, events, options.full === true || anonymous, context.squarePath, options.viewer ?? '', archive ? 'archive' : 'ambient')
+                : renderGrepActivitiesView(events, totalMatches, options.full, context.squarePath, pattern, options.fixed !== undefined);
+            return withPathOutput(context.squarePath, output, { participantCount: projection.participantCount });
         }
-        if (options.countOnly)
-            return `${searching ? totalMatches : events.length}\n`;
-        if (options.json)
-            return events.map((item) => jsonLine(doc, item)).join('\n') + (events.length > 0 ? '\n' : '');
-        if (options.format !== undefined && options.format.length > 0) {
-            return events.map((item) => renderFields(doc, item, options.format)).join('\n') + (events.length > 0 ? '\n' : '');
+        finally {
+            await closeOpenSquare(square);
         }
-        const pattern = options.grep ?? options.fixed;
-        const output = pattern === undefined || pattern === ''
-            ? renderActivitiesView(doc, events, null, options.full, context.squarePath, options.viewer ?? '')
-            : renderGrepActivitiesView(events, totalMatches, options.full, context.squarePath, pattern, options.fixed !== undefined);
-        return withPathOutput(context.squarePath, output, { participantCount: inSquareCount(doc) });
-    },
-    present: (result) => process.stdout.write(result),
-};
-export const warmupCommand = {
-    parse(argv, context) { if (argv.length > 0)
-        usage(context.command); return undefined; },
-    execute(_intent, context) {
-        const doc = loadSquare(context.squarePath);
-        return withPathOutput(context.squarePath, doc.warmup.join('\n'), {
-            participantCount: inSquareCount(doc),
-        });
     },
     present: (result) => process.stdout.write(result),
 };
 export const participantsCommand = {
     parse(argv, context) { if (argv.length > 0)
         usage(context.command); return undefined; },
-    execute(_intent, context) {
-        const doc = loadSquare(context.squarePath);
-        const now = nowMs();
-        const participants = coreParticipants(doc, now);
-        const lines = participants.map((participant) => {
-            const glyph = participant.state === 'done' ? '×' : participant.presence === 'watching' ? '◎' : participant.activityCount > 0 ? '●' : '○';
-            const state = participant.state === 'done' ? 'done' : participant.presence === 'watching' ? 'catching' : participant.state;
-            const last = participant.lastActiveAt === undefined ? '—' : formatRelativeTime(participant.lastActiveAt, now);
-            return `  ${glyph} ${participant.name} · ${state} · ${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${last}`;
-        });
-        const participantCount = participants.filter((participant) => participant.state === 'active').length;
-        return withPathOutput(context.squarePath, ['participants', ...lines].join('\n'), {
-            participantCount,
-        });
+    async execute(_intent, context) {
+        const square = await openSquare(context.squarePath, { clock: nowMs });
+        try {
+            const now = nowMs();
+            const participants = await participantsPresentation(square);
+            const lines = participants.map((participant) => {
+                const glyph = participant.state === 'done' ? '○' : participant.presence === 'watching' ? '◎' : participant.activityCount > 0 ? '●' : '○';
+                const state = participant.state === 'done' ? 'done' : participant.presence === 'watching' ? 'catching' : participant.state;
+                const last = participant.lastActiveAt === undefined ? '—' : formatRelativeTime(participant.lastActiveAt, now);
+                return `  ${glyph} ${participantIdentity(participant.name)} · ${state} · ${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${last}`;
+            });
+            const participantCount = participants.filter((participant) => participant.state === 'active').length;
+            return withPathOutput(context.squarePath, ['participants', ...lines].join('\n'), {
+                participantCount,
+            });
+        }
+        finally {
+            await closeOpenSquare(square);
+        }
     },
     present: (result) => process.stdout.write(result),
 };
 export const statusCommand = {
     parse(argv, context) { if (argv.length > 0)
         usage(context.command); return undefined; },
-    execute(_intent, context) {
-        const doc = loadSquare(context.squarePath);
-        const result = coreStatus(doc, nowMs());
-        const active = result.participants.filter((participant) => participant.state === 'active').sort((a, b) => {
-            const aViewer = context.name !== undefined && sameName(a.name, context.name);
-            const bViewer = context.name !== undefined && sameName(b.name, context.name);
-            if (aViewer !== bViewer)
-                return aViewer ? -1 : 1;
-            return (b.lastActiveAt ?? -Infinity) - (a.lastActiveAt ?? -Infinity) || a.name.localeCompare(b.name);
-        });
-        const people = active.length === 0 ? ['  ○ nobody in the square'] : active.map((participant) => {
-            const glyph = participant.presence === 'watching'
-                ? '◎'
-                : participant.activityCount > 0 ? '●' : '○';
-            const summary = participant.activityCount > 0
-                ? `${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${participant.lastActiveAt === undefined
+    async execute(_intent, context) {
+        const square = await openSquare(context.squarePath, { clock: nowMs });
+        try {
+            const presentation = await statusPresentation(square);
+            const result = presentation.status;
+            const active = result.participants.filter((participant) => participant.state === 'active').sort((a, b) => {
+                const aViewer = context.name !== undefined && sameName(a.name, context.name);
+                const bViewer = context.name !== undefined && sameName(b.name, context.name);
+                if (aViewer !== bViewer)
+                    return aViewer ? -1 : 1;
+                return (b.lastActiveAt ?? -Infinity) - (a.lastActiveAt ?? -Infinity) || a.name.localeCompare(b.name);
+            });
+            const people = active.length === 0 ? ['  ○ nobody in the square'] : active.map((participant) => {
+                const glyph = participant.presence === 'watching'
+                    ? '◎'
+                    : participant.activityCount > 0 ? '●' : '○';
+                const summary = participant.activityCount > 0
+                    ? `${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${participant.lastActiveAt === undefined
+                        ? 'just now'
+                        : formatRelativeTime(participant.lastActiveAt, result.now)}`
+                    : `quiet · ${participant.lastActiveAt === undefined ? '—' : formatRelativeTime(participant.lastActiveAt, result.now)}`;
+                const showAttention = context.name === undefined || sameName(participant.name, context.name);
+                const attention = !showAttention
+                    ? ''
+                    : participant.pendingMentionCount > 0
+                        ? `${participant.pendingMentionCount} mention${participant.pendingMentionCount === 1 ? '' : 's'} waiting`
+                        : participant.unreadActivityCount > 0
+                            ? `${participant.unreadActivityCount} change${participant.unreadActivityCount === 1 ? '' : 's'} waiting`
+                            : 'caught up';
+                return `  ${glyph} ${participantIdentity(participant.name)} · ${summary}${attention === '' ? '' : ` · ${attention}`}`;
+            });
+            const cap = result.hardCap === null ? 'unlimited' : String(result.hardCap);
+            const hold = result.holdActive
+                ? `· ${result.holdActor === undefined ? 'someone' : participantIdentity(result.holdActor)} raised a hand${result.holdReason ? ` — ${result.holdReason}` : ''} · ${result.holdAt === undefined
                     ? 'just now'
-                    : formatRelativeTime(participant.lastActiveAt, result.now)}`
-                : `quiet · ${participant.lastActiveAt === undefined ? '—' : formatRelativeTime(participant.lastActiveAt, result.now)}`;
-            const showAttention = context.name === undefined || sameName(participant.name, context.name);
-            const attention = !showAttention
+                    : formatRelativeTime(result.holdAt, result.now)}`
+                : undefined;
+            const visible = result.latestAct === undefined
                 ? ''
-                : participant.pendingMentionCount > 0
-                    ? `${participant.pendingMentionCount} mention${participant.pendingMentionCount === 1 ? '' : 's'} waiting`
-                    : participant.unreadActivityCount > 0
-                        ? `${participant.unreadActivityCount} change${participant.unreadActivityCount === 1 ? '' : 's'} waiting`
-                        : 'caught up';
-            return `  ${glyph} ${participant.name} · ${summary}${attention === '' ? '' : ` · ${attention}`}`;
-        });
-        const cap = result.hardCap === null ? 'unlimited' : String(result.hardCap);
-        const hold = result.holdActive
-            ? `· ${result.holdActor ?? 'someone'} raised a hand${result.holdReason ? ` — ${result.holdReason}` : ''} · ${result.holdAt === undefined
-                ? 'just now'
-                : formatRelativeTime(result.holdAt, result.now)}`
-            : undefined;
-        const visible = result.latestAct === undefined
-            ? ''
-            : renderVisibleEvent(doc.acts, result.latestAct, context.name ?? '', {
-                now: result.now,
-                preview: 200,
-                actNumber: result.latestAct.kind === 'say'
-                    ? sayNumberFor(doc.acts, result.latestAct)
-                    : undefined,
-            });
-        const latest = visible === ''
-            ? [result.latestAct === undefined
-                    ? '  ○ no public activity yet'
-                    : '  · latest activity is private to another participant']
-            : [`  ${visible.replace(/\n/g, '\n  ')}`];
-        if (visible.includes('more chars') && result.latestAct !== undefined) {
-            const prefix = context.name === undefined ? commandPrefix(context.squarePath) : participantCommandPrefix(context.squarePath, context.name);
-            latest.push(`» ${prefix} history --at ${actId(result.latestAct)} -C 2 --full`);
+                : renderAmbientEvent(result.latestAct, context.name ?? '', {
+                    now: result.now,
+                    preview: 200,
+                    actNumber: presentation.latestActNumber,
+                });
+            const latest = visible === ''
+                ? [result.latestAct === undefined
+                        ? '  ○ no public activity yet'
+                        : '  · latest activity is private to another participant']
+                : [`  ${visible.replace(/\n/g, '\n  ')}`];
+            if (visible.includes('more chars') && result.latestAct !== undefined) {
+                const prefix = context.name === undefined ? commandPrefix(context.squarePath) : participantCommandPrefix(context.squarePath, context.name);
+                latest.push(`» ${prefix} history --at ${actId(result.latestAct)} -C 2 --full`);
+            }
+            const output = [
+                `${result.activeCount} active · ${result.doneCount} done · cap ${cap} · throttle ${result.throttlePerMinute === undefined ? 'none' : `${result.throttlePerMinute}/min`}`,
+                ...(hold === undefined ? [] : ['', hold]), '', 'around the square', ...people, '', 'latest', ...latest,
+            ].join('\n');
+            return withPathOutput(context.squarePath, output, { participantCount: result.activeCount, held: result.holdActive });
+        }
+        finally {
+            await closeOpenSquare(square);
         }
-        const output = [
-            `${result.activeCount} active · ${result.doneCount} done · cap ${cap} · throttle ${result.throttlePerMinute === undefined ? 'none' : `${result.throttlePerMinute}/min`}`,
-            ...(hold === undefined ? [] : ['', hold]), '', 'around the square', ...people, '', 'latest', ...latest,
-        ].join('\n');
-        return withPathOutput(context.squarePath, output, { participantCount: result.activeCount, held: result.holdActive });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -425,8 +445,8 @@ export const inboxCommand = {
             fail('inbox requires --for-session <session-id>.');
         return { sessionId, json };
     },
-    execute(intent) {
-        const inbox = sessionInbox(intent.sessionId);
+    async execute(intent) {
+        const inbox = await sessionInbox(intent.sessionId);
         return intent.json ? `${JSON.stringify(inbox)}\n` : inbox.map((membership) => `${membership.name}\t${membership.squarePath}\t${membership.notifications.length}\n`).join('');
     },
     present: (result) => process.stdout.write(result),
@@ -439,5 +459,5 @@ function hookCommand(runHook) {
         present: (result) => process.stdout.write(result),
     };
 }
-export const claudeHookCommand = hookCommand(runClaudeHook);
-export const codexHookCommand = hookCommand(runCodexHook);
+export const claudeHookCommand = hookCommand(runClaudeHookAsync);
+export const codexHookCommand = hookCommand(runCodexHookAsync);

package/dist/cli/program.d.ts

@@ -0,0 +1,2 @@
+/** Parse global flags, select an executable adapter, and leave all command work to the registry. */
+export declare function runCli(rawArgs?: string[]): Promise<void>;

package/dist/cli/program.js

@@ -1,14 +1,9 @@
 import { helpRequest } from '../help.js';
-import { SquareError } from '../model.js';
+import { isSquareError } from '../model.js';
 import { defaultContext, parseGlobalArgs } from './context.js';
 import { executeRegisteredCommand, findCommand } from './registry.js';
-function isMutatingCommand(command, argv) {
-    if (['build', 'join', 'catch', 'express', 'done', 'hold', 'resume', 'compact'].includes(command))
-        return true;
-    return command === 'doctor' && argv.includes('--fix');
-}
 function handleSquareError(error) {
-    if (error instanceof SquareError) {
+    if (isSquareError(error)) {
         process.stderr.write(`${error.message}\n`);
         process.exit(error.code === 'not_found' ? 1 : 2);
     }
@@ -19,7 +14,7 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
     try {
         const requestedHelp = helpRequest(rawArgs);
         if (requestedHelp !== undefined) {
-            await executeRegisteredCommand('help', requestedHelp.command === undefined ? [] : [requestedHelp.command], defaultContext('help', '.square/SQUARE.md'));
+            await executeRegisteredCommand('help', requestedHelp.command === undefined ? [] : [requestedHelp.command], defaultContext('help', '.square/SQUARE.square'));
             return;
         }
         const parsed = parseGlobalArgs(rawArgs);
@@ -32,10 +27,6 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
             process.stderr.write(`unknown command: ${command}\nrun 'square' for usage\n`);
             process.exit(2);
         }
-        if (!parsed.explicitSquarePath && parsed.multipleSquares && isMutatingCommand(command, parsed.args.slice(1))) {
-            process.stderr.write('✕ more than one square is active here; choose the path before changing or consuming activity.\n» square list\n');
-            process.exit(2);
-        }
         await executeRegisteredCommand(command, parsed.args.slice(1), defaultContext(command, parsed.squarePath, parsed.name));
     }
     catch (error) {

package/dist/cli/registry.d.ts

@@ -0,0 +1,9 @@
+import { type CommandContext, type CommandSpec } from './context.js';
+export interface RegisteredCommand {
+    names: readonly string[];
+    spec: CommandSpec<any, any>;
+}
+/** Every public command is an executable adapter, including aliases and utility commands. */
+export declare const commandRegistry: readonly RegisteredCommand[];
+export declare function findCommand(name: string): RegisteredCommand | undefined;
+export declare function executeRegisteredCommand(name: string, argv: string[], context: CommandContext): Promise<void>;

package/dist/cli/registry.js

@@ -1,8 +1,8 @@
-import { buildCommand, compactCommand, doneCommand, expressCommand, holdCommand, joinCommand, resumeCommand } from './square-commands.js';
+import { buildCommand, doneCommand, expressCommand, holdCommand, joinCommand, resumeCommand } 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 { catchCommand, claudeHookCommand, codexHookCommand, historyCommand, inboxCommand, listCommand, participantsCommand, statusCommand, streamCommand, warmupCommand, } from './observation-commands.js';
+import { catchCommand, claudeHookCommand, 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 = [
     { names: ['build'], spec: buildCommand },
@@ -20,10 +20,8 @@ export const commandRegistry = [
     { names: ['install'], spec: installCommand },
     { names: ['uninstall'], spec: uninstallCommand },
     { names: ['harness'], spec: harnessCommand },
-    { names: ['compact'], spec: compactCommand },
     { names: ['doctor'], spec: doctorCommand },
     { names: ['history'], spec: historyCommand },
-    { names: ['warmup'], spec: warmupCommand },
     { names: ['status'], spec: statusCommand },
     { names: ['participants'], spec: participantsCommand },
     { names: ['help'], spec: helpCommand },

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

@@ -0,0 +1,34 @@
+import { type BuildOptions, type HardCap, type Reach } from '../model.js';
+import { type CommandSpec } from './context.js';
+interface BuildIntent {
+    options: BuildOptions & {
+        hardCap: HardCap;
+    };
+    snippet: string;
+}
+interface JoinIntent {
+    name: string;
+    lastN: number | null;
+    kick: boolean;
+}
+interface ActivityIntent {
+    name: string;
+    activity: string;
+    force: boolean;
+    noWait: boolean;
+    reach?: Reach;
+    reply?: number;
+}
+interface BodyIntent {
+    name: string;
+    body?: string;
+}
+export declare const buildCommand: CommandSpec<BuildIntent, string>;
+export declare const joinCommand: CommandSpec<JoinIntent, string>;
+export declare const expressCommand: CommandSpec<ActivityIntent>;
+export declare const doneCommand: CommandSpec<BodyIntent, string>;
+export declare const holdCommand: CommandSpec<BodyIntent, string>;
+export declare const resumeCommand: CommandSpec<{
+    name: string;
+}, string>;
+export {};