@astrosheep/square 0.3.106 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/square",
-  "version": "0.3.106",
+  "version": "0.4.1",
   "description": "A shared public square where agents join, catch activity, express, and step out when done.",
   "type": "module",
   "bin": {
@@ -50,13 +50,9 @@
     "ws": "^8.21.3"
   },
   "exports": {
-    "./channel": {
-      "types": "./dist/channel.d.ts",
-      "default": "./dist/channel.js"
-    },
-    "./delivery": {
-      "types": "./dist/delivery-primitives.d.ts",
-      "default": "./dist/delivery-primitives.js"
+    "./delivery-ledger": {
+      "types": "./dist/delivery-ledger.d.ts",
+      "default": "./dist/delivery-ledger.js"
     },
     "./receive": {
       "types": "./dist/receive.d.ts",
@@ -74,6 +70,10 @@
       "types": "./dist/paseo.d.ts",
       "default": "./dist/paseo.js"
     },
+    "./opencode-v1": {
+      "types": "./dist/plugins/opencode-v1/index.d.ts",
+      "default": "./dist/plugins/opencode-v1/index.js"
+    },
     "./server": {
       "types": "./dist/plugins/opencode/index.d.ts",
       "default": "./dist/plugins/opencode/index.js"

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

@@ -1,6 +1,6 @@
 {
   "name": "square",
-  "version": "0.3.106",
+  "version": "0.4.1",
   "description": "Native Claude Code inbox delivery for Square participants",
   "types": "./types.d.ts",
   "author": {

package/plugins/claude/hooks/hooks.json

@@ -1 +1 @@
-{"modules":["./register.js"]}
+{"modules":["../mods/square.js"]}

package/plugins/claude/{hooks/register.js → mods/square.js}

@@ -11,15 +11,12 @@ async function bridge($, value, budget = 2800) {
 }
 async function snapshot($, id) { return (await $.state.get({ plugin: 'square', key: 'inbox', id })).value; }
 async function cancellation($, id) { return (await $.state.get({ plugin: 'square', key: 'cancelAt', id })).value; }
-function confirmLater($, c, operation, text) {
+function confirmLater($, c, operation, text, refs) {
   // State reads are dispatch snapshots. This ONE fresh timer dispatch is not polling.
   // Reload cancels it; lost evidence stays unknown and is never blindly replayed.
   try { $.clock.after(0, () => {
     (async () => {
-      if (await $.session.id() !== c.sessionId) return;
-      const old = await snapshot($, c.sessionId);
-      const cancelled = await cancellation($, c.sessionId);
-      await bridge($, { ...c, cancelAt: cancelled?.at, cancelledBindings: cancelled?.bindings, bindings: old?.bindings, operation, text });
+      await bridge($, { ...c, operation, text, refs });
     })().catch(() => undefined);
   }); } catch { /* denied scheduling leaves evidence unknown, never a second next */ }
 }
@@ -112,10 +109,10 @@ export function register(on) {
     const old = await snapshot($, c.sessionId).catch(() => undefined);
     const cancelled = await cancellation($, c.sessionId).catch(() => undefined);
     const guard = await bridge($, { ...c, cancelAt: cancelled?.at, cancelledBindings: cancelled?.bindings, bindings: old?.bindings, operation: 'guard', text: e.text }).catch(() => undefined);
-    if (guard?.recognized && !guard.current) return { consumed: 'Square delivery is stale or cancelled' };
+    if (!guard || (guard.recognized && !guard.current)) return { consumed: 'Square delivery is stale, cancelled, or unavailable' };
     // Preserve native policy: hold/refuse reject this gate; never call next twice.
     const result = await next(e);
-    if (guard?.current && result.text === e.text) confirmLater($, c, 'admitted', result.text);
+    if (guard?.current && result.text === e.text) confirmLater($, c, 'admitted', result.text, guard.refs);
     return result;
   });
   on('session.append', async ($, e, next) => {

package/plugins/claude/types.d.ts

@@ -1,4 +1,4 @@
-export type SquareInboxBinding = { location: string; participant: string; session: string; generation?: `act/${number}` };
+export type SquareInboxBinding = { location: string; participant: string; session: string; generation?: string };
 export type SquareInboxCoordinate = { sessionId: string; cwd: string; version: string; endpoint?: string };
 export type SquareInboxCancellation = { at: number; bindings?: SquareInboxBinding[] };
 export type SquareInboxState = { coordinate: SquareInboxCoordinate; bindings?: SquareInboxBinding[] };

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

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

package/plugins/codex/hooks/hooks.json

@@ -3,38 +3,26 @@
     "SessionStart": [
       { "hooks": [{ "type": "command", "command": "square codex-hook", "timeout": 5, "statusMessage": "Square" }] }
     ],
-    "SessionResume": [
-      { "hooks": [{ "type": "command", "command": "square codex-hook", "timeout": 5, "statusMessage": "Square" }] }
-    ],
     "SessionEnd": [
       { "hooks": [{ "type": "command", "command": "square codex-hook", "timeout": 3, "statusMessage": "Square" }] }
     ],
     "UserPromptSubmit": [
       { "hooks": [{ "type": "command", "command": "square codex-hook", "timeout": 5, "statusMessage": "Square" }] }
     ],
+    "PreToolUse": [
+      { "hooks": [{ "type": "command", "command": "square codex-hook", "timeout": 5, "statusMessage": "Square" }] }
+    ],
     "PostToolUse": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "square codex-hook",
-            "timeout": 5,
-            "statusMessage": "Square"
-          }
-        ]
-      }
+      { "hooks": [{ "type": "command", "command": "square codex-hook", "timeout": 5, "statusMessage": "Square" }] }
     ],
     "Stop": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "square codex-hook",
-            "timeout": 5,
-            "statusMessage": "Square"
-          }
-        ]
-      }
+      { "hooks": [
+        { "type": "command", "command": "square codex-hook", "timeout": 5, "statusMessage": "Square" },
+        { "type": "command", "command": "square codex-watch", "timeout": 86400, "async": true, "statusMessage": "Square" }
+      ] }
+    ],
+    "Interrupt": [
+      { "hooks": [{ "type": "command", "command": "square codex-interrupt", "timeout": 3, "statusMessage": "Square" }] }
     ]
   }
 }

