@astrosheep/square 0.3.70 → 0.3.71

package/dist/attention-presentation.js

@@ -25,17 +25,13 @@ export function renderAttentionDescription({ actor, recipient, route }) {
     }
 }
 export function renderAttentionPreview(attention) {
-    // The fence is what keeps the body from being re-rendered by Markdown. It grows past any
-    // backtick run in the body so a body containing a fence cannot break out of this one.
-    // Everything outside the fence is the system's voice, which participant bodies cannot fake.
-    const fence = '`'.repeat(Math.max(3, longestBacktickRun(attention.body) + 1));
     return [
-        `${fence}square-activity`,
+        '<square-activity>',
         `· ${displayAttentionPath(attention.squarePath)} · ${formatActivityId(attention.actIndex)}`,
         `● ${renderAttentionDescription(attention)}`,
         '',
         previewAttentionBody(attention.body),
-        fence,
+        '</square-activity>',
         // A clipped body ends with the full command to read it all: a labeled caption, then the
         // command bare on its own line so it can be copied and run as it is.
         ...(attentionBodyIsClipped(attention.body)
@@ -43,6 +39,3 @@ export function renderAttentionPreview(attention) {
             : []),
     ].join('\n');
 }
-function longestBacktickRun(value) {
-    return value.match(/`+/g)?.reduce((longest, run) => Math.max(longest, run.length), 0) ?? 0;
-}

package/dist/automatic-session.js

@@ -1,9 +1,9 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { openSquare } from './square-file-adapter.js';
+import { openSquare } from './open-square.js';
 import { closeOpenSquare } from './open-square.js';
-import { Square } from './square-wiring.js';
-import { entryPresentation } from './views.js';
+import { Square } from './square-application.js';
+import { currentParticipant } from './views.js';
 import { automaticParticipant, harnessSessionSources } from './participant-identity.js';
 import { SquareError } from './model.js';
 import { projectSessionBindings } from './square-projections.js';
@@ -49,10 +49,10 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
     const name = automaticParticipant(provider, sessionId, env);
     const hostLedger = hostLedgerForEnv(env);
     let bindings;
-    let entry;
+    let standing;
     try {
         bindings = await hostLedger.listPresence({ location: squarePath, participant: name });
-        entry = await entryPresentation(reader, name);
+        standing = await currentParticipant(reader, name);
     }
     finally {
         await closeOpenSquare(reader);
@@ -60,7 +60,7 @@ export async function automaticSessionStart(provider, sessionId, cwd, env = proc
     if (bindings.some((binding) => binding.session !== sessionId)) {
         throw new SquareError('already_joined', `✕ ${name} already stands here — another session holds the name`);
     }
-    if (entry.joined && !bindings.some((binding) => binding.session === sessionId)) {
+    if (standing !== undefined && !bindings.some((binding) => binding.session === sessionId)) {
         throw new SquareError('already_joined', `✕ ${name} already stands here — another session holds the name`);
     }
     const scopedEnv = operationEnv(provider, sessionId, env);

package/dist/boundary-presentation.js

@@ -2,7 +2,7 @@ import { hostLedgerRoot } from './host-ledger-root.js';
 import { createHash } from 'node:crypto';
 import path from 'node:path';
 import { withFileLock } from './file-lock.js';
-import { openSquare } from './square-file-adapter.js';
+import { openSquare } from './open-square.js';
 import { closeOpenSquare } from './open-square.js';
 import { presentPending } from './presentation-operations.js';
 import { hostLedgerForEnv } from './registry.js';
@@ -117,8 +117,8 @@ async function presentPendingAtBoundaryUnlocked(sessionId, present, lookup = ses
                     // A stale projection can outlive its activity; still surface the bounded preview,
                     // but there is no artifact observation to commit.
                     if (!outcome.presented) {
-                        const snapshot = await square.artifact.read(signal).catch(() => undefined);
-                        if (snapshot?.state.acts.every((activity) => activity.index !== index))
+                        const exists = await square.artifact.read((facts) => facts.activity(index) !== undefined, signal).catch(() => undefined);
+                        if (exists?.value === false)
                             await renderOnce();
                     }
                 });

package/dist/catch-decisions.d.ts

@@ -1,17 +1,24 @@
-import { type Perception } from './square-core.js';
-import { type PerceptionProjection } from './perception-projection.js';
-import { type SquareState, type StoredAct } from './model.js';
+import { type ActivityId } from './square-core.js';
+import { type StoredAct } from './model.js';
+import type { DirectedFilter, SquareRead, SquareWrite } from './ports.js';
 import type { CatchOptions } from './square-facade.js';
-export interface CatchDecision {
-    readonly viewer: string;
-    readonly delivered: readonly StoredAct[];
-    readonly perceptions: ReadonlyMap<number, Perception>;
-    readonly consumedThrough: string | null;
-    readonly changed: boolean;
+export interface CatchSelection {
+    readonly participant: string;
+    readonly activities: readonly StoredAct[];
+    readonly consumedThrough: ActivityId | null;
     readonly remaining: number;
+    readonly sayNumbers: Readonly<Record<number, number>>;
+    readonly standingCount: number;
+    readonly held: boolean;
+    readonly now: number;
+    readonly ownActivityCount: number;
+    readonly hardCap: number | null;
+    readonly terminalStatus: 'capped' | 'quorum' | undefined;
 }
+/** Capture a selected page (or an empty completion) without opening another resource. */
+export declare function observeCatchSelection(facts: SquareRead, participant: string, activities: readonly StoredAct[], filter: DirectedFilter, at: number): CatchSelection;
 export declare const CATCH_DEFAULT_LIMIT = 10;
 export declare const CATCH_MAX_LIMIT = 100;
-export type CatchProjection = Pick<PerceptionProjection, 'cursorFor' | 'directedTo' | 'perceive' | 'isSeen'>;
-/** Pure catch selection and acknowledgement over one SquareState snapshot. */
-export declare function decideCatch(state: SquareState, requestedName: string, options: CatchOptions, at: number, project?: (state: SquareState) => CatchProjection): CatchDecision;
+export declare function catchLimit(value: number | undefined): number;
+/** Selection, receipts and resulting cursor belong to one artifact write transaction. */
+export declare function decideCatch(facts: SquareWrite, requestedName: string, options: CatchOptions, at: number): CatchSelection;

package/dist/catch-decisions.js

@@ -1,88 +1,52 @@
-import { activityAuthors, audienceOf, formatActivityId, parseActivityId } from './square-core.js';
-import { derivePerceptionProjection } from './perception-projection.js';
-import { recordObservation } from './runtime.js';
-import { matchesCatchSelection } from './catch-selection.js';
-import { participantIdentity } from './participant-identity.js';
-import { SquareError, validateName } from './model.js';
-import { resolveRosterName } from './runtime.js';
+import { formatActivityId, parseActivityId } from './square-core.js';
+import { inSquareCount, readCursor, watchTerminalStatus } from './runtime.js';
+import { SquareError } from './model.js';
+import { resolveKnownName } from './decisions.js';
+/** Capture a selected page (or an empty completion) without opening another resource. */
+export function observeCatchSelection(facts, participant, activities, filter, at) {
+    const cursor = readCursor(facts, participant);
+    return {
+        participant, activities, consumedThrough: cursor < 0 ? null : formatActivityId(cursor),
+        remaining: facts.directedCount(participant, filter),
+        sayNumbers: activities.length === 0 ? {} : facts.sayOrdinals(activities.map((item) => item.index)),
+        standingCount: inSquareCount(facts), held: facts.hold().active, now: at,
+        ownActivityCount: facts.participant(participant).sayCount, hardCap: facts.header().hardCap,
+        terminalStatus: watchTerminalStatus(facts, participant),
+    };
+}
 export const CATCH_DEFAULT_LIMIT = 10;
 export const CATCH_MAX_LIMIT = 100;
-function catchLimit(value) {
+export function catchLimit(value) {
     const limit = value ?? CATCH_DEFAULT_LIMIT;
     if (!Number.isSafeInteger(limit) || limit < 1 || limit > CATCH_MAX_LIMIT) {
         throw new SquareError('invalid_args', `Catch limit must be a positive integer no greater than ${CATCH_MAX_LIMIT}.`);
     }
     return limit;
 }
-function resolveCatchName(state, requestedName) {
-    validateName(requestedName);
-    const known = resolveRosterName(state, requestedName);
-    if (known === undefined) {
-        throw new SquareError('invalid_args', `✕ ${participantIdentity(requestedName)} has never stepped into this square`, { reason: 'never_joined' });
-    }
-    return known;
-}
-/** Pure catch selection and acknowledgement over one SquareState snapshot. */
-export function decideCatch(state, requestedName, options, at, project = derivePerceptionProjection) {
-    const viewer = resolveCatchName(state, requestedName);
+/** Selection, receipts and resulting cursor belong to one artifact write transaction. */
+export function decideCatch(facts, requestedName, options, at) {
+    const viewer = resolveKnownName(facts, requestedName);
     const limit = catchLimit(options.limit);
-    const delivery = project(state);
+    let delivered;
+    let filter = { unseenOnly: true };
     if (options.id !== undefined) {
-        if (['idle', 'from', 'mention', 'limit'].some((key) => Object.hasOwn(options, key))) {
+        if (['idle', 'from', 'mention', 'limit'].some((key) => Object.hasOwn(options, key)))
             throw new SquareError('invalid_args', 'Catch id cannot be combined with idle, from, mention or limit.');
-        }
         const index = parseActivityId(options.id);
         if (index === undefined)
             throw new SquareError('invalid_args', 'Invalid catch id: expected an activity id like act/12.');
-        const activity = state.acts.find((item) => item.index === index);
-        if (activity === undefined || activity.kind !== 'say' || !delivery.directedTo(activity, viewer)) {
+        const activity = facts.activity(index);
+        if (activity === undefined || activity.kind !== 'say' || facts.directedAt(viewer, index) === undefined) {
             throw new SquareError('invalid_args', `✕ ${formatActivityId(index)} isn't addressed to you`, {
-                reason: 'not_addressed',
-                activityId: formatActivityId(index),
-                activityExists: activity !== undefined,
+                reason: 'not_addressed', activityId: formatActivityId(index), activityExists: activity !== undefined,
             });
         }
