@astrosheep/square 0.3.73 → 0.3.75

package/dist/mcp.js

@@ -4,7 +4,7 @@ import { z } from 'zod/v4';
 import { SquareError, isSquareError } from './model.js';
 import { operationEnv } from './automatic-session.js';
 import { SQUARE_IDENTITY } from './identity.js';
-import { createSquareApplication } from './square-application.js';
+import { createSquareApplication, createSquareResourceOwner } from './square-application.js';
 const activityId = z.string().regex(/^act\/(0|[1-9][0-9]*)$/);
 const stringArray = z.array(z.string());
 const participantName = z.string().optional().describe("Participant name, same as --as. Defaults to the server's configured participant.");
@@ -44,37 +44,62 @@ function operation(app, name, args, control) {
 }
 export function createSquareMcpServer(options) {
     const baseEnv = { ...options.env };
+    const resources = createSquareResourceOwner();
+    // One explicit lifetime for this server: every tool call borrows the same connection.
+    const inFlight = new Set();
     const server = new McpServer({ name: 'square', version: SQUARE_IDENTITY.packageVersion }, {
         instructions: 'The catch tool consumes activities. Use history with act/<index> cursors for read-only archive access.',
     });
     for (const tool of TOOL_DEFINITIONS) {
-        server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, async (args, extra) => {
-            try {
-                const { as: participant, ...operationArgs } = args;
-                const threadId = extra._meta?.threadId;
-                const opencodeSessionId = extra._meta?.['ai.opencode/sessionID'];
-                const env = typeof threadId === 'string' && threadId.trim()
-                    ? operationEnv('codex', threadId, baseEnv)
-                    : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
-                        ? operationEnv('opencode', opencodeSessionId, baseEnv)
-                        : baseEnv;
-                const app = createSquareApplication({ ...options, env, participant: participant ?? options.participant });
-                const outcome = await operation(app, tool.name, operationArgs, { signal: extra.signal });
-                const structuredContent = outcome.data;
-                return { content: [{ type: 'text', text: JSON.stringify(structuredContent) }], structuredContent };
-            }
-            catch (error) {
-                const normalized = extra.signal.aborted
-                    ? { code: 'cancelled', message: 'The MCP request was cancelled' }
-                    : isSquareError(error)
-                        ? { code: error.code, message: error.message, ...(error.facts === undefined ? {} : { facts: error.facts }) }
-                        : { code: 'internal', message: error instanceof Error ? error.message : String(error) };
-                const operation = error instanceof Error ? error.operation : undefined;
-                const failure = operation === undefined ? normalized : { ...normalized, operation };
-                return { isError: true, content: [{ type: 'text', text: JSON.stringify(failure) }], structuredContent: { error: failure } };
-            }
+        server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, (args, extra) => {
+            const call = (async () => {
+                try {
+                    const { as: participant, ...operationArgs } = args;
+                    const threadId = extra._meta?.threadId;
+                    const opencodeSessionId = extra._meta?.['ai.opencode/sessionID'];
+                    const env = typeof threadId === 'string' && threadId.trim()
+                        ? operationEnv('codex', threadId, baseEnv)
+                        : typeof opencodeSessionId === 'string' && opencodeSessionId.trim()
+                            ? operationEnv('opencode', opencodeSessionId, baseEnv)
+                            : baseEnv;
+                    const app = createSquareApplication({ ...options, env, participant: participant ?? options.participant, resources }, { presentation: false });
+                    const outcome = await operation(app, tool.name, operationArgs, { signal: extra.signal });
+                    const structuredContent = outcome.data;
+                    return { content: [{ type: 'text', text: JSON.stringify(structuredContent) }], structuredContent };
+                }
+                catch (error) {
+                    const normalized = extra.signal.aborted
+                        ? { code: 'cancelled', message: 'The MCP request was cancelled' }
+                        : isSquareError(error)
+                            ? { code: error.code, message: error.message, ...(error.facts === undefined ? {} : { facts: error.facts }) }
+                            : { code: 'internal', message: error instanceof Error ? error.message : String(error) };
+                    const operation = error instanceof Error ? error.operation : undefined;
+                    const failure = operation === undefined ? normalized : { ...normalized, operation };
+                    return { isError: true, content: [{ type: 'text', text: JSON.stringify(failure) }], structuredContent: { error: failure } };
+                }
+            })();
+            inFlight.add(call);
+            return call.finally(() => { inFlight.delete(call); });
         });
     }
+    const close = server.close.bind(server);
+    // One idempotent shutdown for both close paths: an explicit server.close() and a
+    // transport-initiated disconnect, where the SDK protocol fires onclose by itself.
+    let draining;
+    const drain = () => draining ??= (async () => {
+        // The SDK aborts in-flight request signals before onclose/close returns; wait for
+        // those handlers to release the shared connection (their cleanup writes included).
+        await Promise.allSettled([...inFlight]);
+        await resources.close();
+    })();
+    server.close = async () => { await close(); await drain(); };
+    const priorOnclose = server.server.onclose;
+    server.server.onclose = () => {
+        // onclose is synchronous, so the disconnect path starts the drain without awaiting it;
+        // the handler's own catch keeps an unexpected close failure from crashing the process.
+        void drain().catch(() => undefined);
+        priorOnclose?.();
+    };
     return server;
 }
 export async function runSquareMcpStdio(options) {

package/dist/model.d.ts

@@ -20,9 +20,8 @@ export type InternalSquareErrorCode = SquareErrorCode | 'not_found' | 'cap_reach
 export interface SquareErrorFacts {
     /** Express admission rejected before any activity was committed. */
     activityUnsent?: true;
-    /** Why a name could not be resolved: never in the roster, no longer standing in it, a bell
-     * colliding with a mention, an @name that matches nobody, or an activity catch cannot address. */
-    reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'unmatched_mention' | 'not_addressed' | 'migration_required' | 'explicit_reach_required' | 'invalid_reply' | 'invalid_done_body';
+    /** Refusal reason, including absent participants, conflicting reach, and inaccessible activities. */
+    reason?: 'never_joined' | 'not_standing' | 'bell_mention_conflict' | 'not_addressed' | 'migration_required' | 'explicit_reach_required' | 'invalid_reply' | 'invalid_done_body';
     /** The activity id a `catch --id` refusal named. */
     activityId?: string;
     /** Requested recipient spellings, without parsing presentation copy. */

package/dist/model.js

@@ -37,11 +37,14 @@ export function nameKey(name) {
 export function sameName(a, b) {
     return nameKey(a) === nameKey(b);
 }
+const TEXT_NAME_GRAPHEME_SOURCE = String.raw `[[\p{L}\p{N}\p{M}_\x2D]--[\p{Variation_Selector}]]`;
 /** One name grapheme: Unicode letters, digits, marks, hyphens, or underscores (no isolated variation selectors), or a complete RGI emoji. Shared by name validation and body @mention scanning. */
-export const NAME_GRAPHEME_SOURCE = String.raw `[[\p{L}\p{N}\p{M}_\x2D]--[\p{Variation_Selector}]]|\p{RGI_Emoji}`;
+export const NAME_GRAPHEME_SOURCE = String.raw `${TEXT_NAME_GRAPHEME_SOURCE}|\p{RGI_Emoji}`;
+// Ordinary Unicode names need not trigger the full RGI emoji matcher’s cold compilation.
+const TEXT_NAME_PATTERN = new RegExp(`^(?:${TEXT_NAME_GRAPHEME_SOURCE})+(?:/(?:${TEXT_NAME_GRAPHEME_SOURCE})+)*$`, 'v');
 const NAME_PATTERN = new RegExp(`^(?:${NAME_GRAPHEME_SOURCE})+(?:/(?:${NAME_GRAPHEME_SOURCE})+)*$`, 'v');
 export function validateName(name) {
-    if (!name || !NAME_PATTERN.test(name)) {
+    if (!name || (!TEXT_NAME_PATTERN.test(name) && !NAME_PATTERN.test(name))) {
         throw new SquareError('invalid_name', 'Invalid name: names must contain non-empty slash-separated segments using Unicode letters, digits, marks, hyphens, underscores, or complete RGI emoji graphemes.');
     }
 }

package/dist/open-square.d.ts

@@ -1,4 +1,4 @@
-import type { HostLedgerPort, SquareArtifactPort, WakeTransportPort } from './ports.js';
+import type { HostLedgerPort, SquareArtifactPort, SquareResourceOwner, WakeTransportPort } from './ports.js';
 import type { OperationControl } from './square-facade.js';
 /** Host-bound resource: artifact, captured environment, clock, ledger and transport. */
 export interface OpenSquare {
@@ -8,6 +8,8 @@ export interface OpenSquare {
     readonly hostLedger?: HostLedgerPort;
     readonly wakeTransport?: WakeTransportPort;
     readonly env?: NodeJS.ProcessEnv;
+    /** False when a long-lived owner lent the connection; closing this view leaves it open. */
+    readonly ownsArtifact: boolean;
 }
 export interface SquareBuildOptions {
     markdown: string;
@@ -20,7 +22,15 @@ export interface SquareBuildOptions {
     /** One caller deadline propagated into artifact busy retries. */
     signal?: AbortSignal;
 }
-export declare function openSquare(squarePath: string, options?: Pick<SquareBuildOptions, 'clock' | 'hostLedger' | 'wakeTransport' | 'env' | 'signal'>, control?: OperationControl): Promise<OpenSquare>;
+export interface SquareOpenOptions extends Pick<SquareBuildOptions, 'clock' | 'hostLedger' | 'wakeTransport' | 'env' | 'signal'> {
+    /** A caller-owned connection to reuse; this view never closes it. */
+    readonly artifact?: SquareArtifactPort;
+}
+export declare function openSquare(squarePath: string, options?: SquareOpenOptions, control?: OperationControl): Promise<OpenSquare>;
 export declare function buildSquare(squarePath: string, options: SquareBuildOptions): Promise<OpenSquare>;
 export declare function buildMemorySquare(options: SquareBuildOptions): OpenSquare;
 export declare function closeOpenSquare(square: OpenSquare): Promise<void>;
+/** Explicit-lifetime holder of one reused artifact connection. The first request
+ * binds the location; a request for any other location is refused instead of
+ * silently sharing the wrong square. The owner closes the connection once. */
+export declare function createSquareResourceOwner(): SquareResourceOwner;

package/dist/open-square.js

@@ -1,20 +1,25 @@
+import path from 'node:path';
 import { createArtifactPort, createSquare, prepareSquareBuild } from './artifact.js';
 import { InternalSquareError, SquareError } from './model.js';
 import { hostLedgerRoot } from './host-ledger-root.js';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
 export async function openSquare(squarePath, options = {}, control) {
     const env = { ...(options.env ?? process.env) };
-    const artifact = createArtifactPort(squarePath, undefined, options.signal);
+    const borrowed = options.artifact;
+    // A borrowed connection was opened by its owner without a request signal; this
+    // request may only abort its own read, never the shared connection's lifetime.
+    const artifact = borrowed ?? createArtifactPort(squarePath, undefined, options.signal);
     try {
         await artifact.read(facts => facts.header(), control?.signal);
         return {
-            artifact, clock: options.clock ?? Date.now, location: squarePath, env,
+            artifact, clock: options.clock ?? Date.now, location: squarePath, env, ownsArtifact: borrowed === undefined,
             hostLedger: options.hostLedger ?? createHostLedgerPort({ rootPath: hostLedgerRoot(env) }),
             wakeTransport: options.wakeTransport,
         };
     }
     catch (error) {
-        await artifact.close();
+        if (borrowed === undefined)
+            await artifact.close();
         if (error instanceof InternalSquareError && error.code === 'not_found')
             throw new SquareError('unavailable', `Square is unavailable at ${squarePath}`);
         throw error;
@@ -36,8 +41,41 @@ export function buildMemorySquare(options) {
         artifact: createArtifactPort(':memory:', prepareSquareBuild(options, options.markdown)),
         clock: options.clock ?? Date.now, location: 'memory',
         hostLedger: options.hostLedger, wakeTransport: options.wakeTransport,
+        ownsArtifact: true,
     };
 }
 export function closeOpenSquare(square) {
-    return square.artifact.close();
+    // A borrowed connection belongs to its owner; only owned views close it here.
+    return square.ownsArtifact === false ? Promise.resolve() : square.artifact.close();
+}
+/** Explicit-lifetime holder of one reused artifact connection. The first request
+ * binds the location; a request for any other location is refused instead of
+ * silently sharing the wrong square. The owner closes the connection once. */
+export function createSquareResourceOwner() {
+    let held;
+    let closed = false;
+    return {
+        artifact(location) {
+            if (closed)
+                throw new SquareError('unavailable', 'Square resource owner is closed');
+            const key = path.resolve(location);
+            if (held === undefined) {
+                // No external signal: a request must never become the shared connection's lifetime.
+                held = { location: key, artifact: createArtifactPort(key) };
+            }
+            if (held.location !== key) {
+                throw new SquareError('unavailable', `Square resource owner already holds ${held.location}; it cannot also open ${key}`);
+            }
+            return held.artifact;
+        },
+        async close() {
+            if (closed)
+                return;
+            closed = true;
+            const artifact = held?.artifact;
+            held = undefined;
+            if (artifact !== undefined)
+                await artifact.close();
+        },
+    };
 }

package/dist/participant-host.js

@@ -11,8 +11,12 @@ export async function identityRouteDraft(context, participant) {
         return undefined;
     const identity = processIdentity(context.env ?? process.env);
     const provider = identity.channel === 'claude-code' ? 'claude' : identity.channel === 'opencode' ? 'opencode' : identity.channel === 'pi' ? 'pi' : identity.channel === 'paseo' ? 'paseo' : 'codex';
-    const capabilities = context.hostLedger === undefined ? { canUse: () => false } : await defaultWakeRouteCapabilities(context.hostLedger);
-    return resolvePrimaryWakeRoute({ location: context.location, participant, sessionId: identity.session, provider }, context.env ?? process.env, capabilities);
+    const boundary = { location: context.location, participant, sessionId: identity.session, provider };
+    const env = context.env ?? process.env;
+    // No adapter can add a route when the host has no candidate in the first place.
+    if (context.hostLedger === undefined || resolvePrimaryWakeRoute(boundary, env, { canUse: () => true }) === undefined)
+        return undefined;
+    return resolvePrimaryWakeRoute(boundary, env, await defaultWakeRouteCapabilities(context.hostLedger));
 }
 /** One postcommit host observation; presence and route publication fail independently. */
 export async function publishCommittedIdentity(context, participant, epoch) {

package/dist/ports.d.ts

@@ -165,6 +165,16 @@ export interface SquareArtifactPort {
     changed(sinceVersion: number, timeoutMs: number, signal?: AbortSignal): Promise<boolean>;
     close(): Promise<void>;
 }
+/** Explicit lifetime for an artifact connection reused by a long-lived caller.
+ * Only the connection is shared: every open still derives its own environment,
+ * clock, ledger and transport, and no request signal becomes a connection lifetime.
+ * The owner holds one location and refuses a second rather than sharing the wrong
+ * square; the caller lends the connection and never closes it. */
+export interface SquareResourceOwner {
+    /** The shared connection for a location. Never close it; the owner does. */
+    artifact(location: string): SquareArtifactPort;
+    close(): Promise<void>;
+}
 /** Capability-neutral wake transport. Unused by this Contract's activity operations. */
 export interface WakeTransportPort {
     /** Capability check that performs no external wake and writes no evidence. */

package/dist/presentation.js

@@ -39,7 +39,7 @@ export function formatRefusal(squarePath, bodyLines, opts = {}) {
 }
 export function refusalText(error) {
     const text = error instanceof Error ? error.message : String(error);
-    const marked = isSquareError(error) && ['never_joined', 'not_standing', 'unmatched_mention'].includes(error.facts?.reason ?? '');
+    const marked = isSquareError(error) && ['never_joined', 'not_standing'].includes(error.facts?.reason ?? '');
     return marked ? text.split('\n').map((line) => `✕ ${line}`).join('\n') : text;
 }
 export function quoteShell(value) {

package/dist/square-actions.d.ts

@@ -8,7 +8,9 @@ export interface OperationContext extends HostContext {
 export type { OwnershipFenceOptions };
 export declare function catchUp(square: OperationContext, name: string, options?: CatchOptions, control?: OperationControl): Promise<CatchSelection>;
 export declare function catchUp(square: OperationContext, name: string, options: CatchOptions, control: OperationControl | undefined, leaseId: string): Promise<CatchSelection | null>;
-export declare function join(square: OperationContext, name: string, control?: OperationControl): Promise<{
+export declare function join(square: OperationContext, name: string, control?: OperationControl, admission?: {
+    readonly requireKnown?: boolean;
+}): Promise<{
     readonly name: string;
     readonly activity: Activity | null;
     readonly participantCount: number;

package/dist/square-actions.js

@@ -33,14 +33,19 @@ export async function catchUp(square, name, options = {}, control, leaseId) {
         await publishCommittedIdentity(square, selected.participant);
     return selected;
 }
-export async function join(square, name, control) {
+export async function join(square, name, control, admission = {}) {
     throwIfAborted(control);
     validateName(name);
     const hostLedger = square.hostLedger;
-    const preview = (await square.artifact.read((facts) => ({
-        ...decideJoin(facts, name, square.clock()),
-        participantCount: facts.roster().filter((p) => p.joined || p.done).length,
-    }), control?.signal)).value;
+    const preview = (await square.artifact.read((facts) => {
+        // Express may reenter a known participant, but must never create a new name.
+        const selected = admission.requireKnown ? resolveKnownName(facts, name) : name;
+        return {
+            ...decideJoin(facts, selected, square.clock()),
+            participantCount: facts.roster().filter((p) => p.joined || p.done).length,
+        };
+    }, control?.signal)).value;
+    name = preview.joinedName;
     if (preview.joinAct === undefined) {
         if (hostLedger === undefined)
             return { name: preview.joinedName, activity: null, participantCount: preview.participantCount, reconnected: false };

package/dist/square-application.d.ts

@@ -1,5 +1,6 @@
 import type { Activity, ExpressResult, HistoryQuery, OperationControl, Participant, ParticipantStatus, SquareApplication, SquareApplicationContext, SquareAtInput, SquareBuildInput, SquareSnapshot } from './square-facade.js';
 export type * from './square-facade.js';
+export { createSquareResourceOwner } from './open-square.js';
 export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
 export { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from './catch-decisions.js';
 export { HELD_WAIT_BUDGET_MS } from './runtime.js';
@@ -32,3 +33,6 @@ export declare class Square {
     retireEndedSessionRoutes(sessionId: string): Promise<void>;
 }
 export declare function createSquareApplication(context: SquareApplicationContext): SquareApplication;
+export declare function createSquareApplication(context: SquareApplicationContext, demand: {
+    readonly presentation: false;
+}): SquareApplication<false>;

package/dist/square-application.js

@@ -2,7 +2,7 @@ import path from 'node:path';
 import crypto from 'node:crypto';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { SquareError, isSquareError, nameKey, validateName } from './model.js';
-import { validateDoneBody } from './decisions.js';
+import { resolveKnownName, validateDoneBody } from './decisions.js';
 import { HELD_WAIT_BUDGET_MS, WATCH_HEARTBEAT_MS, inSquareCount, presenceAnchor } from './runtime.js';
 import { catchLimit, observeCatchSelection } from './catch-decisions.js';
 import { directedSuffix } from './activity-feed.js';
@@ -19,6 +19,7 @@ import { createSquare, diagnoseSquareFile } from './artifact.js';
 import { migrateSquareFile } from './square-migration.js';
 import { discoverSquares, DEFAULT_LIST_DEPTH, DEFAULT_LIST_LIMIT } from './list.js';
 import { streamSquare } from './stream.js';
+export { createSquareResourceOwner } from './open-square.js';
 export { formatActivityId, parseActivityId, MAX_IDENTITY_SET_SIZE } from './square-core.js';
 export { CATCH_DEFAULT_LIMIT, CATCH_MAX_LIMIT } from './catch-decisions.js';
 export { HELD_WAIT_BUDGET_MS } from './runtime.js';
@@ -82,8 +83,8 @@ async function joinOwned(square, requested, options = {}, control) {
 async function prepareExpression(square, requested, control) {
     try {
         checkControl(control);
-        const name = (await resolveParticipant(square, requested, control)).name;
-        return await joinOwned(square, name, {}, control);
+        const result = await join(square, requested, control, { requireKnown: true });
+        return { participant: result.name, activity: result.activity };
     }
     catch (error) {
         throw failure(error, { operation: 'express', subject: 'caller', participant: requested, expressEffect: 'unsent' });
@@ -133,18 +134,18 @@ async function landExpression(square, name, body, options, transport, control) {
     }
     catch (error) {
         const recipient = isSquareError(error)
-            && ['not_standing', 'unmatched_mention', 'bell_mention_conflict'].includes(error.facts?.reason ?? '');
+            && ['not_standing', 'bell_mention_conflict'].includes(error.facts?.reason ?? '');
         throw failure(error, {
             operation: 'express', participant: name, subject: recipient ? 'recipient' : 'caller', expressEffect: effect,
         });
     }
 }
-async function expressOwned(square, requested, body, options, transport, control) {
+async function expressOwned(square, requested, body, options, transport, presentation, control) {
     const entry = await prepareExpression(square, requested, control);
     const name = entry.participant;
     let result;
     try {
-        const feed = (await square.artifact.read((facts) => {
+        const feed = !presentation ? undefined : (await square.artifact.read((facts) => {
             const pendingPublic = directedSuffix(facts, name);
             return {
                 pendingPublic,
@@ -161,7 +162,7 @@ async function expressOwned(square, requested, body, options, transport, control
                 activity: result.activity, waited: result.waited,
                 ...(result.replyAuthorNotHere === undefined ? {} : { replyAuthorNotHere: result.replyAuthorNotHere }),
             },
-            projection: {
+            projection: feed === undefined ? undefined : {
                 ...fresh, ...feed, participant: name,
                 location: square.location, now: square.clock(), automaticDeliveryAvailable: hasAutomaticDeliveryIdentity(square.env),
                 ...(entry.activity === null ? {} : { reentry: entry.activity }),
@@ -217,9 +218,11 @@ async function catchOwned(square, requested, options = {}, control) {
         if (Object.hasOwn(options, 'replace') && idle === 0)
             throw new SquareError('invalid_args', 'Catch replacement requires a positive idle duration');
         catchLimit(options.limit);
-        name = (await resolveParticipant(square, requested, control)).name;
-        subject = 'filter';
-        const from = options.from === undefined ? undefined : await Promise.all(options.from.map(async (target) => (await resolveParticipant(square, target, control)).name));
+        const from = (await square.artifact.read((facts) => {
+            name = resolveKnownName(facts, requested);
+            subject = 'filter';
+            return options.from?.map((target) => resolveKnownName(facts, target));
+        }, control?.signal)).value;
         selection = { ...options, ...(from === undefined ? {} : { from }) };
         subject = 'caller';
         if (idle === 0) {
@@ -360,12 +363,14 @@ export class Square {
     endOwnedSession(name, sessionId, expectedEpoch) { return endOwnedSession(this.square, name, sessionId, expectedEpoch); }
     retireEndedSessionRoutes(sessionId) { return retireEndedSessionRoutes(this.square, sessionId); }
 }
-export function createSquareApplication(context) {
+export function createSquareApplication(context, demand = { presentation: true }) {
+    const presentation = demand.presentation;
     const env = { ...context.env };
     const clock = clockFor(env, context.clock);
     const hostLedger = context.hostLedger ?? hostLedgerForEnv(env);
     const openOptions = { env, clock, hostLedger, wakeTransport: context.wakeTransport };
     const getTransport = defaultTransport(openOptions);
+    const resources = context.resources;
     function location() {
         const selected = context.squarePath ?? env.SQUARE_LOCATION;
         if (selected === undefined || selected.trim() === '')
@@ -385,7 +390,9 @@ export function createSquareApplication(context) {
     }
     async function scoped(operation, control) {
         checkControl(control);
-        const square = await openSquare(location(), openOptions, control);
+        const selected = location();
+        const artifact = resources?.artifact(selected);
+        const square = await openSquare(selected, { ...openOptions, artifact }, control);
         try {
             return await operation(square);
         }
@@ -416,7 +423,7 @@ export function createSquareApplication(context) {
             const result = await (verb === 'listen' ? listen : ignore)(square, name, target, control);
             return {
                 data: result,
-                projection: {
+                projection: !presentation ? undefined : {
                     ...await contextProjection(square, name), participant: name,
                     requestedTarget: target, target: result.activity?.target ?? target,
                 },
@@ -442,6 +449,8 @@ export function createSquareApplication(context) {
             else {
                 result = await resume(square, name, control);
             }
+            if (!presentation)
+                return { data: { activity: result.activity }, projection: undefined };
             const view = await eventPresentation(square, result.activity.id);
             return {
                 data: { activity: result.activity },
@@ -461,7 +470,7 @@ export function createSquareApplication(context) {
             }, input.markdown, control?.signal);
             return {
                 data: { location: squarePath, ...configuration },
-                projection: { location: squarePath, standingCount: 0, held: false, now,
+                projection: !presentation ? undefined : { location: squarePath, standingCount: 0, held: false, now,
                     automaticDeliveryAvailable: hasAutomaticDeliveryIdentity(env) },
             };
         },
@@ -472,6 +481,8 @@ export function createSquareApplication(context) {
                     throw new SquareError('invalid_args', 'Join history limit must be between 1 and 100');
                 }
                 const data = await joinOwned(square, name, options, control);
+                if (!presentation)
+                    return { data, projection: undefined };
                 try {
                     const view = await entryPresentation(square, data.participant, last);
                     return {
@@ -485,19 +496,19 @@ export function createSquareApplication(context) {
             }, control);
         },
         express(body, options = {}, control) {
-            return selected('express', (square, name) => expressOwned(square, name, body, options, getTransport, control), control);
+            return selected('express', (square, name) => expressOwned(square, name, body, options, getTransport, presentation, control), control);
         },
         catch(options, control) {
             return selected('catch', async (square, name) => {
                 const result = await catchOwned(square, name, options, control);
-                const presence = await catchPresence(square, control).catch(() => undefined);
+                const presence = !presentation ? undefined : await catchPresence(square, control).catch(() => undefined);
                 const view = result.selection;
                 const stop = result.stop;
                 const status = stop === 'already-active' || stop === 'replaced' || stop === 'capped' || stop === 'quorum'
                     ? stop : undefined;
                 return {
                     data: { ...caughtResult(result), ...(status === undefined ? {} : { status }) },
-                    projection: {
+                    projection: !presentation ? undefined : {
                         ...observedContext(square, view.standingCount, view.held, view.participant, view.now),
                         participant: view.participant, sayNumbers: view.sayNumbers,
                         ownActivityCount: view.ownActivityCount, hardCap: view.hardCap, stop,
@@ -525,12 +536,15 @@ export function createSquareApplication(context) {
                 const limit = query.limit ?? (query.at?.length ? null : HISTORY_DEFAULT_LIMIT);
                 const kinds = query.at?.length || query.contextBefore !== undefined || query.contextAfter !== undefined || query.since !== undefined ? undefined : NON_READ;
                 return (await square.artifact.read((facts) => {
-                    const selected = selectHistory(facts, query, limit, kinds);
+                    const selected = selectHistory(facts, query, limit, kinds, presentation);
                     if (limit === null && selected.totalMatches > HISTORY_MAX_LIMIT) {
                         throw failure(new SquareError('invalid_args', `History context exceeds ${HISTORY_MAX_LIMIT} activities`), {
                             operation: 'history', historyBounds: { maxLimit: HISTORY_MAX_LIMIT, totalMatches: selected.totalMatches },
                         });
                     }
+                    const data = { activities: publicActivities(selected.activities) };
+                    if (!presentation)
+                        return { data, projection: undefined };
                     const indexes = selected.activities.map((activity) => activity.index);
                     const presenceAnchors = {};
                     for (const participant of facts.roster()) {
@@ -539,7 +553,7 @@ export function createSquareApplication(context) {
                             (presenceAnchors[anchor] ??= []).push(participant.name);
                     }
                     return {
-                        data: { activities: publicActivities(selected.activities) },
+                        data,
                         projection: {
                             ...observedContext(square, inSquareCount(facts), facts.hold().active), ...selected,
                             sayNumbers: facts.sayOrdinals(indexes), presenceAnchors,
@@ -554,7 +568,7 @@ export function createSquareApplication(context) {
             return selected('other', async (square, requested) => {
                 const name = (await resolveParticipant(square, requested, control)).name;
                 const targets = await listening(square, name, control);
-                return { data: { listening: targets }, projection: await contextProjection(square, name, control) };
+                return { data: { listening: targets }, projection: !presentation ? undefined : await contextProjection(square, name, control) };
             }, control);
         },
         hold: (reason, control) => lifecycle('hold', reason, control),
@@ -562,15 +576,15 @@ export function createSquareApplication(context) {
         done: (body, control) => lifecycle('done', body, control),
         async status(viewer, control) {
             checkControl(control);
-            const selectedViewer = viewer ?? await actor().catch(() => '');
+            const selectedViewer = !presentation ? '' : viewer ?? await actor().catch(() => '');
             return scoped(async (square) => (await square.artifact.read((facts) => queryStatus(facts, {
                 location: square.location, now: square.clock(), automaticDeliveryAvailable: hasAutomaticDeliveryIdentity(square.env),
-            }, selectedViewer), control?.signal)).value, control);
+            }, selectedViewer, presentation), control?.signal)).value, control);
         },
         participants(control) {
             return scoped(async (square) => (await square.artifact.read((facts) => queryParticipants(facts, {
                 location: square.location, now: square.clock(), automaticDeliveryAvailable: hasAutomaticDeliveryIdentity(square.env),
-            }), control?.signal)).value, control);
+            }, presentation), control?.signal)).value, control);
         },
         async diagnose(control) {
             checkControl(control);
@@ -578,7 +592,7 @@ export function createSquareApplication(context) {
             const data = await diagnoseSquareFile(squarePath);
             return {
                 data,
-                projection: { location: squarePath, now: clock(),
+                projection: !presentation ? undefined : { location: squarePath, now: clock(),
                     ...(data.standingCount === undefined ? {} : { standingCount: data.standingCount }) },
             };
         },
@@ -586,14 +600,14 @@ export function createSquareApplication(context) {
             checkControl(control);
             const squarePath = location();
             const data = await migrateSquareFile(squarePath, control?.signal);
-            return { data, projection: { location: squarePath, now: clock(), standingCount: data.standing } };
+            return { data, projection: !presentation ? undefined : { location: squarePath, now: clock(), standingCount: data.standing } };
         },
         async discover(options, control) {
             checkControl(control);
             const data = await discoverSquares(context.cwd, options, control, openOptions);
             return {
                 data,
-                projection: { cwd: context.cwd, now: clock(),
+                projection: !presentation ? undefined : { cwd: context.cwd, now: clock(),
                     depth: options.depth ?? DEFAULT_LIST_DEPTH, limit: options.limit ?? DEFAULT_LIST_LIMIT },
             };
         },
@@ -633,7 +647,7 @@ export function createSquareApplication(context) {
                 const compare = (left, right) => left < right ? -1 : left > right ? 1 : 0;
                 return compare(a.squarePath, b.squarePath) || compare(nameKey(a.name), nameKey(b.name)) || compare(a.name, b.name);
             });
-            return { data: { rows: rows.slice(0, limit), total: rows.length }, projection: { sessionId, now: clock(), limit } };
+            return { data: { rows: rows.slice(0, limit), total: rows.length }, projection: !presentation ? undefined : { sessionId, now: clock(), limit } };
         },
         async recovery(control) {
             let projection = { now: clock() };
@@ -659,7 +673,7 @@ export function createSquareApplication(context) {
                 }, control);
             }
             catch { /* unavailable recovery observations never replace the original error */ }
-            return { data: projection, projection };
+            return { data: projection, projection: presentation ? projection : undefined };
         },
         stream(options, control) {
             checkControl(control);