package/plugins/opencode/index.ts

@@ -1,7 +1,32 @@
-import { observeSquareIndex } from '../../square-index.js';
+import { createHash } from 'node:crypto';
+import { renderDeliveryReminder } from '../../delivery-frame.js';
+import type { DeliveryTransport } from '../../delivery-ledger.js';
 import { canonicalPath } from '../../canonical-path.js';
-import { connectNative, type OpenCodeNativeSession, type OpenCodeSessionCapability } from '../../packages/agent-delivery/src/opencode-native.js';
-import { cancelOpenCodeDeliveries, endOpenCodeSession, indexedOpenCodeSessions, observeOpenCodeContext, publishOpenCodeAddress, receiveOpenCodePending, type OpenCodeContextMessage } from './delivery.js';
+import { connectNative, createNativeInputId, sendNativeText, type OpenCodeNativeSession, type OpenCodeSessionCapability } from '../../packages/agent-delivery/src/opencode-native.js';
+import { cancelOpenCodeDeliveries, currentOpenCodeGeneration, detachOpenCodeSession, endOpenCodeSession, listOpenCodeSessions, observeOpenCodeContext, observeOpenCodeSessions, publishOpenCodeAddress, receiveOpenCodePending, type OpenCodeContextMessage } from '../opencode-shared/delivery.js';
+
+const routeKind = 'opencode-server' as const;
+
+export function createOpenCodeWakeTransport(target: OpenCodeNativeSession, lifetime: AbortSignal): DeliveryTransport {
+  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';
+    },
+  };
+}
 
 interface OpenCodePluginContext {
   readonly app: { readonly version: string };
@@ -12,17 +37,33 @@ interface OpenCodePluginContext {
   };
   readonly event: { subscribe(options: { signal: AbortSignal }): AsyncIterable<{ type: string; data: { sessionID?: string; reason?: string } }> };
 }
