@astrosheep/square 0.4.4 → 0.4.5

package/dist/artifact-store.d.ts

@@ -19,7 +19,7 @@ export interface StoreTransaction {
 export declare function requireSquareExtension(location: string): void;
 export declare function storageError(error: unknown, location: string): unknown;
 /** Private storage opening; never creates a missing file. */
-export declare function openExistingSquareDatabase(location: string): DatabaseSync;
+export declare function openExistingSquareDatabase(location: string, readOnly?: boolean): DatabaseSync;
 export declare function abort(signal?: AbortSignal): void;
 /** One ordered connection and transaction lifetime, shared by Channel and Agora compositions. */
 export declare function createArtifactStore(location: string, format: StoreFormat, initialize?: StoreInitializer, externalSignal?: AbortSignal): {

package/dist/artifact-store.js

@@ -6,7 +6,7 @@ import { pathToFileURL } from 'node:url';
 import { setTimeout as sleep } from 'node:timers/promises';
 import { canonicalPath } from './canonical-path.js';
 import { observeFileVersion } from './file-changes.js';
-import { retrySqliteBusy, inSqliteTransaction } from './sqlite-transaction.js';
+import { retrySqliteBusy, inSqliteTransaction, awaitSqliteQueue } from './sqlite-transaction.js';
 import { InternalSquareError, SquareError } from './neutral.js';
 import { readStorageRevision } from './sqlite-framing.js';
 import { invalidArtifact } from './sqlite-values.js';
@@ -24,12 +24,12 @@ export function storageError(error, location) {
     return error;
 }
 /** Private storage opening; never creates a missing file. */
-export function openExistingSquareDatabase(location) {
+export function openExistingSquareDatabase(location, readOnly = false) {
     requireSquareExtension(location);
     const uri = pathToFileURL(path.resolve(location));
-    uri.searchParams.set('mode', 'rw');
+    uri.searchParams.set('mode', readOnly ? 'ro' : 'rw');
     try {
-        return new DatabaseSync(uri.href);
+        return new DatabaseSync(uri.href, { readOnly });
     }
     catch (error) {
         throw storageError(error, location);
@@ -69,10 +69,19 @@ export function createArtifactStore(location, format, initialize, externalSignal
             return database;
         location = await canonical;
         abort(signal);
-        database = openExistingSquareDatabase(location);
+        const probe = await retrySqliteBusy(() => openExistingSquareDatabase(location, true), signal);
         try {
-            await retrySqliteBusy(() => validate(database), signal);
-            database.exec('PRAGMA busy_timeout=0; PRAGMA synchronous=FULL');
+            await retrySqliteBusy(() => validate(probe), signal);
+        }
+        catch (error) {
+            throw storageError(error, location);
+        }
+        finally {
+            probe.close();
+        }
+        database = await retrySqliteBusy(() => openExistingSquareDatabase(location), signal);
+        try {
+            await retrySqliteBusy(() => { validate(database); database.exec('PRAGMA busy_timeout=0; PRAGMA synchronous=FULL'); }, signal);
         }
         catch (error) {
             database.close();
@@ -86,9 +95,10 @@ export function createArtifactStore(location, format, initialize, externalSignal
             throw new TypeError('Square artifact operations cannot nest inside a callback.');
         if (closed)
             return Promise.reject(new Error('Square artifact is closed'));
-        const result = tail.then(() => { abort(signal); return operation(signal); });
+        let started = false;
+        const result = tail.then(() => { abort(signal); started = true; return operation(signal); });
         tail = result.then(() => undefined, () => undefined);
-        return result;
+        return awaitSqliteQueue(result, signal, () => started);
     }
     function transaction(write, callback, signal) {
         return connection(signal).then(db => inSqliteTransaction(db, write, () => validate(db), version => {
@@ -193,7 +203,7 @@ export function createArtifactStore(location, format, initialize, externalSignal
     };
 }
 export async function inspectStore(location, format, select, signal) {
-    const db = openExistingSquareDatabase(location);
+    const db = await retrySqliteBusy(() => openExistingSquareDatabase(location, true), signal);
     return inSqliteTransaction(db, false, () => format.validate(db, location), () => select(db), signal)
         .catch(error => { throw storageError(error, location); }).finally(() => db.close());
 }
@@ -220,9 +230,9 @@ export async function createStoreFile(location, format, initialize, signal) {
     const handle = await fs.promises.open(temporary, 'wx');
     await handle.close();
     try {
-        const db = new DatabaseSync(temporary);
+        const db = await retrySqliteBusy(() => new DatabaseSync(temporary), signal);
         try {
-            db.exec('PRAGMA journal_mode=DELETE; PRAGMA synchronous=FULL');
+            await retrySqliteBusy(() => db.exec('PRAGMA journal_mode=DELETE; PRAGMA synchronous=FULL'), signal);
             await inSqliteTransaction(db, true, () => { }, () => { initialize(db); db.exec(`PRAGMA application_id=${format.applicationId}; PRAGMA user_version=${format.userVersion}`); }, signal);
         }
         finally {
@@ -254,10 +264,17 @@ export async function replaceStoreFile(location, format, initialize, signal) {
     if (await createStoreFile(location, format, db => initialize(db, 0), signal))
         return;
     abort(signal);
-    const db = openExistingSquareDatabase(await canonicalPath(location));
+    location = await canonicalPath(location);
+    const probe = await retrySqliteBusy(() => openExistingSquareDatabase(location, true), signal);
+    try {
+        await retrySqliteBusy(() => format.validate(probe, location), signal);
+    }
+    finally {
+        probe.close();
+    }
+    const db = await retrySqliteBusy(() => openExistingSquareDatabase(location), signal);
     try {
-        await retrySqliteBusy(() => format.validate(db, location), signal);
-        db.exec('PRAGMA busy_timeout=0; PRAGMA synchronous=FULL');
+        await retrySqliteBusy(() => { format.validate(db, location); db.exec('PRAGMA busy_timeout=0; PRAGMA synchronous=FULL'); }, signal);
         await inSqliteTransaction(db, true, () => format.validate(db, location), () => {
             const revision = readStorageRevision(db);
             if (revision === Number.MAX_SAFE_INTEGER)

package/dist/artifact.d.ts

@@ -1,10 +1,7 @@
 import { type BuildOptions } from './model.js';
-import type { SquareResourceOwner, SquareArtifactPort } from './ports.js';
+import type { SquareArtifactPort } from './ports.js';
 import { type SquareState } from './square-sqlite.js';
 export { openExistingSquareDatabase } from './artifact-store.js';
-/** Explicit-lifetime holder of one reused artifact connection. Request cancellation
- * never becomes the shared connection's lifetime; close drains the owner once. */
-export declare function createSquareResourceOwner(): SquareResourceOwner;
 /** All build paths share configuration validation and lazy guide preparation. */
 export declare function prepareSquareBuild(options: Omit<BuildOptions, 'force'>, snippet: string, includeGuides?: boolean): SquareState;
 /** File build owns publication and CLI conflict semantics, not host resources. */

package/dist/artifact.js

@@ -1,4 +1,3 @@
-import path from 'node:path';
 import fs from 'node:fs';
 import { canonicalPath } from './canonical-path.js';
 import { InternalSquareError, SquareError } from './model.js';
@@ -8,33 +7,6 @@ import { resetStorageMeta } from './sqlite-framing.js';
 import { createArtifactStore, createStoreFile, replaceStoreFile, inspectStore, observeStoreRevision } from './artifact-store.js';
 export { openExistingSquareDatabase } from './artifact-store.js';
 const format = squareStoreFormat(resetStorageMeta);
-/** Explicit-lifetime holder of one reused artifact connection. Request cancellation
- * never becomes the shared connection's lifetime; close drains the owner 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)
-                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();
-        },
-    };
-}
 const guideContents = new Map();
 function readGuide(name) {
     if (!['participant', 'architect', 'brainstorm'].includes(name))

package/dist/attention-presentation.js

@@ -41,7 +41,7 @@ export function projectNotification(attention) {
     ];
     return {
         text: [`<square-activity ${attributes.join(' ')}>`, `${description}.`, '', escapeSquareTags(preview),
-            ...(!isFull ? ['', escapeSquareTags(`Use square_catch with location=${JSON.stringify(attention.squarePath)}, as=${JSON.stringify(attention.recipient)}, id=${JSON.stringify(formatActivityId(attention.actIndex))} for the full activity.`)] : []),
+            ...(!isFull ? ['', escapeSquareTags(`Use square_perceive with location=${JSON.stringify(attention.squarePath)}, as=${JSON.stringify(attention.recipient)}, id=${JSON.stringify(formatActivityId(attention.actIndex))} for the full activity.`)] : []),
             '</square-activity>'].join('\n'),
         full: ['<square-activity>', `· ${displayAttentionPath(attention.squarePath)} · ${attention.recipient} · ${formatActivityId(attention.actIndex)}`,
             `● ${description}`, '', body, '</square-activity>'].join('\n'),

package/dist/boundary-presentation.js

@@ -3,9 +3,9 @@ import { deliveryFrameOverhead, renderDeliveryReminder } from './delivery-frame.
 const CONTEXT_MAX = 1200;
 /** The sink must resolve only after the host has actually accepted the output. */
 export async function presentPendingAtBoundary(owner, present, env = process.env, signal) {
-    const ledger = await DeliveryLedger.open({ location: env.SQUARE_DELIVERY });
+    const ledger = await DeliveryLedger.open({ location: env.SQUARE_DELIVERY, signal });
     try {
-        const session = await ledger.session(owner);
+        const session = await ledger.session(owner, signal);
         if (!session || session.state !== 'attached' || signal?.aborted)
             return undefined;
         const claim = await ledger.claimPresentation(owner, { generation: session.generation, budgetChars: CONTEXT_MAX - deliveryFrameOverhead({ tagged: true }), signal });

package/dist/claude-boundary-state.d.ts

@@ -9,12 +9,12 @@ declare const stateSchema: z.ZodObject<{
 export type ClaudeBoundary = z.infer<typeof stateSchema>;
 /** Receiver operational facts only: no cards, claims, or payload copies. */
 export declare function claudeBoundaryStore(session: string, env: NodeJS.ProcessEnv): {
-    start(attach: () => Promise<string | false>): Promise<void>;
-    end(): Promise<ClaudeBoundary | undefined>;
-    prompt(promptId: string | undefined): Promise<void>;
-    capture(promptId: string): Promise<ClaudeBoundary | undefined>;
-    current(captured: ClaudeBoundary): Promise<boolean>;
-    consume(captured: ClaudeBoundary): Promise<void>;
+    start(attach: () => Promise<string | false>, signal?: AbortSignal): Promise<void>;
+    end(signal?: AbortSignal): Promise<ClaudeBoundary | undefined>;
+    prompt(promptId: string | undefined, signal?: AbortSignal): Promise<void>;
+    capture(promptId: string, signal?: AbortSignal): Promise<ClaudeBoundary | undefined>;
+    current(captured: ClaudeBoundary, signal?: AbortSignal): Promise<boolean>;
+    consume(captured: ClaudeBoundary, signal?: AbortSignal): Promise<void>;
     watch<T>(signal: AbortSignal, run: () => Promise<T>): Promise<T>;
 };
 export {};

package/dist/claude-boundary-state.js

@@ -13,10 +13,10 @@ export function claudeBoundaryStore(session, env) {
     const root = path.join(path.dirname(deliveryLedgerLocation(env)), 'claude-hooks');
     const key = createHash('sha256').update(session).digest('hex');
     const file = path.join(root, `${key}.json`);
-    async function mutate(change) {
+    async function mutate(change, signal) {
         await fs.mkdir(root, { recursive: true, mode: 0o700 });
         await fs.chmod(root, 0o700);
-        return withFileLock(path.join(root, `${key}.lock`), { retryMs: 10, signal: AbortSignal.timeout(2500) }, async () => {
+        return withFileLock(path.join(root, `${key}.lock`), { retryMs: 10, signal: signal ?? AbortSignal.timeout(2500) }, async () => {
             let state;
             try {
                 state = stateSchema.parse(JSON.parse(await fs.readFile(file, 'utf8')));
@@ -40,37 +40,37 @@ export function claudeBoundaryStore(session, env) {
     const matches = (state, captured) => !!state && !state.ended && !state.consumed
         && state.generation === captured.generation && state.promptId === captured.promptId && state.stopEpoch === captured.stopEpoch;
     return {
-        async start(attach) {
+        async start(attach, signal) {
             await mutate(async (state, save) => {
                 if (state)
                     await save({ ...state, promptId: undefined, ended: true, stopEpoch: randomUUID() });
                 const generation = await attach();
                 if (generation)
                     await save({ generation, stopEpoch: randomUUID(), consumed: false, ended: false });
-            });
+            }, signal);
         },
-        async end() {
+        async end(signal) {
             return mutate(async (state, save) => {
                 if (state)
                     await save({ ...state, ended: true, stopEpoch: randomUUID() });
                 return state;
-            });
+            }, signal);
         },
-        async prompt(promptId) {
+        async prompt(promptId, signal) {
             await mutate(async (state, save) => {
                 if (state && !state.ended)
                     await save({ ...state, promptId, stopEpoch: randomUUID(), consumed: false });
-            });
+            }, signal);
         },
-        capture(promptId) {
-            return mutate(async (state) => state && !state.ended && !state.consumed && state.promptId === promptId ? state : undefined);
+        capture(promptId, signal) {
+            return mutate(async (state) => state && !state.ended && !state.consumed && state.promptId === promptId ? state : undefined, signal);
         },
-        current(captured) { return mutate(async (state) => matches(state, captured)); },
-        async consume(captured) {
+        current(captured, signal) { return mutate(async (state) => matches(state, captured), signal); },
+        async consume(captured, signal) {
             await mutate(async (state, save) => {
                 if (matches(state, captured))
                     await save({ ...state, consumed: true });
-            });
+            }, signal);
         },
         async watch(signal, run) {
             await fs.mkdir(root, { recursive: true, mode: 0o700 });

package/dist/claude-hook.js

@@ -53,43 +53,44 @@ export async function runClaudeHook(text, env = process.env, sink = value => { p
             await denyMcpTool(sink);
         return '';
     }
+    const signal = AbortSignal.timeout(4500);
     const boundaries = claudeBoundaryStore(input.session_id, env);
     const mainOwner = ownerFor(input);
     const owner = harnessOwner({ channel: 'claude-code', session: input.session_id, ...(input.agent_id === undefined ? {} : { agent: input.agent_id }) });
     if (input.hook_event_name === 'SessionStart') {
         await boundaries.start(async () => {
-            const session = await attachDeliverySessionRoutes(mainOwner, env, [{ kind: route, address: { sessionId: input.session_id } }], AbortSignal.timeout(4500));
+            const session = await attachDeliverySessionRoutes(mainOwner, env, [{ kind: route, address: { sessionId: input.session_id } }], signal);
             if (!session)
                 return false;
-            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env) });
+            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env), signal });
             try {
-                await ledger.updateRoutes({ owner: mainOwner, generation: session.generation, routes: session.routes.filter(item => item.kind !== 'claude-native') });
+                await ledger.updateRoutes({ owner: mainOwner, generation: session.generation, routes: session.routes.filter(item => item.kind !== 'claude-native') }, signal);
             }
             finally {
                 await ledger.close();
             }
             return session.generation;
-        });
+        }, signal);
         return '';
     }
     if (input.hook_event_name === 'SessionEnd') {
-        const captured = await boundaries.end();
+        const captured = await boundaries.end(signal);
         if (captured)
-            await detachDeliverySession(mainOwner, captured.generation, env);
+            await detachDeliverySession(mainOwner, captured.generation, env, signal);
         return '';
     }
     if (input.hook_event_name === 'UserPromptSubmit') {
-        await boundaries.prompt(input.prompt_id);
+        await boundaries.prompt(input.prompt_id, signal);
         if (!input.prompt_id)
             return '';
         if (input.prompt) {
-            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env) });
+            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env), signal });
             try {
                 for (const frame of observedFrames(input.prompt)) {
-                    const handoff = await ledger.handoff(frame.token);
+                    const handoff = await ledger.handoff(frame.token, signal);
                     if (!handoff || handoff.owner !== owner || handoff.routeKind !== route || handoff.payloadHash !== frame.payloadHash)
                         continue;
-                    await ledger.observePresentation(handoff);
+                    await ledger.observePresentation(handoff, undefined, signal);
                 }
             }
             finally {
@@ -98,7 +99,7 @@ export async function runClaudeHook(text, env = process.env, sink = value => { p
         }
         await presentPendingAtBoundary(owner, async (context) => {
             await sink(`${JSON.stringify({ hookSpecificOutput: { hookEventName: 'UserPromptSubmit', additionalContext: context } })}\n`);
-        }, env, AbortSignal.timeout(4500));
+        }, env, signal);
         return '';
     }
     if (input.hook_event_name === 'PreToolUse' && input.tool_name?.startsWith('mcp__plugin_square_square__')) {
@@ -107,7 +108,7 @@ export async function runClaudeHook(text, env = process.env, sink = value => { p
             return '';
         }
         try {
-            await beginClaudeMcpCall({ toolUseId: input.tool_use_id, sessionId: input.session_id, cwd: input.cwd, agentId: input.agent_id }, env);
+            await beginClaudeMcpCall({ toolUseId: input.tool_use_id, sessionId: input.session_id, cwd: input.cwd, agentId: input.agent_id }, env, signal);
         }
         catch {
             await denyMcpTool(sink);
@@ -116,12 +117,12 @@ export async function runClaudeHook(text, env = process.env, sink = value => { p
     }
     if ((input.hook_event_name === 'PostToolUse' || input.hook_event_name === 'PostToolUseFailure')
         && input.tool_name?.startsWith('mcp__plugin_square_square__') && input.tool_use_id) {
-        await endClaudeMcpCallForSession(input.tool_use_id, input.session_id, env, input.agent_id).catch(() => undefined);
+        await endClaudeMcpCallForSession(input.tool_use_id, input.session_id, env, input.agent_id, signal).catch(() => undefined);
     }
     if (input.hook_event_name === 'PostToolUse') {
         await presentPendingAtBoundary(owner, async (context) => {
             await sink(`${JSON.stringify({ hookSpecificOutput: { hookEventName: input.hook_event_name, additionalContext: context } })}\n`);
-        }, env, AbortSignal.timeout(4500));
+        }, env, signal);
     }
     return '';
 }
@@ -151,24 +152,24 @@ export async function runClaudeWatch(text, env = process.env, signal, output = f
     process.once('SIGINT', stop);
     const combined = signal ? AbortSignal.any([signal, controller.signal]) : controller.signal;
     try {
-        const captured = await boundaries.capture(input.prompt_id);
+        const captured = await boundaries.capture(input.prompt_id, combined);
         if (!captured)
             return '';
         await boundaries.watch(combined, async () => {
-            if (!await boundaries.current(captured))
+            if (!await boundaries.current(captured, combined))
                 return;
-            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env) });
+            const ledger = await DeliveryLedger.open({ location: deliveryLedgerLocation(env), signal: combined });
             const lifetime = retainDeliveryLedger(ledger);
             const observer = await ledger.observe(owner);
             try {
                 while (!combined.aborted) {
                     let version = await observer.read(combined);
-                    const live = await boundaries.current(captured);
-                    const session = await ledger.session(owner);
+                    const live = await boundaries.current(captured, combined);
+                    const session = await ledger.session(owner, combined);
                     if (!live || session?.state !== 'attached' || session.generation !== captured.generation || !session.routes.some(item => item.kind === route))
                         return;
-                    const cards = await ledger.pending(owner, { generation: captured.generation });
-                    const held = new Set((await ledger.handoffs(owner, { generation: captured.generation }))
+                    const cards = await ledger.pending(owner, { generation: captured.generation }, combined);
+                    const held = new Set((await ledger.handoffs(owner, { generation: captured.generation }, combined))
                         .filter(attempt => !['failed', 'released'].includes(attempt.outcome)).map(attempt => attempt.seq));
                     for (const card of cards) {
                         if (held.has(card.seq))
@@ -182,18 +183,18 @@ export async function runClaudeWatch(text, env = process.env, signal, output = f
                                 const payloadHash = createHash('sha256').update(frame).digest('hex');
                                 if (!await context.prepare({ token: context.token, messageId: context.token, payloadHash }))
                                     return 'not-capable';
-                                const currentSession = await ledger.session(owner);
+                                const currentSession = await ledger.session(owner, context.signal);
                                 if (currentSession?.state !== 'attached' || currentSession.generation !== captured.generation
                                     || !currentSession.routes.some(item => item.kind === route) || !await context.beforeSend())
                                     return 'not-capable';
-                                const native = await boundaries.current(captured);
+                                const native = await boundaries.current(captured, context.signal);
                                 if (!native || context.signal.aborted || Date.now() >= context.deadline)
                                     return 'not-capable';
                                 try {
                                     await output(frame);
                                 }
                                 finally {
-                                    await boundaries.consume(captured);
+                                    await boundaries.consume(captured, AbortSignal.timeout(5000));
                                 }
                                 process.exitCode = 2;
                                 return 'unknown';

package/dist/claude-mcp-context.d.ts

@@ -6,10 +6,10 @@ declare const coordinate: z.ZodObject<{
     agentId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type ClaudeMcpCall = z.infer<typeof coordinate>;
-export declare function beginClaudeMcpCall(input: ClaudeMcpCall, env?: NodeJS.ProcessEnv): Promise<{
+export declare function beginClaudeMcpCall(input: ClaudeMcpCall, env?: NodeJS.ProcessEnv, signal?: AbortSignal): Promise<{
     token: string;
 }>;
 export declare function endClaudeMcpCall(toolUseId: string, token: string, env?: NodeJS.ProcessEnv): Promise<void>;
-export declare function endClaudeMcpCallForSession(toolUseId: string, sessionId: string, env?: NodeJS.ProcessEnv, agentId?: string): Promise<void>;
+export declare function endClaudeMcpCallForSession(toolUseId: string, sessionId: string, env?: NodeJS.ProcessEnv, agentId?: string, signal?: AbortSignal): Promise<void>;
 export declare function readClaudeMcpCall(toolUseId: unknown, env?: NodeJS.ProcessEnv): Promise<ClaudeMcpCall>;
 export {};

package/dist/claude-mcp-context.js

@@ -26,13 +26,13 @@ async function readRecord(file) {
 }
 // Only publishers/cleanup mutate this private transport directory. Readers see an
 // immutable record via atomic rename, so they need neither a lock nor housekeeping.
-async function mutate(env, fn) {
+async function mutate(env, fn, signal) {
     const root = storeRoot(env);
     await fs.mkdir(root, { recursive: true, mode: 0o700 });
     await fs.chmod(root, 0o700);
-    return withFileLock(path.join(root, 'store.lock'), { retryMs: 10, signal: AbortSignal.timeout(2000) }, () => fn(root));
+    return withFileLock(path.join(root, 'store.lock'), { retryMs: 10, signal: signal ?? AbortSignal.timeout(2000) }, () => fn(root));
 }
-export async function beginClaudeMcpCall(input, env = process.env) {
+export async function beginClaudeMcpCall(input, env = process.env, signal) {
     const parsed = coordinate.safeParse(input);
     if (!parsed.success)
         throw unavailable();
@@ -59,7 +59,7 @@ export async function beginClaudeMcpCall(input, env = process.env) {
             await fs.rm(temporary, { force: true });
         }
         return { token };
-    });
+    }, signal);
 }
 export async function endClaudeMcpCall(toolUseId, token, env = process.env) {
     if (!text.safeParse(toolUseId).success || !text.safeParse(token).success)
@@ -71,7 +71,7 @@ export async function endClaudeMcpCall(toolUseId, token, env = process.env) {
             await fs.unlink(file);
     });
 }
-export async function endClaudeMcpCallForSession(toolUseId, sessionId, env = process.env, agentId) {
+export async function endClaudeMcpCallForSession(toolUseId, sessionId, env = process.env, agentId, signal) {
     if (!text.safeParse(toolUseId).success || !text.safeParse(sessionId).success)
         throw unavailable();
     await mutate(env, async (root) => {
@@ -79,7 +79,7 @@ export async function endClaudeMcpCallForSession(toolUseId, sessionId, env = pro
         const stored = await readRecord(file);
         if (stored?.toolUseId === toolUseId && stored.sessionId === sessionId && stored.agentId === agentId)
             await fs.unlink(file);
-    });
+    }, signal);
 }
 export async function readClaudeMcpCall(toolUseId, env = process.env) {
     if (!text.safeParse(toolUseId).success)

package/dist/cli/context.js

@@ -92,7 +92,7 @@ const LOCATION_REQUIRED_COMMANDS = new Set([
     'build',
     'stream',
     'join',
-    'catch',
+    'perceive',
     'express',
     'listen',
     'ignore',
@@ -130,13 +130,10 @@ export async function parseGlobalArgs(rawArgs) {
     if (name !== undefined)
         validateName(name);
     const explicitSquarePath = requestedPath !== undefined;
-    const configuredLocation = process.env.SQUARE_LOCATION?.trim();
-    const configured = configuredLocation === '' ? undefined : configuredLocation;
-    if (command !== undefined && !['--help', '-h'].includes(command) && locationIsRequired(command) && requestedPath === undefined && configured === undefined) {
+    if (command !== undefined && !['--help', '-h'].includes(command) && locationIsRequired(command) && requestedPath === undefined) {
         fail(`✕ ${command} needs a square location\nsquare ls`);
     }
-    const squarePath = requestedPath ?? configured;
-    return { squarePath, explicitSquarePath: explicitSquarePath || configured !== undefined, multipleSquares: false, name, owner, args };
+    return { squarePath: requestedPath, explicitSquarePath, multipleSquares: false, name, owner, args };
 }
 export function locationIsRequired(command) {
     return LOCATION_REQUIRED_COMMANDS.has(command);

package/dist/cli/json.js

@@ -1,5 +1,5 @@
 export const JSON_COMMANDS = new Set([
-    'join', 'express', 'catch', 'history', 'listen', 'ignore', 'unlisten', 'listening',
+    'join', 'express', 'perceive', 'history', 'listen', 'ignore', 'unlisten', 'listening',
     'done', 'status', 'participants', 'inbox',
 ]);
 /** Serialize the SDK receipt, not its optional presentation or live participant handle. */

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

@@ -1,13 +1,13 @@
-import { fail, squareInput, commandIdentity } from './context.js';
+import { fail, commandIdentity } from './context.js';
 export const mcpServerCommand = {
     parse(argv) {
         if (argv.length > 0)
-            fail('Usage: square [--location <square>] [--as <name>] mcp-server');
+            fail('Usage: square mcp-server');
         return undefined;
     },
     async execute(_intent, context) {
         const { runSquareMcpStdio } = await import('../mcp.js');
-        await runSquareMcpStdio({ ...squareInput(context), ...commandIdentity(context.env, context.owner) });
+        await runSquareMcpStdio({ cwd: context.cwd, env: context.env, ...commandIdentity(context.env, context.owner) });
     },
     present() { },
 };

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

@@ -1,4 +1,4 @@
-import type { CatchOptions, DiscoveryOptions, HistoryQuery, StreamStart } from '../square-facade.js';
+import type { PerceiveOptions, DiscoveryOptions, HistoryQuery, StreamStart } from '../square-facade.js';
 import { type CommandSpec } from './context.js';
 interface HistoryCommandOptions {
     query: HistoryQuery;
@@ -13,7 +13,7 @@ interface StreamIntent {
     start: StreamStart;
 }
 export declare const streamCommand: CommandSpec<StreamIntent>;
-export declare const catchCommand: CommandSpec<CatchOptions>;
+export declare const perceiveCommand: CommandSpec<PerceiveOptions>;
 export declare const historyCommand: CommandSpec<HistoryCommandOptions, string>;
 interface ParticipantsCommandOptions {
     limit: number;