@astrosheep/square 0.3.78 → 0.3.80

package/dist/attention-presentation.d.ts

@@ -14,4 +14,6 @@ export declare function displayAttentionPath(squarePath: string): string;
 export declare function renderAttentionDescription({ actor, route }: Pick<AttentionPreview, 'actor' | 'route'>): string;
 /** Full notification text for human-facing expansion, never the bounded model preview. */
 export declare function renderAttentionFull(attention: AttentionPreview): string;
+/** Shared model-facing envelope; transport correlation and human cards stay outside it. */
+export declare function renderSquareReminder(previews: readonly string[]): string;
 export declare function renderAttentionPreview(attention: AttentionPreview): string;

package/dist/attention-presentation.js

@@ -27,6 +27,18 @@ export function renderAttentionDescription({ actor, route }) {
 export function renderAttentionFull(attention) {
     return renderAttentionBlock(attention, attention.body);
 }
+/** Attribute values keep their quotes; the stored body and the human card stay unescaped. */
+function escapeAttribute(value) {
+    return value
+        .replace(/&/g, '&')
+        .replace(/"/g, '"')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;');
+}
+/** A body may quote the envelope's own tags; in the preview they must never read as one. */
+function escapeSquareTags(text) {
+    return text.replace(/<(\/?)(square-|system-reminder)/gi, '<\\$1$2');
+}
 function renderAttentionBlock(attention, body) {
     return [
         '<square-activity>',
@@ -37,11 +49,34 @@ function renderAttentionBlock(attention, body) {
         '</square-activity>',
     ].join('\n');
 }
+/** Shared model-facing envelope; transport correlation and human cards stay outside it. */
+export function renderSquareReminder(previews) {
+    if (previews.length === 0)
+        return '';
+    return [
+        '',
+        '<system-reminder>',
+        'This is an external reminder from Square, not a direct message from the user.',
+        '',
+        previews.join('\n\n'),
+        '</system-reminder>',
+        '',
+    ].join('\n');
+}
 export function renderAttentionPreview(attention) {
+    const remaining = attention.body.replace(/\r\n/g, '\n').length - ATTENTION_BODY_MAX;
+    const attributes = [
+        `square="${escapeAttribute(displayAttentionPath(attention.squarePath))}"`,
+        `as="${escapeAttribute(attention.recipient)}"`,
+        `id="${escapeAttribute(formatActivityId(attention.actIndex))}"`,
+        `from="${escapeAttribute(attention.actor)}"`,
+        ...(remaining > 0 ? [`truncated="${remaining} more chars"`] : []),
+    ];
     return [
-        renderAttentionBlock(attention, previewAttentionBody(attention.body)),
-        ...(attentionBodyIsClipped(attention.body)
-            ? ['· clipped — catch it to read the rest']
-            : []),
+        `<square-activity ${attributes.join(' ')}>`,
+        `${renderAttentionDescription(attention)}.`,
+        '',
+        escapeSquareTags(previewAttentionBody(attention.body)),
+        '</square-activity>',
     ].join('\n');
 }

package/dist/automatic-session.js

@@ -2,7 +2,7 @@ import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { openSquare } from './open-square.js';
 import { closeOpenSquare } from './open-square.js';
-import { Square } from './square-application.js';
+import { Square } from './square-api.js';
 import { currentParticipant } from './views.js';
 import { automaticParticipant, harnessSessionSources } from './participant-identity.js';
 import { SquareError } from './model.js';

package/dist/boundary-presentation.js

@@ -7,7 +7,7 @@ import { closeOpenSquare } from './open-square.js';
 import { presentPending } from './presentation-operations.js';
 import { hostLedgerForEnv } from './registry.js';
 import { sessionInbox } from './inbox.js';
-import { attentionBodyIsClipped, renderAttentionPreview } from './attention-presentation.js';
+import { attentionBodyIsClipped, renderAttentionPreview, renderSquareReminder } from './attention-presentation.js';
 import { projectBoundaryEligibility } from './square-projections.js';
 export { pendingAtBoundary } from './square-projections.js';
 const CONTEXT_MAX = 1200;
@@ -38,15 +38,12 @@ async function awaitWithSignal(promise, signal) {
 export function renderPendingAtBoundary(inbox) {
     return renderBoundary(inbox).context;
 }
-function frameBoundary(lines) {
-    return `\n${lines.join('\n')}\n`;
-}
 function renderBoundary(inbox) {
     const queued = inbox.flatMap((membership) => membership.notifications.map((notification) => ({ membership, notification })));
     const blocks = [];
     const complete = [];
     let omitted = 0;
-    const omission = (count) => `… ${count} more — catch up to read them`;
+    const omission = (count) => `${count} more ${count === 1 ? 'activity' : 'activities'} not shown.`;
     for (const [index, entry] of queued.entries()) {
         const { membership, notification } = entry;
         const block = [
@@ -60,7 +57,7 @@ function renderBoundary(inbox) {
             }),
         ].join('\n');
         const omittedAfter = omitted + queued.length - index - 1;
-        const prospective = frameBoundary([...blocks, block, ...(omittedAfter > 0 ? [omission(omittedAfter)] : [])]);
+        const prospective = renderSquareReminder([...blocks, block, ...(omittedAfter > 0 ? [omission(omittedAfter)] : [])]);
         if (prospective.length > CONTEXT_MAX) {
             omitted += 1;
             continue;
@@ -73,7 +70,7 @@ function renderBoundary(inbox) {
         });
     }
     return {
-        context: frameBoundary([...blocks, ...(omitted > 0 ? [omission(omitted)] : [])]),
+        context: renderSquareReminder([...blocks, ...(omitted > 0 ? [omission(omitted)] : [])]),
         complete,
     };
 }

package/dist/claude-mod.js

@@ -3,7 +3,7 @@ import { claimSessionParticipant, hostLedgerForEnv } from './registry.js';
 import { openSquare } from './open-square.js';
 import { closeOpenSquare } from './open-square.js';
 import { publishWakeRoute, retireWakeRouteFromArtifact } from './routes.js';
-import { Square } from './square-application.js';
+import { Square } from './square-api.js';
 import { observeClaudeDelivery } from './claude-delivery.js';
 import { processActNotificationsOnce } from './notifications.js';
 import { sweepPending } from './delivery-operations.js';

package/dist/cli/catch-presentation.d.ts

@@ -1,7 +1,7 @@
-import type { ApplicationOutcome, CatchApplicationData, CatchApplicationOptions, CatchProjection, OperationProgress } from '../square-facade.js';
+import type { CatchResult, CatchOptions, OperationProgress } from '../square-facade.js';
 export declare function renderCatchProgress(squarePath: string, progress: OperationProgress): string | undefined;
 /** Render settled catch facts; no selection, terminal decisions, receipts or wait machinery. */
-export declare function renderCatchOutcome(squarePath: string, outcome: ApplicationOutcome<CatchApplicationData, CatchProjection>, options?: CatchApplicationOptions): {
+export declare function renderCatchOutcome(squarePath: string, data: CatchResult, options?: CatchOptions): {
     stdout: string;
     exitCode: number;
 };

package/dist/cli/catch-presentation.js

@@ -1,4 +1,4 @@
-import { parseActivityId } from '../square-application.js';
+import { parseActivityId } from '../square-api.js';
 import { participantCommandPrefix, renderAmbientEvent, renderWatchAlreadyActive, renderWatchForceTakeover, renderWatchReplaceMissing, renderWatchReplaced, renderWatchStatus, withPathOutput, } from '../presentation.js';
 export function renderCatchProgress(squarePath, progress) {
     if (progress.kind !== 'catch-started' || !progress.replacementRequested)
@@ -18,8 +18,8 @@ function continuationCommand(squarePath, name, options) {
     return `${participantCommandPrefix(squarePath, name)} catch ${args.join(' ')}`;
 }
 /** Render settled catch facts; no selection, terminal decisions, receipts or wait machinery. */
-export function renderCatchOutcome(squarePath, outcome, options = {}) {
-    const { data, projection } = outcome;
+export function renderCatchOutcome(squarePath, data, options = {}) {
+    const projection = data.observation;
     const location = projection.location ?? squarePath;
     const name = projection.participant;
     const stop = projection.stop ?? data.status;

package/dist/cli/context.d.ts

@@ -1,4 +1,6 @@
 import { type HardCap } from '../model.js';
+import { Square } from '../square-api.js';
+import type { OperationControl } from '../square-facade.js';
 export interface CommandContext {
     cwd: string;
     env: NodeJS.ProcessEnv;
@@ -33,5 +35,13 @@ export interface ParsedGlobalArgs {
 export declare function parseGlobalArgs(rawArgs: string[]): Promise<ParsedGlobalArgs>;
 export declare function locationIsRequired(command: string): boolean;
 export declare function defaultContext(command: string, squarePath?: string, name?: string): CommandContext;
-export declare function applicationFor(context: CommandContext): import("../square-facade.js").SquareApplication<true>;
+export declare function squareInput(context: CommandContext): {
+    cwd: string;
+    env: NodeJS.ProcessEnv;
+    path: string | undefined;
+    participant: string | undefined;
+};
+/** Adapter lifetime only; each callback uses the actual public resource API. */
+export declare function withSquare<T>(context: CommandContext, run: (square: Square) => Promise<T>, control?: OperationControl): Promise<T>;
+export declare function now(context: CommandContext): number;
 export declare function requireSquarePath(context: CommandContext): string;

package/dist/cli/context.js

@@ -1,7 +1,7 @@
 import os from 'node:os';
 import { commandUsageHint } from '../help.js';
 import { parseParticipantList, validateName } from '../model.js';
-import { createSquareApplication } from '../square-application.js';
+import { Square, squareClock } from '../square-api.js';
 export async function readStdin() {
     try {
         let content = '';
@@ -137,9 +137,20 @@ export function locationIsRequired(command) {
 export function defaultContext(command, squarePath, name) {
     return { command, cwd: process.cwd(), env: { ...process.env }, squarePath, name, homeDir: os.homedir() };
 }
-export function applicationFor(context) {
-    return createSquareApplication({ cwd: context.cwd, env: context.env, squarePath: context.squarePath, participant: context.name });
+export function squareInput(context) {
+    return { cwd: context.cwd, env: context.env, path: context.squarePath, participant: context.name };
 }
+/** Adapter lifetime only; each callback uses the actual public resource API. */
+export async function withSquare(context, run, control) {
+    const square = await Square.at(squareInput(context), control);
+    try {
+        return await run(square);
+    }
+    finally {
+        await square.close();
+    }
+}
+export function now(context) { return squareClock(context.env)(); }
 export function requireSquarePath(context) {
     if (context.squarePath === undefined)
         fail(`✕ ${context.command} needs a square location\nsquare ls`);

package/dist/cli/express-presentation.d.ts

@@ -1,10 +1,11 @@
-import type { ApplicationOutcome, ExpressApplicationData, ExpressApplicationOptions, ExpressProjection, SquareApplication } from '../square-facade.js';
-export interface ActivityOptions extends Omit<ExpressApplicationOptions, 'reply'> {
+import { type Square } from '../square-api.js';
+import type { OperationControl, ExpressResult, ExpressOptions } from '../square-facade.js';
+export interface ActivityOptions extends Omit<ExpressOptions, 'reply'> {
     readonly reply?: string;
 }
 export declare function saveActivityDraft(squarePath: string, name: string, body: string, now?: number): string;
 /** Retry choices are transport syntax, never a second admission decision. */
 export declare function activityRetryCommand(squarePath: string, name: string, opts: ActivityOptions, force?: boolean): string;
-export declare function renderExpression(squarePath: string, outcome: ApplicationOutcome<ExpressApplicationData, ExpressProjection>): string;
-/** Body adaptation, terminal IO and drafts only; the application owns every attempt and wait. */
-export declare function executeExpression(application: SquareApplication, squarePath: string, requestedName: string | undefined, rawInput: string, opts: ActivityOptions): Promise<void>;
+export declare function renderExpression(squarePath: string, data: ExpressResult): string;
+/** Body adaptation, terminal IO and drafts only; Participant owns every attempt and wait. */
+export declare function executeExpression(open: (control?: OperationControl) => Promise<Square>, squarePath: string, requestedName: string | undefined, rawInput: string, opts: ActivityOptions): Promise<void>;

package/dist/cli/express-presentation.js

@@ -2,7 +2,7 @@ import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 import { isSquareError } from '../model.js';
-import { formatActivityId, parseActivityId } from '../square-application.js';
+import { formatActivityId, parseActivityId } from '../square-api.js';
 import { expressHintLine, formatRefusal, refusalText, renderActivityBlocked, renderActivityLimit, renderActivityUncertain, renderExpressNoWait, renderExpressWaiting, renderPendingFeed, joinRecoveryCommand, participantIdentity, participantsRecoveryCommand, participantCommandPrefix, commandPrefix, quoteShell, takeoverRecoveryLines, withPathOutput, } from '../presentation.js';
 import { formatDuration } from '../time.js';
 import { style } from '../tty-style.js';
@@ -33,19 +33,16 @@ function replyArgument(reply) {
 }
 /** Retry choices are transport syntax, never a second admission decision. */
 export function activityRetryCommand(squarePath, name, opts, force = opts.force ?? false) {
-    const reach = opts.reach === 'bell' ? ' --bell'
-        : opts.mentions?.length ? opts.mentions.map((target) => ` --mention ${quoteShell(target)}`).join('')
-            : opts.noMention === true ? ' --no-mention' : '';
+    const reach = (opts.reach === 'bell' ? ' --bell' : '')
+        + (opts.mentions ?? []).map((target) => ` --mention ${quoteShell(target)}`).join('')
+        + (opts.noMention === true ? ' --no-mention' : '');
     return `${participantCommandPrefix(squarePath, name)} express${force ? ' --force' : ''}${opts.noWait ? ' --no-wait' : ''}${reach}${replyArgument(opts.reply)} -`;
 }
-function mentionRepairCommand(squarePath, name, opts, bell) {
-    return `${participantCommandPrefix(squarePath, name)} express${opts.force ? ' --force' : ''}${opts.noWait ? ' --no-wait' : ''}${bell ? ' --bell' : ' --no-mention'}${replyArgument(opts.reply)} -`;
-}
 function isGestureOnly(body) {
     return /\*[^*]*\*/.test(body) && body.replace(/\*[^*]*\*/g, '').trim() === '';
 }
-export function renderExpression(squarePath, outcome) {
-    const { data, projection } = outcome;
+export function renderExpression(squarePath, data) {
+    const projection = data.observation;
     const name = projection.participant;
     const pendingSpeaker = projection.pendingPublic[0]?.actor;
     const pendingLead = pendingSpeaker === undefined ? ''
@@ -63,11 +60,15 @@ export function renderExpression(squarePath, outcome) {
     const hint = expressHintLine(ownCount);
     const replyNotice = data.replyAuthorNotHere === undefined ? ''
         : `\n○ ${participantIdentity(data.replyAuthorNotHere)} isn't in the square right now — the reply landed without reaching them`;
+    const unmatchedNotice = data.unmatchedMentions?.length
+        ? `\n  · ${data.unmatchedMentions.map((token) => `@${token} isn't standing here`).join('; ')} — ${activity.mentions.length === 0 && activity.reply === undefined ? 'activity landed bare' : 'left as literal text'}` : '';
     return withPathOutput(projection.location ?? squarePath, (projection.reentry === undefined ? '' : '● you stepped back into the square\n')
-        + confirmation + (hint ? `\n${style('dim', hint)}` : '') + replyNotice + pending, { participantCount: projection.standingCount, held: projection.held });
+        + confirmation + (hint ? `\n${style('dim', hint)}` : '') + replyNotice + unmatchedNotice + pending, { participantCount: projection.standingCount, held: projection.held });
 }
-/** Body adaptation, terminal IO and drafts only; the application owns every attempt and wait. */
-export async function executeExpression(application, squarePath, requestedName, rawInput, opts) {
+/** Body adaptation, terminal IO and drafts only; Participant owns every attempt and wait. */
+export async function executeExpression(open, squarePath, requestedName, rawInput, opts) {
+    let square;
+    let attempted = false;
     let announcedWait;
     let landedId;
     let name = requestedName;
@@ -75,8 +76,12 @@ export async function executeExpression(application, squarePath, requestedName,
     const interrupt = () => controller.abort();
     process.once('SIGINT', interrupt);
     try {
-        const outcome = await application.express(rawInput.replace(/\r\n/g, '\n').trim(), {
-            ...opts, reply: opts.reply, requireExplicitReach: true,
+        square = await open({ signal: controller.signal });
+        const participant = await square.participant(requestedName);
+        name = participant.name;
+        attempted = true;
+        const outcome = await participant.express(rawInput.replace(/\r\n/g, '\n').trim(), {
+            ...opts, reply: opts.reply, observe: true,
         }, {
             signal: controller.signal,
             onProgress(progress) {
@@ -86,8 +91,8 @@ export async function executeExpression(application, squarePath, requestedName,
                 announcedWait = progress.reason;
             },
         });
-        landedId = outcome.data.activity.id;
-        name = outcome.projection.participant;
+        landedId = outcome.activity.id;
+        name = outcome.observation.participant;
         process.stdout.write(renderExpression(squarePath, outcome));
     }
     catch (error) {
@@ -95,13 +100,14 @@ export async function executeExpression(application, squarePath, requestedName,
         name = detail?.participant ?? name ?? 'participant';
         // This MUST precede recovery: even an unreadable artifact cannot eat the raw body.
         const draftPath = saveActivityDraft(squarePath, name, rawInput);
-        const recovered = await application.recovery().catch(() => undefined);
-        const fresh = recovered?.data;
+        if (square === undefined)
+            square = await open().catch(() => undefined);
+        const fresh = await square?.recovery(name).catch(() => undefined);
         name = fresh?.participant ?? name;
         const output = { squarePath, name, draftPath, participantCount: fresh?.standingCount, held: fresh?.held };
         const confirmedUnsent = landedId === undefined && detail?.landedId === undefined
             && detail?.expressEffect !== 'landed' && detail?.expressEffect !== 'unknown'
-            && (detail?.expressEffect === 'unsent' || (isSquareError(error) && error.facts?.activityUnsent === true));
+            && (!attempted || detail?.expressEffect === 'unsent' || (isSquareError(error) && error.facts?.activityUnsent === true));
         const retryCommand = activityRetryCommand(squarePath, name, opts);
         const exitCode = (code) => { process.exitCode = controller.signal.aborted ? 130 : code; };
         if (!confirmedUnsent) {
@@ -144,29 +150,25 @@ export async function executeExpression(application, squarePath, requestedName,
         }
         const facts = isSquareError(error) ? error.facts : undefined;
         const reason = facts?.reason;
-        const message = reason === 'explicit_reach_required'
-            ? '✕ express needs --mention <name>, --no-mention, --bell, or an @name in the body\n  · --reply <activity-id> also reaches the author it answers'
-            : reason === 'bell_mention_conflict'
-                ? '✕ a bell cannot be combined with a mention'
-                : reason === 'invalid_reply'
-                    ? facts?.activityExists === false
-                        ? `Invalid --reply: ${facts.activityId ?? opts.reply ?? 'that activity'} is not in this square's history`
-                        : 'Invalid --reply: expected an activity id like act/12'
-                    : refusalText(error);
+        const message = reason === 'bell_mention_conflict'
+            ? '✕ a bell cannot be combined with a mention'
+            : reason === 'invalid_reply'
+                ? facts?.activityExists === false
+                    ? `Invalid --reply: ${facts.activityId ?? opts.reply ?? 'that activity'} is not in this square's history`
+                    : 'Invalid --reply: expected an activity id like act/12'
+                : refusalText(error);
         const lines = [message, `· draft kept: ${draftPath}`];
-        const recipientFailure = detail?.subject === 'recipient';
-        const repair = reason === 'bell_mention_conflict' ? { bell: true, fromBody: true }
-            : reason === 'not_standing' && recipientFailure ? { bell: false, fromBody: false } : undefined;
+        const repair = reason === 'bell_mention_conflict' || (reason === 'not_standing' && detail?.subject === 'recipient');
         if (isSquareError(error)) {
             if ((reason === 'never_joined' && detail?.subject === 'caller') || error.code === 'unknown_participant' || error.code === 'not_joined') {
                 lines.push(joinRecoveryCommand(squarePath, name));
             }
             if (error.code === 'already_joined')
                 lines.push(...takeoverRecoveryLines(squarePath, name));
-            if (repair !== undefined) {
-                lines.push(participantsRecoveryCommand(squarePath), repair.fromBody
-                    ? "  · edit the draft first — the body's @name must be removed or wrapped in backticks:"
-                    : '  · pick someone standing here, or land it bare:', `${mentionRepairCommand(squarePath, name, opts, repair.bell)} < ${quoteShell(draftPath)}`);
+            if (repair) {
+                lines.push(participantsRecoveryCommand(squarePath), reason === 'bell_mention_conflict'
+                    ? '  · ring the bell without explicit mentions:'
+                    : '  · retry without explicit recipients:', `${activityRetryCommand(squarePath, name, { ...opts, mentions: [] })} < ${quoteShell(draftPath)}`);
             }
             else if (error.code === 'invalid_args' || error.code === 'invalid_name') {
                 if (opts.mentions?.length)
@@ -175,15 +177,11 @@ export async function executeExpression(application, squarePath, requestedName,
                     lines.push(`${commandPrefix(squarePath)} history --limit 10`);
             }
         }
-        if (reason === 'explicit_reach_required') {
-            lines.push('  · choose someone with --mention <name>, or send without addressing anyone:', `${activityRetryCommand(squarePath, name, { ...opts, noMention: true })} < ${quoteShell(draftPath)}`);
-        }
-        else if (reason === 'invalid_reply') {
-            const hasFlagReach = opts.reach !== undefined || (opts.mentions?.length ?? 0) > 0 || opts.noMention === true;
-            const withoutReply = { ...opts, reply: undefined, ...(hasFlagReach ? {} : { noMention: true }) };
-            lines.push(`${commandPrefix(squarePath)} history --limit 10`, '  · choose a valid --reply from history, or send without a reply using this repair:', ...(hasFlagReach ? [] : ['  · this repair is bare; replace --no-mention with --mention <name> to address someone']), `${activityRetryCommand(squarePath, name, withoutReply)} < ${quoteShell(draftPath)}`);
+        if (reason === 'invalid_reply') {
+            const withoutReply = { ...opts, reply: undefined };
+            lines.push(`${commandPrefix(squarePath)} history --limit 10`, '  · choose a valid --reply from history, or send without a reply using this repair:', `${activityRetryCommand(squarePath, name, withoutReply)} < ${quoteShell(draftPath)}`);
         }
-        else if (repair === undefined) {
+        else if (!repair) {
             lines.push('  · correct the problem above before retrying; keep your intended recipients and reply:', `${retryCommand} < ${quoteShell(draftPath)}`);
         }
         process.stderr.write(formatRefusal(squarePath, lines, output));
@@ -191,5 +189,6 @@ export async function executeExpression(application, squarePath, requestedName,
     }
     finally {
         process.off('SIGINT', interrupt);
+        await square?.close();
     }
 }

package/dist/cli/maintenance-commands.js

@@ -1,6 +1,6 @@
-import { createSquareApplication } from '../square-application.js';
+import { diagnoseSquare, migrateSquare } from '../square-api.js';
 import { commandPrefix, renderDoctorClean, renderDoctorUnfixable, withPathOutput } from '../presentation.js';
-import { requireSquarePath, usage } from './context.js';
+import { requireSquarePath, squareInput, usage } from './context.js';
 export const migrateCommand = {
     parse(argv, context) {
         if (argv.length > 0)
@@ -9,14 +9,14 @@ export const migrateCommand = {
     },
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
-        const { data: outcome, projection } = await createSquareApplication({ cwd: context.cwd, env: context.env, squarePath }).migrate();
+        const outcome = await migrateSquare(squareInput(context));
         const body = outcome.status === 'migrated' && outcome.counts !== undefined
             ? [
                 '✓ migrated to row storage',
                 `  · ${outcome.counts.activities} activities · ${outcome.counts.receipts} receipts · ${outcome.counts.leases} leases · ${outcome.counts.routes} routes`,
             ].join('\n')
             : '· already format 2 — nothing changed';
-        return { output: withPathOutput(squarePath, body, { participantCount: projection.standingCount }) };
+        return { output: withPathOutput(squarePath, body, { participantCount: outcome.standing }) };
     },
     present(result) {
         process.stdout.write(result.output);
@@ -30,7 +30,7 @@ export const doctorCommand = {
     },
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
-        const { data: diagnosis, projection } = await createSquareApplication({ cwd: context.cwd, env: context.env, squarePath }).diagnose();
+        const diagnosis = await diagnoseSquare(squareInput(context));
         if (diagnosis.migrationRequired !== undefined) {
             return { output: withPathOutput(squarePath, `${diagnosis.migrationRequired}\n${commandPrefix(squarePath)} migrate\n`), exitCode: 2 };
         }
@@ -42,7 +42,7 @@ export const doctorCommand = {
         }
         return {
             output: withPathOutput(squarePath, renderDoctorClean(), {
-                participantCount: projection.standingCount,
+                participantCount: diagnosis.standingCount,
             }),
         };
     },

package/dist/cli/mcp-server-command.js

@@ -7,7 +7,7 @@ export const mcpServerCommand = {
     },
     async execute(_intent, context) {
         const { runSquareMcpStdio } = await import('../mcp.js');
-        await runSquareMcpStdio({ cwd: context.cwd, env: context.env, squarePath: context.squarePath, participant: context.name });
+        await runSquareMcpStdio({ cwd: context.cwd, env: context.env, path: context.squarePath, participant: context.name });
     },
     present() { },
 };

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

@@ -1,20 +1,20 @@
-import type { CatchApplicationOptions, DiscoveryApplicationOptions, HistoryApplicationQuery, StreamStart } from '../square-facade.js';
+import type { CatchOptions, DiscoveryOptions, HistoryQuery, StreamStart } from '../square-facade.js';
 import { type CommandSpec } from './context.js';
 interface HistoryCommandOptions {
-    query: HistoryApplicationQuery;
+    query: HistoryQuery;
     noTruncate: boolean;
     format?: string[];
     json: boolean;
     continuationArgs: string[];
 }
-export declare const listCommand: CommandSpec<DiscoveryApplicationOptions, string>;
+export declare const listCommand: CommandSpec<DiscoveryOptions, string>;
 interface StreamIntent {
     ndjson: boolean;
     forName?: string;
     start: StreamStart;
 }
 export declare const streamCommand: CommandSpec<StreamIntent>;
-export declare const catchCommand: CommandSpec<CatchApplicationOptions>;
+export declare const catchCommand: CommandSpec<CatchOptions>;
 export declare const historyCommand: CommandSpec<HistoryCommandOptions, string>;
 interface ParticipantsCommandOptions {
     limit: number;

package/dist/cli/observation-commands.js

@@ -6,9 +6,9 @@ import { isSquareError, sameName } from '../model.js';
 import { commandPrefix, participantIdentity, renderGrepActivitiesView, renderEventCli, renderAmbientEventFacts, renderPresenceAnchor, truncateChars, withPathOutput, quoteShell, } from '../presentation.js';
 import { style } from '../tty-style.js';
 import { formatRelativeTime, formatTimestamp, parseTimeOrRelative } from '../time.js';
-import { formatActivityId, parseActivityId, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT } from '../square-application.js';
+import { discover, inbox, formatActivityId, parseActivityId, CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT, HISTORY_MAX_LIMIT, DEFAULT_LIST_DEPTH, MAX_LIST_DEPTH, DEFAULT_LIST_LIMIT, MAX_LIST_LIMIT } from '../square-api.js';
 import { renderCatchOutcome, renderCatchProgress } from './catch-presentation.js';
-import { applicationFor as application, fail, parseBoundedLimit, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdin, requireSquarePath, requireValue, usage, } from './context.js';
+import { withSquare, squareInput, now, fail, parseBoundedLimit, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdin, requireSquarePath, requireValue, usage, } from './context.js';
 const STATUS_PARTICIPANT_PREVIEW_LIMIT = 10;
 const PARTICIPANTS_DEFAULT_LIMIT = 20;
 const PARTICIPANTS_MAX_LIMIT = 100;
@@ -80,8 +80,8 @@ export const listCommand = {
         return { depth, limit, after };
     },
     async execute(intent, context) {
-        const outcome = await application(context).discover(intent);
-        return renderSquareList(outcome.data, outcome.projection);
+        const result = await discover(squareInput(context), intent);
+        return renderSquareList(result, { now: now(context), depth: intent.depth ?? DEFAULT_LIST_DEPTH, limit: intent.limit ?? DEFAULT_LIST_LIMIT });
     },
     present: (result) => process.stdout.write(result),
 };
@@ -132,10 +132,12 @@ export const streamCommand = {
         const interrupt = () => controller.abort();
         process.once('SIGINT', interrupt);
         try {
-            for await (const record of application(context).stream({ recipient: intent.forName, start: intent.start }, { signal: controller.signal })) {
-                if (!process.stdout.write(`${JSON.stringify(record)}\n`))
-                    await once(process.stdout, 'drain', { signal: controller.signal });
-            }
+            await withSquare(context, async (square) => {
+                for await (const record of square.stream({ recipient: intent.forName, start: intent.start }, { signal: controller.signal })) {
+                    if (!process.stdout.write(`${JSON.stringify(record)}\n`))
+                        await once(process.stdout, 'drain', { signal: controller.signal });
+                }
+            }, { signal: controller.signal });
         }
         catch (error) {
             if (controller.signal.aborted)
@@ -218,14 +220,14 @@ export const catchCommand = {
         const interrupt = () => controller.abort();
         process.once('SIGINT', interrupt);
         try {
-            const outcome = await application(context).catch(intent, {
+            const outcome = await withSquare(context, async (square) => (await square.participant(context.name)).catch({ ...intent, observe: true }, {
                 signal: controller.signal,
                 onProgress(progress) {
                     const line = renderCatchProgress(squarePath, progress);
                     if (line !== undefined)
                         process.stderr.write(line);
                 },
-            });
+            }), { signal: controller.signal });
             const rendered = renderCatchOutcome(squarePath, outcome, intent);
             process.stdout.write(rendered.stdout);
             process.exitCode = rendered.exitCode;
@@ -301,7 +303,7 @@ function parseHistory(argv, context) {
             index += 1;
         }
         else if (flag === '--since') {
-            since = parseTimestamp(requireValue(argv, index, flag), flag, application(context).now());
+            since = parseTimestamp(requireValue(argv, index, flag), flag, now(context));
             index += 1;
         }
         else if (flag === '--after') {
@@ -446,7 +448,7 @@ export const historyCommand = {
         const squarePath = requireSquarePath(context);
         let outcome;
         try {
-            outcome = await application(context).history(options.query);
+            outcome = await withSquare(context, (square) => square.history({ ...options.query, observe: true }));
         }
         catch (error) {
             const bounds = error?.operation?.historyBounds;
@@ -454,7 +456,7 @@ export const historyCommand = {
                 fail(`✕ history is capped at ${bounds.maxLimit} activities\n${historyContinuationCommand(options, squarePath, ['--limit', String(bounds.maxLimit)])}`);
             throw error;
         }
-        const projection = outcome.projection;
+        const projection = outcome.observation;
         const events = projection.activities;
         if (options.json)
             return events.map((item) => jsonLine(projection.sayNumbers, item)).join('\n') + (events.length > 0 ? '\n' : '');
@@ -488,7 +490,8 @@ export const participantsCommand = {
     parse(argv, context) { return parseParticipants(argv, context); },
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        const { data, projection } = await application(context).participants();
+        const data = await withSquare(context, (square) => square.participants({ observe: true }));
+        const projection = data.observation;
         const now = projection.now;
         const participants = data.participants;
         const lines = participants.slice(0, intent.limit).map((participant) => {
@@ -516,7 +519,8 @@ export const statusCommand = {
         usage(context.command); return undefined; },
     async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
-        const { data: result, projection: presentation } = await application(context).status(context.name);
+        const result = await withSquare(context, (square) => square.status({ viewer: context.name, observe: true }));
+        const presentation = result.observation;
         const participantsByName = new Map(result.participants.map((participant) => [participant.name, participant]));
         const orderedHere = presentation.orderedHereNames.map((name) => participantsByName.get(name));
         const lingering = presentation.lingeringCount;
@@ -639,7 +643,7 @@ export const inboxCommand = {
         return { sessionId, json, limit };
     },
     async execute(intent, context) {
-        const { data } = await application(context).inbox(intent.sessionId, { limit: intent.limit });
+        const data = await inbox(squareInput(context), intent.sessionId, { limit: intent.limit });
         const rows = data.rows.map((membership) => ({
             namePreview: inboxDisplay(membership.name),
             squarePathPreview: inboxDisplay(membership.squarePath),

package/dist/cli/program.d.ts

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