@astrosheep/square 0.3.34 → 0.3.36

package/dist/cli/observation-commands.js

@@ -3,8 +3,8 @@ import { runCodexHookAsync } from '../codex-hook.js';
 import { sessionInbox } from '../inbox.js';
 import { sweepPendingNotifications } from '../notifications.js';
 import { cmdListSquares } from '../list.js';
-import { parseActivityId, sameName } from '../model.js';
-import { commandPrefix, participantCommandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEvent, renderPresenceAnchor, withPathOutput, quoteShell, } from '../presentation.js';
+import { nameKey, parseActivityId, sameName } from '../model.js';
+import { commandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEvent, renderPresenceAnchor, truncateChars, withPathOutput, quoteShell, } from '../presentation.js';
 import { actId, nowMs } from '../runtime.js';
 import { cmdStream, cmdStreamNdjson } from '../stream.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.js';
@@ -12,8 +12,23 @@ 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, readStdin, requireParticipant, requireSquarePath, requireValue, usage, } from './context.js';
+import { fail, parseBoundedLimit, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdin, requireParticipant, requireSquarePath, requireValue, usage, } from './context.js';
+import { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from '../catch-decisions.js';
 const STATUS_PARTICIPANT_PREVIEW_LIMIT = 10;
+const HISTORY_DEFAULT_LIMIT = 10;
+const HISTORY_MAX_LIMIT = 100;
+const PARTICIPANTS_DEFAULT_LIMIT = 20;
+const PARTICIPANTS_MAX_LIMIT = 100;
+const INBOX_DEFAULT_LIMIT = 20;
+const INBOX_MAX_LIMIT = 100;
+const INBOX_DISPLAY_CHARS = 160;
+function inboxDisplay(value) {
+    const truncated = truncateChars(value, INBOX_DISPLAY_CHARS - 1);
+    return truncated.remaining === 0 ? truncated.text : `${truncated.text}…`;
+}
+function inboxLimitCommand(sessionId, json) {
+    return `square inbox --for-session ${quoteShell(sessionId)} --limit ${INBOX_MAX_LIMIT}${json ? ' --json' : ''}`;
+}
 export const listCommand = {
     parse: (argv) => argv,
     async execute(argv, context) {
@@ -25,6 +40,9 @@ export const streamCommand = {
     parse(argv, context) {
         let ndjson = false;
         let forName;
+        let last = 10;
+        let after;
+        let hasLast = false;
         for (let index = 0; index < argv.length; index++) {
             if (argv[index] === '--ndjson')
                 ndjson = true;
@@ -32,17 +50,32 @@ export const streamCommand = {
                 forName = requireValue(argv, index, argv[index]);
                 index += 1;
             }
+            else if (argv[index] === '--last') {
+                if (after !== undefined)
+                    fail('Invalid stream options: --last and --after cannot be combined.');
+                last = parseNonNegativeInteger(requireValue(argv, index, argv[index]), '--last');
+                if (last > 100)
+                    fail('Invalid --last: maximum is 100.');
+                hasLast = true;
+                index += 1;
+            }
+            else if (argv[index] === '--after') {
+                if (hasLast)
+                    fail('Invalid stream options: --last and --after cannot be combined.');
+                after = parseActRef(requireValue(argv, index, argv[index]), '--after');
+                index += 1;
+            }
             else
                 usage(context.command);
         }
-        if (forName !== undefined && !ndjson)
+        if (!ndjson && argv.length > 0)
             usage(context.command);
-        return { ndjson, forName };
+        return { ndjson, forName, start: after === undefined ? { kind: 'tail', last } : { kind: 'after', after } };
     },
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
         if (intent.ndjson)
-            await cmdStreamNdjson(squarePath, intent.forName);
+            await cmdStreamNdjson(squarePath, intent.forName, intent.start);
         else
             await cmdStream(squarePath);
     },
@@ -53,6 +86,7 @@ export const catchCommand = {
         const name = requireParticipant(context.name);
         let idleMs;
         let mention;
+        let limit = CATCH_DEFAULT_LIMIT;
         let replace = false;
         let now = false;
         const participants = [];
@@ -66,14 +100,11 @@ export const catchCommand = {
                 index += 1;
             }
             else if (argv[index] === '--mention') {
-                const value = argv[index + 1];
-                if (value !== undefined && !value.startsWith('--')) {
-                    mention = value;
-                    index += 1;
-                }
-                else {
-                    mention = name;
-                }
+                mention = name;
+            }
+            else if (argv[index] === '--limit') {
+                limit = parseBoundedLimit(argv[index + 1], '--limit', CATCH_MAX_LIMIT, `${commandPrefix(requireSquarePath(context))} catch --now --limit ${CATCH_MAX_LIMIT}`);
+                index += 1;
             }
             else if (argv[index] === '--replace')
                 replace = true;
@@ -89,6 +120,7 @@ export const catchCommand = {
         return {
             ...(participants.length > 0 ? { participants } : {}),
             ...(mention === undefined ? {} : { mention }),
+            limit,
             ...(idleMs === undefined ? {} : { idleMs }),
             ...(replace ? { replace } : {}),
             ...(now ? { now } : {}),
@@ -135,8 +167,7 @@ function historyContinuationArgs(argv) {
 }
 function parseHistory(argv, context) {
     const squarePath = requireSquarePath(context);
-    const viewer = context.name;
-    let lastN = 10;
+    let lastN = HISTORY_DEFAULT_LIMIT;
     let lastNExplicit = false;
     let after;
     let afterIndex;
@@ -145,7 +176,6 @@ function parseHistory(argv, context) {
     let beforeContext;
     let afterContext;
     let mention;
-    let pending = false;
     let noTruncate = false;
     let grep;
     let fixed;
@@ -156,14 +186,7 @@ function parseHistory(argv, context) {
     for (let index = 0; index < argv.length; index++) {
         const flag = argv[index];
         if (flag === '--limit') {
-            const value = argv[index + 1];
-            const retry = `${commandPrefix(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);
+            lastN = parseBoundedLimit(argv[index + 1], '--limit', HISTORY_MAX_LIMIT, `${commandPrefix(squarePath)} history --limit ${HISTORY_MAX_LIMIT}`);
             lastNExplicit = true;
             index += 1;
         }
@@ -210,8 +233,6 @@ function parseHistory(argv, context) {
             mention = requireValue(argv, index, flag);
             index += 1;
         }
-        else if (flag === '--pending')
-            pending = true;
         else if (flag === '--grep') {
             grep = requireValue(argv, index, flag);
             index += 1;
@@ -236,15 +257,13 @@ function parseHistory(argv, context) {
         else
             fail(`✕ history does not know ${flag}\n» square history --help`);
     }
-    if (pending && !viewer)
-        fail('--pending requires --as <name>.');
     if (grep !== undefined && fixed !== undefined)
         fail('--grep and --fixed cannot be combined.');
     if (grep === '' || fixed === '')
         fail('--grep and --fixed require non-empty text.');
     if (beforeIndex !== undefined && afterIndex !== undefined)
         fail('--before and --after cannot be combined.');
-    if (!lastNExplicit && (atIndexes.length > 0 || pending))
+    if (!lastNExplicit && atIndexes.length > 0)
         lastN = null;
     return {
         lastN,
@@ -256,8 +275,6 @@ function parseHistory(argv, context) {
         beforeContext,
         afterContext,
         mention,
-        pending,
-        viewer,
         noTruncate,
         grep,
         fixed,
@@ -268,11 +285,14 @@ function parseHistory(argv, context) {
     };
 }
 function historyContinuationCommand(options, squarePath, direction, index) {
-    const prefix = options.viewer === undefined ? commandPrefix(squarePath) : participantCommandPrefix(squarePath, options.viewer);
-    const args = [...(options.continuationArgs ?? []), direction, actId(index), '--limit', String(options.lastN ?? 10)];
-    return `${prefix} history ${args.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
+    const args = [...(options.continuationArgs ?? []), direction, actId(index), '--limit', String(options.lastN ?? HISTORY_DEFAULT_LIMIT)];
+    return `${commandPrefix(squarePath)} history ${args.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
+}
+function boundedHistoryCommand(options, squarePath) {
+    const args = [...(options.continuationArgs ?? []), '--limit', String(HISTORY_MAX_LIMIT)];
+    return `${commandPrefix(squarePath)} history ${args.map((arg) => arg.startsWith('-') || /^act\/\d+$/.test(arg) || /^\d+$/.test(arg) ? arg : quoteShell(arg)).join(' ')}`;
 }
-function renderFields(sayNumbers, item, fields, perception) {
+function renderFields(sayNumbers, item, fields) {
     return fields.map((field) => {
         switch (field) {
             case 'id': return actId(item.index);
@@ -281,14 +301,14 @@ function renderFields(sayNumbers, item, fields, perception) {
             case 'ts':
             case 'at': return formatTimestamp(item.at);
             case 'kind': return item.kind;
-            case 'body': return perception === 'presence' ? '' : 'body' in item && typeof item.body === 'string' ? item.body.replace(/\s+/g, ' ').trim() : '';
+            case 'body': return 'body' in item && typeof item.body === 'string' ? item.body.replace(/\s+/g, ' ').trim() : '';
             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(sayNumbers, item, perception) {
+function jsonLine(sayNumbers, item) {
     const act = item;
     return JSON.stringify({
         id: actId(item.index),
@@ -297,25 +317,23 @@ function jsonLine(sayNumbers, item, perception) {
         author: act.actor ?? null,
         at: act.at,
         ts: formatTimestamp(act.at),
-        body: perception === 'presence' ? '' : 'body' in act && typeof act.body === 'string' ? act.body : '',
+        body: 'body' in act && typeof act.body === 'string' ? act.body : '',
         number: act.kind === 'say' ? sayNumbers[act.index] : null,
+        mentions: act.kind === 'say' ? [...(act.mentions ?? [])] : [],
         reach: act.kind === 'say' ? act.reach ?? null : null,
         reply: act.kind === 'say' && act.reply !== undefined ? actId(act.reply) : null,
     });
 }
-function renderHistoryProjection(projection, visible, noTruncate, squarePath, viewer, mode) {
+function renderHistoryProjection(projection, visible, noTruncate, squarePath) {
     const shown = visible.filter((activity) => activity.kind === 'say' || activity.kind === 'done');
-    const preview = noTruncate ? undefined : 200;
+    const preview = noTruncate || shown.length <= 1 ? undefined : 200;
     const chunks = [];
     for (const activity of shown) {
         const options = {
             preview,
             actNumber: activity.kind === 'say' ? projection.sayNumbers[activity.index] : undefined,
-            perception: activity.perception,
         };
-        const rendered = mode === 'archive'
-            ? renderEventCli(activity, options)
-            : renderAmbientEvent(activity, viewer, options);
+        const rendered = renderEventCli(activity, options);
         if (rendered !== '')
             chunks.push(rendered);
         const participants = projection.presenceAnchors[activity.index];
@@ -324,7 +342,7 @@ function renderHistoryProjection(projection, visible, noTruncate, squarePath, vi
     }
     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'))) {
+    if (preview !== undefined && shown.some((activity) => activity.kind === 'say' && activity.body.length > preview)) {
         chunks.push(`» ${commandPrefix(squarePath)} history --no-truncate`);
     }
     return chunks.join('\n\n');
@@ -339,6 +357,9 @@ export const historyCommand = {
             // then --order only changes how the selected page is displayed.
             const projection = await historyPresentation(square, { ...options, order: 'asc' });
             let events = [...projection.activities];
+            if (options.lastN === null && events.length > HISTORY_MAX_LIMIT) {
+                fail(`✕ history is capped at ${HISTORY_MAX_LIMIT} activities\n» ${boundedHistoryCommand(options, squarePath)}`);
+            }
             const searching = options.grep !== undefined || options.fixed !== undefined;
             const totalMatches = searching ? events.length : 0;
             if (options.lastN != null) {
@@ -349,16 +370,14 @@ export const historyCommand = {
             if (options.order === 'desc')
                 events.reverse();
             if (options.json)
-                return events.map((item) => jsonLine(projection.sayNumbers, item, item.perception)).join('\n') + (events.length > 0 ? '\n' : '');
+                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, item.perception)).join('\n') + (events.length > 0 ? '\n' : '');
+                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 = anonymous;
             const output = pattern === undefined || pattern === ''
-                ? renderHistoryProjection(projection, events, options.noTruncate === true, squarePath, options.viewer ?? '', archive ? 'archive' : 'ambient')
-                : renderGrepActivitiesView(events, totalMatches, options.noTruncate, squarePath, pattern, options.fixed !== undefined, (item) => projection.activities.find((candidate) => candidate.index === item.index)?.perception ?? 'full');
+                ? renderHistoryProjection(projection, events, options.noTruncate === true, squarePath)
+                : renderGrepActivitiesView(events, totalMatches, options.noTruncate, squarePath, pattern, options.fixed !== undefined, () => 'full');
             const publicEvents = events.filter((item) => item.kind === 'say' || item.kind === 'done');
             const allPublic = projection.activities.filter((item) => item.kind === 'say' || item.kind === 'done');
             const pageMin = publicEvents.length === 0 ? undefined : Math.min(...publicEvents.map((item) => item.index));
@@ -377,23 +396,43 @@ export const historyCommand = {
     },
     present: (result) => process.stdout.write(result),
 };
+function participantsLimitCommand(squarePath, limit) {
+    return `${commandPrefix(squarePath)} participants --limit ${limit}`;
+}
+function parseParticipants(argv, context) {
+    let limit = PARTICIPANTS_DEFAULT_LIMIT;
+    for (let index = 0; index < argv.length; index++) {
+        if (argv[index] !== '--limit')
+            usage(context.command);
+        limit = parseBoundedLimit(argv[index + 1], '--limit', PARTICIPANTS_MAX_LIMIT, participantsLimitCommand(requireSquarePath(context), PARTICIPANTS_MAX_LIMIT));
+        index += 1;
+    }
+    return { limit };
+}
 export const participantsCommand = {
-    parse(argv, context) { if (argv.length > 0)
-        usage(context.command); return undefined; },
-    async execute(_intent, context) {
+    parse(argv, context) { return parseParticipants(argv, context); },
+    async execute(intent, context) {
         const squarePath = requireSquarePath(context);
         const square = await openSquare(squarePath, { clock: nowMs });
         try {
             const now = nowMs();
             const participants = await participantsPresentation(square);
-            const lines = participants.map((participant) => {
+            const lines = participants.slice(0, intent.limit).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}`;
+                return `  ${glyph} ${participant.name} · ${state} · ${participant.activityCount} ${participant.activityCount === 1 ? 'activity' : 'activities'} · ${last}`;
             });
             const participantCount = participants.filter((participant) => participant.state === 'active').length;
-            return withPathOutput(squarePath, ['participants', ...lines].join('\n'), {
+            const tail = participants.length <= intent.limit
+                ? []
+                : [
+                    `  ○ ${lines.length} of ${participants.length} participants shown`,
+                    ...(participants.length <= PARTICIPANTS_MAX_LIMIT ? [
+                        `» ${participantsLimitCommand(squarePath, participants.length)}`,
+                    ] : []),
+                ];
+            return withPathOutput(squarePath, ['participants', ...lines, ...tail].join('\n'), {
                 participantCount,
             });
         }
@@ -440,7 +479,9 @@ export const statusCommand = {
             });
             if (active.length > STATUS_PARTICIPANT_PREVIEW_LIMIT) {
                 people.push(`  ○ … ${active.length - STATUS_PARTICIPANT_PREVIEW_LIMIT} more participants`);
-                people.push(`» ${commandPrefix(squarePath)} participants`);
+                people.push(`» ${result.participants.length <= PARTICIPANTS_MAX_LIMIT
+                    ? participantsLimitCommand(squarePath, result.participants.length)
+                    : `${commandPrefix(squarePath)} participants`}`);
             }
             const cap = result.hardCap === null ? 'unlimited' : String(result.hardCap);
             const hold = result.holdActive
@@ -462,8 +503,7 @@ export const statusCommand = {
                         : '  · 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(squarePath) : participantCommandPrefix(squarePath, context.name);
-                latest.push(`» ${prefix} history --at ${actId(result.latestAct)} -C 2 --no-truncate`);
+                latest.push(`» ${commandPrefix(squarePath)} history --at ${actId(result.latestAct)} -C 2 --no-truncate`);
             }
             const output = [
                 `${result.activeCount} active · ${result.doneCount} done · cap ${cap} · throttle ${result.throttlePerMinute === undefined ? 'none' : `${result.throttlePerMinute}/min`}`,
@@ -481,6 +521,9 @@ export const inboxCommand = {
     parse(argv, context) {
         let sessionId;
         let json = false;
+        let limitValue;
+        let hasLimit = false;
+        let duplicateLimit = false;
         for (let index = 0; index < argv.length; index++) {
             if (argv[index] === '--for-session') {
                 sessionId = requireValue(argv, index, argv[index]);
@@ -488,16 +531,59 @@ export const inboxCommand = {
             }
             else if (argv[index] === '--json')
                 json = true;
+            else if (argv[index] === '--limit') {
+                if (hasLimit)
+                    duplicateLimit = true;
+                hasLimit = true;
+                const value = argv[index + 1];
+                if (value !== undefined && !value.startsWith('--')) {
+                    limitValue = value;
+                    index += 1;
+                }
+            }
             else
                 usage(context.command);
         }
         if (!sessionId)
             fail('inbox requires --for-session <session-id>.');
-        return { sessionId, json };
+        const retry = inboxLimitCommand(sessionId, json);
+        if (duplicateLimit)
+            fail(`✕ inbox accepts one --limit\n» ${retry}`);
+        const limit = hasLimit
+            ? parseBoundedLimit(limitValue, '--limit', INBOX_MAX_LIMIT, retry)
+            : INBOX_DEFAULT_LIMIT;
+        return { sessionId, json, limit };
     },
     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('');
+        const ordered = [...inbox].sort((left, right) => {
+            if (left.squarePath < right.squarePath)
+                return -1;
+            if (left.squarePath > right.squarePath)
+                return 1;
+            const leftName = nameKey(left.name);
+            const rightName = nameKey(right.name);
+            if (leftName < rightName)
+                return -1;
+            if (leftName > rightName)
+                return 1;
+            if (left.name < right.name)
+                return -1;
+            if (left.name > right.name)
+                return 1;
+            return 0;
+        });
+        const rows = ordered.slice(0, intent.limit).map((membership) => ({
+            namePreview: inboxDisplay(membership.name),
+            squarePathPreview: inboxDisplay(membership.squarePath),
+            pending: membership.notifications.length,
+        }));
+        if (intent.json)
+            return `${JSON.stringify({ rows, total: ordered.length })}\n`;
+        return [
+            ...rows.map((row) => `${row.namePreview}\t${row.squarePathPreview}\t${row.pending}\n`),
+            ...(rows.length < ordered.length ? [`${rows.length} of ${ordered.length} memberships shown\n`] : []),
+        ].join('');
     },
     present: (result) => process.stdout.write(result),
 };

package/dist/cli/program.js

@@ -1,16 +1,21 @@
 import { helpRequest } from '../help.js';
 import { isSquareError } from '../model.js';
+import { commandPrefix } from '../presentation.js';
 import { defaultContext, parseGlobalArgs } from './context.js';
 import { executeRegisteredCommand, findCommand } from './registry.js';
-function handleSquareError(error) {
+function handleSquareError(error, squarePath) {
     if (isSquareError(error)) {
         process.stderr.write(`${error.message}\n`);
+        if (squarePath !== undefined && /^(Unknown participant|Unknown mention target)/.test(error.message)) {
+            process.stderr.write(`» ${commandPrefix(squarePath)} participants\n`);
+        }
         process.exit(error.code === 'not_found' ? 1 : 2);
     }
     throw error;
 }
 /** Parse global flags, select an executable adapter, and leave all command work to the registry. */
 export async function runCli(rawArgs = process.argv.slice(2)) {
+    let squarePath;
     try {
         const requestedHelp = helpRequest(rawArgs);
         if (requestedHelp !== undefined) {
@@ -18,6 +23,7 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
             return;
         }
         const parsed = await parseGlobalArgs(rawArgs);
+        squarePath = parsed.squarePath;
         if (parsed.args.length === 0 || parsed.args[0] === '--help' || parsed.args[0] === '-h') {
             await executeRegisteredCommand('help', [], defaultContext('help', parsed.squarePath, parsed.name));
             return;
@@ -30,6 +36,6 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
         await executeRegisteredCommand(command, parsed.args.slice(1), defaultContext(command, parsed.squarePath, parsed.name));
     }
     catch (error) {
-        handleSquareError(error);
+        handleSquareError(error, squarePath);
     }
 }

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

@@ -8,7 +8,7 @@ interface BuildIntent {
 }
 interface JoinIntent {
     name: string;
-    lastN: number | null;
+    lastN: number;
     kick: boolean;
 }
 interface ActivityIntent {
@@ -16,6 +16,8 @@ interface ActivityIntent {
     activity: string;
     force: boolean;
     noWait: boolean;
+    noMention: boolean;
+    mentions: string[];
     reach?: Reach;
     reply?: number;
 }

package/dist/cli/square-commands.js

@@ -1,7 +1,7 @@
 import { cmdActivity } from '../activity.js';
 import { formatActivityId, formatHardCap, parseActivityId, } from '../model.js';
-import { participantCommandPrefix, participantIdentity, renderEventCli, renderAmbientEvent, withPathOutput, } from '../presentation.js';
-import { hasAutomaticDeliveryIdentity, } from '../registry.js';
+import { participantCommandPrefix, participantIdentity, quoteShell, renderEventCli, renderAmbientEvent, withPathOutput, } from '../presentation.js';
+import { hasAutomaticDeliveryIdentity, lookupParticipant, recordSessionDone, } from '../registry.js';
 import { createHostLedgerPort } from '../host-ledger-file-adapter.js';
 import { projectLocalParticipantBinding, sessionIdsFromEnvironment } from '../square-projections.js';
 import { nowMs } from '../runtime.js';
@@ -10,7 +10,9 @@ import { closeOpenSquare } from '../open-square.js';
 import { openParticipant, Square } from '../square-wiring.js';
 import { entryPresentation, eventPresentation } from '../views.js';
 import { createDefaultWakeTransport } from '../notifications.js';
-import { fail, parseHardCap, parsePositiveInteger, readStdin, requireParticipant, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
+import { fail, parseBoundedLimit, parseHardCap, parsePositiveInteger, readStdin, requireParticipant, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
+const JOIN_DEFAULT_LAST = 10;
+const JOIN_MAX_LAST = 100;
 function parseBuild(argv) {
     const options = { force: false, hardCap: null };
     for (let index = 0; index < argv.length; index++) {
@@ -60,16 +62,15 @@ export const buildCommand = {
     present: (result) => process.stdout.write(result),
 };
 function parseJoin(argv, context) {
-    let lastN = 10;
+    const name = requireParticipant(context.name);
+    const squarePath = requireSquarePath(context);
+    let lastN = JOIN_DEFAULT_LAST;
     let kick = false;
     for (let index = 0; index < argv.length; index++) {
         if (argv[index] === '--last') {
-            lastN = parsePositiveInteger(requireValue(argv, index, argv[index]), argv[index]);
+            lastN = parseBoundedLimit(argv[index + 1], '--last', JOIN_MAX_LAST, `${participantCommandPrefix(squarePath, name)} join --last ${JOIN_MAX_LAST}`);
             index += 1;
         }
-        else if (argv[index] === '--all') {
-            lastN = null;
-        }
         else if (argv[index] === '--kick') {
             kick = true;
         }
@@ -77,7 +78,7 @@ function parseJoin(argv, context) {
             usage(context.command);
         }
     }
-    return { name: requireParticipant(context.name), lastN, kick };
+    return { name, lastN, kick };
 }
 export const joinCommand = {
     parse: parseJoin,
@@ -96,17 +97,27 @@ export const joinCommand = {
                     participant: intent.name,
                     sessionIds: sessionIdsFromEnvironment(),
                 }) !== undefined;
-            const participant = await square.join(intent.name);
-            const joinedName = participant.name;
             const isRejoin = before.joined;
             if (isRejoin && !intent.kick && !reconnect) {
                 fail([
-                    `✕ ${participantIdentity(joinedName)} shoos you out of the square`,
+                    `✕ ${participantIdentity(intent.name)} shoos you out of the square`,
                     `  · a same-named participant stands here — the name is taken`,
                     `  · --kick banishes her and the name becomes yours`,
-                    `» ${participantCommandPrefix(squarePath, joinedName)} join --kick`,
+                    `» ${participantCommandPrefix(squarePath, intent.name)} join --kick`,
                 ].join('\n'));
             }
+            const takeoverNeeded = isRejoin && intent.kick && !reconnect;
+            const oldBindings = takeoverNeeded ? await lookupParticipant(squarePath, intent.name) : [];
+            const participant = takeoverNeeded ? await square.takeover(intent.name, oldBindings.map((binding) => binding.sessionId)) : await square.join(intent.name);
+            const joinedName = participant.name;
+            if (takeoverNeeded) {
+                const currentSessions = new Set(sessionIdsFromEnvironment());
+                for (const binding of oldBindings) {
+                    if (!currentSessions.has(binding.sessionId)) {
+                        await recordSessionDone(binding.sessionId, binding.name, binding.squarePath, binding.channel).catch(() => undefined);
+                    }
+                }
+            }
             const afterSquare = await openSquare(squarePath, { clock: nowMs });
             const after = await entryPresentation(afterSquare, joinedName, intent.lastN);
             await closeOpenSquare(afterSquare);
@@ -146,6 +157,8 @@ function parseActivity(argv, context) {
     let force = false;
     let noWait = false;
     let bell = false;
+    let noMention = false;
+    const mentions = [];
     let reply;
     const bodyArgs = [];
     for (let index = 0; index < argv.length; index++) {
@@ -158,6 +171,12 @@ function parseActivity(argv, context) {
             fail('✕ express does not know --beside\n» square express --help');
         else if (argument === '--bell')
             bell = true;
+        else if (argument === '--no-mention')
+            noMention = true;
+        else if (argument === '--mention') {
+            mentions.push(requireParticipant(requireValue(argv, index, argument)));
+            index += 1;
+        }
         else if (argument === '--reply') {
             const replyIndex = parseActivityId(requireValue(argv, index, argument));
             if (replyIndex === undefined)
@@ -169,24 +188,31 @@ function parseActivity(argv, context) {
             bodyArgs.push(argument);
     }
     const reach = bell ? 'bell' : undefined;
+    if (bell && (noMention || mentions.length > 0))
+        fail('✕ --bell cannot be combined with --mention or --no-mention\n» square express --help');
+    if (noMention && mentions.length > 0)
+        fail('✕ --no-mention cannot be combined with --mention\n» square express --help');
+    if (!bell && !noMention && mentions.length === 0)
+        fail('✕ express needs --mention <name>, --no-mention, or --bell\n» square express --help');
     if (bodyArgs.length !== 1) {
         if (bodyArgs.length === 0) {
             if (!process.stdin.isTTY)
-                return { name: requireParticipant(context.name), activity: '-', force, noWait, reach, reply };
+                return { name: requireParticipant(context.name), activity: '-', force, noWait, noMention, mentions, reach, reply };
         }
         fail("express requires a body argument (a quoted string or '-' with piped stdin)");
     }
-    return { name: requireParticipant(context.name), activity: bodyArgs[0], force, noWait, reach, reply };
+    return { name: requireParticipant(context.name), activity: bodyArgs[0], force, noWait, noMention, mentions, reach, reply };
 }
 export const expressCommand = {
     parse: parseActivity,
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
         const body = await resolveBody(intent.activity);
-        const reachArg = intent.reach === 'bell' ? ' --bell' : '';
+        const reachArg = intent.reach === 'bell' ? ' --bell' : intent.noMention ? ' --no-mention' : intent.mentions.map((name) => ` --mention ${quoteShell(name)}`).join('');
         await cmdActivity(squarePath, intent.name, body, (value) => value, {
             force: intent.force,
             noWait: intent.noWait,
+            mentions: intent.mentions,
             reach: intent.reach,
             reply: intent.reply,
             forceCommand: `${participantCommandPrefix(squarePath, intent.name)} express --force${reachArg}${intent.reply === undefined ? '' : ` --reply ${formatActivityId(intent.reply)}`} -`,

package/dist/codex-queue.d.ts

@@ -10,6 +10,7 @@ export declare class CodexQueueSendError extends Error {
     constructor(message: string, kind: CodexQueueFailureKind);
 }
 export declare function sendCodexQueue({ threadId, message }: CodexQueueRequest, opts?: {
+    args?: string[];
     bin?: string;
     env?: NodeJS.ProcessEnv;
     timeoutMs?: number;

package/dist/codex-queue.js

@@ -16,7 +16,7 @@ function classifyFailure(message) {
     return 'unknown';
 }
 export function sendCodexQueue({ threadId, message }, opts = {}) {
-    const result = spawnSync(opts.bin ?? process.env.SQUARE_CODEX_BIN ?? 'codex', ['queue', '--thread', threadId, '--message', message], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: opts.timeoutMs ?? 5000, env: opts.env ?? process.env });
+    const result = spawnSync(opts.bin ?? process.env.SQUARE_CODEX_BIN ?? 'codex', [...(opts.args ?? []), 'queue', '--thread', threadId, '--message', message], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: opts.timeoutMs ?? 5000, env: opts.env ?? process.env });
     if (result.error) {
         const messageText = result.error.message;
         throw new CodexQueueSendError(messageText, classifyFailure(messageText));

package/dist/decisions.d.ts

@@ -63,6 +63,7 @@ export declare function decideAct(squareState: SquareState, input: {
     body: string;
     force: boolean;
     now: number;
+    mentions?: readonly string[];
     reach?: Reach;
     reply?: number;
 }): ActDecision;