@astrosheep/square 0.3.10 → 0.3.12

package/dist/boundary-presentation.js

@@ -16,7 +16,7 @@ export function pendingAtBoundary(inbox) {
             return membership;
         return {
             ...membership,
-            notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, { ...notification, recipient: membership.name })),
+            notifications: membership.notifications.filter((notification) => !leaseOwnsNotification(lease, notification)),
         };
     })
         .filter((membership) => membership.notifications.length > 0);

package/dist/cli/context.js

@@ -4,7 +4,7 @@ import path from 'node:path';
 import { loadSquare } from '../artifact.js';
 import { commandUsageHint } from '../help.js';
 import { parseParticipantList, validateName } from '../model.js';
-export const DEFAULT_SQUARE_PATH = '.square/SQUARE.md';
+export const DEFAULT_SQUARE_PATH = '.square/SQUARE.square';
 export function readStdinSync() {
     try {
         return fs.readFileSync(0, 'utf8');
@@ -99,7 +99,7 @@ function resolveDefaultSquarePath() {
     }
     const candidates = [];
     for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith('.md'))
+        if (!entry.isFile() || !entry.name.endsWith('.square'))
             continue;
         const fullPath = path.join(directory, entry.name);
         try {
@@ -118,7 +118,7 @@ export function parseGlobalArgs(rawArgs) {
     let requestedPath;
     let name;
     for (let index = 0; index < args.length; index++) {
-        if (args[index] === '--square-path') {
+        if (args[index] === '--location') {
             requestedPath = requireValue(args, index, args[index]);
             args.splice(index, 2);
             index -= 1;

package/dist/cli/harness-command.js

@@ -87,7 +87,7 @@ export function formatHarnessResult(result) {
     return `${[...result.notes, ...result.lines].join('\n')}\n`;
 }
 export function runHarnessCommand(argv, squarePath) {
-    const context = { homeDir: os.homedir(), squarePath: squarePath ?? '.square/SQUARE.md', command: 'harness' };
+    const context = { homeDir: os.homedir(), squarePath: squarePath ?? '.square/SQUARE.square', command: 'harness' };
     const intent = harnessCommand.parse(argv, context);
     return Promise.resolve(harnessCommand.execute(intent, context)).then(formatHarnessResult);
 }

package/dist/cli/maintenance-commands.js

@@ -1,71 +1,25 @@
-import fs from 'node:fs';
-import { diagnoseSquare, loadSquare } from '../artifact.js';
-import { renderDoctorClean, renderDoctorProblems, renderDoctorRepaired, renderDoctorUnfixable, withPathOutput, } from '../presentation.js';
+import { diagnoseSquareFile } from '../artifact.js';
+import { renderDoctorClean, renderDoctorUnfixable, withPathOutput } from '../presentation.js';
 import { inSquareCount } from '../runtime.js';
-import { repairSquare } from '../square-application.js';
-import { SquareError } from '../model.js';
-import { pruneRegistry } from '../registry.js';
 import { usage } from './context.js';
-function readSquareText(squarePath) {
-    try {
-        return fs.readFileSync(squarePath, 'utf8');
-    }
-    catch (error) {
-        if (error.code === 'ENOENT')
-            throw new SquareError('not_found', `square file not found: ${squarePath}`);
-        throw error;
-    }
-}
-function quarantinePath(squarePath) {
-    return squarePath.replace(/\.md$/, '') + '.quarantine.md';
-}
 export const doctorCommand = {
     parse(argv, context) {
-        let fix = false;
-        for (let index = 0; index < argv.length; index++) {
-            const argument = argv[index];
-            if (argument === '--fix')
-                fix = true;
-            else if (argument === '--before') {
-                index += 1;
-                if (argv[index] === undefined)
-                    usage(context.command);
-            }
-            else
-                usage(context.command);
-        }
-        return { fix };
+        if (argv.length > 0)
+            usage(context.command);
+        return undefined;
     },
-    async execute(intent, context) {
-        if (!intent.fix) {
-            const diagnosis = diagnoseSquare(readSquareText(context.squarePath));
-            if (diagnosis.unfixable) {
-                return {
-                    output: withPathOutput(context.squarePath, renderDoctorUnfixable(diagnosis.unfixable), { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
-                    exitCode: 2,
-                };
-            }
-            const summary = diagnosis.problems.length === 0 ? renderDoctorClean() : renderDoctorProblems(diagnosis.problems);
+    execute(_intent, context) {
+        const diagnosis = diagnoseSquareFile(context.squarePath);
+        if (diagnosis.unfixable !== undefined || diagnosis.doc === undefined) {
             return {
-                output: withPathOutput(context.squarePath, summary, { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
-                exitCode: diagnosis.problems.length === 0 ? 0 : 1,
-            };
-        }
-        const repair = await repairSquare(context.squarePath);
-        if (repair.diagnosis.unfixable) {
-            return {
-                output: withPathOutput(context.squarePath, renderDoctorUnfixable(repair.diagnosis.unfixable), { participantCount: inSquareCount(loadSquare(context.squarePath)) }),
+                output: withPathOutput(context.squarePath, renderDoctorUnfixable(diagnosis.unfixable ?? 'the snapshot could not be decoded')),
                 exitCode: 2,
             };
         }
-        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)) }),
+            output: withPathOutput(context.squarePath, renderDoctorClean(), {
+                participantCount: inSquareCount(diagnosis.doc),
+            }),
         };
     },
     present(result) {

package/dist/cli/observation-commands.js

@@ -3,11 +3,12 @@ import { runClaudeHook } from '../claude-hook.js';
 import { runCodexHook } from '../codex-hook.js';
 import { coreActivities, coreParticipants, coreStatus } from '../decisions.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 { recordLocalJoin } from '../registry.js';
-import { actId, inSquareCount, isCurrentlyJoined, nowMs, resolveRosterName, sayNumberFor, } from '../runtime.js';
+import { parseActivityId } from '../square-core.js';
+import { commandPrefix, participantCommandPrefix, renderActivitiesView, renderGrepActivitiesView, renderAmbientEvent, withPathOutput, } from '../presentation.js';
+import { actId, inSquareCount, nowMs, sayNumberFor } from '../runtime.js';
 import { cmdStream, cmdStreamNdjson } from '../stream.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.js';
 import { cmdWatch } from '../watch.js';
@@ -93,14 +94,15 @@ export const catchCommand = {
     },
     async execute(intent, context) {
         await cmdWatch(context.squarePath, requireParticipant(context.name), intent);
+        await sweepPendingNotifications(context.squarePath);
     },
     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());
@@ -304,24 +306,16 @@ export const historyCommand = {
             return events.map((item) => renderFields(doc, item, options.format)).join('\n') + (events.length > 0 ? '\n' : '');
         }
         const pattern = options.grep ?? options.fixed;
+        const archive = options.atIndex != null
+            || (options.ids !== undefined && options.ids.length > 0)
+            || (options.lastN == null && options.full === true);
         const output = pattern === undefined || pattern === ''
-            ? renderActivitiesView(doc, events, null, options.full, context.squarePath, options.viewer ?? '')
+            ? renderActivitiesView(doc, events, null, options.full, context.squarePath, options.viewer ?? '', archive ? 'archive' : 'ambient')
             : 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; },
@@ -382,7 +376,7 @@ export const statusCommand = {
             : undefined;
         const visible = result.latestAct === undefined
             ? ''
-            : renderVisibleEvent(doc.acts, result.latestAct, context.name ?? '', {
+            : renderAmbientEvent(result.latestAct, context.name ?? '', {
                 now: result.now,
                 preview: 200,
                 actNumber: result.latestAct.kind === 'say'
@@ -440,17 +434,3 @@ function hookCommand(runHook) {
 }
 export const claudeHookCommand = hookCommand(runClaudeHook);
 export const codexHookCommand = hookCommand(runCodexHook);
-/** Maintain the local discovery cache before participant-facing adapters run. */
-export function refreshLocalRegistration(squarePath, name) {
-    if (name === undefined)
-        return;
-    try {
-        const doc = loadSquare(squarePath);
-        const known = resolveRosterName(doc, name);
-        if (known !== undefined && isCurrentlyJoined(doc.acts, known))
-            recordLocalJoin(known, squarePath);
-    }
-    catch {
-        // The machine-local discovery cache never makes a Square command fail.
-    }
-}

package/dist/cli/program.js

@@ -1,12 +1,12 @@
 import { helpRequest } from '../help.js';
 import { SquareError } from '../model.js';
 import { defaultContext, parseGlobalArgs } from './context.js';
-import { refreshLocalRegistration } from './observation-commands.js';
 import { executeRegisteredCommand, findCommand } from './registry.js';
 function isMutatingCommand(command, argv) {
+    void argv;
     if (['build', 'join', 'catch', 'express', 'done', 'hold', 'resume', 'compact'].includes(command))
         return true;
-    return command === 'doctor' && argv.includes('--fix');
+    return false;
 }
 function handleSquareError(error) {
     if (error instanceof SquareError) {
@@ -20,7 +20,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);
@@ -37,9 +37,6 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
             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 (['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));
     }
     catch (error) {

package/dist/cli/registry.js

@@ -2,7 +2,7 @@ import { buildCommand, compactCommand, doneCommand, expressCommand, holdCommand,
 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 },
@@ -23,7 +23,6 @@ export const commandRegistry = [
     { 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.js

@@ -2,10 +2,12 @@ import { cmdActivity } from '../activity.js';
 import { loadSquare } from '../artifact.js';
 import { cmdCompact } from '../compact.js';
 import { SquareError, formatHardCap, validateName, } from '../model.js';
-import { participantCommandPrefix, quoteShell, renderEventCli, renderPublicTail, withPathOutput, } from '../presentation.js';
-import { hasAutomaticDeliveryIdentity, recordLocalDone, recordLocalJoin } from '../registry.js';
+import { participantCommandPrefix, renderEventCli, renderPublicTail, withPathOutput, } from '../presentation.js';
+import { hasAutomaticDeliveryIdentity, localParticipantOwner, recordLocalDone, recordLocalJoin } from '../registry.js';
+import { sweepPendingNotifications } from '../notifications.js';
 import { inSquareCount, isCurrentlyJoined, nowMs, resolveRosterName } from '../runtime.js';
 import { createSquare, execute } from '../square-application.js';
+import { formatActivityId, parseActivityId } from '../square-core.js';
 import { fail, parseHardCap, parsePositiveInteger, readPipedBodyFallback, readStdinSync, requireParticipant, requireValue, resolveBody, usage, } from './context.js';
 function parseBuild(argv) {
     const options = { force: false, hardCap: null };
@@ -56,6 +58,7 @@ export const buildCommand = {
 };
 function parseJoin(argv, context) {
     let lastN = 10;
+    let kick = false;
     for (let index = 0; index < argv.length; index++) {
         if (argv[index] === '--last') {
             lastN = parsePositiveInteger(requireValue(argv, index, argv[index]), argv[index]);
@@ -64,11 +67,14 @@ function parseJoin(argv, context) {
         else if (argv[index] === '--all') {
             lastN = null;
         }
+        else if (argv[index] === '--kick') {
+            kick = true;
+        }
         else {
             usage(context.command);
         }
     }
-    return { name: requireParticipant(context.name), lastN };
+    return { name: requireParticipant(context.name), lastN, kick };
 }
 export const joinCommand = {
     parse: parseJoin,
@@ -81,16 +87,18 @@ export const joinCommand = {
             const after = loadSquare(context.squarePath);
             const preamble = after.preamble.at(-1) === '---' ? after.preamble.slice(0, -1) : after.preamble;
             recordLocalJoin(joinedName, context.squarePath);
+            await sweepPendingNotifications(context.squarePath);
             const activities = renderPublicTail(after.acts, intent.lastN, nowMs(), joinedName);
             const contextText = preamble.join('\n').trim();
             const fallback = hasAutomaticDeliveryIdentity()
                 ? []
                 : ['', `» ${participantCommandPrefix(context.squarePath, joinedName)} catch --idle 30m`, '  no session delivery detected — keep this catch open for new activity'];
+            const scene = after.warmup.join('\n').trim();
             const output = [
-                `● ${joinedName} stepped into the square`,
+                `● You stepped into the square`,
+                ...(isRejoin || scene === '' ? [] : ['', scene]),
                 ...(isRejoin || contextText === '' ? [] : ['', 'context', contextText]),
                 ...(activities === '' ? [] : ['', 'recent activity', activities]),
-                ...(isRejoin ? [] : ['', `» ${participantCommandPrefix(context.squarePath, joinedName)} warmup`]),
                 ...fallback,
             ].join('\n');
             return withPathOutput(context.squarePath, output, { participantCount: inSquareCount(after) });
@@ -102,11 +110,26 @@ export const joinCommand = {
             const joinedName = resolveRosterName(doc, intent.name);
             if (joinedName === undefined || !isCurrentlyJoined(doc.acts, joinedName))
                 throw error;
+            const reconnect = localParticipantOwner(context.squarePath, joinedName) !== undefined;
+            if (!intent.kick && !reconnect) {
+                fail([
+                    `✕ ${joinedName} 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(context.squarePath, joinedName)} join --kick`,
+                ].join('\n'));
+            }
             recordLocalJoin(joinedName, context.squarePath);
+            await sweepPendingNotifications(context.squarePath);
             const fallback = hasAutomaticDeliveryIdentity()
                 ? ''
                 : `\n» ${participantCommandPrefix(context.squarePath, joinedName)} catch --idle 30m\n  no session delivery detected — keep this catch open for new activity`;
-            return withPathOutput(context.squarePath, `● ${joinedName} is already in the square${fallback}`, { participantCount: inSquareCount(doc) });
+            const line = reconnect && !intent.kick
+                ? `● you are already in the square`
+                : `✓ you banished the original ${joinedName} — the name is yours`;
+            const scene = doc.warmup.join('\n').trim();
+            const showScene = !(reconnect && !intent.kick) && scene !== '';
+            return withPathOutput(context.squarePath, `${line}${showScene ? `\n\n${scene}` : ''}${fallback}`, { participantCount: inSquareCount(doc) });
         }
     },
     present: (result) => process.stdout.write(result),
@@ -114,7 +137,6 @@ export const joinCommand = {
 function parseActivity(argv, context) {
     let force = false;
     let noWait = false;
-    let beside;
     let bell = false;
     let reply;
     const bodyArgs = [];
@@ -124,25 +146,21 @@ function parseActivity(argv, context) {
             force = true;
         else if (argument === '--no-wait')
             noWait = true;
-        else if (argument === '--beside') {
-            beside = requireValue(argv, index, argument);
-            index += 1;
-        }
+        else if (argument === '--beside')
+            fail('✕ express does not know --beside\n» square express --help');
         else if (argument === '--bell')
             bell = true;
         else if (argument === '--reply') {
-            const value = requireValue(argv, index, argument).trim().match(/^(?:act_)?(\d+)$/i);
-            if (!value || !Number.isSafeInteger(Number(value[1])))
-                fail('Invalid --reply: expected an activity id like act_12 or 12.');
-            reply = Number(value[1]);
+            const replyIndex = parseActivityId(requireValue(argv, index, argument));
+            if (replyIndex === undefined)
+                fail('Invalid --reply: expected an activity id like act/12');
+            reply = replyIndex;
             index += 1;
         }
         else
             bodyArgs.push(argument);
     }
-    if (bell && beside !== undefined)
-        fail('Invalid express options: --beside and --bell are mutually exclusive.');
-    const reach = bell ? 'bell' : beside === undefined ? undefined : { beside };
+    const reach = bell ? 'bell' : undefined;
     if (bodyArgs.length !== 1) {
         if (bodyArgs.length === 0) {
             const piped = readPipedBodyFallback();
@@ -156,13 +174,14 @@ function parseActivity(argv, context) {
 export const expressCommand = {
     parse: parseActivity,
     async execute(intent, context) {
-        const reachArg = intent.reach === 'bell' ? ' --bell' : intent.reach === undefined ? '' : ` --beside ${quoteShell(intent.reach.beside)}`;
+        await sweepPendingNotifications(context.squarePath);
+        const reachArg = intent.reach === 'bell' ? ' --bell' : '';
         await cmdActivity(context.squarePath, intent.name, intent.activity, resolveBody, {
             force: intent.force,
             noWait: intent.noWait,
             reach: intent.reach,
             reply: intent.reply,
-            forceCommand: `${participantCommandPrefix(context.squarePath, intent.name)} express --force${reachArg}${intent.reply === undefined ? '' : ` --reply act_${intent.reply}`} -`,
+            forceCommand: `${participantCommandPrefix(context.squarePath, intent.name)} express --force${reachArg}${intent.reply === undefined ? '' : ` --reply ${formatActivityId(intent.reply)}`} -`,
         });
     },
     present: () => { },

package/dist/cmd/notify-once.js

@@ -1,13 +1,12 @@
 #!/usr/bin/env node
 import { resolve } from 'node:path';
 import { setTimeout as sleep } from 'node:timers/promises';
-import { recordNotificationFailure } from '../notification-failures.js';
-import { notificationDeliveryWaitMs, processActNotificationsOnce } from '../notifications.js';
+import { processActNotificationsOnce, wakeGraceMs } from '../notifications.js';
 function args(argv) {
     let squarePath;
     let actIndex;
     for (let index = 0; index < argv.length; index += 1) {
-        if (argv[index] === '--square-path' && argv[index + 1] !== undefined)
+        if (argv[index] === '--location' && argv[index + 1] !== undefined)
             squarePath = resolve(argv[++index]);
         else if (argv[index] === '--act-index' && /^\d+$/.test(argv[index + 1] ?? ''))
             actIndex = Number(argv[++index]);
@@ -15,25 +14,16 @@ function args(argv) {
             throw new Error(`Unknown notify-once argument: ${argv[index]}`);
     }
     if (squarePath === undefined || actIndex === undefined)
-        throw new Error('notify-once requires --square-path and --act-index.');
+        throw new Error('notify-once requires --location and --act-index.');
     return { squarePath, actIndex };
 }
 async function main() {
     if (process.env.SQUARE_DISABLE_PASEO_WAKE === '1')
         return;
     const { squarePath, actIndex } = args(process.argv.slice(2));
-    await sleep(notificationDeliveryWaitMs());
+    await sleep(wakeGraceMs());
     await processActNotificationsOnce(squarePath, actIndex);
 }
-main().catch((error) => {
-    const squarePath = process.argv.includes('--square-path') ? process.argv[process.argv.indexOf('--square-path') + 1] : undefined;
-    if (squarePath) {
-        recordNotificationFailure(squarePath, {
-            actIndex: Number(process.argv[process.argv.indexOf('--act-index') + 1]) || 0,
-            sink: 'worker',
-            message: error instanceof Error ? error.message : String(error),
-            diagnostic: { phase: 'worker' },
-        });
-    }
+main().catch(() => {
     process.exitCode = 0;
 });

package/dist/compact.js

@@ -1,19 +1,19 @@
 import { SquareError } from './model.js';
 import { withPathOutput } from './presentation.js';
 import { execute } from './square-application.js';
-function sidecarPath(squarePath) {
-    return squarePath.replace(/\.md$/, '') + '.archive.md';
+function archivePath(squarePath) {
+    return squarePath.replace(/\.square$/, '') + '.archive.square';
 }
 export async function cmdCompact(squarePath, opts) {
     try {
         let archivedCount;
         let keptCount;
-        const archive = sidecarPath(squarePath);
+        const archive = archivePath(squarePath);
         const committed = await execute(squarePath, { type: 'compact', keep: opts.keep, archivePath: archive });
         const result = committed.result;
         archivedCount = result.archived.length;
         keptCount = result.doc.acts.length;
-        const summary = ['✓ compacted', `  · archived ${archivedCount} activities`, `  · kept ${keptCount} activities`, ...(archivedCount > 0 ? [`  · sidecar ${archive}`] : [])].join('\n');
+        const summary = ['✓ compacted', `  · archived ${archivedCount} activities`, `  · kept ${keptCount} activities`, ...(archivedCount > 0 ? [`  · archive ${archive}`] : [])].join('\n');
         process.stdout.write(withPathOutput(squarePath, summary));
     }
     catch (err) {

package/dist/decisions.js

@@ -1,7 +1,7 @@
 import { SquareError, sameName, validateName, } from './model.js';
 import { UNREAD_BLOCK_GRACE_MS, actId, actStableIndex, foldedState, freshWatchLease, getReadState, publicActs, readCursor, resolveRosterName, rosterNames, matchesMentionTarget, THROTTLE_WINDOW_MS, } from './runtime.js';
 import { actDelta, peerPublicActs, peerRoomChanges } from './activity-feed.js';
-import { validate } from './square-core.js';
+import { extractMentions, formatActivityId, validate } from './square-core.js';
 import { deriveDeliveryModel } from './delivery.js';
 import { compileSearchPattern } from './search.js';
 export function resolveKnownName(doc, name) {
@@ -27,7 +27,7 @@ export function decideJoin(doc, name, now) {
     return {
         joinedName,
         addParticipant: knownName === undefined,
-        joinAct: { kind: 'join', actor: joinedName, at: now, body: '' },
+        joinAct: { kind: 'join', actor: joinedName, at: now },
     };
 }
 const UNREAD_PREVIEW_LIMIT = 3;
@@ -41,12 +41,21 @@ export function decideAct(doc, input) {
     const reply = input.reply;
     if (reply !== undefined) {
         if (!Number.isSafeInteger(reply) || reply < 0 || reply >= doc.runtime.nextActIndex) {
-            throw new SquareError('invalid_args', `Unknown reply activity: act_${reply}`);
+            const label = Number.isSafeInteger(reply) && reply >= 0 ? formatActivityId(reply) : String(reply);
+            throw new SquareError('invalid_args', `Unknown reply activity: ${label}`);
         }
     }
     const state = foldedState(doc);
+    if (reach !== 'bell'
+        && extractMentions(body).length === 0) {
+        throw new SquareError('invalid_args', 'express requires an @mention unless using --bell');
+    }
     const current = participantState(state, name);
-    const result = validate(state, { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}), ...(reply !== undefined ? { reply } : {}) }, { hardCap: doc.hardCap, throttlePerMinute: doc.throttlePerMinute, throttleWindowMs: THROTTLE_WINDOW_MS });
+    const result = validate(state, {
+        kind: 'say', actor: name, at: now, body,
+        ...(reach !== undefined ? { reach } : {}),
+        ...(reply !== undefined ? { reply } : {}),
+    }, { hardCap: doc.hardCap, throttlePerMinute: doc.throttlePerMinute, throttleWindowMs: THROTTLE_WINDOW_MS });
     if (!result.ok) {
         if (result.reason === 'done')
             throw new SquareError('conflict', `${name} is done; rejoin to express again`);
@@ -93,7 +102,8 @@ export function decideAct(doc, input) {
     }))
         .sort((a, b) => a.latestActivityAgeMs - b.latestActivityAgeMs || a.name.localeCompare(b.name));
     const latestActivityAgeMs = activitySummaries[0]?.latestActivityAgeMs;
-    const hasUnread = unreadPublic.length > 0 || unreadRoomChanges.length > 0;
+    const hasUnreadBlockingChange = unreadRoomChanges.some((act) => act.kind !== 'join');
+    const hasUnread = unreadPublic.length > 0 || hasUnreadBlockingChange;
     const hasFreshUnreadActivity = latestActivityAgeMs !== undefined && latestActivityAgeMs <= UNREAD_BLOCK_GRACE_MS;
     if (!force && hasUnread && !hasFreshUnreadActivity) {
         return { type: 'blocked', activitySummaries, unreadRoomChanges };
@@ -101,7 +111,11 @@ export function decideAct(doc, input) {
     const ownActCount = (current?.activityCount ?? 0) + 1;
     return {
         type: 'sent',
-        act: { kind: 'say', actor: name, at: now, body, ...(reach !== undefined ? { reach } : {}), ...(reply !== undefined ? { reply } : {}) },
+        act: {
+            kind: 'say', actor: name, at: now, body,
+            ...(reach !== undefined ? { reach } : {}),
+            ...(reply !== undefined ? { reply } : {}),
+        },
         confirmation: `● heads turn your way — #${ownActCount}`,
         ownActCount,
         pendingPublic: unreadPublic,
@@ -116,7 +130,7 @@ export function coreHold(_doc, actor, body, now) {
     return { kind: 'hold', actor, at: now, body: body.replace(/\r\n/g, '\n').trim() };
 }
 export function coreResume(_doc, actor, now) {
-    return { kind: 'resume', actor, at: now, body: '' };
+    return { kind: 'resume', actor, at: now };
 }
 function presenceFor(doc, snapshot, name, now) {
     if (snapshot?.done)