@astrosheep/square 0.4.0 → 0.4.1

package/dist/paseo-delivery.d.ts

@@ -1,16 +1,16 @@
-import type { WakeRequest, WakeOutcome, WakeTransportPort } from './channel-transport.js';
+import type { DeliveryCard, DeliveryTransport, DeliveryTransportContext, TransportOutcome } from './delivery-ledger.js';
 import { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';
 import { sendPaseoWake } from './wake-sink.js';
 export interface PaseoWakeTransportOptions {
-    discover?: (timeoutMs: number) => ReturnType<typeof discoverPaseoAgents> | Awaited<ReturnType<typeof discoverPaseoAgents>>;
+    discover?: typeof discoverPaseoAgents;
     waitForBoundary?: typeof waitForPaseoWakeBoundary;
     sendWake?: typeof sendPaseoWake;
 }
-export declare class PaseoWakeTransport implements WakeTransportPort {
+export declare class PaseoWakeTransport implements DeliveryTransport {
     private readonly opts;
+    readonly kind = "paseo";
     private discovering?;
     constructor(opts?: PaseoWakeTransportOptions);
-    /** Coalesce overlapping inventory reads only; a later send must rediscover current status. */
     private discover;
-    attempt(request: WakeRequest, timeoutMs: number, beforeSend: () => Promise<boolean>): Promise<WakeOutcome>;
+    send(card: DeliveryCard, address: Readonly<Record<string, string>>, context: DeliveryTransportContext): Promise<TransportOutcome>;
 }

package/dist/paseo-delivery.js

@@ -1,117 +1,39 @@
+import { renderDeliveryReminder } from './delivery-frame.js';
 import { DeliveryError } from './packages/agent-delivery/src/index.js';
-import { resolvePaseoDaemon } from './packages/agent-delivery/src/paseo-native.js';
 import { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';
 import { sendPaseoWake } from './wake-sink.js';
-/** Every send failure is a DeliveryError; only its code and certainty decide retry. */
-function diagnostic(phase, address, code) {
-    return {
-        phase,
-        code,
-        // Only discovery still runs a Paseo CLI; a wake is a capability call on the shared entry.
-        ...(phase === 'discovery' ? { command: 'paseo ls --global --json' } : {}),
-        endpoint: resolvePaseoDaemon(undefined)?.url ?? 'unresolved',
-        paseoAgentIds: [address.agentId].filter(Boolean),
-        passwordPresent: Boolean(process.env.PASEO_PASSWORD),
-    };
-}
 export class PaseoWakeTransport {
     opts;
+    kind = 'paseo';
     discovering;
     constructor(opts = {}) {
         this.opts = opts;
     }
-    /** Coalesce overlapping inventory reads only; a later send must rediscover current status. */
     discover(timeoutMs) {
         return this.discovering ??= Promise.resolve().then(() => (this.opts.discover ?? discoverPaseoAgents)(timeoutMs))
             .finally(() => { this.discovering = undefined; });
     }
-    async attempt(request, timeoutMs, beforeSend) {
-        const address = request.route.address;
-        const deadline = Date.now() + timeoutMs;
-        const remainingMs = () => Math.max(0, deadline - Date.now());
-        const budgetUnavailable = () => ({
-            outcome: 'failed',
-            signature: 'dispatch_budget_exhausted',
-            message: 'The wake dispatch budget elapsed before Paseo accepted the wake.',
-        });
+    async send(card, address, context) {
         const agentId = address.agentId?.trim();
-        if (!agentId) {
-            return {
-                outcome: 'failed',
-                signature: 'invalid_address',
-                message: 'Paseo route has no agent id.',
-                diagnostic: diagnostic('selection', address, 'invalid_address'),
-            };
-        }
-        const payload = request.presentation?.payload;
-        if (payload === undefined)
-            return { outcome: 'not-capable', diagnostic: 'No pending Square activity to preview.' };
-        let remaining = remainingMs();
-        if (remaining === 0)
-            return budgetUnavailable();
-        const discovery = await this.discover(remaining);
-        if (discovery.error && discovery.agents.length === 0) {
-            return {
-                outcome: 'failed',
-                // A credential or authorization refusal is proven; anything else may be transient.
-                signature: /password|auth|unauthori[sz]ed/i.test(discovery.error) ? 'discovery_rejected'
-                    : /DAEMON_NOT_RUNNING|ECONNREFUSED|ENOENT|not found.*executable|ETIMEDOUT|timed out|timeout/i.test(discovery.error)
-                        ? 'discovery_transient' : 'discovery_rejected',
-                message: `Paseo unavailable: ${discovery.error}`,
-                diagnostic: diagnostic('discovery', address, 'unavailable'),
-            };
-        }
-        const agent = discovery.agents.find((candidate) => candidate.id === agentId);
-        if (agent === undefined || agent.status !== 'idle') {
-            return {
-                outcome: 'failed',
-                signature: agent === undefined ? 'address_not_found' : 'agent_not_idle',
-                message: agent === undefined ? 'The registered Paseo agent was not found.' : 'The registered Paseo agent is not idle.',
-                diagnostic: diagnostic('selection', address, agent === undefined ? 'not_found' : 'not_idle'),
-            };
-        }
-        remaining = remainingMs();
-        if (remaining === 0)
-            return budgetUnavailable();
-        if (!(await (this.opts.waitForBoundary ?? waitForPaseoWakeBoundary)(agent, remaining))) {
-            return {
-                outcome: 'failed',
-                signature: 'boundary_unavailable',
-                message: 'Paseo did not reach the current tool boundary before the wake timeout.',
-                diagnostic: diagnostic('boundary', address, 'unavailable'),
-            };
-        }
-        if (!(await beforeSend()))
-            return { outcome: 'not-capable' };
-        remaining = remainingMs();
-        if (remaining === 0)
-            return budgetUnavailable();
+        if (!agentId)
+            return 'not-capable';
+        const remaining = () => Math.max(0, context.deadline - Date.now());
+        if (context.signal.aborted || !remaining())
+            return 'not-capable';
         try {
-            await (this.opts.sendWake ?? sendPaseoWake)({
-                agentId,
-                prompt: payload,
-                location: request.location,
-                participant: request.participant,
-                message: request.message,
-                ...(request.attemptN === undefined ? {} : { attemptN: request.attemptN }),
-            }, { timeoutMs: remaining });
-            return { outcome: 'accepted' };
+            const discovery = await this.discover(remaining());
+            const agent = discovery.agents.find(candidate => candidate.id === agentId);
+            if (!agent || agent.status !== 'idle' || !remaining())
+                return 'failed';
+            if (!await (this.opts.waitForBoundary ?? waitForPaseoWakeBoundary)(agent, remaining()))
+                return 'failed';
+            if (!await context.prepare({ messageId: context.token }) || context.signal.aborted || !remaining())
+                return 'not-capable';
+            await (this.opts.sendWake ?? sendPaseoWake)({ agentId, prompt: renderDeliveryReminder([card.text], { tagged: true }), messageId: context.token }, { timeoutMs: remaining(), beforeSend: context.beforeSend, signal: context.signal });
+            return 'accepted';
         }
         catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            const kind = !(error instanceof DeliveryError) || error.maybeDelivered ? 'unknown'
-                : error.code === 'unavailable' ? 'transient'
-                    : ['authentication_failed', 'session_not_found', 'rejected', 'invalid_arguments'].includes(error.code) ? 'rejected'
-                        : 'unknown';
-            const details = { ...diagnostic('send', address, 'failed'), outcome: kind };
-            if (kind === 'unknown')
-                return { outcome: 'unknown', signature: 'send_unknown', message, diagnostic: details };
-            return {
-                outcome: 'failed',
-                signature: kind === 'transient' ? 'send_pre_accept_transient' : 'send_pre_accept_rejected',
-                message,
-                diagnostic: details,
-            };
+            return error instanceof DeliveryError && !error.maybeDelivered ? 'failed' : 'unknown';
         }
     }
 }

package/dist/paseo.d.ts

@@ -1,6 +1,6 @@
 /** Optional Paseo integration. Importing this entry requires the Paseo peer dependencies. */
 export { PaseoWakeTransport } from './paseo-delivery.js';
-export { paseoWakeMessageId, sendPaseoWake } from './wake-sink.js';
+export { sendPaseoWake } from './wake-sink.js';
 export type { PaseoWakeRequest } from './wake-sink.js';
 export { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';
 export type { PaseoAgent } from './paseo-state.js';

package/dist/paseo.js

@@ -1,4 +1,4 @@
 /** Optional Paseo integration. Importing this entry requires the Paseo peer dependencies. */
 export { PaseoWakeTransport } from './paseo-delivery.js';
-export { paseoWakeMessageId, sendPaseoWake } from './wake-sink.js';
+export { sendPaseoWake } from './wake-sink.js';
 export { discoverPaseoAgents, waitForPaseoWakeBoundary } from './paseo-state.js';

package/dist/plugins/opencode/index.d.ts

@@ -1,5 +1,7 @@
-import { type OpenCodeSessionCapability } from '../../packages/agent-delivery/src/opencode-native.js';
-import { type OpenCodeContextMessage } from './delivery.js';
+import type { DeliveryTransport } from '../../delivery-ledger.js';
+import { type OpenCodeNativeSession, type OpenCodeSessionCapability } from '../../packages/agent-delivery/src/opencode-native.js';
+import { type OpenCodeContextMessage } from '../opencode-shared/delivery.js';
+export declare function createOpenCodeWakeTransport(target: OpenCodeNativeSession, lifetime: AbortSignal): DeliveryTransport;
 interface OpenCodePluginContext {
     readonly app: {
         readonly version: string;
@@ -32,7 +34,7 @@ interface OpenCodePluginContext {
         }>;
     };
 }
-/** Actual OpenCode 2.0.20 server plugin. Harness identity belongs to ctx, never process.env. */
+/** OpenCode v2 server plugin. Harness identity belongs to ctx, never process.env. */
 declare const _default: {
     id: string;
     setup(ctx: OpenCodePluginContext): Promise<() => Promise<void>>;

package/dist/plugins/opencode/index.js

@@ -1,17 +1,58 @@
-import { observeSquareIndex } from '../../square-index.js';
+import { createHash } from 'node:crypto';
+import { renderDeliveryReminder } from '../../delivery-frame.js';
 import { canonicalPath } from '../../canonical-path.js';
-import { connectNative } from '../../packages/agent-delivery/src/opencode-native.js';
-import { cancelOpenCodeDeliveries, endOpenCodeSession, indexedOpenCodeSessions, observeOpenCodeContext, publishOpenCodeAddress, receiveOpenCodePending } from './delivery.js';
-/** Actual OpenCode 2.0.20 server plugin. Harness identity belongs to ctx, never process.env. */
+import { connectNative, createNativeInputId, sendNativeText } from '../../packages/agent-delivery/src/opencode-native.js';
+import { cancelOpenCodeDeliveries, currentOpenCodeGeneration, detachOpenCodeSession, endOpenCodeSession, listOpenCodeSessions, observeOpenCodeContext, observeOpenCodeSessions, publishOpenCodeAddress, receiveOpenCodePending } from '../opencode-shared/delivery.js';
+const routeKind = 'opencode-server';
+export function createOpenCodeWakeTransport(target, lifetime) {
+    return {
+        kind: routeKind,
+        async send(card, address, context) {
+            const signal = AbortSignal.any([lifetime, context.signal]);
+            if (address.sessionId !== target.sessionId || signal.aborted)
+                return 'not-capable';
+            const messageId = createNativeInputId();
+            const text = renderDeliveryReminder([card.text], { tagged: true });
+            const payloadHash = createHash('sha256').update(text).digest('hex');
+            if (!await context.prepare({ token: context.token, messageId, payloadHash }) || signal.aborted
+                || !await context.beforeSend() || signal.aborted || Date.now() >= context.deadline)
+                return 'not-capable';
+            const result = await sendNativeText(target, text, {
+                inputId: messageId, delivery: 'steer', timeoutMs: Math.max(1, context.deadline - Date.now()), signal,
+            });
+            if (result.state === 'accepted')
+                return 'accepted';
+            if (result.state === 'unavailable')
+                return 'failed';
+            return 'unknown';
+        },
+    };
+}
+/** OpenCode v2 server plugin. Harness identity belongs to ctx, never process.env. */
 export default {
     id: 'square',
     async setup(ctx) {
-        if (ctx.app.version !== '2.0.20')
+        // OpenCode publishes semantic versions; unknown version forms are not evidence of a v2 host.
+        const version = ctx?.app?.version;
+        const reason = typeof version !== 'string' || !/^2\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(version)
+            ? 'expected an OpenCode 2.x semantic version'
+            : typeof ctx.location?.directory !== 'string' || !ctx.location.directory ||
+                typeof ctx.location.project?.id !== 'string' || !ctx.location.project.id ||
+                (ctx.location.workspaceID !== undefined && typeof ctx.location.workspaceID !== 'string')
+                ? 'missing location directory or project identity'
+                : typeof ctx.session?.hook !== 'function' || typeof ctx.session.get !== 'function' || typeof ctx.session.prompt !== 'function'
+                    ? 'missing session hook, get, or prompt capability'
+                    : typeof ctx.event?.subscribe !== 'function' ? 'missing event subscription capability' : undefined;
+        if (reason) {
+            console.warn(`Square OpenCode plugin inactive: ${reason}.`);
             return async () => { };
+        }
         const env = { ...process.env };
-        const index = await observeSquareIndex(env);
+        const discovery = await observeOpenCodeSessions(env);
         const lifetime = new AbortController();
         const receivers = new Map(); // Operational handles only; presence owns membership.
+        const interrupting = new Set();
+        const cancellationFailed = new Set();
         const directory = await canonicalPath(ctx.location.directory);
         let coordinating = Promise.resolve();
         const coordinate = (operation) => {
@@ -39,26 +80,37 @@ export default {
             return target;
         };
         const reconcile = async (activeSession) => {
-            const candidates = new Set(await indexedOpenCodeSessions(env));
+            const candidates = new Set(await listOpenCodeSessions(env));
             if (activeSession)
                 candidates.add(activeSession);
             for (const sessionId of candidates) {
                 if (lifetime.signal.aborted)
                     return;
+                if (interrupting.has(sessionId) || cancellationFailed.has(sessionId))
+                    continue;
                 const target = await validate(sessionId);
                 if (!target) {
+                    const receiver = receivers.get(sessionId);
                     stop(sessionId);
+                    if (receiver)
+                        await detachOpenCodeSession(sessionId, receiver.generation, env);
                     continue;
                 }
-                if (!await publishOpenCodeAddress(sessionId, env, lifetime.signal)) {
+                const existing = receivers.get(sessionId);
+                if (existing?.settled === false || interrupting.has(sessionId))
+                    continue;
+                const generation = existing?.generation ?? await publishOpenCodeAddress(sessionId, env, lifetime.signal);
+                if (!generation) {
                     stop(sessionId);
                     continue;
                 }
-                if (receivers.get(sessionId)?.settled === false)
+                if (lifetime.signal.aborted || interrupting.has(sessionId)) {
+                    await detachOpenCodeSession(sessionId, generation, env);
                     continue;
+                }
                 const abort = new AbortController();
                 const signal = AbortSignal.any([lifetime.signal, abort.signal]);
-                const receiver = { abort, settled: false, running: receiveOpenCodePending(target, env, signal).catch(() => { }).finally(() => { receiver.settled = true; }) };
+                const receiver = { abort, generation, settled: false, running: receiveOpenCodePending(sessionId, generation, createOpenCodeWakeTransport(target, signal), env, signal).catch(() => { }).finally(() => { receiver.settled = true; }) };
                 receivers.set(sessionId, receiver);
             }
             for (const sessionId of receivers.keys())
@@ -66,16 +118,31 @@ export default {
                     stop(sessionId);
         };
         const cancel = async (sessionId) => {
-            if (!receivers.has(sessionId))
+            const receiver = receivers.get(sessionId);
+            if (!receiver)
                 return;
-            // Stop synchronously; persist the cutoff before allowing reconciliation to start fresh work.
             stop(sessionId);
-            await cancelOpenCodeDeliveries(sessionId, env, lifetime.signal);
-            await reconcile();
+            await receiver.running;
+            try {
+                if (!await cancelOpenCodeDeliveries(sessionId, receiver.generation, env))
+                    throw new Error('OpenCode cancellation fence lost');
+            }
+            catch (error) {
+                cancellationFailed.add(sessionId);
+                await detachOpenCodeSession(sessionId, receiver.generation, env).catch(() => { });
+                throw error;
+            }
+            finally {
+                interrupting.delete(sessionId);
+            }
+            await reconcile(sessionId);
         };
         const end = async (sessionId) => {
+            const receiver = receivers.get(sessionId);
             stop(sessionId);
-            await endOpenCodeSession(sessionId, env, lifetime.signal);
+            const generation = receiver?.generation ?? await currentOpenCodeGeneration(sessionId, env);
+            if (generation)
+                await endOpenCodeSession(sessionId, generation, env);
         };
         await ctx.session.hook('prompt', (event) => coordinate(() => reconcile(event.sessionID)));
         await ctx.session.hook('context', async (event) => {
@@ -83,13 +150,13 @@ export default {
             const receiver = receivers.get(event.sessionID);
             if (!receiver || lifetime.signal.aborted)
                 return;
-            await observeOpenCodeContext(event.sessionID, event.messages, env, AbortSignal.any([lifetime.signal, receiver.abort.signal])).catch(() => { });
+            await observeOpenCodeContext(event.sessionID, receiver.generation, event.messages, env, AbortSignal.any([lifetime.signal, receiver.abort.signal])).catch(() => { });
         });
         const presenceLoop = (async () => {
             while (!lifetime.signal.aborted) {
-                const baseline = await index.read(lifetime.signal);
+                const baseline = discovery.observer.generation;
                 await coordinate(() => reconcile());
-                await index.changed(baseline, Infinity, lifetime.signal);
+                await discovery.observer.hinted(baseline, 2000, lifetime.signal);
             }
         })().catch(() => { });
         const eventLoop = (async () => {
@@ -100,8 +167,17 @@ export default {
                 if (event.type === 'session.deleted')
                     await coordinate(() => end(sessionId));
                 else if (event.type === 'session.moved')
-                    await coordinate(async () => { stop(sessionId); await reconcile(); });
+                    await coordinate(async () => {
+                        const receiver = receivers.get(sessionId);
+                        stop(sessionId);
+                        if (receiver)
+                            await detachOpenCodeSession(sessionId, receiver.generation, env);
+                        await reconcile();
+                    });
                 else if (event.type === 'session.execution.interrupted' && event.data.reason === 'user') {
+                    if (interrupting.has(sessionId) || !receivers.has(sessionId))
+                        continue;
+                    interrupting.add(sessionId);
                     receivers.get(sessionId)?.abort.abort();
                     await coordinate(() => cancel(sessionId));
                 }
@@ -110,8 +186,8 @@ export default {
         // Do not await any native prompt in setup: plugin activation itself is lazy.
         return async () => {
             lifetime.abort();
-            index.close();
-            const tasks = [presenceLoop, eventLoop, coordinating, ...[...receivers.keys()].map(stop)];
+            const captured = [...receivers.entries()];
+            const tasks = [presenceLoop, eventLoop, coordinating, ...captured.map(([id]) => stop(id))];
             let timer;
             try {
                 await Promise.race([Promise.allSettled(tasks), new Promise((resolve) => { timer = setTimeout(resolve, 3000); })]);
@@ -120,6 +196,8 @@ export default {
                 if (timer !== undefined)
                     clearTimeout(timer);
             }
+            await Promise.allSettled(captured.map(([id, receiver]) => detachOpenCodeSession(id, receiver.generation, env)));
+            await discovery.close();
             // Instance unload is not session deletion: retain memberships and uncertain correlations.
         };
     },

package/dist/plugins/opencode-shared/delivery.d.ts

@@ -0,0 +1,23 @@
+import { type DeliveryTransport } from '../../delivery-ledger.js';
+export interface OpenCodeContextMessage {
+    readonly id?: string;
+    readonly role: string;
+    readonly content: readonly {
+        readonly type: string;
+        readonly text?: string;
+    }[];
+}
+export declare function listOpenCodeSessions(env: NodeJS.ProcessEnv): Promise<readonly string[]>;
+/** The file observer is a hint; callers must always reread the ledger after an edge. */
+export declare function observeOpenCodeSessions(env: NodeJS.ProcessEnv): Promise<{
+    observer: import("../../file-changes.js").VersionObserver<string>;
+    close: () => Promise<void>;
+}>;
+export declare function publishOpenCodeAddress(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<string | undefined>;
+export declare function currentOpenCodeGeneration(sessionId: string, env: NodeJS.ProcessEnv): Promise<string | undefined>;
+export declare function detachOpenCodeSession(sessionId: string, generation: string, env: NodeJS.ProcessEnv): Promise<void>;
+export declare function endOpenCodeSession(sessionId: string, generation: string, env: NodeJS.ProcessEnv): Promise<void>;
+export declare function cancelOpenCodeDeliveries(sessionId: string, generation: string, env: NodeJS.ProcessEnv): Promise<boolean>;
+/** Confirmation is observer-level: another host plugin may subsequently remove the message. */
+export declare function observeOpenCodeContext(sessionId: string, generation: string, messages: readonly OpenCodeContextMessage[], env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
+export declare function receiveOpenCodePending(sessionId: string, generation: string, transport: DeliveryTransport, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;

package/dist/plugins/opencode-shared/delivery.js

@@ -0,0 +1,109 @@
+import { createHash } from 'node:crypto';
+import { DeliveryLedger } from '../../delivery-ledger.js';
+import { retainDeliveryLedger } from '../../delivery-lifetime.js';
+import { harnessOwner, decodeHarnessOwner } from '../../owner.js';
+import { attachDeliverySessionRoutes, detachDeliverySession, markDeliverySessionDeleted } from '../../session-lifecycle.js';
+const routeKind = 'opencode-server';
+const ownerFor = (sessionId) => harnessOwner({ channel: 'opencode', session: sessionId });
+const open = (env) => DeliveryLedger.open(env.SQUARE_DELIVERY ? { location: env.SQUARE_DELIVERY } : {});
+const payloadHash = (payload) => createHash('sha256').update(payload).digest('hex');
+export async function listOpenCodeSessions(env) {
+    const ledger = await open(env);
+    try {
+        return (await ledger.sessions()).flatMap(session => {
+            const coordinate = decodeHarnessOwner(session.owner);
+            return session.state !== 'deleted' && coordinate?.channel === 'opencode' ? [coordinate.session] : [];
+        });
+    }
+    finally {
+        await ledger.close();
+    }
+}
+/** The file observer is a hint; callers must always reread the ledger after an edge. */
+export async function observeOpenCodeSessions(env) {
+    const ledger = await open(env);
+    const observer = await ledger.observe(ownerFor('discovery'));
+    return { observer, close: async () => { observer.close(); await ledger.close(); } };
+}
+export async function publishOpenCodeAddress(sessionId, env, signal) {
+    const session = await attachDeliverySessionRoutes(ownerFor(sessionId), env, [{ kind: routeKind, address: { sessionId } }], signal);
+    return session ? session.generation : undefined;
+}
+export async function currentOpenCodeGeneration(sessionId, env) {
+    const ledger = await open(env);
+    try {
+        return (await ledger.session(ownerFor(sessionId)))?.generation;
+    }
+    finally {
+        await ledger.close();
+    }
+}
+export async function detachOpenCodeSession(sessionId, generation, env) {
+    await detachDeliverySession(ownerFor(sessionId), generation, env);
+}
+export async function endOpenCodeSession(sessionId, generation, env) {
+    await markDeliverySessionDeleted(ownerFor(sessionId), generation, env);
+}
+export async function cancelOpenCodeDeliveries(sessionId, generation, env) {
+    const ledger = await open(env);
+    try {
+        return await ledger.cancel({ owner: ownerFor(sessionId), generation });
+    }
+    finally {
+        await ledger.close();
+    }
+}
+function textMessage(message) {
+    if (message.role !== 'user' || message.id === undefined || !message.content.every(part => part.type === 'text' && typeof part.text === 'string'))
+        return undefined;
+    return message.content.map(part => part.text).join('');
+}
+/** Confirmation is observer-level: another host plugin may subsequently remove the message. */
+export async function observeOpenCodeContext(sessionId, generation, messages, env, signal) {
+    const observed = new Map(messages.flatMap(message => {
+        const text = textMessage(message);
+        return text === undefined ? [] : [[message.id, payloadHash(text)]];
+    }));
+    if (!observed.size || signal.aborted)
+        return;
+    const ledger = await open(env);
+    try {
+        for (const attempt of await ledger.handoffs(ownerFor(sessionId), { generation })) {
+            if (signal.aborted)
+                return;
+            const { correlation } = attempt;
+            if (attempt.routeKind === routeKind && correlation.token === attempt.token && correlation.messageId !== undefined
+                && correlation.payloadHash !== undefined && observed.get(correlation.messageId) === correlation.payloadHash)
+                await ledger.observePresentation({ token: attempt.token, owner: ownerFor(sessionId), generation, routeKind, payloadHash: correlation.payloadHash }, { requireCurrent: true });
+        }
+    }
+    finally {
+        await ledger.close();
+    }
+}
+export async function receiveOpenCodePending(sessionId, generation, transport, env, signal) {
+    const owner = ownerFor(sessionId);
+    const ledger = await open(env);
+    const lifetime = retainDeliveryLedger(ledger);
+    const observer = await ledger.observe(owner);
+    try {
+        while (!signal.aborted) {
+            const baseline = observer.generation;
+            for (const card of await ledger.pending(owner, { generation })) {
+                if (signal.aborted)
+                    return;
+                lifetime.track(await ledger.dispatchHandoff(owner, card.key, transport, { generation, timeoutMs: 5000, signal }));
+            }
+            if (!signal.aborted)
+                await observer.hinted(baseline, 2000, signal);
+        }
+    }
+    catch (error) {
+        if (!signal.aborted)
+            throw error;
+    }
+    finally {
+        observer.close();
+        await lifetime.close();
+    }
+}

package/dist/plugins/opencode-v1/index.d.ts

@@ -0,0 +1,28 @@
+interface LegacyContext {
+    readonly serverUrl: string | URL;
+    readonly directory: string;
+    readonly project: {
+        readonly id: string;
+    };
+    readonly client: {
+        readonly session: {
+            get(input: unknown): Promise<{
+                data?: unknown;
+                error?: unknown;
+            }>;
+            promptAsync(input: unknown): Promise<{
+                error?: unknown;
+                response?: Response;
+            }>;
+        };
+    };
+}
+/** Legacy loader: no storage imports until the actual host and runtime qualify. */
+export default function squareOpenCodeV1(ctx: LegacyContext): Promise<{
+    'shell.env': (input: {
+        sessionID?: string;
+    }, output: {
+        env: Record<string, string>;
+    }) => Promise<void>;
+}>;
+export {};

package/dist/plugins/opencode-v1/index.js

@@ -0,0 +1,41 @@
+/** Legacy loader: no storage imports until the actual host and runtime qualify. */
+export default async function squareOpenCodeV1(ctx) {
+    const shell = async (input, output) => {
+        if (typeof input.sessionID === 'string' && input.sessionID)
+            output.env.OPENCODE_SESSION_ID = input.sessionID;
+    };
+    const reduced = { 'shell.env': shell };
+    try {
+        let response;
+        try {
+            response = await fetch(new URL('/global/health', ctx.serverUrl), { signal: AbortSignal.timeout(1500) });
+        }
+        catch {
+            throw new Error('health endpoint unreachable (embedded TUI may not expose it)');
+        }
+        if (!response.ok)
+            throw new Error(`health endpoint returned HTTP ${response.status} (embedded TUI may not expose it)`);
+        const health = await response.json();
+        const match = typeof health.version === 'string' && /^(\d+)\.(\d+)\.(\d+)$/.exec(health.version);
+        if (!match || Number(match[1]) !== 1 || Number(match[2]) < 15 || (Number(match[2]) === 15 && Number(match[3]) < 11))
+            throw new Error('native version below resident floor or unknown');
+        if (typeof ctx.client?.session?.get !== 'function' || typeof ctx.client.session.promptAsync !== 'function')
+            throw new Error('native session API unavailable');
+        const { DatabaseSync } = await import('node:sqlite');
+        const db = new DatabaseSync(':memory:');
+        try {
+            db.exec('CREATE TABLE capability (value TEXT)');
+            db.prepare('INSERT INTO capability VALUES (?)').run('ok');
+            db.prepare('SELECT value FROM capability').get();
+        }
+        finally {
+            db.close();
+        }
+        const { startReceiver } = await import('./runtime.js');
+        return { ...reduced, ...await startReceiver(ctx) };
+    }
+    catch (error) {
+        console.warn(`[square] OpenCode 1.x reduced mode (no proactive delivery): ${error instanceof Error ? error.message : String(error)}`);
+        return reduced;
+    }
+}

package/dist/plugins/opencode-v1/runtime.d.ts

@@ -0,0 +1,56 @@
+interface Context {
+    readonly directory: string;
+    readonly project: {
+        readonly id: string;
+    };
+    readonly client: {
+        readonly session: {
+            get(input: unknown): Promise<{
+                data?: unknown;
+                error?: unknown;
+            }>;
+            promptAsync(input: unknown): Promise<{
+                error?: unknown;
+                response?: Response;
+            }>;
+        };
+    };
+}
+interface NativeMessage {
+    info?: {
+        id?: string;
+        sessionID?: string;
+        role?: string;
+    };
+    parts?: {
+        type?: string;
+        text?: string;
+        sessionID?: string;
+        messageID?: string;
+        synthetic?: boolean;
+        ignored?: boolean;
+    }[];
+}
+export declare function startReceiver(ctx: Context): Promise<{
+    'experimental.chat.messages.transform': (_input: unknown, output: {
+        messages: NativeMessage[];
+    }) => Promise<void>;
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: {
+                sessionID?: string;
+                error?: {
+                    name?: string;
+                };
+                info?: {
+                    id?: string;
+                    projectID?: string;
+                    directory?: string;
+                };
+            };
+        };
+    }) => Promise<void>;
+    dispose: () => Promise<void>;
+}>;
+export {};