@astrosheep/square 0.3.63 → 0.3.64

package/dist/notifications.js

@@ -1,20 +1,14 @@
 import { hostLedgerRoot } from './host-ledger-root.js';
 import path from 'node:path';
 import fs from 'node:fs';
-import { planActNotifications, } from './delivery.js';
 import { SquareError } from './model.js';
-import { matchesMentionTarget } from './runtime.js';
-import { formatActivityId, parseActivityId } from './square-core.js';
 import { displayAttentionPath } from './attention-presentation.js';
-import { openSquare, observeSquareChanges } from './square-file-adapter.js';
+import { openSquare } from './square-file-adapter.js';
 import { closeOpenSquare } from './open-square.js';
-import { notificationDelivered, resolveParticipant } from './views.js';
-import { deliverPending, observeSquare, sweepPending, sweepPendingFromState } from './delivery-operations.js';
-import { nameKey } from './model.js';
-import { projectPresentationEvidence } from './square-projections.js';
+import { deliverPending, sweepPending } from './delivery-operations.js';
+import { projectWakeEvidenceFromState } from './square-projections.js';
+import { canonicalPath } from './canonical-path.js';
 import { createHostLedgerPort } from './host-ledger-file-adapter.js';
-export { planActNotifications, matchesMentionTarget };
-export { notificationMessageId } from './delivery.js';
 export const PRIVILEGED_HOOK_BUDGET_MS = 3000;
 export function wakeGraceMs(env = process.env) {
     const value = Number.parseInt(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? '5000', 10);
@@ -23,71 +17,6 @@ export function wakeGraceMs(env = process.env) {
     }
     return value;
 }