-interface Receiver { readonly abort: AbortController; readonly running: Promise<void>; settled: boolean }
+interface Receiver { readonly abort: AbortController; readonly running: Promise<void>; readonly generation: string; settled: boolean }
 
-/** 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. */
 export default {
   id: 'square',
   async setup(ctx: OpenCodePluginContext): Promise<() => Promise<void>> {
-    if (ctx.app.version !== '2.0.20') return async () => {};
+    // 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<string, Receiver>(); // Operational handles only; presence owns membership.
+    const interrupting = new Set<string>();
+    const cancellationFailed = new Set<string>();
     const directory = await canonicalPath(ctx.location.directory);
     let coordinating = Promise.resolve();
     const coordinate = (operation: () => Promise<void>) => {
@@ -49,31 +90,49 @@ export default {
       return target;
     };
     const reconcile = async (activeSession?: string) => {
-      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) { stop(sessionId); continue; }
-        if (!await publishOpenCodeAddress(sessionId, env, lifetime.signal)) { stop(sessionId); continue; }
-        if (receivers.get(sessionId)?.settled === false) continue;
+        if (!target) {
+          const receiver = receivers.get(sessionId);
+          stop(sessionId);
+          if (receiver) await detachOpenCodeSession(sessionId, receiver.generation, env);
+          continue;
+        }
+        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 (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: Receiver = { abort, settled: false, running: receiveOpenCodePending(target, env, signal).catch(() => {}).finally(() => { receiver.settled = true; }) };
+        const receiver: 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()) if (!candidates.has(sessionId)) stop(sessionId);
     };
     const cancel = async (sessionId: string) => {
-      if (!receivers.has(sessionId)) return;
-      // Stop synchronously; persist the cutoff before allowing reconciliation to start fresh work.
+      const receiver = receivers.get(sessionId);
+      if (!receiver) return;
       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: string) => {
+      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)));
@@ -81,14 +140,14 @@ export default {
       await coordinate(() => reconcile(event.sessionID));
       const receiver = receivers.get(event.sessionID);
       if (!receiver || lifetime.signal.aborted) return;
-      await observeOpenCodeContext(event.sessionID, event.messages, env,
+      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 () => {
@@ -96,8 +155,15 @@ export default {
         const sessionId = event.data.sessionID;
         if (!sessionId) continue;
         if (event.type === 'session.deleted') await coordinate(() => end(sessionId));
-        else if (event.type === 'session.moved') await coordinate(async () => { stop(sessionId); await reconcile(); });
+        else if (event.type === 'session.moved') 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));
         }
@@ -106,11 +172,13 @@ 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: ReturnType<typeof setTimeout> | undefined;
       try { await Promise.race([Promise.allSettled(tasks), new Promise<void>((resolve) => { timer = setTimeout(resolve, 3000); })]); }
       finally { 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/plugins/opencode-shared/delivery.ts

@@ -0,0 +1,91 @@
+import { createHash } from 'node:crypto';
+import { DeliveryLedger, type DeliveryTransport } 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: string) => harnessOwner({ channel: 'opencode', session: sessionId });
+const open = (env: NodeJS.ProcessEnv) => DeliveryLedger.open(env.SQUARE_DELIVERY ? { location: env.SQUARE_DELIVERY } : {});
+const payloadHash = (payload: string) => createHash('sha256').update(payload).digest('hex');
+export interface OpenCodeContextMessage { readonly id?: string; readonly role: string; readonly content: readonly { readonly type: string; readonly text?: string }[] }
+
+export async function listOpenCodeSessions(env: NodeJS.ProcessEnv): Promise<readonly string[]> {
+  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: NodeJS.ProcessEnv) {
+  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: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<string | undefined> {
+  const session = await attachDeliverySessionRoutes(ownerFor(sessionId), env, [{ kind: routeKind, address: { sessionId } }], signal);
+  return session ? session.generation : undefined;
+}
+
+export async function currentOpenCodeGeneration(sessionId: string, env: NodeJS.ProcessEnv): Promise<string | undefined> {
+  const ledger = await open(env);
+  try { return (await ledger.session(ownerFor(sessionId)))?.generation; } finally { await ledger.close(); }
+}
+
+export async function detachOpenCodeSession(sessionId: string, generation: string, env: NodeJS.ProcessEnv): Promise<void> {
+  await detachDeliverySession(ownerFor(sessionId), generation, env);
+}
+export async function endOpenCodeSession(sessionId: string, generation: string, env: NodeJS.ProcessEnv): Promise<void> {
+  await markDeliverySessionDeleted(ownerFor(sessionId), generation, env);
+}
+export async function cancelOpenCodeDeliveries(sessionId: string, generation: string, env: NodeJS.ProcessEnv): Promise<boolean> {
+  const ledger = await open(env);
+  try { return await ledger.cancel({ owner: ownerFor(sessionId), generation }); } finally { await ledger.close(); }
+}
+
+function textMessage(message: OpenCodeContextMessage): string | undefined {
+  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: string, generation: string, messages: readonly OpenCodeContextMessage[], env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void> {
+  const observed = new Map(messages.flatMap(message => {
+    const text = textMessage(message);
+    return text === undefined ? [] : [[message.id!, payloadHash(text)] as const];
+  }));
+  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: string, generation: string, transport: DeliveryTransport, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void> {
+  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/plugins/opencode-v1/index.ts

@@ -0,0 +1,36 @@
+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 async function squareOpenCodeV1(ctx: LegacyContext) {
+  const shell = async (input: { sessionID?: string }, output: { env: Record<string, string> }) => {
+    if (typeof input.sessionID === 'string' && input.sessionID) output.env.OPENCODE_SESSION_ID = input.sessionID;
+  };
+  const reduced = { 'shell.env': shell };
+  try {
+    let response: 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() as { version?: unknown };
+    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/plugins/opencode-v1/runtime.ts

@@ -0,0 +1,134 @@
+import { canonicalPath } from '../../canonical-path.js';
+import { cancelOpenCodeDeliveries, currentOpenCodeGeneration, detachOpenCodeSession, endOpenCodeSession, listOpenCodeSessions, observeOpenCodeContext, observeOpenCodeSessions, publishOpenCodeAddress, receiveOpenCodePending } from '../opencode-shared/delivery.js';
+import { legacyTransport } from './transport.js';
+
+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 }[] }
+interface Receiver { abort: AbortController; running: Promise<void>; generation: string; settled: boolean }
+
+export async function startReceiver(ctx: Context) {
+  const env = { ...process.env };
+  const directory = await canonicalPath(ctx.directory);
+  const discovery = await observeOpenCodeSessions(env);
+  const lifetime = new AbortController();
+  const receivers = new Map<string, Receiver>();
+  const terminal = new Set<string>();
+  const interrupting = new Set<string>();
+  const cancellationFailed = new Set<string>();
+  let coordinating = Promise.resolve();
+  const coordinate = (operation: () => Promise<void>) => {
+    coordinating = coordinating.then(() => lifetime.signal.aborted ? undefined : operation()).catch(() => {});
+    return coordinating;
+  };
+  const stop = (id: string) => {
+    const receiver = receivers.get(id);
+    receiver?.abort.abort();
+    receivers.delete(id);
+    return receiver?.running;
+  };
+  const validate = async (id: string) => {
+    const result = await ctx.client.session.get({ path: { id }, signal: lifetime.signal }).catch(() => undefined);
+    const info = result?.data as { id?: string; projectID?: string; directory?: string } | undefined;
+    return !result?.error && info?.id === id && info.projectID === ctx.project.id && typeof info.directory === 'string'
+      && await canonicalPath(info.directory) === directory;
+  };
+  const reconcile = async (active?: string) => {
+    const candidates = new Set(await listOpenCodeSessions(env));
+    if (active) candidates.add(active);
+    for (const id of candidates) {
+      if (lifetime.signal.aborted) return;
+      if (interrupting.has(id) || cancellationFailed.has(id)) continue;
+      if (terminal.has(id) || !await validate(id) || terminal.has(id)) {
+        const receiver = receivers.get(id);
+        stop(id);
+        if (receiver) await detachOpenCodeSession(id, receiver.generation, env);
+        continue;
+      }
+      const existing = receivers.get(id);
+      if (existing?.settled === false || interrupting.has(id)) continue;
+      const generation = existing?.generation ?? await publishOpenCodeAddress(id, env, lifetime.signal);
+      if (!generation) { stop(id); continue; }
+      if (terminal.has(id) || interrupting.has(id) || lifetime.signal.aborted) { await detachOpenCodeSession(id, generation, env); continue; }
+      const abort = new AbortController();
+      const signal = AbortSignal.any([lifetime.signal, abort.signal]);
+      const receiver: Receiver = { abort, generation, settled: false, running: receiveOpenCodePending(id, generation, legacyTransport(ctx.client, id, signal), env, signal).catch(() => {}).finally(() => { receiver.settled = true; }) };
+      receivers.set(id, receiver);
+    }
+    for (const id of receivers.keys()) if (!candidates.has(id)) stop(id);
+  };
+  const loop = (async () => {
+    while (!lifetime.signal.aborted) {
+      const baseline = discovery.observer.generation;
+      await coordinate(() => reconcile());
+      await discovery.observer.hinted(baseline, 2000, lifetime.signal);
+    }
+  })().catch(() => {});
+  let disposal: Promise<void> | undefined;
+  return {
+    'experimental.chat.messages.transform': async (_input: unknown, output: { messages: NativeMessage[] }) => {
+      const ids = new Set(output.messages.map(message => message.info?.sessionID));
+      if (ids.size !== 1 || typeof [...ids][0] !== 'string') return;
+      const id = [...ids][0]!;
+      if (terminal.has(id)) return;
+      await coordinate(() => reconcile(id));
+      const receiver = receivers.get(id);
+      if (!receiver || terminal.has(id) || lifetime.signal.aborted) return;
+      const messages = output.messages.flatMap(({ info, parts }) => {
+        if (info?.role !== 'user' || !info.id || !parts?.length || !parts.every(part => part.type === 'text'
+          && typeof part.text === 'string' && part.sessionID === id && part.messageID === info.id && !part.synthetic && !part.ignored)) return [];
+        return [{ id: info.id, role: 'user', content: parts.map(part => ({ type: 'text', text: part.text })) }];
+      });
+      await observeOpenCodeContext(id, receiver.generation, messages, env, AbortSignal.any([lifetime.signal, receiver.abort.signal])).catch(() => {});
+    },
+    event: async ({ event }: { event: { type: string; properties?: { sessionID?: string; error?: { name?: string }; info?: { id?: string; projectID?: string; directory?: string } } } }) => {
+      const interrupted = event.type === 'session.error' && event.properties?.error?.name === 'MessageAbortedError'
+        ? event.properties.sessionID : undefined;
+      if (interrupted) {
+        const receiver = receivers.get(interrupted);
+        if (!receiver || interrupting.has(interrupted)) return;
+        interrupting.add(interrupted);
+        stop(interrupted);
+        await coordinate(async () => {
+          try {
+            await receiver.running;
+            if (!await cancelOpenCodeDeliveries(interrupted, receiver.generation, env)) throw new Error('OpenCode cancellation fence lost');
+          } catch (error) {
+            cancellationFailed.add(interrupted);
+            await detachOpenCodeSession(interrupted, receiver.generation, env).catch(() => {});
+            throw error;
+          } finally { interrupting.delete(interrupted); }
+          await reconcile(interrupted);
+        });
+        return;
+      }
+      const info = event.properties?.info;
+      if (event.type !== 'session.deleted' || !info?.id || info.projectID !== ctx.project.id || typeof info.directory !== 'string'
+        || await canonicalPath(info.directory).catch(() => undefined) !== directory) return;
+      const id = info.id;
+      terminal.add(id);
+      const receiver = receivers.get(id);
+      stop(id);
+      await coordinate(async () => {
+        const generation = receiver?.generation ?? await currentOpenCodeGeneration(id, env);
+        if (generation) await endOpenCodeSession(id, generation, env);
+      });
+    },
+    dispose: () => disposal ??= (async () => {
+      lifetime.abort();
+      const captured = [...receivers.entries()];
+      const tasks = [loop, coordinating, ...captured.map(([id]) => stop(id))];
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      try { await Promise.race([Promise.allSettled(tasks), new Promise<void>(resolve => { timer = setTimeout(resolve, 3000); })]); }
+      finally { if (timer !== undefined) clearTimeout(timer); }
+      await Promise.allSettled(captured.map(([id, receiver]) => detachOpenCodeSession(id, receiver.generation, env)));
+      await discovery.close();
+    })(),
+  };
+}

package/plugins/opencode-v1/transport.ts

@@ -0,0 +1,41 @@
+import { randomInt, createHash } from 'node:crypto';
+import { renderDeliveryReminder } from '../../delivery-frame.js';
+import type { DeliveryTransport } from '../../delivery-ledger.js';
+
+type Client = { session: { promptAsync(input: unknown): Promise<{ error?: unknown; response?: Response }> } };
+let lastTime = 0, counter = 0;
+const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+
+/** OpenCode's 48-bit timestamp/counter prefix followed by 14 random base62 digits. */
+export function nativeMessageId(): string {
+  const now = Math.max(Date.now(), lastTime);
+  counter = now === lastTime ? counter + 1 : 0;
+  if (counter >= 0x1000) { lastTime = now + 1; counter = 0; } else lastTime = now;
+  const prefix = (BigInt(lastTime) * 0x1000n + BigInt(counter)).toString(16).slice(-12).padStart(12, '0');
+  return `msg_${prefix}${Array.from({ length: 14 }, () => alphabet[randomInt(62)]).join('')}`;
+}
+
+export function legacyTransport(client: Client, sessionId: string, lifetime: AbortSignal): DeliveryTransport {
+  return {
+    kind: 'opencode-server',
+    async send(card, address, context) {
+      const signal = AbortSignal.any([lifetime, context.signal]);
+      if (address.sessionId !== sessionId || signal.aborted) return 'not-capable';
+      const messageId = nativeMessageId();
+      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';
+      let onAbort: (() => void) | undefined;
+      try {
+        await Promise.race([
+          client.session.promptAsync({ path: { id: sessionId }, body: { messageID: messageId, parts: [{ type: 'text', text }] }, signal }),
+          new Promise<never>((_, reject) => { onAbort = () => reject(signal.reason); signal.addEventListener('abort', onAbort, { once: true }); if (signal.aborted) onAbort(); }),
+        ]);
+        // promptAsync acknowledges only submission, not native acceptance or presentation.
+        return 'unknown';
+      } catch { return 'unknown'; }
+      finally { if (onAbort) signal.removeEventListener('abort', onAbort); }
+    },
+  };
+}