-        const perception = delivery.perceive(activity, viewer);
-        const changed = recordObservation(state, viewer, index, 'seen', at);
-        const cursor = delivery.cursorFor(viewer);
-        return {
-            viewer,
-            delivered: [activity],
-            perceptions: new Map([[index, perception]]),
-            consumedThrough: cursor < 0 ? null : formatActivityId(cursor),
-            changed,
-            remaining: state.acts.filter((item) => item.kind === 'say' && delivery.directedTo(item, viewer) && !delivery.isSeen(viewer, item.index)).length,
-        };
-    }
-    const filter = { participants: options.from, mention: options.mention === true ? viewer : undefined };
-    const authors = activityAuthors(state.acts);
-    const delivered = [];
-    const perceptions = new Map();
-    const matching = [];
-    for (const activity of state.acts) {
-        if (activity.kind !== 'say' || !delivery.directedTo(activity, viewer))
-            continue;
-        const replyAuthor = activity.reply === undefined ? undefined : authors.get(activity.reply);
-        if (!matchesCatchSelection(activity.actor, audienceOf(activity), filter, replyAuthor))
-            continue;
-        if (delivery.isSeen(viewer, activity.index))
-            continue;
-        matching.push(activity);
+        delivered = [activity];
     }
-    delivered.push(...matching.slice(0, limit));
-    for (const activity of delivered)
-        perceptions.set(activity.index, delivery.perceive(activity, viewer));
-    let changed = false;
-    for (const activity of delivered) {
-        changed = recordObservation(state, viewer, activity.index, 'seen', at) || changed;
+    else {
+        filter = { unseenOnly: true, ...(options.from === undefined ? {} : { senders: options.from }), ...(options.mention === true ? { attentionOnly: true } : {}) };
+        delivered = facts.activities(facts.directed(viewer, filter, { edge: 'oldest', limit }).items.map((item) => item.index));
     }
-    const consumed = delivery.cursorFor(viewer);
-    return {
-        viewer,
-        delivered,
-        perceptions,
-        consumedThrough: consumed < 0 ? null : formatActivityId(consumed),
-        changed,
-        remaining: Math.max(0, matching.length - delivered.length),
-    };
+    facts.markSeen(viewer, delivered.map((item) => item.index), at);
+    return observeCatchSelection(facts, viewer, delivered, filter, at);
 }

