@astrosheep/square 0.3.5 → 0.3.6

package/dist/claude-hook.js

@@ -1,12 +1,13 @@
 import { leaseOwnsNotification } from './delivery.js';
-import { notificationMessageId } from './delivery-health.js';
+import { notificationMessageId } from './delivery.js';
 import { sessionInbox } from './inbox.js';
 import { participantCommandPrefix } from './presentation.js';
 import { presentOnce } from './presented.js';
 function pendingCount(inbox) {
     return inbox.reduce((total, membership) => total + membership.notifications.length, 0);
 }
-const INJECT_BODY_MAX = 2048;
+const INJECT_BODY_MAX = 200;
+const INJECT_TOTAL_MAX = 1200;
 /** Let a fresh blocking catch own notifications it can deliver; hook injection remains the fallback. */
 export function deferToActiveCatch(inbox) {
     return inbox
@@ -16,38 +17,61 @@ export function deferToActiveCatch(inbox) {
             return membership;
         return {
             ...membership,
-            notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, notification)),
+            notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.name })),
         };
     })
         .filter((membership) => membership.notifications.length > 0);
 }
-function injectBodyPreview(body, squarePath, name, actIndex) {
+function injectBodyPreview(body) {
     const compact = body.replace(/\r\n/g, '\n');
     if (compact.length <= INJECT_BODY_MAX)
         return compact;
-    const pointer = `${participantCommandPrefix(squarePath, name)} echo --ids act_${actIndex} --full`;
-    return `${compact.slice(0, INJECT_BODY_MAX).trimEnd()}\n… [truncated] full echo: ${pointer}`;
+    return `${compact.slice(0, INJECT_BODY_MAX).trimEnd()}\n… [truncated; run catch --now]`;
 }
 export function renderClaudeInboxContext(inbox) {
     const count = pendingCount(inbox);
     const noun = count === 1 ? 'notification' : 'notifications';
-    return [
-        `<system-reminder source="square">You have ${count} unread Square ${noun}.`,
-        ...inbox.flatMap((membership) => {
-            const command = `${participantCommandPrefix(membership.squarePath, membership.name)} catch --now`;
-            return membership.notifications.map((notification) => {
-                const id = notificationMessageId(membership.squarePath, notification.actIndex);
-                const body = injectBodyPreview(notification.body, membership.squarePath, membership.name, notification.actIndex);
-                return [
-                    `${id} · ${membership.squarePath}: @${membership.name} from @${notification.actor} (${notification.via})`,
-                    body,
-                    `Ack with: ${command}`,
-                ].join('\n');
-            });
-        }),
+    const header = `<system-reminder source="square">You have ${count} unread Square ${noun}.`;
+    const footer = [
         // Body here is a cache only. Delivered is written solely by catch.
         'Ids are stable across turns. If you already acted on an id, do not repeat the action; still run catch --now to mark delivered.',
         'Read and respond in the square before finishing the current turn.</system-reminder>',
+    ];
+    const queued = inbox.flatMap((membership) => membership.notifications.map((notification) => ({ membership, notification })));
+    const blocks = [];
+    let omitted = 0;
+    for (const [index, entry] of queued.entries()) {
+        const { membership, notification } = entry;
+        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})`,
+            injectBodyPreview(notification.body),
+            `Ack with: ${command}`,
+        ].join('\n');
+        const omittedAfter = omitted + queued.length - index - 1;
+        const prospective = [
+            header,
+            ...blocks,
+            block,
+            ...(omittedAfter > 0
+                ? [`… ${omittedAfter} unread ${omittedAfter === 1 ? 'notification' : 'notifications'} omitted. Run catch --now to receive them.`]
+                : []),
+            ...footer,
+        ].join('\n');
+        if (prospective.length > INJECT_TOTAL_MAX) {
+            omitted += 1;
+            continue;
+        }
+        blocks.push(block);
+    }
+    return [
+        header,
+        ...blocks,
+        ...(omitted > 0
+            ? [`… ${omitted} unread ${omitted === 1 ? 'notification' : 'notifications'} omitted. Run catch --now to receive them.`]
+            : []),
+        ...footer,
     ].join('\n');
 }
 function nativeHookResponse(input, lookup, env) {
@@ -58,7 +82,7 @@ function nativeHookResponse(input, lookup, env) {
     }
     if (input.hook_event_name === 'Stop' && input.stop_hook_active === true)
         return undefined;
-    // Delivery membership is only claimed by explicit participant actions (join/act/catch/...).
+    // Delivery membership is only claimed by explicit participant actions (join/express/catch/...).
     // Inherited PASEO_AGENT_ID proves process ancestry, not conversational ownership.
     // Stop is the guaranteed "don't leave while undelivered" nudge; it does not consume presentation.
     if (input.hook_event_name === 'Stop') {

package/dist/cli/context.js

@@ -3,7 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { loadSquare } from '../artifact.js';
 import { commandUsageHint } from '../help.js';
-import { parseParticipantList, validateParticipantName } from '../model.js';
+import { parseParticipantList, validateName } from '../model.js';
 export const DEFAULT_SQUARE_PATH = '.square/SQUARE.md';
 export function readStdinSync() {
     try {
@@ -65,13 +65,13 @@ export function parseNonNegativeInteger(value, flag) {
     return parsed;
 }
 export function parseHardCap(value) {
-    if (value === '-1')
+    if (value === 'unlimited')
         return null;
     if (!/^[1-9]\d*$/.test(value))
-        fail('Invalid build option: --cap must be a positive integer or -1.');
+        fail('Invalid build option: --cap must be a positive integer or unlimited.');
     const parsed = Number(value);
     if (!Number.isSafeInteger(parsed))
-        fail('Invalid build option: --cap must be a positive integer or -1.');
+        fail('Invalid build option: --cap must be a positive integer or unlimited.');
     return parsed;
 }
 export function parseNameList(value, flag) {
@@ -79,13 +79,13 @@ export function parseNameList(value, flag) {
     if (names.length === 0)
         fail(`Invalid ${flag}: expected at least one participant name.`);
     for (const name of names)
-        validateParticipantName(name);
+        validateName(name);
     return names;
 }
 export function requireParticipant(name) {
     if (!name)
         fail('Missing required option: --as <name>.');
-    validateParticipantName(name);
+    validateName(name);
     return name;
 }
 function resolveDefaultSquarePath() {
@@ -130,7 +130,7 @@ export function parseGlobalArgs(rawArgs) {
         }
     }
     if (name !== undefined)
-        validateParticipantName(name);
+        validateName(name);
     const explicitSquarePath = requestedPath !== undefined;
     const command = args[0];
     const resolved = !explicitSquarePath && !['ls', 'list', 'version'].includes(command ?? '')

package/dist/cli/maintenance-commands.js

@@ -1,11 +1,11 @@
 import fs from 'node:fs';
 import { diagnoseSquare, loadSquare } from '../artifact.js';
-import { doctorDeliveryHealth, findStalePendingMentions } from '../delivery-health.js';
 import { renderDoctorClean, renderDoctorProblems, renderDoctorRepaired, renderDoctorUnfixable, withPathOutput, } from '../presentation.js';
 import { inSquareCount } from '../runtime.js';
-import { reconcileBacklog, repairSquare } from '../square-application.js';
+import { repairSquare } from '../square-application.js';
 import { SquareError } from '../model.js';
-import { fail, usage } from './context.js';
+import { pruneRegistry } from '../registry.js';
+import { usage } from './context.js';
 function readSquareText(squarePath) {
     try {
         return fs.readFileSync(squarePath, 'utf8');
@@ -22,13 +22,10 @@ function quarantinePath(squarePath) {
 export const doctorCommand = {
     parse(argv, context) {
         let fix = false;
-        let reconcileBacklog = false;
         for (let index = 0; index < argv.length; index++) {
             const argument = argv[index];
             if (argument === '--fix')
                 fix = true;
-            else if (argument === 'reconcile-backlog')
-                reconcileBacklog = true;
             else if (argument === '--before') {
                 index += 1;
                 if (argv[index] === undefined)
@@ -37,9 +34,7 @@ export const doctorCommand = {
             else
                 usage(context.command);
         }
-        if (reconcileBacklog && !fix)
-            fail('doctor reconcile-backlog requires --fix.');
-        return { fix, reconcileBacklog };
+        return { fix };
     },
     async execute(intent, context) {
         if (!intent.fix) {
@@ -51,24 +46,9 @@ export const doctorCommand = {
                 };
             }
             const summary = diagnosis.problems.length === 0 ? renderDoctorClean() : renderDoctorProblems(diagnosis.problems);
-            const delivery = doctorDeliveryHealth(context.squarePath).join('\n');
-            const stale = findStalePendingMentions(context.squarePath);
             return {
-                output: withPathOutput(context.squarePath, `${summary}\n\n${delivery}`, { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
-                exitCode: diagnosis.problems.length === 0 && stale.length === 0 ? 0 : 1,
-            };
-        }
-        if (intent.reconcileBacklog) {
-            const result = await reconcileBacklog(context.squarePath);
-            const delivery = doctorDeliveryHealth(context.squarePath).join('\n');
-            return {
-                output: withPathOutput(context.squarePath, [
-                    `✓ reconciled ${result.reconciled} backlog receipt(s) as delivered(reason=reconciled)`,
-                    result.skippedRecent > 0 ? `· left ${result.skippedRecent} recent liveness failure(s) untouched` : '· no recent liveness failures present',
-                    '',
-                    delivery,
-                ].join('\n'), { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
-                exitCode: result.skippedRecent > 0 ? 1 : 0,
+                output: withPathOutput(context.squarePath, summary, { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
+                exitCode: diagnosis.problems.length === 0 ? 0 : 1,
             };
         }
         const repair = await repairSquare(context.squarePath);
@@ -79,6 +59,10 @@ export const doctorCommand = {
             };
         }
         const repaired = repair.repaired;
+        const registry = pruneRegistry();
+        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)) }),

package/dist/cli/meta-commands.js

@@ -1,6 +1,5 @@
-import fs from 'node:fs';
-import { fileURLToPath } from 'node:url';
 import { renderGlobalHelp, renderSubcommandHelp } from '../help.js';
+import { SQUARE_IDENTITY } from '../identity.js';
 import { fail } from './context.js';
 export const helpCommand = {
     parse(argv) {
@@ -13,7 +12,7 @@ export const helpCommand = {
             return renderGlobalHelp();
         const rendered = renderSubcommandHelp(intent.command);
         if (rendered === undefined)
-            fail(`unknown command: ${intent.command}\nrun 'square help' to list every command`);
+            fail(`unknown command: ${intent.command}\nrun 'square help' to list available commands`);
         return rendered;
     },
     present: (result) => process.stdout.write(result),
@@ -23,9 +22,7 @@ export const versionCommand = {
         return undefined;
     },
     execute() {
-        const packagePath = fileURLToPath(new URL('../../package.json', import.meta.url));
-        const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-        return `${packageJson.version ?? 'unknown'}\n`;
+        return `${SQUARE_IDENTITY.packageVersion}\n`;
     },
     present: (result) => process.stdout.write(result),
 };

package/dist/cli/observation-commands.js

@@ -10,7 +10,7 @@ import { actId, inSquareCount, isCurrentlyJoined, nowMs, resolveRosterName, sayN
 import { cmdStream, cmdStreamNdjson } from '../stream.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.js';
 import { cmdWatch } from '../watch.js';
-import { fail, parseDurationMs, parseNameList, parseNonNegativeInteger, parsePositiveInteger, readStdinSync, requireParticipant, requireValue, usage, } from './context.js';
+import { fail, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdinSync, requireParticipant, requireValue, usage, } from './context.js';
 export const listCommand = {
     parse: (argv) => argv,
     execute(argv, context) {
@@ -47,19 +47,13 @@ export const streamCommand = {
 export const catchCommand = {
     parse(argv, context) {
         const name = requireParticipant(context.name);
-        let activityCount = 1;
         let idleMs;
         let mention;
-        let force = false;
+        let replace = false;
         let now = false;
-        let follow = false;
         const participants = [];
         for (let index = 0; index < argv.length; index++) {
-            if (argv[index] === '--count') {
-                activityCount = parsePositiveInteger(requireValue(argv, index, argv[index]), argv[index]);
-                index += 1;
-            }
-            else if (argv[index] === '--by') {
+            if (argv[index] === '--from') {
                 participants.push(...parseNameList(requireValue(argv, index, argv[index]), argv[index]));
                 index += 1;
             }
@@ -77,25 +71,23 @@ export const catchCommand = {
                     mention = name;
                 }
             }
-            else if (argv[index] === '-f' || argv[index] === '--force')
-                force = true;
+            else if (argv[index] === '--replace')
+                replace = true;
             else if (argv[index] === '--now')
                 now = true;
-            else if (argv[index] === '--follow')
-                follow = true;
             else
-                usage(context.command);
+                fail(`✕ catch does not know ${argv[index]}\n» square catch --help`);
         }
-        if (now && follow)
-            fail('--follow cannot be combined with --now');
+        if (now === (idleMs !== undefined))
+            fail('catch requires exactly one mode: --now or --idle <duration>.');
+        if (replace && now)
+            fail('--replace can only be used with --idle.');
         return {
-            activityCount,
             ...(participants.length > 0 ? { participants } : {}),
             ...(mention === undefined ? {} : { mention }),
             ...(idleMs === undefined ? {} : { idleMs }),
-            ...(force ? { force } : {}),
+            ...(replace ? { replace } : {}),
             ...(now ? { now } : {}),
-            ...(follow ? { follow } : {}),
         };
     },
     async execute(intent, context) {
@@ -106,7 +98,7 @@ export const catchCommand = {
 function parseActRef(value, flag) {
     const match = value.trim().match(/^(?:act_)?(\d+)$/i);
     if (!match)
-        fail(`Invalid ${flag}: expected act id like act_12 or 12.`);
+        fail(`Invalid ${flag}: expected an activity id like act_12 or 12.`);
     return Number(match[1]);
 }
 function parseTimestamp(value, flag) {
@@ -115,7 +107,8 @@ function parseTimestamp(value, flag) {
         fail(`Invalid ${flag} timestamp: ${value}`);
     return timestamp;
 }
-function parseEcho(argv, viewer) {
+function parseHistory(argv, context) {
+    const viewer = context.name;
     let lastN = 10;
     let lastNExplicit = false;
     let before;
@@ -125,7 +118,6 @@ function parseEcho(argv, viewer) {
     let beforeContext;
     let afterContext;
     let mention;
-    let mentionsViewer = false;
     let pending = false;
     let full = false;
     let grep;
@@ -138,8 +130,15 @@ function parseEcho(argv, viewer) {
     const participants = [];
     for (let index = 0; index < argv.length; index++) {
         const flag = argv[index];
-        if (flag === '--last' || flag === '--limit') {
-            lastN = parsePositiveInteger(requireValue(argv, index, flag), flag);
+        if (flag === '--limit') {
+            const value = argv[index + 1];
+            const retry = `${commandPrefix(context.squarePath)} history --limit 30`;
+            if (value === undefined || value.startsWith('--'))
+                fail(`✕ --limit needs a positive number\n» ${retry}`);
+            if (!/^[1-9]\d*$/.test(value) || !Number.isSafeInteger(Number(value))) {
+                fail(`✕ --limit needs a positive number\n» ${retry}`);
+            }
+            lastN = Number(value);
             lastNExplicit = true;
             index += 1;
         }
@@ -147,11 +146,11 @@ function parseEcho(argv, viewer) {
             lastN = null;
             lastNExplicit = true;
         }
-        else if (flag === '--by' || flag === '--from') {
+        else if (flag === '--from') {
             participants.push(...parseNameList(requireValue(argv, index, flag), flag));
             index += 1;
         }
-        else if (flag === '--before' || flag === '--until') {
+        else if (flag === '--until') {
             before = parseTimestamp(requireValue(argv, index, flag), flag);
             index += 1;
         }
@@ -187,13 +186,6 @@ function parseEcho(argv, viewer) {
             mention = requireValue(argv, index, flag);
             index += 1;
         }
-        else if (flag === '--mentions') {
-            const value = requireValue(argv, index, flag);
-            if (value !== 'me')
-                fail(`Invalid --mentions: only 'me' is supported (got ${value}).`);
-            mentionsViewer = true;
-            index += 1;
-        }
         else if (flag === '--pending')
             pending = true;
         else if (flag === '--grep') {
@@ -228,10 +220,10 @@ function parseEcho(argv, viewer) {
         else if (flag === '--json')
             json = true;
         else
-            fail('✕ invalid arguments for echo');
+            fail(`✕ history does not know ${flag}\n» square history --help`);
     }
-    if ((mentionsViewer || pending) && !viewer)
-        fail('--mentions me / --pending require --as <name>.');
+    if (pending && !viewer)
+        fail('--pending requires --as <name>.');
     if (grep !== undefined && fixed !== undefined)
         fail('--grep and --fixed cannot be combined.');
     if (grep === '' || fixed === '')
@@ -248,7 +240,6 @@ function parseEcho(argv, viewer) {
         beforeContext,
         afterContext,
         mention,
-        mentionsViewer,
         pending,
         viewer,
         full,
@@ -266,18 +257,18 @@ function renderFields(doc, item, fields) {
         switch (field) {
             case 'id': return actId(item.index);
             case 'author':
-            case 'actor': return item.act.actor ?? '';
+            case 'actor': return item.actor ?? '';
             case 'ts':
-            case 'at': return formatTimestamp(item.act.at);
-            case 'kind': return item.act.kind;
-            case 'body': return 'body' in item.act && typeof item.act.body === 'string' ? item.act.body.replace(/\s+/g, ' ').trim() : '';
-            case 'number': return item.act.kind === 'say' ? String(sayNumberFor(doc.acts, item.act)) : '';
+            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)) : '';
             default: return '';
         }
     }).join('\t');
 }
 function jsonLine(doc, item) {
-    const act = item.act;
+    const act = item;
     return JSON.stringify({
         id: actId(item.index),
         index: item.index,
@@ -290,8 +281,8 @@ function jsonLine(doc, item) {
         reach: act.kind === 'say' ? act.reach ?? null : null,
     });
 }
-export const echoCommand = {
-    parse(argv, context) { return parseEcho(argv, context.name); },
+export const historyCommand = {
+    parse(argv, context) { return parseHistory(argv, context); },
     execute(options, context) {
         const doc = loadSquare(context.squarePath);
         let events = coreActivities(doc, options);
@@ -333,14 +324,15 @@ export const participantsCommand = {
         usage(context.command); return undefined; },
     execute(_intent, context) {
         const doc = loadSquare(context.squarePath);
-        const result = coreParticipants(doc, nowMs());
-        const lines = result.participants.map((participant) => {
+        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, result.now);
-            return `  ${glyph} ${participant.name} · ${state} · ${participant.activityCount} act${participant.activityCount === 1 ? '' : 's'} · ${last}`;
+            const last = participant.lastActiveAt === undefined ? '—' : formatRelativeTime(participant.lastActiveAt, now);
+            return `  ${glyph} ${participant.name} · ${state} · ${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${last}`;
         });
-        const participantCount = result.participants.filter((participant) => participant.state === 'active').length;
+        const participantCount = participants.filter((participant) => participant.state === 'active').length;
         return withPathOutput(context.squarePath, ['participants', ...lines].join('\n'), {
             participantCount,
         });
@@ -365,7 +357,7 @@ export const statusCommand = {
                 ? '◎'
                 : participant.activityCount > 0 ? '●' : '○';
             const summary = participant.activityCount > 0
-                ? `${participant.activityCount} act${participant.activityCount === 1 ? '' : 's'} · ${participant.lastActiveAt === undefined
+                ? `${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)}`;
@@ -401,7 +393,7 @@ export const statusCommand = {
             : [`  ${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} echo --at ${actId(result.latestAct)} -C 2 --full`);
+            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`}`,

package/dist/cli/program.js

@@ -4,9 +4,9 @@ import { defaultContext, parseGlobalArgs } from './context.js';
 import { refreshLocalRegistration } from './observation-commands.js';
 import { executeRegisteredCommand, findCommand } from './registry.js';
 function isMutatingCommand(command, argv) {
-    if (['build', 'join', 'catch', 'act', 'done', 'hold', 'resume', 'compact'].includes(command))
+    if (['build', 'join', 'catch', 'express', 'done', 'hold', 'resume', 'compact'].includes(command))
         return true;
-    return command === 'doctor' && argv.some((argument) => argument === '--fix' || argument === 'reconcile-backlog');
+    return command === 'doctor' && argv.includes('--fix');
 }
 function handleSquareError(error) {
     if (error instanceof SquareError) {
@@ -34,10 +34,10 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
             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 ls\n');
+            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);
         }
-        if (['act', 'catch', 'done', 'hold', 'resume'].includes(command)) {
+        if (['express', 'catch', 'done', 'hold', 'resume'].includes(command)) {
             refreshLocalRegistration(parsed.squarePath, parsed.name);
         }
         await executeRegisteredCommand(command, parsed.args.slice(1), defaultContext(command, parsed.squarePath, parsed.name));

package/dist/cli/registry.js

@@ -1,26 +1,26 @@
-import { actCommand, buildCommand, compactCommand, doneCommand, holdCommand, joinCommand, resumeCommand } from './square-commands.js';
+import { buildCommand, compactCommand, doneCommand, expressCommand, holdCommand, joinCommand, resumeCommand } from './square-commands.js';
 import { doctorCommand } from './maintenance-commands.js';
 import { harnessCommand } from './harness-command.js';
 import { helpCommand, versionCommand } from './meta-commands.js';
-import { catchCommand, claudeHookCommand, codexHookCommand, echoCommand, inboxCommand, listCommand, participantsCommand, statusCommand, streamCommand, warmupCommand, } from './observation-commands.js';
+import { catchCommand, claudeHookCommand, codexHookCommand, historyCommand, inboxCommand, listCommand, participantsCommand, statusCommand, streamCommand, warmupCommand, } from './observation-commands.js';
 /** Every public command is an executable adapter, including aliases and utility commands. */
 export const commandRegistry = [
     { names: ['build'], spec: buildCommand },
-    { names: ['ls', 'list'], spec: listCommand },
+    { names: ['list', 'ls'], spec: listCommand },
     { names: ['join'], spec: joinCommand },
     { names: ['stream'], spec: streamCommand },
     { names: ['inbox'], spec: inboxCommand },
     { names: ['claude-hook'], spec: claudeHookCommand },
     { names: ['codex-hook'], spec: codexHookCommand },
     { names: ['catch'], spec: catchCommand },
-    { names: ['act'], spec: actCommand },
+    { names: ['express'], spec: expressCommand },
     { names: ['done'], spec: doneCommand },
     { names: ['hold'], spec: holdCommand },
     { names: ['resume'], spec: resumeCommand },
     { names: ['harness'], spec: harnessCommand },
     { names: ['compact'], spec: compactCommand },
     { names: ['doctor'], spec: doctorCommand },
-    { names: ['echo'], spec: echoCommand },
+    { names: ['history'], spec: historyCommand },
     { names: ['warmup'], spec: warmupCommand },
     { names: ['status'], spec: statusCommand },
     { names: ['participants'], spec: participantsCommand },