@astrosheep/square 0.3.70 → 0.3.72

package/dist/cli/program.d.ts

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

package/dist/cli/program.js

@@ -1,58 +1,46 @@
 import { helpRequest } from '../help.js';
 import { isSquareError } from '../model.js';
-import { commandPrefix, formatRefusal, joinRecoveryCommand, participantsRecoveryCommand, takeoverRecoveryLines } from '../presentation.js';
-import { inSquareCount, nowMs } from '../runtime.js';
-import { openSquare } from '../square-file-adapter.js';
-import { closeOpenSquare } from '../open-square.js';
-import { defaultContext, parseGlobalArgs } from './context.js';
+import { commandPrefix, formatRefusal, refusalText, joinRecoveryCommand, participantIdentity, participantsRecoveryCommand, takeoverRecoveryLines, } from '../presentation.js';
+import { applicationFor, defaultContext, parseGlobalArgs } from './context.js';
 import { executeRegisteredCommand, findCommand } from './registry.js';
-async function handleSquareError(error, squarePath, name) {
-    if (isSquareError(error)) {
-        const existing = [error.message];
-        if (squarePath !== undefined && name !== undefined && error.code === 'already_joined') {
-            existing.push(...takeoverRecoveryLines(squarePath, name));
-        }
-        else if (squarePath !== undefined && error.facts?.reason === 'never_joined') {
-            // The caller's name has never joined this square; only a join admits it.
-            if (name !== undefined)
-                existing.push(joinRecoveryCommand(squarePath, name));
-            else
-                existing.push(participantsRecoveryCommand(squarePath));
-        }
-        else if (squarePath !== undefined && error.facts?.reason === 'not_standing') {
-            existing.push(participantsRecoveryCommand(squarePath));
-        }
-        else if (squarePath !== undefined && error.facts?.reason === 'not_addressed' && typeof error.facts.activityId === 'string') {
-            // An anchor only works for an activity the artifact actually holds.
-            existing.push(error.facts.activityExists === true
-                ? `${commandPrefix(squarePath)} history --at ${error.facts.activityId} -C 2`
-                : `${commandPrefix(squarePath)} history --limit 10`);
-        }
-        if (squarePath === undefined) {
-            process.stderr.write(`${existing.join('\n')}\n`);
-        }
-        else {
-            let participantCount;
-            try {
-                const square = await openSquare(squarePath, { clock: nowMs });
-                try {
-                    participantCount = inSquareCount((await square.artifact.read()).state);
-                }
-                finally {
-                    await closeOpenSquare(square);
-                }
-            }
-            catch { /* the header count is best effort */ }
-            process.stderr.write(formatRefusal(squarePath, existing, participantCount === undefined ? {} : { participantCount }));
-        }
-        process.exit(error.code === 'not_found' ? 1 : 2);
+async function handleSquareError(error, context) {
+    if (!isSquareError(error))
+        throw error;
+    const detail = error.operation;
+    const squarePath = context?.squarePath;
+    const recovery = context === undefined || squarePath === undefined ? undefined
+        : await applicationFor({ ...context, name: detail?.participant ?? context.name }).recovery().catch(() => undefined);
+    const name = detail?.participant ?? recovery?.data.participant ?? context?.name;
+    const existing = [refusalText(error)];
+    if (squarePath !== undefined && name !== undefined && error.code === 'already_joined') {
+        existing.splice(0, 1, `✕ ${participantIdentity(name)} shoos you out of the square`, `  · ${participantIdentity(name)} already stands here — another session holds the name`);
+        existing.push(...takeoverRecoveryLines(squarePath, name));
     }
-    throw error;
+    else if (squarePath !== undefined && error.facts?.reason === 'never_joined') {
+        existing.push(detail?.subject !== 'filter' && name !== undefined
+            ? joinRecoveryCommand(squarePath, name) : participantsRecoveryCommand(squarePath));
+    }
+    else if (squarePath !== undefined && error.facts?.reason === 'not_standing') {
+        existing.push(participantsRecoveryCommand(squarePath));
+    }
+    else if (squarePath !== undefined && error.facts?.reason === 'not_addressed' && typeof error.facts.activityId === 'string') {
+        existing.push(error.facts.activityExists === true
+            ? `${commandPrefix(squarePath)} history --at ${error.facts.activityId} -C 2`
+            : `${commandPrefix(squarePath)} history --limit 10`);
+    }
+    if (error.facts?.reason === 'invalid_done_body')
+        existing.push('square done --help');
+    if (squarePath === undefined)
+        process.stderr.write(`${existing.join('\n')}\n`);
+    else
+        process.stderr.write(formatRefusal(squarePath, existing, {
+            participantCount: recovery?.data.standingCount, held: recovery?.data.held,
+        }));
+    process.exit(error.code === 'not_found' ? 1 : 2);
 }
-/** Parse global flags, select an executable adapter, and leave all command work to the registry. */
+/** Parse global flags, select an executable adapter, and leave operations to the application. */
 export async function runCli(rawArgs = process.argv.slice(2)) {
-    let squarePath;
-    let requestedName;
+    let context;
     try {
         const requestedHelp = helpRequest(rawArgs);
         if (requestedHelp !== undefined) {
@@ -60,20 +48,19 @@ export async function runCli(rawArgs = process.argv.slice(2)) {
             return;
         }
         const parsed = await parseGlobalArgs(rawArgs);
-        squarePath = parsed.squarePath;
-        requestedName = parsed.name;
-        if (parsed.args.length === 0 || parsed.args[0] === '--help' || parsed.args[0] === '-h') {
-            await executeRegisteredCommand('help', [], defaultContext('help', parsed.squarePath, parsed.name));
+        const command = parsed.args[0];
+        context = defaultContext(command ?? 'help', parsed.squarePath, parsed.name);
+        if (command === undefined || command === '--help' || command === '-h') {
+            await executeRegisteredCommand('help', [], context);
             return;
         }
-        const command = parsed.args[0];
         if (findCommand(command) === undefined) {
             process.stderr.write(`unknown command: ${command}\nrun 'square' for usage\n`);
             process.exit(2);
         }
-        await executeRegisteredCommand(command, parsed.args.slice(1), defaultContext(command, parsed.squarePath, parsed.name));
+        await executeRegisteredCommand(command, parsed.args.slice(1), context);
     }
     catch (error) {
-        await handleSquareError(error, squarePath, requestedName);
+        await handleSquareError(error, context);
     }
 }

package/dist/cli/registry.js

@@ -1,5 +1,5 @@
 import { buildCommand, doneCommand, expressCommand, holdCommand, ignoreCommand, joinCommand, listenCommand, listeningCommand, resumeCommand } from './square-commands.js';
-import { doctorCommand } from './maintenance-commands.js';
+import { doctorCommand, migrateCommand } from './maintenance-commands.js';
 import { harnessCommand, installCommand, uninstallCommand } from './harness-command.js';
 import { helpCommand, versionCommand } from './meta-commands.js';
 import { mcpServerCommand } from './mcp-server-command.js';
@@ -25,6 +25,7 @@ export const commandRegistry = [
     { names: ['uninstall'], spec: uninstallCommand },
     { names: ['harness'], spec: harnessCommand },
     { names: ['doctor'], spec: doctorCommand },
+    { names: ['migrate'], spec: migrateCommand },
     { names: ['history'], spec: historyCommand },
     { names: ['status'], spec: statusCommand },
     { names: ['participants'], spec: participantsCommand },

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

@@ -1,18 +1,16 @@
-import { type BuildOptions, type HardCap, type Reach } from '../model.js';
+import { type BuildOptions, type HardCap } from '../model.js';
+import type { Reach } from '../square-facade.js';
 import { type CommandSpec } from './context.js';
 interface BuildIntent {
     options: BuildOptions & {
         hardCap: HardCap;
     };
-    snippet: string;
 }
 interface JoinIntent {
-    name: string;
     lastN: number;
     kick: boolean;
 }
 interface ActivityIntent {
-    name: string;
     activity: string;
     force: boolean;
     noWait: boolean;
@@ -22,11 +20,9 @@ interface ActivityIntent {
     reply?: string;
 }
 interface BodyIntent {
-    name: string;
     body?: string;
 }
 interface ListenerIntent {
-    name: string;
     target?: string;
 }
 export declare const buildCommand: CommandSpec<BuildIntent, string>;
@@ -37,7 +33,5 @@ export declare const ignoreCommand: CommandSpec<ListenerIntent, string>;
 export declare const listeningCommand: CommandSpec<ListenerIntent, string>;
 export declare const doneCommand: CommandSpec<BodyIntent, string>;
 export declare const holdCommand: CommandSpec<BodyIntent, string>;
-export declare const resumeCommand: CommandSpec<{
-    name: string;
-}, string>;
+export declare const resumeCommand: CommandSpec<Record<string, never>, string>;
 export {};

package/dist/cli/square-commands.js

@@ -1,149 +1,98 @@
-import { cmdActivity } from '../activity.js';
-import { scanMentionCandidates } from '../mention-parse.js';
-import { validateDoneBody } from '../decisions.js';
-import { formatHardCap, sameName, } from '../model.js';
-import { formatRefusal, participantCommandPrefix, participantIdentity, takeoverRecoveryLines, renderRoomChangeText, renderAmbientEvent, withPathOutput, } from '../presentation.js';
-import { hostLedgerForEnv, hasAutomaticDeliveryIdentity, } from '../registry.js';
-import { actId, nowMs } from '../runtime.js';
-import { createSquare, openSquare } from '../square-file-adapter.js';
-import { closeOpenSquare } from '../open-square.js';
-import { Square } from '../square-wiring.js';
-import { createSquareApplication } from '../square-application.js';
-import { entryPresentation, eventPresentation } from '../views.js';
-import { createDefaultWakeTransport } from '../notifications.js';
+import { formatHardCap } from '../model.js';
+import { commandPrefix, participantCommandPrefix, participantIdentity, renderRoomChangeText, renderAmbientEvent, withPathOutput, } from '../presentation.js';
+import { formatActivityId } from '../square-application.js';
 import { style } from '../tty-style.js';
-import { fail, parseBoundedLimit, parseHardCap, parsePositiveInteger, readStdin, requireParticipant, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
+import { executeExpression } from './express-presentation.js';
+import { applicationFor, fail, parseBoundedLimit, parseHardCap, parsePositiveInteger, readStdin, 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++) {
-        const flag = argv[index];
-        switch (flag) {
-            case '--cap':
-                options.hardCap = parseHardCap(requireValue(argv, index, flag));
-                index += 1;
-                break;
-            case '--template':
-                options.template = requireValue(argv, index, flag);
-                index += 1;
-                break;
-            case '--throttle':
-            case '--throttle-per-minute':
-                options.throttlePerMinute = parsePositiveInteger(requireValue(argv, index, flag), flag);
-                index += 1;
-                break;
-            case '--force':
-            case '-f':
-                options.force = true;
-                break;
-            default:
-                fail(`Unknown build option: ${flag}`);
-        }
-    }
-    if (options.template !== undefined && !/^[a-zA-Z0-9-]+$/.test(options.template)) {
-        fail('Invalid template name: only letters, digits, and hyphens allowed.');
-    }
-    if (options.throttlePerMinute !== undefined && options.throttlePerMinute <= 0) {
-        fail('Invalid build option: --throttle must be a positive integer.');
-    }
-    return { options, snippet: '' };
-}
 export const buildCommand = {
-    parse: (argv) => parseBuild(argv),
+    parse(argv) {
+        const options = { force: false, hardCap: null };
+        for (let index = 0; index < argv.length; index++) {
+            const flag = argv[index];
+            switch (flag) {
+                case '--cap':
+                    options.hardCap = parseHardCap(requireValue(argv, index, flag));
+                    index += 1;
+                    break;
+                case '--template':
+                    options.template = requireValue(argv, index, flag);
+                    index += 1;
+                    break;
+                case '--throttle':
+                case '--throttle-per-minute':
+                    options.throttlePerMinute = parsePositiveInteger(requireValue(argv, index, flag), flag);
+                    index += 1;
+                    break;
+                case '--force':
+                case '-f':
+                    options.force = true;
+                    break;
+                default:
+                    fail(`Unknown build option: ${flag}`);
+            }
+        }
+        if (options.template !== undefined && !/^[a-zA-Z0-9-]+$/.test(options.template)) {
+            fail('Invalid template name: only letters, digits, and hyphens allowed.');
+        }
+        return { options };
+    },
     async execute(intent, context) {
-        const squarePath = requireSquarePath(context);
-        const snippet = await readStdin();
-        if (snippet.trim() === '')
+        const markdown = await readStdin();
+        if (markdown.trim() === '')
             fail('Missing Markdown body snippet on stdin.');
-        await createSquare(squarePath, intent.options, snippet);
-        const cap = intent.options.hardCap === null ? 'unlimited' : formatHardCap(intent.options.hardCap);
-        const throttle = intent.options.throttlePerMinute === undefined ? [] : [`  · throttle ${intent.options.throttlePerMinute}/min`];
-        return withPathOutput(squarePath, ['· the square stands ready', `  · cap ${cap}`, ...throttle].join('\n'), { participantCount: 0 });
+        const { data, projection } = await applicationFor(context).build({ ...intent.options, markdown });
+        const cap = data.hardCap === null ? 'unlimited' : formatHardCap(data.hardCap);
+        const throttle = data.throttlePerMinute === undefined ? [] : [`  · throttle ${data.throttlePerMinute}/min`];
+        return withPathOutput(data.location, ['· the square stands ready', `  · cap ${cap}`, ...throttle].join('\n'), {
+            participantCount: projection.standingCount, held: projection.held,
+        });
     },
     present: (result) => process.stdout.write(result),
 };
-function parseJoin(argv, context) {
-    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 = parseBoundedLimit(argv[index + 1], '--last', JOIN_MAX_LAST, `${participantCommandPrefix(squarePath, name)} join --last ${JOIN_MAX_LAST}`);
-            index += 1;
-        }
-        else if (argv[index] === '--kick') {
-            kick = true;
-        }
-        else {
-            usage(context.command);
-        }
-    }
-    return { name, lastN, kick };
-}
 export const joinCommand = {
-    parse: parseJoin,
-    async execute(intent, context) {
-        const squarePath = requireSquarePath(context);
-        const hostLedger = hostLedgerForEnv(context.env);
-        const beforeSquare = await openSquare(squarePath, { clock: nowMs, env: context.env, hostLedger });
-        const before = await entryPresentation(beforeSquare, intent.name, intent.lastN);
-        await closeOpenSquare(beforeSquare);
-        const application = createSquareApplication({ cwd: context.cwd, env: context.env, squarePath, participant: intent.name, clock: nowMs, hostLedger, wakeTransport: await createDefaultWakeTransport(hostLedger, nowMs) });
-        let joinedName;
-        let joinKind;
-        try {
-            const result = await application.join({ takeover: intent.kick });
-            joinedName = result.participant;
-            joinKind = result.kind;
-        }
-        catch (error) {
-            if (error instanceof Error && 'code' in error && error.code === 'already_joined') {
-                process.stderr.write(formatRefusal(squarePath, [
-                    `✕ ${participantIdentity(intent.name)} shoos you out of the square`,
-                    '  · a same-named participant stands here — the name is taken',
-                    ...takeoverRecoveryLines(squarePath, intent.name),
-                ], { participantCount: before.participantCount }));
-                process.exit(2);
+    parse(argv, context) {
+        let lastN = JOIN_DEFAULT_LAST;
+        let kick = false;
+        for (let index = 0; index < argv.length; index++) {
+            if (argv[index] === '--last') {
+                lastN = parseBoundedLimit(argv[index + 1], '--last', JOIN_MAX_LAST, `${context.name === undefined ? commandPrefix(requireSquarePath(context)) : participantCommandPrefix(requireSquarePath(context), context.name)} join --last ${JOIN_MAX_LAST}`);
+                index += 1;
             }
-            throw error;
+            else if (argv[index] === '--kick')
+                kick = true;
+            else
+                usage(context.command);
         }
-        const afterSquare = await openSquare(squarePath, { clock: nowMs, env: context.env, hostLedger });
-        const after = await entryPresentation(afterSquare, joinedName, intent.lastN);
-        await closeOpenSquare(afterSquare);
-        const activities = after.recentActivities.map((event) => renderAmbientEvent(event, joinedName, {
-            now: nowMs(),
-            preview: intent.lastN === null ? undefined : 200,
+        return { lastN, kick };
+    },
+    async execute(intent, context) {
+        const { data, projection: after } = await applicationFor(context).join({ takeover: intent.kick, last: intent.lastN });
+        const name = data.participant;
+        const activities = after.recentActivities.map((event) => renderAmbientEvent(event, name, {
+            now: after.now, preview: 200,
             actNumber: event.kind === 'say' ? after.sayNumbers[event.index] : undefined,
-            squareState: after.state,
+            perception: after.perceptions[event.index],
         })).filter(Boolean).join('\n\n');
-        const contextText = after.joinContext;
-        const fallback = hasAutomaticDeliveryIdentity()
-            ? []
-            : ['', `${participantCommandPrefix(squarePath, joinedName)} catch --idle 30m`, '  the square has no way to call you — keep this catch open and stay within earshot'];
-        const scene = after.scene;
-        const entryLine = joinKind === 'joined'
-            ? '● you stepped into the square'
-            : joinKind === 'reconnected'
-                ? '● you are already in the square'
-                : `✓ you banished the original ${participantIdentity(joinedName)} — the name is yours`;
-        const isRejoin = joinKind !== 'joined';
-        const reconnect = joinKind === 'reconnected';
-        // The long scene belongs to a name's first join here; a return reads its own line.
-        const joinedBefore = after.state.acts.filter((act) => act.kind === 'join' && sameName(act.actor, joinedName)).length > 1;
-        const rejoinScene = '*the flagstones are where you left them. so is your shadow.*';
-        const entryScene = joinKind !== 'joined' ? '' : joinedBefore ? rejoinScene : scene;
-        const output = [
-            entryLine,
-            '',
+        const fallback = after.automaticDeliveryAvailable ? [] : [
+            '', `${participantCommandPrefix(after.location, name)} catch --idle 30m`,
+            '  the square has no way to call you — keep this catch open and stay within earshot',
+        ];
+        const entryLine = data.kind === 'joined' ? '● you stepped into the square'
+            : data.kind === 'reconnected' ? '● you are already in the square'
+                : `✓ you banished the original ${participantIdentity(name)} — the name is yours`;
+        const isRejoin = data.kind !== 'joined';
+        const entryScene = isRejoin ? '' : after.joinedBefore
+            ? '*the flagstones are where you left them. so is your shadow.*' : after.scene;
+        return withPathOutput(after.location, [
+            entryLine, '',
             "· carved into the fountain's edge: every word here lands on a real ear — speak when someone needs it.",
-            ...(reconnect || entryScene === '' ? [] : ['', entryScene]),
-            ...(isRejoin || contextText === '' ? [] : ['', style('dim', 'context'), contextText]),
+            ...(entryScene === '' ? [] : ['', entryScene]),
+            ...(isRejoin || after.joinContext === '' ? [] : ['', style('dim', 'context'), after.joinContext]),
             ...(isRejoin || activities === '' ? [] : ['', style('dim', 'recent activity'), activities]),
             ...fallback,
-        ].join('\n');
-        return withPathOutput(squarePath, output, { participantCount: after.participantCount });
+        ].join('\n'), { participantCount: after.standingCount, held: after.held });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -184,31 +133,20 @@ function parseActivity(argv, context) {
     if (noMention && mentions.length > 0)
         fail('✕ --no-mention cannot be combined with --mention\nsquare express --help');
     if (bodyArgs.length !== 1) {
-        if (bodyArgs.length === 0) {
-            if (!process.stdin.isTTY)
-                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)");
+        if (bodyArgs.length === 0 && !process.stdin.isTTY)
+            bodyArgs.push('-');
+        else
+            fail("express requires a body argument (a quoted string or '-' with piped stdin)");
     }
-    return { name: requireParticipant(context.name), activity: bodyArgs[0], force, noWait, noMention, mentions, reach, reply };
+    return { 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);
-        if (intent.reach === undefined && !intent.noMention && intent.mentions.length === 0 && intent.reply === undefined && scanMentionCandidates(body).length === 0) {
-            fail("✕ express needs --mention <name>, --no-mention, --bell, or an @name in the body\n  · --reply <activity-id> also reaches the author it answers\nsquare express --help");
-        }
-        await cmdActivity(squarePath, intent.name, body, (value) => value, {
-            force: intent.force,
-            noWait: intent.noWait,
-            noMention: intent.noMention,
-            mentions: intent.mentions,
-            reach: intent.reach,
-            reply: intent.reply,
-            cwd: context.cwd,
-            env: context.env,
+        const rawInput = await resolveBody(intent.activity);
+        await executeExpression(applicationFor(context), requireSquarePath(context), context.name, rawInput, {
+            force: intent.force, noWait: intent.noWait, noMention: intent.noMention,
+            mentions: intent.mentions, reach: intent.reach, reply: intent.reply,
         });
     },
     present: () => { },
@@ -216,117 +154,63 @@ export const expressCommand = {
 function parseListener(argv, context, targetRequired) {
     if (targetRequired ? argv.length !== 1 : argv.length !== 0)
         usage(context.command);
-    return { name: requireParticipant(context.name), ...(targetRequired ? { target: argv[0] } : {}) };
+    return targetRequired ? { target: argv[0] } : {};
 }
-function listenerPresentation(squarePath, actor, target, verb, activity, participantCount) {
-    if (activity !== null) {
-        const action = verb === 'listen'
-            ? `${participantIdentity(actor)} turns an ear toward ${participantIdentity(target)}`
-            : `${participantIdentity(actor)} turns away from ${participantIdentity(target)}`;
-        return withPathOutput(squarePath, `· ${action}`, { participantCount });
-    }
-    const action = verb === 'listen'
-        ? `${participantIdentity(actor)} already turns an ear toward ${participantIdentity(target)}`
-        : `${participantIdentity(actor)} is not turned toward ${participantIdentity(target)}`;
-    return withPathOutput(squarePath, `○ ${action}`, { participantCount });
+function listenerCommand(verb) {
+    return {
+        parse(argv, context) { return parseListener(argv, context, true); },
+        async execute(intent, context) {
+            const { data, projection } = await applicationFor(context)[verb](intent.target);
+            const actor = participantIdentity(projection.participant);
+            const target = participantIdentity(projection.target);
+            const action = data.activity !== null
+                ? verb === 'listen' ? `${actor} turns an ear toward ${target}` : `${actor} turns away from ${target}`
+                : verb === 'listen' ? `${actor} already turns an ear toward ${target}` : `${actor} is not turned toward ${target}`;
+            return withPathOutput(projection.location, `${data.activity === null ? '○' : '·'} ${action}`, {
+                participantCount: projection.standingCount, held: projection.held,
+            });
+        },
+        present: (result) => process.stdout.write(result),
+    };
 }
-export const listenCommand = {
-    parse(argv, context) { return parseListener(argv, context, true); },
-    async execute(intent, context) {
-        const squarePath = requireSquarePath(context);
-        const square = await Square.at({ path: squarePath, clock: nowMs });
-        try {
-            const result = await createSquareApplication({ cwd: context.cwd, env: context.env, squarePath, participant: intent.name, clock: nowMs }).listen(intent.target);
-            const participantCount = (await square.snapshot()).participants.filter((item) => item.state === 'joined').length;
-            return listenerPresentation(squarePath, intent.name, intent.target, 'listen', result.activity, participantCount);
-        }
-        finally {
-            await square.close();
-        }
-    },
-    present: (result) => process.stdout.write(result),
-};
-export const ignoreCommand = {
-    parse(argv, context) { return parseListener(argv, context, true); },
-    async execute(intent, context) {
-        const squarePath = requireSquarePath(context);
-        const square = await Square.at({ path: squarePath, clock: nowMs });
-        try {
-            const result = await createSquareApplication({ cwd: context.cwd, env: context.env, squarePath, participant: intent.name, clock: nowMs }).ignore(intent.target);
-            const participantCount = (await square.snapshot()).participants.filter((item) => item.state === 'joined').length;
-            return listenerPresentation(squarePath, intent.name, intent.target, 'ignore', result.activity, participantCount);
-        }
-        finally {
-            await square.close();
-        }
-    },
-    present: (result) => process.stdout.write(result),
-};
+export const listenCommand = listenerCommand('listen');
+export const ignoreCommand = listenerCommand('ignore');
 export const listeningCommand = {
     parse(argv, context) { return parseListener(argv, context, false); },
-    async execute(intent, context) {
-        const squarePath = requireSquarePath(context);
-        const square = await Square.at({ path: squarePath, clock: nowMs });
-        try {
-            const participant = { name: intent.name };
-            const targets = await createSquareApplication({ cwd: context.cwd, env: context.env, squarePath, participant: intent.name, clock: nowMs }).listening();
-            const participantCount = (await square.snapshot()).participants.filter((item) => item.state === 'joined').length;
-            const body = targets.length === 0
-                ? `○ ${participantIdentity(participant.name)} is not turned toward anyone`
-                : ['listening', ...targets.map((target) => `  · ${participantIdentity(target)}`)].join('\n');
-            return withPathOutput(squarePath, body, { participantCount });
-        }
-        finally {
-            await square.close();
-        }
+    async execute(_intent, context) {
+        const { data, projection } = await applicationFor(context).listening();
+        const body = data.listening.length === 0
+            ? `○ ${participantIdentity(projection.participant)} is not turned toward anyone`
+            : ['listening', ...data.listening.map((target) => `  · ${participantIdentity(target)}`)].join('\n');
+        return withPathOutput(projection.location, body, { participantCount: projection.standingCount, held: projection.held });
     },
     present: (result) => process.stdout.write(result),
 };
-function validateDoneInput(body) {
-    try {
-        validateDoneBody(body);
-    }
-    catch (error) {
-        fail(`${error instanceof Error ? error.message : String(error)}\nsquare done --help`);
-    }
-}
-function parseDone(argv, context) {
-    if (argv.length > 1)
-        usage(context.command);
-    if (argv[0] !== '-')
-        validateDoneInput(argv[0]);
-    return { name: requireParticipant(context.name), body: argv.length === 1 ? argv[0] : undefined };
-}
 export const doneCommand = {
-    parse: parseDone,
+    parse(argv, context) {
+        if (argv.length > 1)
+            usage(context.command);
+        return { body: argv[0] };
+    },
     async execute(intent, context) {
-        const squarePath = requireSquarePath(context);
-        const body = intent.body === '-' || !process.stdin.isTTY ? await readStdin() : '';
-        validateDoneInput(body);
-        const application = createSquareApplication({ cwd: context.cwd, env: context.env, squarePath, clock: nowMs, participant: intent.name });
-        const result = await application.done(body);
-        const name = result.activity.actor;
-        const presentation = await openSquare(squarePath, { clock: nowMs, env: context.env, hostLedger: hostLedgerForEnv(context.env) });
-        const participantCount = (await entryPresentation(presentation, name).finally(() => closeOpenSquare(presentation))).participantCount;
-        return withPathOutput(squarePath, `○ you stepped out — your footsteps fade · ${result.activity.id}`, { participantCount });
+        const body = intent.body === '-' || ((intent.body === undefined || intent.body === '') && !process.stdin.isTTY)
+            ? await readStdin() : intent.body;
+        const { data, projection } = await applicationFor(context).done(body);
+        return withPathOutput(projection.location, `○ you stepped out — your footsteps fade · ${data.activity.id}`, {
+            participantCount: projection.standingCount, held: projection.held,
+        });
     },
     present: (result) => process.stdout.write(result),
 };
-function parseHold(argv, context) {
-    if (argv.length > 1)
-        usage(context.command);
-    return { name: requireParticipant(context.name), body: argv[0] };
-}
 export const holdCommand = {
-    parse: parseHold,
+    parse(argv, context) {
+        if (argv.length > 1)
+            usage(context.command);
+        return { body: argv[0] };
+    },
     async execute(intent, context) {
-        const squarePath = requireSquarePath(context);
-        const application = createSquareApplication({ cwd: context.cwd, env: context.env, squarePath, clock: nowMs, participant: intent.name });
-        const result = await application.hold((await resolveBody(intent.body ?? '')).replace(/\r\n/g, '\n').trim());
-        const presentationSquare = await openSquare(squarePath, { clock: nowMs, env: context.env, hostLedger: hostLedgerForEnv(context.env) });
-        const presentation = await eventPresentation(presentationSquare, result.activity.id);
-        await closeOpenSquare(presentationSquare);
-        return withPathOutput(squarePath, `· ${renderRoomChangeText(presentation.activity)} · ${actId(presentation.activity.index)} · just now`, { participantCount: presentation.participantCount, held: true });
+        const { projection } = await applicationFor(context).hold((await resolveBody(intent.body ?? '')).replace(/\r\n/g, '\n').trim());
+        return withPathOutput(projection.location, `· ${renderRoomChangeText(projection.activity)} · ${formatActivityId(projection.activity.index)} · just now`, { participantCount: projection.standingCount, held: projection.held });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -334,16 +218,11 @@ export const resumeCommand = {
     parse(argv, context) {
         if (argv.length !== 0)
             usage(context.command);
-        return { name: requireParticipant(context.name) };
+        return {};
     },
-    async execute(intent, context) {
-        const squarePath = requireSquarePath(context);
-        const application = createSquareApplication({ cwd: context.cwd, env: context.env, squarePath, clock: nowMs, participant: intent.name });
-        const result = await application.resume();
-        const presentationSquare = await openSquare(squarePath, { clock: nowMs, env: context.env, hostLedger: hostLedgerForEnv(context.env) });
-        const presentation = await eventPresentation(presentationSquare, result.activity.id);
-        await closeOpenSquare(presentationSquare);
-        return withPathOutput(squarePath, `✓ ${renderRoomChangeText(presentation.activity)} · ${actId(presentation.activity.index)} · just now`, { participantCount: presentation.participantCount });
+    async execute(_intent, context) {
+        const { projection } = await applicationFor(context).resume();
+        return withPathOutput(projection.location, `✓ ${renderRoomChangeText(projection.activity)} · ${formatActivityId(projection.activity.index)} · just now`, { participantCount: projection.standingCount, held: projection.held });
     },
     present: (result) => process.stdout.write(result),
 };