-function wakeLabel(kind) {
-    if (kind === 'paseo')
-        return 'paseo';
-    if (kind.startsWith('codex'))
-        return 'codex-queue';
-    return kind;
-}
-function renderWakePayload(request) {
-    return [
-        `<system-reminder source="square" wake="${wakeLabel(request.route.kind)}">`,
-        `square: ${displayAttentionPath(request.location)}`,
-        `attention: ${request.activity} for ${request.participant} from ${request.actor}`,
-        '</system-reminder>',
-    ].join('\n');
-}
-function notificationIndex(ref) {
-    if (typeof ref === 'number')
-        return ref;
-    const index = parseActivityId(ref);
-    if (index === undefined)
-        throw new Error(`Invalid act ref: ${ref}`);
-    return index;
-}
-export async function hasDeliveredNotification(squarePath, name, ref) {
-    const square = await openSquare(squarePath);
-    try {
-        const recipient = (await resolveParticipant(square, name)).name;
-        return notificationDelivered(square, recipient, notificationIndex(ref));
-    }
-    finally {
-        await closeOpenSquare(square);
-    }
-}
-export async function hasAttentionNotification(squarePath, name, ref, env = process.env) {
-    const square = await openSquare(squarePath);
-    try {
-        const recipient = (await resolveParticipant(square, name)).name;
-        const index = notificationIndex(ref);
-        if (await notificationDelivered(square, recipient, index))
-            return true;
-        const root = hostLedgerRoot(env);
-        const hostLedger = createHostLedgerPort({ rootPath: root });
-        return (await projectPresentationEvidence({ hostLedger, location: squarePath, participant: recipient, activity: formatActivityId(index), now: Date.now() })).some((row) => row.outcome === 'presented');
-    }
-    finally {
-        await closeOpenSquare(square);
-    }
-}
-export async function waitForDeliveredNotification(squarePath, name, ref, opts = {}) {
-    const deadline = Date.now() + (opts.timeoutMs ?? 30000);
-    const observer = await observeSquareChanges(squarePath);
-    try {
-        while (Date.now() <= deadline) {
-            const baseline = await observer.read(opts.signal);
-            if (await hasDeliveredNotification(squarePath, name, ref))
-                return true;
-            if (!await observer.changed(baseline, Math.max(0, deadline - Date.now()), opts.signal))
-                return false;
-        }
-        return false;
-    }
-    finally {
-        observer.close();
-    }
-}
 export async function defaultWakeAdapters() {
     const adapters = [];
     try {
@@ -106,41 +35,35 @@ export async function defaultWakeAdapters() {
     }
     return adapters;
 }
-export async function createDefaultWakeTransport(hostLedger, clock, env = process.env) {
-    const adapters = await defaultWakeAdapters();
-    return createWakeTransport(env.SQUARE_DISABLE_PASEO_WAKE === '1' ? adapters.filter((adapter) => adapter.kind !== 'paseo') : adapters, hostLedger, clock);
+export async function createDefaultWakeTransport(hostLedger, clock, env = process.env, suppliedAdapters) {
+    const adapters = suppliedAdapters ?? await defaultWakeAdapters();
+    const { createClaudeWakeTransport } = await import('./claude-delivery.js');
+    return createWakeTransport(suppliedAdapters === undefined && env.SQUARE_DISABLE_PASEO_WAKE === '1' ? adapters.filter((adapter) => adapter.kind !== 'paseo') : adapters, hostLedger, clock, { 'claude-native': createClaudeWakeTransport(hostLedger, env) });
 }
-async function wakeRequestCurrentness(request, hostLedger, now) {
-    const activity = parseActivityId(request.activity);
-    if (activity === undefined)
-        return { current: false, activityPending: false, sessionBound: false, routePublished: false, observationAvailable: true };
+async function observeWakeRequest(request, hostLedger, now) {
     let square;
     try {
-        square = await openSquare(request.location, { hostLedger });
-        const current = await observeSquare({ artifact: square.artifact, hostLedger, location: request.location, now });
-        const activityPending = current.pending.some((entry) => nameKey(entry.recipient) === nameKey(request.participant)
-            && entry.notifications.some((notification) => notification.item.index === activity));
-        const sessionBound = current.bindings.some((binding) => nameKey(binding.participant) === nameKey(request.route.participant)
-            && binding.sessionId === request.route.sessionId
-            && binding.location === request.route.location);
-        const routePublished = (current.state.routes ?? []).some((route) => route.location === request.route.location
-            && nameKey(route.participant) === nameKey(request.route.participant)
-            && route.sessionId === request.route.sessionId
-            && route.kind === request.route.kind
-            && JSON.stringify(route.address) === JSON.stringify(request.route.address));
-        return { current: activityPending && sessionBound && routePublished, activityPending, sessionBound, routePublished, observationAvailable: true };
+        const location = await canonicalPath(request.location);
+        square = await openSquare(location, { hostLedger });
+        const { state } = await square.artifact.read();
+        const eligibility = await projectWakeEvidenceFromState({ state, hostLedger, location, now });
+        return { ...eligibility.currentness({ ...request, location }), observationAvailable: true };
     }
     catch {
-        return { current: false, activityPending: false, sessionBound: false, routePublished: false, observationAvailable: false };
+        return { current: false, activityPending: false, sessionBound: false, routePublished: false,
+            selectedOwner: false, cancelled: false, presented: false, observationAvailable: false };
     }
     finally {
         if (square !== undefined)
             await closeOpenSquare(square);
     }
 }
-export function createWakeTransport(adapters, hostLedger, clock) {
+export function createWakeTransport(adapters, hostLedger, clock, nativePorts = {}) {
     return {
         probe: async (route) => {
+            const native = nativePorts[route.kind];
+            if (native !== undefined)
+                return native.probe?.(route) ?? true;
             const adapter = adapters.find((candidate) => candidate.kind === route.kind);
             if (adapter === undefined)
                 return { outcome: 'not-capable', diagnostic: `no adapter for ${route.kind}` };
@@ -155,26 +78,29 @@ export function createWakeTransport(adapters, hostLedger, clock) {
             }
         },
         attempt: async (request, timeoutMs, beforeSend) => {
+            let revalidation;
+            const finalGate = beforeSend ?? (async () => {
+                revalidation = await observeWakeRequest(request, hostLedger, clock());
+                return revalidation.current;
+            });
+            const native = nativePorts[request.route.kind];
+            if (native !== undefined)
+                return native.attempt(request, timeoutMs, finalGate);
             const adapter = adapters.find((candidate) => candidate.kind === request.route.kind);
             if (adapter === undefined)
                 return { outcome: 'not-capable', diagnostic: `no adapter for ${request.route.kind}` };
             try {
-                let revalidation;
-                const result = await adapter.dispatch(request.route.address, renderWakePayload(request), async () => {
-                    if (!(await (beforeSend ?? (async () => true))()))
-                        return false;
-                    revalidation = await wakeRequestCurrentness(request, hostLedger, clock());
-                    return revalidation.current;
-                }, timeoutMs);
-                if (result.outcome === 'accepted')
-                    return { outcome: 'accepted' };
-                if (result.outcome === 'failed')
-                    return { outcome: 'failed', ...(result.signature === undefined ? {} : { signature: result.signature }), message: result.message, ...(result.diagnostic === undefined ? {} : { diagnostic: result.diagnostic }) };
-                if (result.outcome === 'unavailable')
-                    return { outcome: 'failed', signature: result.signature, message: result.message, ...(result.diagnostic === undefined ? {} : { diagnostic: result.diagnostic }), unavailable: true, ...(result.retainRoute === true ? { retainRoute: true } : {}), ...(result.routeStale === true ? { routeStale: true } : {}) };
-                if (result.outcome === 'unknown')
-                    return { outcome: 'unknown', ...(result.signature === undefined ? {} : { signature: result.signature }), ...(result.message === undefined ? {} : { message: result.message }), ...(result.diagnostic === undefined ? {} : { diagnostic: result.diagnostic }) };
-                if (result.outcome === 'cancelled' && revalidation !== undefined && !revalidation.current) {
+                const kind = request.route.kind;
+                const payload = [
+                    `<system-reminder source="square" wake="${kind === 'paseo' ? 'paseo' : kind.startsWith('codex') ? 'codex-queue' : kind}">`,
+                    `square: ${displayAttentionPath(request.location)}`,
+                    `attention: ${request.activity} for ${request.participant} from ${request.actor}`,
+                    '</system-reminder>',
+                ].join('\n');
+                const result = await adapter.dispatch(request.route.address, payload, finalGate, timeoutMs, request);
+                if (result.outcome !== 'gate-rejected')
+                    return result;
+                if (revalidation !== undefined && !revalidation.current) {
                     return {
                         outcome: 'failed',
                         signature: 'pre_send_revalidation_failed',
@@ -202,8 +128,7 @@ export async function processActNotificationsOnce(squarePath, actIndex, opts = {
     });
     const square = await openSquare(squarePath, { clock: now, hostLedger, env });
     try {
-        const adapters = opts.adapters ?? await defaultWakeAdapters();
-        const transport = createWakeTransport(adapters, hostLedger, now);
+        const transport = await createDefaultWakeTransport(hostLedger, now, env, opts.adapters);
         try {
             return await deliverPending({ artifact: square.artifact, hostLedger, transport, location: squarePath, activity: actIndex, timeoutMs: Number(env.SQUARE_NOTIFY_DELIVERY_WAIT_MS ?? 5000), now: now() });
         }
@@ -237,7 +162,7 @@ export async function sweepPrivilegedPending(cwd, env = process.env, suppliedAda
     catch { /* no local square directory */ }
     if (remainingMs() === 0 || signal?.aborted)
         return;
-    const adapters = suppliedAdapters ?? await defaultWakeAdapters();
+    const transport = await createDefaultWakeTransport(hostLedger, Date.now, env, suppliedAdapters);
     for (const squarePath of paths) {
         if (remainingMs() === 0 || signal?.aborted)
             break;
@@ -249,7 +174,6 @@ export async function sweepPrivilegedPending(cwd, env = process.env, suppliedAda
                 const limit = Number.parseInt(env.SQUARE_NOTIFY_SWEEP_LIMIT ?? '8', 10);
                 const graceMs = 0;
                 const selected = await sweepPending({ artifact: square.artifact, hostLedger, location: squarePath, now: Date.now(), graceMs, limit: Number.isFinite(limit) && limit > 0 ? limit : 8 }).catch(() => []);
-                const transport = createWakeTransport(adapters, hostLedger, Date.now);
                 for (const actIndex of selected) {
                     const remaining = remainingMs();
                     if (remaining === 0 || signal?.aborted)
@@ -266,11 +190,6 @@ export async function sweepPrivilegedPending(cwd, env = process.env, suppliedAda
         catch { /* stale index entries are ignored by the hook */ }
     }
 }
-/** Select sweep candidates from one frozen snapshot and one delivery replay. */
-export async function pendingNotificationSweepFromState(squarePath, state, now, env, limit, deriveDelivery) {
-    const ledger = createHostLedgerPort({ rootPath: hostLedgerRoot(env) });
-    return sweepPendingFromState({ state, hostLedger: ledger, location: squarePath, now, graceMs: wakeGraceMs(env), limit, deriveDelivery });
-}
 /** Select old pending attention at a bounded action boundary for an explicit executor. */
 export async function sweepPendingNotifications(squarePath, opts = {}) {
     const env = opts.env ?? process.env;

package/dist/opencode-delivery.d.ts

@@ -0,0 +1,14 @@
+import { type OpenCodeNativeSession } from './packages/agent-delivery/src/opencode-native.js';
+export interface OpenCodeContextMessage {
+    readonly id?: string;
+    readonly role: string;
+    readonly content: readonly {
+        readonly type: string;
+        readonly text?: string;
+    }[];
+}
+/** Only the matching prepared primary context authorizes presentation, never admission. */
+export declare function observeOpenCodeContext(sessionId: string, messages: readonly OpenCodeContextMessage[], env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
+/** One existing observer and the existing dispatch owner; no second queue or evidence store. */
+export declare function receiveOpenCodePending(target: OpenCodeNativeSession, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<void>;
+export declare function publishOpenCodeRoutes(sessionId: string, env: NodeJS.ProcessEnv, signal: AbortSignal): Promise<boolean>;

package/dist/opencode-delivery.js

@@ -0,0 +1,171 @@
+import { nameKey } from './model.js';
+import { observeSessionPending, sessionInbox } from './inbox.js';
+import { hostLedgerForEnv } from './registry.js';
+import { openSquare } from './square-file-adapter.js';
+import { closeOpenSquare } from './open-square.js';
+import { nativePendingPreview, presentationSuppressesWake, projectPresentationEvidence } from './square-projections.js';
+import { presentPending } from './presentation-operations.js';
+import { deliverPending } from './delivery-operations.js';
+import { createWakeTransport } from './notifications.js';
+import { publishWakeRoute } from './routes.js';
+import { formatActivityId, parseActivityId } from './square-core.js';
+import { createNativeInputId, sendNativeText } from './packages/agent-delivery/src/opencode-native.js';
+const routeKind = 'opencode-server';
+const key = (location, participant, index) => `${location}\0${nameKey(participant)}\0${index}`;
+/** The one native pending preview: the audience/catch/epoch fence before send and inside presentation. */
+function preview(state, owner, index) {
+    return nativePendingPreview(state, { location: owner.location, routeKind, sessionId: owner.session, participant: owner.participant, actIndex: index, epoch: owner.epoch, address: { sessionId: owner.session }, cancelledThrough: owner.cancelledThrough, now: Date.now() });
+}
+function createOpenCodeWakeTransport(target, env, lifetime) {
+    const ledger = hostLedgerForEnv(env);
+    return {
+        probe: async (route) => !lifetime.aborted && route.kind === routeKind && route.sessionId === target.sessionId && route.address.sessionId === target.sessionId,
+        async attempt(request, timeoutMs, beforeSend) {
+            const signal = AbortSignal.any([lifetime, AbortSignal.timeout(timeoutMs)]);
+            const deadline = Date.now() + timeoutMs;
+            // Start the native call under the ownership fence, but await it OUTSIDE: prompt may
+            // enter our context hook synchronously and that hook needs the same ownership lock.
+            const started = await ledger.withClaimLock(async () => {
+                if (signal.aborted || request.route.sessionId !== target.sessionId || !request.claimToken
+                    || !await (beforeSend?.() ?? Promise.resolve(true)))
+                    return undefined;
+                const owner = (await ledger.listPresence({ location: request.location, participant: request.participant, session: target.sessionId }))
+                    .find((binding) => binding.channel === 'opencode' && binding.epoch === request.route.epoch);
+                const index = parseActivityId(request.activity);
+                if (!owner || index === undefined)
+                    return undefined;
+                const square = await openSquare(owner.location, { hostLedger: ledger, env, signal });
+                try {
+                    const prepared = preview((await square.artifact.read(signal)).state, owner, index);
+                    if (!prepared)
+                        return undefined;
+                    const row = { location: owner.location, participant: owner.participant, session: target.sessionId,
+                        activity: request.activity, kind: 'wake', outcome: 'dispatching', routeKind, attemptN: request.attemptN, claimToken: request.claimToken,
+                        nativeDelivery: { harness: 'opencode', epoch: owner.epoch ?? 0, inputId: createNativeInputId(), payload: prepared.payload } };
+                    if (!await ledger.prepareNativeWake(row) || !await (beforeSend?.() ?? Promise.resolve(true)) || signal.aborted
+                        || preview((await square.artifact.read(signal)).state, owner, index)?.payload !== prepared.payload)
+                        return undefined;
+                    return { sending: sendNativeText(target, prepared.payload, { inputId: row.nativeDelivery.inputId, delivery: 'steer',
+                            timeoutMs: Math.max(1, deadline - Date.now()), signal }) };
+                }
+                finally {
+                    await closeOpenSquare(square);
+                }
+            }, signal);
+            if (!started)
+                return { outcome: 'not-capable', diagnostic: 'OpenCode attention, binding or local delivery generation changed before send.' };
+            const result = await started.sending;
+            if (result.state === 'accepted')
+                return { outcome: 'accepted' };
+            if (result.state === 'unavailable')
+                return { outcome: 'failed', unavailable: true, retainRoute: true, signature: result.code };
+            return { outcome: 'unknown', signature: result.code };
+        },
+    };
+}
+/** Only the matching prepared primary context authorizes presentation, never admission. */
+export async function observeOpenCodeContext(sessionId, messages, env, signal) {
+    const ledger = hostLedgerForEnv(env);
+    await ledger.withClaimLock(async () => {
+        if (signal.aborted)
+            return;
+        const rows = (await ledger.listEvidence({ kind: 'wake', session: sessionId })).filter((row) => row.nativeDelivery?.harness === 'opencode' && !!row.claimToken && ['dispatching', 'unknown', 'accepted'].includes(row.outcome));
+        for (const row of rows) {
+            if (signal.aborted || !messages.some((message) => message.id === row.nativeDelivery.inputId && message.role === 'user'
+                && message.content.every((part) => part.type === 'text' && typeof part.text === 'string')
+                && message.content.map((part) => part.text).join('') === row.nativeDelivery.payload))
+                continue;
+            const owner = (await ledger.listPresence({ location: row.location, participant: row.participant, session: sessionId }))
+                .find((binding) => binding.channel === 'opencode' && binding.epoch === row.nativeDelivery.epoch);
+            const index = parseActivityId(row.activity);
+            if (!owner || index === undefined)
+                continue;
+            const square = await openSquare(row.location, { hostLedger: ledger, env, signal });
+            try {
+                const prepared = preview((await square.artifact.read(signal)).state, owner, index);
+                if (!prepared || prepared.payload !== row.nativeDelivery.payload)
+                    continue;
+                const prior = await projectPresentationEvidence({ hostLedger: ledger, location: row.location, participant: row.participant, sessionId, activity: row.activity });
+                if (presentationSuppressesWake(prior))
+                    continue;
+                await presentPending({ artifact: square.artifact, hostLedger: ledger, location: row.location, participant: row.participant, session: sessionId,
+                    activity: row.activity, sink: { present() { } }, markSeen: !prepared.clipped, signal,
+                    current: (state) => !signal.aborted && preview(state, owner, index)?.payload === row.nativeDelivery.payload });
+            }
+            finally {
+                await closeOpenSquare(square);
+            }
+        }
+    }, signal);
+}
+/** One existing observer and the existing dispatch owner; no second queue or evidence store. */
+export async function receiveOpenCodePending(target, env, signal) {
+    const ledger = hostLedgerForEnv(env);
+    const observer = await observeSessionPending(target.sessionId, env);
+    const excluded = new Set();
+    const refreshExclusions = async () => {
+        excluded.clear();
+        const owners = await ledger.listPresence({ session: target.sessionId });
+        for (const row of await ledger.listEvidence({ kind: 'wake', session: target.sessionId })) {
+            const index = parseActivityId(row.activity);
+            const current = owners.some((owner) => owner.location === row.location && nameKey(owner.participant) === nameKey(row.participant) && owner.epoch === row.nativeDelivery?.epoch);
+            if (index !== undefined && (['accepted', 'unknown'].includes(row.outcome) || row.outcome === 'dispatching' && current && row.nativeDelivery?.harness === 'opencode'))
+                excluded.add(key(row.location, row.participant, index));
+        }
+        for (const membership of await sessionInbox(target.sessionId, env, signal)) {
+            const owner = owners.find((binding) => binding.location === membership.squarePath && nameKey(binding.participant) === nameKey(membership.name));
+            for (const note of membership.notifications)
+                if (note.actIndex <= (owner?.cancelledThrough ?? -1))
+                    excluded.add(key(membership.squarePath, membership.name, note.actIndex));
+        }
+    };
+    const transport = createWakeTransport([], ledger, Date.now, { [routeKind]: createOpenCodeWakeTransport(target, env, signal) });
+    try {
+        await refreshExclusions();
+        let pending = await observer.wait(Infinity, { signal, excludeKeys: excluded });
+        while (!signal.aborted && pending.length > 0) {
+            let armed;
+            const ready = new Promise((resolve) => { armed = resolve; });
+            // Capture the next state edge BEFORE dispatch. Evidence failures alone do not retry.
+            const next = observer.wait(Infinity, { signal, excludeKeys: excluded, skipImmediate: true, onChangeArmed: armed })
+                .catch(() => { armed(false); return []; });
+            if (!await ready || signal.aborted)
+                break;
+            for (const membership of pending) {
+                const square = await openSquare(membership.squarePath, { hostLedger: ledger, env, signal });
+                try {
+                    for (const note of membership.notifications) {
+                        if (signal.aborted || excluded.has(key(membership.squarePath, membership.name, note.actIndex)))
+                            continue;
+                        await deliverPending({ artifact: square.artifact, hostLedger: ledger, transport, location: square.location, activity: formatActivityId(note.actIndex), now: Date.now() });
+                    }
+                }
+                finally {
+                    await closeOpenSquare(square);
+                }
+            }
+            await refreshExclusions();
+            pending = await next;
+        }
+    }
+    finally {
+        observer.close();
+    }
+}
+export async function publishOpenCodeRoutes(sessionId, env, signal) {
+    const ledger = hostLedgerForEnv(env);
+    return ledger.withClaimLock(async () => {
+        const owners = (await ledger.listPresence({ session: sessionId })).filter((binding) => binding.channel === 'opencode');
+        for (const owner of owners) {
+            const square = await openSquare(owner.location, { hostLedger: ledger, env, signal });
+            try {
+                await publishWakeRoute(square.artifact, { location: owner.location, participant: owner.participant, sessionId, channel: 'opencode',
+                    kind: routeKind, address: { sessionId }, epoch: owner.epoch }, { requireCurrentSession: true });
+            }
+            finally {
+                await closeOpenSquare(square);
+            }
+        }
+        return owners.length > 0;
+    }, signal);
+}

package/dist/opencode.d.ts

@@ -1,19 +1,40 @@
-/** OpenCode's server plugin entrypoint for the published Square package. */
-export default function squareOpenCodePlugin(): Promise<{
-    event: ({ event }: {
-        event: {
-            type?: string;
-            properties?: Record<string, any>;
+import { type OpenCodeSessionCapability } from './packages/agent-delivery/src/opencode-native.js';
+import { type OpenCodeContextMessage } from './opencode-delivery.js';
+interface OpenCodePluginContext {
+    readonly app: {
+        readonly version: string;
+    };
+    readonly location: {
+        readonly directory: string;
+        readonly project: {
+            readonly id: string;
         };
-    }) => 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>;
-}>;
+        readonly workspaceID?: string;
+    };
+    readonly session: OpenCodeSessionCapability & {
+        hook(name: 'prompt', callback: (event: {
+            sessionID: string;
+        }) => Promise<void>): Promise<unknown>;
+        hook(name: 'context', callback: (event: {
+            sessionID: string;
+            messages: OpenCodeContextMessage[];
+        }) => Promise<void>): Promise<unknown>;
+    };
+    readonly event: {
+        subscribe(options: {
+            signal: AbortSignal;
+        }): AsyncIterable<{
+            type: string;
+            data: {
+                sessionID?: string;
+                reason?: string;
+            };
+        }>;
+    };
+}
+/** Actual OpenCode 2.0.20 server plugin. Harness identity belongs to ctx, never process.env. */
+declare const _default: {
+    id: string;
+    setup(ctx: OpenCodePluginContext): Promise<() => Promise<void>>;
+};
+export default _default;