package/dist/claude-delivery.js

@@ -1,8 +1,9 @@
 import { stat } from 'node:fs/promises';
-import { openSquare } from './square-file-adapter.js';
+import { openSquare } from './open-square.js';
 import { closeOpenSquare } from './open-square.js';
 import { hostLedgerForEnv } from './registry.js';
-import { nativePendingPreview, projectPresentationEvidence, presentationSuppressesWake } from './square-projections.js';
+import { projectPresentationEvidence, presentationSuppressesWake } from './square-projections.js';
+import { nativePendingPreview } from './inbox.js';
 import { presentPending } from './presentation-operations.js';
 import { canonicalPath } from './canonical-path.js';
 import { parseActivityId } from './square-core.js';
@@ -54,8 +55,7 @@ async function currentDelivery(row, hostLedger) {
         return undefined;
     const square = await openSquare(owner.location, { hostLedger });
     try {
-        const state = (await square.artifact.read()).state;
-        const preview = nativePendingPreview(state, { location: row.location, routeKind: 'claude-native', sessionId: row.session, participant: row.participant, actIndex: index, epoch: native.epoch, address: { endpoint: native.endpoint }, cancelledThrough: owner.cancelledThrough, now: Date.now() });
+        const { value: preview } = await square.artifact.read((facts) => nativePendingPreview(facts, { location: row.location, routeKind: 'claude-native', sessionId: row.session, participant: row.participant, actIndex: index, epoch: native.epoch, address: { endpoint: native.endpoint }, cancelledThrough: owner.cancelledThrough, now: Date.now() }));
         if (!preview || nativePayload(row.claimToken, preview.payload) !== native.payload)
             return undefined;
         return { cancelledThrough: owner.cancelledThrough, clipped: preview.clipped };
@@ -82,7 +82,7 @@ async function dispatchClaude(request, hostLedger, timeoutMs, beforeSend, env =
         let payload;
         try {
             const index = parseActivityId(request.activity);
-            const preview = index === undefined ? undefined : nativePendingPreview((await square.artifact.read()).state, { location: request.location, routeKind: 'claude-native', sessionId: request.route.sessionId, participant: request.participant, actIndex: index, epoch: request.route.epoch, address: { endpoint: request.route.address.endpoint }, cancelledThrough: owner.cancelledThrough, now: Date.now() });
+            const preview = index === undefined ? undefined : (await square.artifact.read((facts) => nativePendingPreview(facts, { location: request.location, routeKind: 'claude-native', sessionId: request.route.sessionId, participant: request.participant, actIndex: index, epoch: request.route.epoch, address: { endpoint: request.route.address.endpoint }, cancelledThrough: owner.cancelledThrough, now: Date.now() }))).value;
             if (!preview)
                 return { outcome: 'not-capable', diagnostic: 'Catch or consumption owns this activity.' };
             payload = nativePayload(request.claimToken, preview.payload);
@@ -127,11 +127,11 @@ export async function observeClaudeDelivery(sessionId, text, operation, env = pr
                     continue;
                 const square = await openSquare(row.location, { hostLedger: ledger, env });
                 try {
-                    await presentPending({ artifact: square.artifact, hostLedger: ledger, location: row.location, participant: row.participant, session: sessionId, activity: row.activity, sink: { present() { } }, markSeen: !pending.clipped, current: (state) => {
+                    await presentPending({ artifact: square.artifact, hostLedger: ledger, location: row.location, participant: row.participant, session: sessionId, activity: row.activity, sink: { present() { } }, markSeen: !pending.clipped, current: (facts) => {
                             const index = parseActivityId(row.activity);
                             if (index === undefined)
                                 return false;
-                            const preview = nativePendingPreview(state, { location: row.location, routeKind: 'claude-native', sessionId: row.session, participant: row.participant, actIndex: index, epoch: native.epoch, address: { endpoint: native.endpoint }, cancelledThrough: pending.cancelledThrough, now: Date.now() });
+                            const preview = nativePendingPreview(facts, { location: row.location, routeKind: 'claude-native', sessionId: row.session, participant: row.participant, actIndex: index, epoch: native.epoch, address: { endpoint: native.endpoint }, cancelledThrough: pending.cancelledThrough, now: Date.now() });
                             return preview !== undefined && nativePayload(row.claimToken, preview.payload) === native.payload;
                         } });
                 }

package/dist/claude-mod.js

@@ -1,9 +1,9 @@
 import { automaticSessionStart, operationEnv } from './automatic-session.js';
 import { claimSessionParticipant, hostLedgerForEnv } from './registry.js';
-import { openSquare } from './square-file-adapter.js';
+import { openSquare } from './open-square.js';
 import { closeOpenSquare } from './open-square.js';
 import { publishWakeRoute, retireWakeRouteFromArtifact } from './routes.js';
-import { Square } from './square-wiring.js';
+import { Square } from './square-application.js';
 import { observeClaudeDelivery } from './claude-delivery.js';
 import { processActNotificationsOnce } from './notifications.js';
 import { sweepPending } from './delivery-operations.js';
@@ -61,8 +61,9 @@ export async function runClaudeMod(inputText, env = process.env) {
                 const probe = await openSquare(row.location, { hostLedger: ledger, env: scoped, signal });
                 let eligible = false;
                 try {
-                    const state = (await probe.artifact.read(signal)).state;
-                    const last = state.acts.findLast((activity) => activity.actor === row.participant && ['join', 'done', 'kick'].includes(activity.kind));
+                    const { value: last } = await probe.artifact.read((facts) => facts.activityHeads({
+                        actors: [row.participant], actorMatch: 'exact', kinds: ['join', 'done'],
+                    }, { edge: 'newest', limit: 1 }).items[0], signal);
                     eligible = last?.kind === 'done' && `act/${last.index}` === row.activity;
                 }
                 finally {
@@ -111,8 +112,7 @@ export async function runClaudeMod(inputText, env = process.env) {
                     await ledger.ensurePresence({ ...current, epoch });
                 const square = await openSquare(binding.location, { hostLedger: ledger, env: scoped, signal });
                 try {
-                    const state = (await square.artifact.read(signal)).state;
-                    const existing = state.routes?.find((route) => route.participant === binding.participant && route.sessionId === input.sessionId && route.kind === 'claude-native' && route.epoch === epoch);
+                    const { value: existing } = await square.artifact.read((facts) => facts.routes().find((route) => route.participant === binding.participant && route.sessionId === input.sessionId && route.kind === 'claude-native' && route.epoch === epoch), signal);
                     if (!supported) {
                         if (existing)
                             await retireWakeRouteFromArtifact(square.artifact, existing, { expectedEpoch: epoch });
@@ -120,7 +120,18 @@ export async function runClaudeMod(inputText, env = process.env) {
                     }
                     const cutoff = cancelled?.epoch === epoch || (lateCancelledJoin && current.epoch === binding.epoch && (current.updatedAt ?? Infinity) <= input.cancelAt) ? input.cancelAt : undefined;
                     if (cutoff !== undefined) {
-                        const through = state.acts.filter((activity) => activity.at <= cutoff).reduce((highest, activity) => Math.max(highest, activity.index), -1);
+                        const { value: through } = await square.artifact.read((facts) => {
+                            let beforeIndex;
+                            for (;;) {
+                                const page = facts.activityHeads({ beforeIndex }, { edge: 'newest', limit: 100 });
+                                const last = [...page.items].reverse().find((activity) => activity.at <= cutoff);
+                                if (last !== undefined)
+                                    return last.index;
+                                if (!page.hasMore)
+                                    return -1;
+                                beforeIndex = page.items[0].index;
+                            }
+                        }, signal);
                         await ledger.suppressPresence({ ...current, epoch }, through);
                     }
                     if (!existing || existing.address.endpoint !== input.endpoint)

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

@@ -0,0 +1,7 @@
+import type { ApplicationOutcome, CatchApplicationData, CatchApplicationOptions, CatchProjection, 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): {
+    stdout: string;
+    exitCode: number;
+};

package/dist/cli/catch-presentation.js

@@ -0,0 +1,55 @@
+import { parseActivityId } from '../square-application.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)
+        return undefined;
+    const options = { squarePath, name: progress.participant };
+    return (progress.replaced
+        ? renderWatchForceTakeover(options) : renderWatchReplaceMissing(options)) + '\n';
+}
+function continuationCommand(squarePath, name, options) {
+    const args = ['--now'];
+    if (options.from?.length)
+        args.push('--from', options.from.join(','));
+    if (options.mention)
+        args.push('--mention');
+    if (options.limit !== undefined)
+        args.push('--limit', String(options.limit));
+    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;
+    const location = projection.location ?? squarePath;
+    const name = projection.participant;
+    const stop = projection.stop ?? data.status;
+    const header = { participantCount: projection.standingCount, held: projection.held };
+    const statusOptions = {
+        squarePath: location, name, presence: projection.presence,
+        showCatchHint: !projection.automaticDeliveryAvailable,
+        ownActivityCount: projection.ownActivityCount, hardCap: projection.hardCap,
+    };
+    if (stop === 'already-active' || stop === 'replaced') {
+        return {
+            stdout: withPathOutput(location, stop === 'already-active'
+                ? renderWatchAlreadyActive(statusOptions) : renderWatchReplaced(statusOptions), header),
+            exitCode: stop === 'already-active' ? 1 : 0,
+        };
+    }
+    const rendered = data.activities.map((activity) => renderAmbientEvent(activity, name, {
+        now: projection.now, actNumber: projection.sayNumbers[parseActivityId(activity.id)],
+        perception: activity.perception, mention: options.mention ? name : undefined,
+    })).filter(Boolean).join('\n\n');
+    const remaining = data.remaining === 0 ? ''
+        : `○ ${data.remaining} matching ${data.remaining === 1 ? 'activity remains' : 'activities remain'}\n${continuationCommand(location, name, options)}`;
+    const terminal = stop === undefined ? '' : renderWatchStatus({
+        ...statusOptions, status: stop,
+        ...(stop === 'stale' && options.idle !== undefined ? { idleMs: options.idle } : {}),
+    });
+    const fallback = stop === undefined && !projection.automaticDeliveryAvailable && data.remaining === 0
+        ? `${participantCommandPrefix(location, name)} catch --idle 30m\n  stay available for new activity` : '';
+    return {
+        stdout: withPathOutput(location, [terminal, rendered, remaining, fallback].filter(Boolean).join('\n\n'), header),
+        exitCode: stop === 'capped' ? 1 : 0,
+    };
+}

package/dist/cli/context.d.ts

@@ -23,7 +23,6 @@ export declare function parseBoundedLimit(value: string | undefined, flag: strin
 export declare function parseNonNegativeInteger(value: string, flag: string): number;
 export declare function parseHardCap(value: string): HardCap;
 export declare function parseNameList(value: string, flag: string): string[];
-export declare function requireParticipant(name: string | undefined): string;
 export interface ParsedGlobalArgs {
     squarePath?: string;
     explicitSquarePath: boolean;
@@ -34,4 +33,5 @@ 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;
 export declare function requireSquarePath(context: CommandContext): string;

package/dist/cli/context.js

@@ -1,9 +1,7 @@
 import os from 'node:os';
 import { commandUsageHint } from '../help.js';
 import { parseParticipantList, validateName } from '../model.js';
-import { createHostLedgerPort } from '../host-ledger-file-adapter.js';
-import { projectSessionBindings } from '../square-projections.js';
-import { sessionIdsFromEnvironment } from '../participant-identity.js';
+import { createSquareApplication } from '../square-application.js';
 export async function readStdin() {
     try {
         let content = '';
@@ -87,12 +85,6 @@ export function parseNameList(value, flag) {
         validateName(name);
     return names;
 }
-export function requireParticipant(name) {
-    if (!name)
-        fail('✕ missing required option: --as <name>');
-    validateName(name);
-    return name;
-}
 const LOCATION_REQUIRED_COMMANDS = new Set([
     'build',
     'stream',
@@ -110,6 +102,7 @@ const LOCATION_REQUIRED_COMMANDS = new Set([
     'participants',
     'mcp-server',
     'doctor',
+    'migrate',
 ]);
 export async function parseGlobalArgs(rawArgs) {
     const args = [...rawArgs];
@@ -128,11 +121,6 @@ export async function parseGlobalArgs(rawArgs) {
         }
     }
     const command = args[0];
-    if (name === undefined) {
-        const configured = process.env.SQUARE_PARTICIPANT_NAME?.trim();
-        if (configured)
-            name = configured;
-    }
     if (name !== undefined)
         validateName(name);
     const explicitSquarePath = requestedPath !== undefined;
@@ -142,15 +130,6 @@ export async function parseGlobalArgs(rawArgs) {
         fail(`✕ ${command} needs a square location\nsquare ls`);
     }
     const squarePath = requestedPath ?? configured;
-    if (name === undefined && squarePath !== undefined && command !== undefined && locationIsRequired(command)) {
-        const bindings = (await Promise.all(sessionIdsFromEnvironment().map((sessionId) => projectSessionBindings({
-            hostLedger: createHostLedgerPort(),
-            location: squarePath,
-            sessionId,
-        })))).flat();
-        const names = new Set(bindings.map((binding) => binding.participant));
-        name = names.size === 1 ? [...names][0] : undefined;
-    }
     return { squarePath, explicitSquarePath: explicitSquarePath || configured !== undefined, multipleSquares: false, name, args };
 }
 export function locationIsRequired(command) {
@@ -159,6 +138,9 @@ 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 requireSquarePath(context) {
     if (context.squarePath === undefined)
         fail(`✕ ${context.command} needs a square location\nsquare ls`);

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

@@ -0,0 +1,10 @@
+import type { ApplicationOutcome, ExpressApplicationData, ExpressApplicationOptions, ExpressProjection, SquareApplication } from '../square-facade.js';
+export interface ActivityOptions extends Omit<ExpressApplicationOptions, '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>;