@astrosheep/square 0.3.26 → 0.3.28

package/claude-plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.26",
+  "version": "0.3.28",
   "description": "Native Claude Code turn-boundary delivery for Square participants",
   "author": {
     "name": "Square"

package/codex-plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.26",
+  "version": "0.3.28",
   "description": "Shared Square activity with reliable participant attention at Codex boundaries.",
   "author": {
     "name": "Square"

package/dist/artifact.d.ts

@@ -14,7 +14,7 @@ export declare function createSquareState(options: BuildOptions & {
 }, snippet: string): SquareState;
 export declare function encodeSquare(squareState: SquareState): Buffer;
 export declare function decodeSquare(bytes: Buffer): SquareState;
-export declare function writeSquareFile(squarePath: string, squareState: SquareState): void;
-export declare function loadSquare(squarePath: string): SquareState;
-export declare function probeSquare(squarePath: string): SquareState | undefined;
-export declare function diagnoseSquareFile(squarePath: string): DiagnoseResult;
+export declare function writeSquareFile(squarePath: string, squareState: SquareState): Promise<void>;
+export declare function loadSquare(squarePath: string): Promise<SquareState>;
+export declare function probeSquare(squarePath: string): Promise<SquareState | undefined>;
+export declare function diagnoseSquareFile(squarePath: string): Promise<DiagnoseResult>;

package/dist/artifact.js

@@ -10,6 +10,8 @@ const LENGTH_BYTES = 4;
 const DIGEST_BYTES = 32;
 const HEADER_BYTES = SQUARE_MAGIC.length + LENGTH_BYTES + DIGEST_BYTES;
 const utf8 = new TextDecoder('utf-8', { fatal: true });
+const guideNames = ['participant', 'architect', 'brainstorm'];
+const guideContents = new Map(await Promise.all(guideNames.map(async (name) => [name, (await fs.promises.readFile(new URL(`../guides/${name}.md`, import.meta.url), 'utf8')).trim()])));
 function invalidArtifact(detail) {
     return new SquareError('invalid_args', `Invalid square artifact: ${detail}`);
 }
@@ -260,7 +262,10 @@ function normalizedLines(value) {
 }
 function readGuide(name) {
     try {
-        return fs.readFileSync(new URL(`../guides/${name}.md`, import.meta.url), 'utf8').trim();
+        const guide = guideContents.get(name);
+        if (guide === undefined)
+            throw Object.assign(new Error('missing guide'), { code: 'ENOENT' });
+        return guide;
     }
     catch (error) {
         if (error.code === 'ENOENT') {
@@ -288,9 +293,9 @@ export function encodeSquare(squareState) {
 export function decodeSquare(bytes) {
     return validateSquareState(decodeEnvelope(bytes, SQUARE_MAGIC));
 }
-function readArtifact(squarePath) {
+async function readArtifact(squarePath) {
     try {
-        return fs.readFileSync(squarePath);
+        return await fs.promises.readFile(squarePath);
     }
     catch (error) {
         if (error.code === 'ENOENT') {
@@ -304,37 +309,37 @@ function requireSquareExtension(squarePath) {
         throw new SquareError('invalid_args', `Square artifacts must use the .square extension: ${squarePath}`);
     }
 }
-function atomicWrite(target, bytes) {
+async function atomicWrite(target, bytes) {
     const temporary = path.join(path.dirname(target), `.${path.basename(target)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`);
-    fs.mkdirSync(path.dirname(target), { recursive: true });
+    await fs.promises.mkdir(path.dirname(target), { recursive: true });
     try {
-        fs.writeFileSync(temporary, bytes);
-        fs.renameSync(temporary, target);
+        await fs.promises.writeFile(temporary, bytes);
+        await fs.promises.rename(temporary, target);
     }
     catch (error) {
         try {
-            fs.unlinkSync(temporary);
+            await fs.promises.unlink(temporary);
         }
         catch { }
         throw error;
     }
 }
-export function writeSquareFile(squarePath, squareState) {
+export async function writeSquareFile(squarePath, squareState) {
     requireSquareExtension(squarePath);
-    atomicWrite(squarePath, encodeSquare(squareState));
+    await atomicWrite(squarePath, encodeSquare(squareState));
 }
-export function loadSquare(squarePath) {
+export async function loadSquare(squarePath) {
     requireSquareExtension(squarePath);
-    return decodeSquare(readArtifact(squarePath));
+    return decodeSquare(await readArtifact(squarePath));
 }
-export function probeSquare(squarePath) {
+export async function probeSquare(squarePath) {
     if (!squarePath.endsWith('.square'))
         return undefined;
     let descriptor;
     try {
-        descriptor = fs.openSync(squarePath, 'r');
+        descriptor = await fs.promises.open(squarePath, 'r');
         const magic = Buffer.alloc(SQUARE_MAGIC.length);
-        if (fs.readSync(descriptor, magic, 0, magic.length, 0) !== magic.length || !magic.equals(SQUARE_MAGIC)) {
+        if ((await descriptor.read(magic, 0, magic.length, 0)).bytesRead !== magic.length || !magic.equals(SQUARE_MAGIC)) {
             return undefined;
         }
     }
@@ -343,18 +348,18 @@ export function probeSquare(squarePath) {
     }
     finally {
         if (descriptor !== undefined)
-            fs.closeSync(descriptor);
+            await descriptor.close();
     }
     try {
-        return loadSquare(squarePath);
+        return await loadSquare(squarePath);
     }
     catch {
         return undefined;
     }
 }
-export function diagnoseSquareFile(squarePath) {
+export async function diagnoseSquareFile(squarePath) {
     try {
-        return { problems: [], state: loadSquare(squarePath) };
+        return { problems: [], state: await loadSquare(squarePath) };
     }
     catch (error) {
         return {

package/dist/cli/context.d.ts

@@ -10,9 +10,9 @@ export interface CommandSpec<Intent = unknown, Result = void> {
     execute(intent: Intent, context: CommandContext): Promise<Result> | Result;
     present(result: Result, context: CommandContext): void;
 }
-export declare function readStdinSync(): string;
-export declare function resolveBody(arg: string): string;
-export declare function readPipedBodyFallback(): string | undefined;
+export declare function readStdin(): Promise<string>;
+export declare function resolveBody(arg: string): Promise<string>;
+export declare function readPipedBodyFallback(): Promise<string | undefined>;
 export declare function fail(message: string, exitCode?: number): never;
 export declare function usage(command: string): never;
 export declare function requireValue(args: string[], index: number, flag: string): string;

package/dist/cli/context.js

@@ -1,23 +1,25 @@
-import fs from 'node:fs';
 import os from 'node:os';
 import { commandUsageHint } from '../help.js';
 import { parseParticipantList, validateName } from '../model.js';
 import { localParticipantName } from '../registry.js';
-export function readStdinSync() {
+export async function readStdin() {
     try {
-        return fs.readFileSync(0, 'utf8');
+        let content = '';
+        for await (const chunk of process.stdin.setEncoding('utf8'))
+            content += chunk;
+        return content;
     }
     catch {
         return '';
     }
 }
-export function resolveBody(arg) {
-    return arg === '-' ? readStdinSync() : arg;
+export async function resolveBody(arg) {
+    return arg === '-' ? readStdin() : arg;
 }
-export function readPipedBodyFallback() {
+export async function readPipedBodyFallback() {
     if (process.stdin.isTTY)
         return undefined;
-    const content = readStdinSync();
+    const content = await readStdin();
     return content.trim() === '' ? undefined : content;
 }
 export function fail(message, exitCode = 2) {

package/dist/cli/maintenance-commands.js

@@ -8,9 +8,9 @@ export const doctorCommand = {
             usage(context.command);
         return undefined;
     },
-    execute(_intent, context) {
+    async execute(_intent, context) {
         const squarePath = requireSquarePath(context);
-        const diagnosis = diagnoseSquareFile(squarePath);
+        const diagnosis = await diagnoseSquareFile(squarePath);
         if (diagnosis.unfixable !== undefined || diagnosis.state === undefined) {
             return {
                 output: withPathOutput(squarePath, renderDoctorUnfixable(diagnosis.unfixable ?? 'the snapshot could not be decoded')),

package/dist/cli/observation-commands.js

@@ -12,7 +12,7 @@ import { cmdWatch } from '../watch.js';
 import { openSquare } from '../square-file-adapter.js';
 import { closeOpenSquare } from '../open-square.js';
 import { historyPresentation, participantsPresentation, statusPresentation } from '../views.js';
-import { fail, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdinSync, requireParticipant, requireSquarePath, requireValue, usage, } from './context.js';
+import { fail, parseDurationMs, parseNameList, parseNonNegativeInteger, readStdin, requireParticipant, requireSquarePath, requireValue, usage, } from './context.js';
 const STATUS_PARTICIPANT_PREVIEW_LIMIT = 10;
 export const listCommand = {
     parse: (argv) => argv,
@@ -470,7 +470,7 @@ function hookCommand(runHook) {
     return {
         parse(argv, context) { if (argv.length > 0)
             usage(context.command); return undefined; },
-        execute: () => runHook(readStdinSync()),
+        execute: async () => runHook(await readStdin()),
         present: (result) => process.stdout.write(result),
     };
 }

package/dist/cli/square-commands.js

@@ -8,7 +8,7 @@ import { createSquare, openSquare } from '../square-file-adapter.js';
 import { closeOpenSquare } from '../open-square.js';
 import { openParticipant, Square } from '../square-wiring.js';
 import { entryPresentation, eventPresentation } from '../views.js';
-import { fail, parseHardCap, parsePositiveInteger, readPipedBodyFallback, readStdinSync, requireParticipant, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
+import { fail, parseHardCap, parsePositiveInteger, readStdin, requireParticipant, requireSquarePath, requireValue, resolveBody, usage, } from './context.js';
 function parseBuild(argv) {
     const options = { force: false, hardCap: null };
     for (let index = 0; index < argv.length; index++) {
@@ -41,16 +41,16 @@ function parseBuild(argv) {
     if (options.throttlePerMinute !== undefined && options.throttlePerMinute <= 0) {
         fail('Invalid build option: --throttle must be a positive integer.');
     }
-    const snippet = readStdinSync();
-    if (snippet.trim() === '')
-        fail('Missing Markdown body snippet on stdin.');
-    return { options, snippet };
+    return { options, snippet: '' };
 }
 export const buildCommand = {
     parse: (argv) => parseBuild(argv),
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        await createSquare(squarePath, intent.options, intent.snippet);
+        const snippet = await readStdin();
+        if (snippet.trim() === '')
+            fail('Missing Markdown body snippet on stdin.');
+        await createSquare(squarePath, intent.options, snippet);
         const cap = intent.options.hardCap === null ? 'unlimited' : formatHardCap(intent.options.hardCap);
         const throttle = intent.options.throttlePerMinute === undefined ? [] : [`  · throttle ${intent.options.throttlePerMinute}/min`];
         return withPathOutput(squarePath, ['✓ built', `  · cap ${cap}`, ...throttle, '  · participants (none seeded — first join adds names)'].join('\n'), { participantCount: 0 });
@@ -164,9 +164,8 @@ function parseActivity(argv, context) {
     const reach = bell ? 'bell' : undefined;
     if (bodyArgs.length !== 1) {
         if (bodyArgs.length === 0) {
-            const piped = readPipedBodyFallback();
-            if (piped !== undefined)
-                return { name: requireParticipant(context.name), activity: piped, force, noWait, reach, reply };
+            if (!process.stdin.isTTY)
+                return { name: requireParticipant(context.name), activity: '-', force, noWait, reach, reply };
         }
         fail("express requires a body argument (a quoted string or '-' with piped stdin)");
     }
@@ -177,7 +176,7 @@ export const expressCommand = {
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
         await sweepPendingNotifications(squarePath);
-        const body = resolveBody(intent.activity);
+        const body = await resolveBody(intent.activity);
         const reachArg = intent.reach === 'bell' ? ' --bell' : '';
         await cmdActivity(squarePath, intent.name, body, (value) => value, {
             force: intent.force,
@@ -269,13 +268,13 @@ export const listeningCommand = {
 function parseDone(argv, context) {
     if (argv.length > 1)
         usage(context.command);
-    return { name: requireParticipant(context.name), body: argv.length === 1 ? argv[0] : readPipedBodyFallback() };
+    return { name: requireParticipant(context.name), body: argv.length === 1 ? argv[0] : undefined };
 }
 export const doneCommand = {
     parse: parseDone,
     async execute(intent, context) {
         const squarePath = requireSquarePath(context);
-        const body = resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim();
+        const body = (await resolveBody(intent.body ?? (process.stdin.isTTY ? '' : '-'))).replace(/\r\n/g, '\n').trim();
         const square = await Square.at({ path: squarePath, clock: nowMs, notifier: wakeNotifierForSquare(squarePath) });
         const participant = await square.join(intent.name);
         const result = await participant.done(body);
@@ -300,7 +299,7 @@ export const holdCommand = {
         const square = await Square.at({ path: squarePath, clock: nowMs, notifier: wakeNotifierForSquare(squarePath) });
         try {
             const participant = await square.join(intent.name);
-            const result = await participant.hold(resolveBody(intent.body ?? '').replace(/\r\n/g, '\n').trim());
+            const result = await participant.hold((await resolveBody(intent.body ?? '')).replace(/\r\n/g, '\n').trim());
             await square.close();
             const presentationSquare = await openSquare(squarePath, { clock: nowMs });
             const presentation = await eventPresentation(presentationSquare, result.activity.id);

package/dist/harness-links.d.ts

@@ -11,7 +11,8 @@ export type OpenCodeCommandRunner = (homeDir: string, args: string[]) => {
     stdout: string;
     stderr: string;
 };
+export declare function installOpenCodePlugin(homeDir: string, force?: boolean, run?: OpenCodeCommandRunner): string[];
+export declare function uninstallOpenCodePlugin(homeDir: string): string[];
 /** Verify that OpenCode accepts its resolved runtime configuration after links are installed. */
 export declare function verifyOpenCodeRuntime(homeDir: string, run?: OpenCodeCommandRunner): string;
 export declare function skillLinks(homeDir?: string, parents?: Array<'.claude' | '.agents'>): HarnessLink[];
-export declare function opencodeExtensionLink(homeDir?: string): HarnessLink;

package/dist/harness-links.js

@@ -1,8 +1,9 @@
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
+import { fileURLToPath } from 'node:url';
 import crossSpawn from 'cross-spawn';
+import { SQUARE_IDENTITY } from './identity.js';
 function packageRoot() {
     // Emitted modules live in dist; package assets are one level above them.
     return fileURLToPath(new URL('../', import.meta.url));
@@ -83,6 +84,42 @@ function runOpenCode(homeDir, args) {
         throw result.error;
     return { status: result.status ?? 1, stdout: result.stdout || '', stderr: result.stderr || '' };
 }
+function requireOpenCodeSuccess(result, action) {
+    if (result.status === 0)
+        return;
+    throw new Error(`OpenCode ${action} failed: ${result.stderr.trim() || result.stdout.trim() || `exit ${result.status}`}`);
+}
+export function installOpenCodePlugin(homeDir, force = false, run = runOpenCode) {
+    const args = ['plugin', SQUARE_IDENTITY.packageName, '--global'];
+    if (force)
+        args.push('--force');
+    requireOpenCodeSuccess(run(homeDir, args), 'plugin install');
+    return [SQUARE_IDENTITY.packageName];
+}
+function configPath(homeDir) {
+    const configHome = process.env.XDG_CONFIG_HOME ?? path.join(homeDir, '.config');
+    return path.join(configHome, 'opencode', 'opencode.jsonc');
+}
+function removeConfiguredPlugin(homeDir) {
+    const target = configPath(homeDir);
+    let source;
+    try {
+        source = fs.readFileSync(target, 'utf8');
+    }
+    catch {
+        return false;
+    }
+    const escaped = SQUARE_IDENTITY.packageName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const packageLine = new RegExp(`^\\s*"${escaped}(?:@[^"\\n]+)?"\\s*,?\\s*$`, 'm');
+    const next = source.replace(packageLine, '');
+    if (next === source)
+        return false;
+    fs.writeFileSync(target, next);
+    return true;
+}
+export function uninstallOpenCodePlugin(homeDir) {
+    return removeConfiguredPlugin(homeDir) ? [SQUARE_IDENTITY.packageName] : [];
+}
 /** Verify that OpenCode accepts its resolved runtime configuration after links are installed. */
 export function verifyOpenCodeRuntime(homeDir, run = runOpenCode) {
     try {
@@ -98,10 +135,10 @@ export function verifyOpenCodeRuntime(homeDir, run = runOpenCode) {
             return '✕ OpenCode debug config returned invalid JSON';
         }
         const plugin = config.config?.plugin;
-        const expected = pathToFileURL(opencodeExtensionLink(homeDir).target).href;
+        const expected = SQUARE_IDENTITY.packageName;
         if (Array.isArray(plugin) && plugin.includes(expected))
-            return '✓ OpenCode debug config loaded';
-        return `○ OpenCode plugin not loaded: ${expected}`;
+            return '✓ OpenCode npm plugin loaded';
+        return `○ OpenCode npm plugin not loaded: ${expected}`;
     }
     catch (error) {
         return `○ OpenCode runtime unavailable (${error instanceof Error ? error.message : String(error)})`;
@@ -114,11 +151,3 @@ export function skillLinks(homeDir = os.homedir(), parents = ['.claude', '.agent
         kind: 'skill',
     })));
 }
-export function opencodeExtensionLink(homeDir = os.homedir()) {
-    const configHome = process.env.XDG_CONFIG_HOME ?? path.join(homeDir, '.config');
-    return {
-        source: path.join(packageRoot(), 'extensions', 'square-opencode.js'),
-        target: path.join(configHome, 'opencode', 'plugins', 'square.js'),
-        kind: 'extension',
-    };
-}

package/dist/harness.js

@@ -4,7 +4,7 @@ import { wakeGraceMs } from './notifications.js';
 import { doctorClaudePlugin, installClaudePlugin, uninstallClaudePlugin, } from './harness-claude.js';
 import { doctorCodexPlugin, installCodexPlugin, uninstallCodexPlugin, } from './harness-codex.js';
 import { doctorPiPackage, installPiPackage, uninstallPiPackage, } from './harness-pi.js';
-import { doctorHarnessLinks, installHarnessLinks, opencodeExtensionLink, skillLinks, uninstallHarnessLinks, verifyOpenCodeRuntime, } from './harness-links.js';
+import { doctorHarnessLinks, installHarnessLinks, installOpenCodePlugin, skillLinks, uninstallOpenCodePlugin, uninstallHarnessLinks, verifyOpenCodeRuntime, } from './harness-links.js';
 function result(lines, notes = []) {
     return { lines, notes };
 }
@@ -17,7 +17,7 @@ async function doctorHost(label, inspect) {
     }
 }
 function openCodeLinks(homeDir) {
-    return [opencodeExtensionLink(homeDir), ...skillLinks(homeDir, ['.agents'])];
+    return skillLinks(homeDir, ['.agents']);
 }
 function readableSquarePath(squarePath) {
     if (squarePath === undefined)
@@ -65,9 +65,15 @@ const TARGETS = [
     {
         name: 'opencode',
         capabilities: ['install', 'uninstall', 'doctor'],
-        install: ({ homeDir, force }) => result(installHarnessLinks(openCodeLinks(homeDir), force)),
-        uninstall: ({ homeDir }) => result(uninstallHarnessLinks(openCodeLinks(homeDir))),
-        doctor: ({ homeDir }) => result([...doctorHarnessLinks(openCodeLinks(homeDir)), verifyOpenCodeRuntime(homeDir)]),
+        install: async ({ homeDir, force }) => result([
+            ...installOpenCodePlugin(homeDir, force),
+            ...installHarnessLinks(openCodeLinks(homeDir), force),
+        ]),
+        uninstall: ({ homeDir }) => result([
+            ...uninstallOpenCodePlugin(homeDir),
+            ...uninstallHarnessLinks(openCodeLinks(homeDir)),
+        ]),
+        doctor: ({ homeDir }) => result([verifyOpenCodeRuntime(homeDir), ...doctorHarnessLinks(openCodeLinks(homeDir))]),
     },
     {
         name: 'pi',

package/dist/list.js

@@ -15,12 +15,12 @@ function contextLines(lines) {
 async function readSquareListItem(filePath, root) {
     let stat;
     try {
-        stat = fs.statSync(filePath);
+        stat = await fs.promises.stat(filePath);
     }
     catch {
         return null;
     }
-    const square = probeSquare(filePath);
+    const square = await probeSquare(filePath);
     if (square === undefined)
         return null;
     const projection = await listPresentation(square).finally(() => closeOpenSquare(square));
@@ -38,7 +38,7 @@ async function collectSquareList(root, maxDepth) {
     async function walk(dir, depth) {
         let entries;
         try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
+            entries = await fs.promises.readdir(dir, { withFileTypes: true });
         }
         catch {
             // Directory vanished or became unreadable mid-walk — skip it, don't abort the scan.

package/dist/opencode.d.ts

@@ -0,0 +1,19 @@
+/** OpenCode's server plugin entrypoint for the published Square package. */
+export default function squareOpenCodePlugin(): Promise<{
+    event: ({ event }: {
+        event: {
+            type?: string;
+            properties?: Record<string, any>;
+        };
+    }) => Promise<void>;
+    'shell.env': (input: {
+        sessionID?: string;
+    }, output: {
+        env: Record<string, string>;
+    }) => Promise<void>;
+    'tool.execute.after': (input: {
+        sessionID: string;
+    }, output: {
+        output: string;
+    }) => Promise<void>;
+}>;

package/dist/opencode.js

@@ -0,0 +1,49 @@
+import { presentPendingAtBoundary } from './boundary-presentation.js';
+import { automaticSessionEnd, automaticSessionStart } from './automatic-session.js';
+/** OpenCode's server plugin entrypoint for the published Square package. */
+export default async function squareOpenCodePlugin() {
+    const joining = new Map();
+    return {
+        event: async ({ event }) => {
+            if (event.type === 'session.created' || event.type === 'session.updated') {
+                const sessionID = event.properties?.sessionID;
+                const cwd = event.properties?.info?.directory || process.cwd();
+                if (sessionID) {
+                    try {
+                        const context = await automaticSessionStart('opencode', sessionID, cwd);
+                        if (context)
+                            joining.set(sessionID, context);
+                    }
+                    catch { /* startup remains bounded */ }
+                }
+            }
+            else if (event.type === 'session.deleted') {
+                const sessionID = event.properties?.sessionID;
+                const cwd = event.properties?.info?.directory || process.cwd();
+                if (sessionID) {
+                    joining.delete(sessionID);
+                    await automaticSessionEnd('opencode', sessionID, cwd);
+                }
+            }
+        },
+        'shell.env': async (input, output) => {
+            if (input.sessionID)
+                output.env.OPENCODE_SESSION_ID = input.sessionID;
+        },
+        'tool.execute.after': async (input, output) => {
+            try {
+                const joined = joining.get(input.sessionID);
+                if (joined) {
+                    joining.delete(input.sessionID);
+                    output.output = `${output.output}${output.output === '' ? '' : '\n\n'}${joined}`;
+                }
+                await presentPendingAtBoundary(input.sessionID, (context) => {
+                    output.output = `${output.output}${output.output === '' ? '' : '\n\n'}${context}`;
+                });
+            }
+            catch {
+                // A failed admission remains available at a later boundary.
+            }
+        },
+    };
+}

package/dist/square-file-adapter.d.ts

@@ -13,7 +13,7 @@ export interface SquareBuildOptions {
     notifier?: WakeNotifier;
 }
 export declare function openSquare(squarePath: string, options?: Pick<SquareBuildOptions, 'clock' | 'notifier'>): Promise<OpenSquare>;
-export declare function probeSquare(squarePath: string): OpenSquare | undefined;
+export declare function probeSquare(squarePath: string): Promise<OpenSquare | undefined>;
 export declare function buildSquare(squarePath: string, options: SquareBuildOptions): Promise<OpenSquare>;
 export declare function buildMemorySquare(options: SquareBuildOptions): OpenSquare;
 /** Wait for any bound artifact to change; delivery callers re-project after the edge. */

package/dist/square-file-adapter.js

@@ -2,17 +2,13 @@ import fs from 'node:fs';
 import { createSquareState, probeSquareFile, writeSquareSnapshot, withSquareFileLock, openSquareCell, createMemoryCell, } from './square-storage.js';
 import { InternalSquareError, SquareError, } from './model.js';
 import { closeOpenSquare } from './open-square.js';
-/** The current CLI file mutation boundary. */
-function writeSquareState(squarePath, squareState) {
-    writeSquareSnapshot(squarePath, squareState);
-}
 /** File-owned artifact creation for the CLI and path-backed public facade. */
 export async function createSquare(squarePath, options, snippet) {
-    await withSquareFileLock(squarePath, () => {
-        if (fs.existsSync(squarePath) && !options.force) {
+    await withSquareFileLock(squarePath, async () => {
+        if (await fs.promises.access(squarePath).then(() => true, () => false) && !options.force) {
             throw new InternalSquareError('conflict', `Refusing to overwrite existing square: ${squarePath}\nPass -f to overwrite.`);
         }
-        writeSquareSnapshot(squarePath, createSquareState(options, snippet));
+        await writeSquareSnapshot(squarePath, await createSquareState(options, snippet));
     });
 }
 function validateBuildOptions(options) {
@@ -39,8 +35,8 @@ export async function openSquare(squarePath, options = {}) {
         throw error;
     }
 }
-export function probeSquare(squarePath) {
-    const state = probeSquareFile(squarePath);
+export async function probeSquare(squarePath) {
+    const state = await probeSquareFile(squarePath);
     return state === undefined ? undefined : { cell: createMemoryCell(state), clock: Date.now, location: squarePath };
 }
 export async function buildSquare(squarePath, options) {

package/dist/square-storage.d.ts

@@ -7,10 +7,10 @@ import { type SquareState } from './model.js';
  * protects it.
  */
 export { createSquareState, };
-export declare function readSquareFile(squarePath: string): SquareState;
-export declare function probeSquareFile(squarePath: string): SquareState | undefined;
+export declare function readSquareFile(squarePath: string): Promise<SquareState>;
+export declare function probeSquareFile(squarePath: string): Promise<SquareState | undefined>;
 export declare function diagnoseSquareFile(squarePath: string): ReturnType<typeof diagnoseArtifactFile>;
-export declare function writeSquareSnapshot(squarePath: string, squareState: SquareState): void;
+export declare function writeSquareSnapshot(squarePath: string, squareState: SquareState): Promise<void>;
 export declare function withSquareFileLock<T>(squarePath: string, fn: () => T | Promise<T>): Promise<T>;
 /** In-process cell for fast application tests and embedded consumers. */
 export declare function createMemoryCell(initial: SquareState): StateCell;

package/dist/square-storage.js

@@ -9,17 +9,17 @@ import { LOCK_RETRY_MS, LOCK_STALE_MS } from './runtime.js';
  * protects it.
  */
 export { createSquareState, };
-export function readSquareFile(squarePath) {
+export async function readSquareFile(squarePath) {
     return loadSquare(squarePath);
 }
-export function probeSquareFile(squarePath) {
+export async function probeSquareFile(squarePath) {
     return probeSquare(squarePath);
 }
-export function diagnoseSquareFile(squarePath) {
+export async function diagnoseSquareFile(squarePath) {
     return diagnoseArtifactFile(squarePath);
 }
-export function writeSquareSnapshot(squarePath, squareState) {
-    writeSquareFile(squarePath, squareState);
+export async function writeSquareSnapshot(squarePath, squareState) {
+    await writeSquareFile(squarePath, squareState);
 }
 export function withSquareFileLock(squarePath, fn) {
     return withFileLock(`${squarePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, fn);
@@ -102,9 +102,9 @@ export function createMemoryCell(initial) {
     };
     return cell;
 }
-function fileFingerprint(squarePath) {
+async function fileFingerprint(squarePath) {
     try {
-        const stat = fs.statSync(squarePath);
+        const stat = await fs.promises.stat(squarePath);
         return `${stat.ino}:${stat.size}:${stat.mtimeMs}:${stat.ctimeMs}`;
     }
     catch {
@@ -115,36 +115,39 @@ function fileFingerprint(squarePath) {
 export function createFileCell(squarePath) {
     let closed = false;
     let version = 0;
-    let fingerprint = fileFingerprint(squarePath);
+    let fingerprint;
     let cached;
-    function observe() {
-        const next = fileFingerprint(squarePath);
-        if (next !== fingerprint) {
+    async function observe() {
+        const next = await fileFingerprint(squarePath);
+        if (fingerprint === undefined) {
+            fingerprint = next;
+        }
+        else if (next !== fingerprint) {
             fingerprint = next;
             cached = undefined;
             version += 1;
         }
         return fingerprint;
     }
-    function currentState() {
-        const observed = observe();
+    async function currentState() {
+        const observed = await observe();
         if (cached?.fingerprint === observed)
             return cloneState(cached.state);
-        const decoded = readSquareFile(squarePath);
+        const decoded = await readSquareFile(squarePath);
         cached = { fingerprint: observed, state: cloneState(decoded) };
         return cloneState(cached.state);
     }
     return {
         async transact(fn) {
             assertCellOpen(closed);
-            return withFileLock(`${squarePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, () => {
+            return withFileLock(`${squarePath}.lock`, { retryMs: LOCK_RETRY_MS, staleMs: LOCK_STALE_MS }, async () => {
                 assertCellOpen(closed);
-                const current = currentState();
+                const current = await currentState();
                 const working = cloneState(current);
                 const outcome = fn(working, version);
                 if (outcome.state !== undefined) {
-                    writeSquareSnapshot(squarePath, outcome.state);
-                    fingerprint = fileFingerprint(squarePath);
+                    await writeSquareSnapshot(squarePath, outcome.state);
+                    fingerprint = await fileFingerprint(squarePath);
                     cached = { fingerprint, state: cloneState(outcome.state) };
                     version += 1;
                 }
@@ -153,13 +156,13 @@ export function createFileCell(squarePath) {
         },
         async read() {
             assertCellOpen(closed);
-            return { state: currentState(), version };
+            return { state: await currentState(), version };
         },
         async changed(sinceVersion, timeoutMs) {
             assertCellOpen(closed);
             const deadline = Date.now() + Math.max(0, timeoutMs);
             while (true) {
-                observe();
+                await observe();
                 if (version > sinceVersion)
                     return true;
                 const remaining = deadline - Date.now();

package/extensions/square-pi.js

@@ -1,6 +1,9 @@
 import { presentPendingAtBoundary, renderPendingAtBoundary } from '../dist/boundary-presentation.js';
 import { automaticSessionEnd, automaticSessionStart } from '../dist/automatic-session.js';
 import { waitForSessionPending } from '../dist/inbox.js';
+import { lookupSessionBindings } from '../dist/registry.js';
+
+const PI_SEND_TIMEOUT_MS = 5_000;
 
 export function pendingInbox(inbox) {
   return inbox.filter((item) => item.notifications?.length > 0);
@@ -52,8 +55,22 @@ export default function squarePiExtension(pi) {
     watcherAbort = undefined;
   };
 
+  const pause = (signal, delayMs) => new Promise((resolve) => {
+    const finish = () => {
+      signal.removeEventListener('abort', finish);
+      clearTimeout(timer);
+      resolve();
+    };
+    const timer = setTimeout(finish, delayMs);
+    signal.addEventListener('abort', finish, { once: true });
+  });
+
   const wake = async (piContext, token, signal) => {
     while (sessionId !== undefined && token === generation && !signal.aborted) {
+      if (lookupSessionBindings(sessionId).length === 0) {
+        await pause(signal, 1_000);
+        continue;
+      }
       const deferredRetry = retryAfterChange;
       const pending = await waitForSessionPending(sessionId, 30_000, {
         signal,
@@ -78,10 +95,21 @@ export default function squarePiExtension(pi) {
         const delivered = await presentPendingAtBoundary(
           sessionId,
           async (content) => {
-            await pi.sendMessage(
+            const send = Promise.resolve(pi.sendMessage(
               { customType: 'square', content, display: true },
               { deliverAs: 'steer', triggerTurn: true },
-            );
+            ));
+            let timer;
+            try {
+              await Promise.race([
+                send,
+                new Promise((_, reject) => {
+                  timer = setTimeout(() => reject(new Error('Pi native injection timed out')), PI_SEND_TIMEOUT_MS);
+                }),
+              ]);
+            } finally {
+              if (timer !== undefined) clearTimeout(timer);
+            }
             return true;
           },
         );
@@ -106,7 +134,8 @@ export default function squarePiExtension(pi) {
     sessionCwd = ctx.cwd || process.cwd();
     previousSessionId = process.env.SQUARE_PI_SESSION_ID;
     process.env.SQUARE_PI_SESSION_ID = sessionId;
-    try { joiningContext = await automaticSessionStart('pi', sessionId, sessionCwd); } catch { joiningContext = undefined; }
+    joiningContext = undefined;
+    void automaticSessionStart('pi', sessionId, sessionCwd).catch(() => undefined);
     watcherAbort = new AbortController();
     const token = generation;
     watcher = wake(ctx, token, watcherAbort.signal).catch(() => undefined);
@@ -138,7 +167,7 @@ export default function squarePiExtension(pi) {
     stopWatcher();
     for (const waiter of settledWaiters) waiter.resolve();
     settledWaiters = [];
-    if (sessionId && sessionCwd) await automaticSessionEnd('pi', sessionId, sessionCwd);
+    if (sessionId && sessionCwd) void automaticSessionEnd('pi', sessionId, sessionCwd).catch(() => undefined);
     if (process.env.SQUARE_PI_SESSION_ID === sessionId) {
       if (previousSessionId === undefined) delete process.env.SQUARE_PI_SESSION_ID;
       else process.env.SQUARE_PI_SESSION_ID = previousSessionId;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.26",
+  "version": "0.3.28",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {
@@ -52,6 +52,10 @@
     "./paseo": {
       "types": "./dist/paseo.d.ts",
       "default": "./dist/paseo.js"
+    },
+    "./server": {
+      "types": "./dist/opencode.d.ts",
+      "default": "./dist/opencode.js"
     }
   },
   "main": "dist/index.js",

package/extensions/square-opencode.js

@@ -1,48 +0,0 @@
-import { presentPendingAtBoundary } from '../dist/boundary-presentation.js';
-import { automaticSessionEnd, automaticSessionStart } from '../dist/automatic-session.js';
-
-export default async function squareOpenCodePlugin() {
-  const joining = new Map();
-  return {
-    event: async ({ event }) => {
-      if (event.type === 'session.created' || event.type === 'session.updated') {
-        const sessionID = event.properties?.sessionID;
-        const cwd = event.properties?.info?.directory || process.cwd();
-        if (sessionID) {
-          try {
-            const context = await automaticSessionStart('opencode', sessionID, cwd);
-            if (context) joining.set(sessionID, context);
-          } catch { /* startup remains bounded */ }
-        }
-      } else if (event.type === 'session.deleted') {
-        const sessionID = event.properties?.sessionID;
-        const cwd = event.properties?.info?.directory || process.cwd();
-        if (sessionID) {
-          joining.delete(sessionID);
-          await automaticSessionEnd('opencode', sessionID, cwd);
-        }
-      }
-    },
-    'shell.env': async (input, output) => {
-      if (input.sessionID) output.env.OPENCODE_SESSION_ID = input.sessionID;
-    },
-
-    'tool.execute.after': async (input, output) => {
-      try {
-        const joined = joining.get(input.sessionID);
-        if (joined) {
-          joining.delete(input.sessionID);
-          output.output = `${output.output}${output.output === '' ? '' : '\n\n'}${joined}`;
-        }
-        await presentPendingAtBoundary(
-          input.sessionID,
-          (context) => {
-            output.output = `${output.output}${output.output === '' ? '' : '\n\n'}${context}`;
-          }
-        );
-      } catch {
-        // A failed admission remains available at a later boundary.
-      }
-    },
-  };
-}