opencode-courier 0.2.3 → 0.4.0

package/dist/tools.js

@@ -1,228 +0,0 @@
-import { Schema } from "effect";
-import { cleanup } from "./cleanup.js";
-import { describeFailure, listChildren, send, spawn, status } from "./courier.js";
-import { cancel, schedule } from "./later.js";
-import { answerText, cancelText, childrenText, cleanupText, laterText, REPLIES, sendText, spawnText, statusText, subscribeText, unsubscribeText, } from "./notices.js";
-import { answerQuestion, isQuestion } from "./question/index.js";
-import { answer } from "./relay.js";
-import { subscribe, unsubscribe } from "./webhook.js";
-/**
- * The courier tools: their input schemas, descriptions, and what each returns. The descriptions are
- * model-facing like the texts in `notices.ts`, and snapshotted with them in `test/notices.test.ts`.
- */
-export const SpawnInput = Schema.Struct({
-    task: Schema.String.annotate({ description: "What the new session should do. It is told who started it and how to report back." }),
-    title: Schema.optional(Schema.String.annotate({ description: "Session title; defaults to the task's first line." })),
-    agent: Schema.optional(Schema.String.annotate({ description: "Agent to run the session with; defaults to the default agent." })),
-    isolate: Schema.optional(Schema.Boolean.annotate({ description: "Run the session in its own git worktree so parallel sessions don't share files." })),
-});
-export const SendInput = Schema.Struct({
-    sessionID: Schema.String.annotate({ description: "The session to deliver to." }),
-    message: Schema.String.annotate({ description: "The message text." }),
-    queue: Schema.optional(Schema.Boolean.annotate({ description: "Wait until the target's current turn ends instead of steering it now." })),
-});
-export const StatusInput = Schema.Struct({
-    sessionID: Schema.String.annotate({ description: "The session to look at." }),
-});
-export const ChildrenInput = Schema.Struct({
-    sessionID: Schema.optional(Schema.String.annotate({ description: "The session whose children to list; defaults to this one." })),
-});
-export const CleanupInput = Schema.Struct({
-    sessionID: Schema.String.annotate({ description: "The isolated child whose worktree to remove." }),
-    force: Schema.optional(Schema.Boolean.annotate({
-        description: "Remove it even with uncommitted changes or commits on no branch; that work is lost.",
-    })),
-});
-export const LaterInput = Schema.Struct({
-    message: Schema.String.annotate({ description: "The message to deliver." }),
-    delayMinutes: Schema.optional(
-    // Some models send the number as a string ("3", "3.0") whatever the schema says, and resend it
-    // unchanged after the error, so a string is accepted and schedule reads it as a number.
-    Schema.Union([Schema.Number, Schema.String]).annotate({
-        description: "Deliver this many minutes from now. Give this or at.",
-    })),
-    at: Schema.optional(Schema.String.annotate({ description: "Deliver at this ISO 8601 time. Give this or delayMinutes." })),
-    sessionID: Schema.optional(Schema.String.annotate({ description: "The session to deliver to; defaults to this one." })),
-});
-export const AnswerInput = Schema.Struct({
-    sessionID: Schema.String.annotate({ description: "The session you started that is waiting, as its notice names it." }),
-    requestID: Schema.String.annotate({ description: "The request id from the notice." }),
-    reply: Schema.optional(Schema.Literals(REPLIES).annotate({
-        description: "For a permission request: the choice the person made, once, always (only when the notice offers it) or reject.",
-    })),
-    message: Schema.optional(Schema.String.annotate({ description: "For a permission request, with reject: the person's reason, passed on with the refusal." })),
-    answers: Schema.optional(Schema.Array(Schema.Union([Schema.String, Schema.Array(Schema.String)])).annotate({
-        description: "For a question: one entry per question, in order, each the label the person chose or the text they gave, " +
-            "or a list of labels where the question allows several.",
-    })),
-});
-export const CancelInput = Schema.Struct({
-    id: Schema.String.annotate({ description: "The id courier_later returned." }),
-});
-export const SubscribeInput = Schema.Struct({
-    topic: Schema.String.annotate({
-        description: "owner/repo for every event of a GitHub repository, owner/repo#<number> for one pull request or issue " +
-            "(reviews, comments, completed CI runs), or a plain name for deliveries posted to /hook/<name>.",
-    }),
-    sessionID: Schema.optional(Schema.String.annotate({ description: "The session to subscribe; defaults to this one." })),
-});
-export const UnsubscribeInput = Schema.Struct({
-    topic: Schema.optional(Schema.String.annotate({ description: "The topic to drop; all of this session's when omitted." })),
-    sessionID: Schema.optional(Schema.String.annotate({ description: "The session to unsubscribe; defaults to this one." })),
-});
-const rethrow = (tool) => (error) => {
-    throw describeFailure(tool, error);
-};
-// One tool answers both: a question's id is the plugin's own, a permission request's OpenCode's.
-async function answerRequest(ports, callerID, input) {
-    const { sessionID, requestID } = input;
-    if (isQuestion(requestID)) {
-        if (input.reply !== undefined || input.message !== undefined)
-            throw new Error(`${requestID} is a question: pass the person's answers in answers, not reply or message.`);
-        if (input.answers === undefined)
-            throw new Error(`${requestID} is a question: answers is required, one entry per question.`);
-        return answerQuestion(ports.questions, callerID, { sessionID, requestID, answers: input.answers });
-    }
-    if (input.answers !== undefined)
-        throw new Error(`${requestID} is a permission request: pass the person's choice in reply (once, always or reject), not answers.`);
-    if (input.reply === undefined)
-        throw new Error(`${requestID} is a permission request: reply is required, once, always or reject.`);
-    return answer(ports.answer, ports.waiting, callerID, {
-        sessionID,
-        requestID,
-        reply: input.reply,
-        ...(input.message !== undefined ? { message: input.message } : {}),
-    });
-}
-/** Adds the courier tools, each a direct tool rather than a code-mode one. */
-export function addTools(tools, ports) {
-    tools.add({
-        name: "courier_spawn",
-        options: { codemode: false },
-        description: "Start a new OpenCode session on a task and return immediately. It runs on your model. The session reports " +
-            "back with courier_send, which wakes this session, and you are told if its turn fails instead, it waits for a " +
-            "permission or it asks a question. DO NOT poll it or call courier_status in a loop: once you have started the sessions " +
-            "you need, end your turn by replying without calling more tools; each report starts a new turn in which you " +
-            "carry on. For long tasks, also courier_later a check-in for yourself in case it never reports, and " +
-            "courier_cancel it when it does.",
-        input: SpawnInput,
-        execute: async (input, context) => {
-            const child = await spawn(ports.courier, context.sessionID, input).catch(rethrow("courier_spawn"));
-            return { content: spawnText(child), metadata: child };
-        },
-    });
-    tools.add({
-        name: "courier_send",
-        options: { codemode: false },
-        description: "Deliver a message to another OpenCode session. If that session is idle, OpenCode starts a new turn for it. " +
-            "Use it to report back to the session that started you, or to steer a session you started.",
-        input: SendInput,
-        execute: async (input, context) => {
-            const delivered = await send(ports.courier, context.sessionID, input).catch(rethrow("courier_send"));
-            return { content: sendText(input.sessionID), metadata: delivered };
-        },
-    });
-    tools.add({
-        name: "courier_status",
-        options: { codemode: false },
-        description: "Look once at a session's state and its last reply, e.g. on a scheduled check-in. Not for waiting: " +
-            "sessions you started report back on their own.",
-        input: StatusInput,
-        execute: async (input) => {
-            const result = await status(ports.courier, input).catch(rethrow("courier_status"));
-            return { content: statusText(result), metadata: result };
-        },
-    });
-    tools.add({
-        name: "courier_children",
-        options: { codemode: false },
-        description: "List the sessions this one started with courier_spawn, with each one's state and last reply, e.g. after a " +
-            "compaction or restart. Like courier_status, for a one-off look, not for waiting.",
-        input: ChildrenInput,
-        execute: async (input, context) => {
-            const listed = await listChildren(ports.courier, input.sessionID || context.sessionID).catch(rethrow("courier_children"));
-            return { content: childrenText(listed), metadata: { children: listed } };
-        },
-    });
-    tools.add({
-        name: "courier_cleanup",
-        options: { codemode: false },
-        description: "Remove the git worktree of a session you started with isolate: true, once you have what you need from it, " +
-            "and drop it from courier_children. A worktree with uncommitted changes or commits on no branch is kept and " +
-            "the result lists them; commit or branch what you want, or pass force: true to discard it.",
-        input: CleanupInput,
-        execute: async (input, context) => {
-            const result = await cleanup(ports.cleanup, context.sessionID, input).catch(rethrow("courier_cleanup"));
-            return { content: cleanupText(result), metadata: result };
-        },
-    });
-    tools.add({
-        name: "courier_answer",
-        options: { codemode: false },
-        description: "Pass on the answer to a permission request or a question that a session you started with courier_spawn (or " +
-            "one started from it) waits on, after a notice from it named the request. The answer is the person's, not yours: " +
-            "first ask the person you are working with, offering the choices the notice lists, then call this with what " +
-            "they chose: reply for a permission request, answers for a question. Never choose for them. The session " +
-            "carries on once it has the answer.",
-        input: AnswerInput,
-        execute: async (input, context) => {
-            const result = await answerRequest(ports, context.sessionID, input).catch(rethrow("courier_answer"));
-            return { content: answerText(result), metadata: result };
-        },
-    });
-    tools.add({
-        name: "courier_later",
-        options: { codemode: false },
-        description: "Schedule a message for a session (this one by default), delivered when due and waking it if idle. " +
-            "Use it as a safety net when you start sessions: schedule one check-in, end your turn by replying without " +
-            "calling more tools, and cancel it with courier_cancel if the child reports first. Survives server restarts; " +
-            "may arrive up to ~15 seconds late.",
-        input: LaterInput,
-        execute: async (input, context) => {
-            const entry = await schedule(ports.later, context.sessionID, input).catch(rethrow("courier_later"));
-            const fireAt = new Date(entry.fireAt).toISOString();
-            return {
-                content: laterText(entry, fireAt, entry.sessionID === context.sessionID),
-                metadata: { id: entry.id, fireAt, sessionID: entry.sessionID },
-            };
-        },
-    });
-    tools.add({
-        name: "courier_cancel",
-        options: { codemode: false },
-        description: "Cancel a message scheduled with courier_later, e.g. because the child it was waiting for reported.",
-        input: CancelInput,
-        execute: async (input) => {
-            const cancelled = await cancel(ports.later, input.id).catch(rethrow("courier_cancel"));
-            return { content: cancelText(input.id, cancelled), metadata: { id: input.id, cancelled } };
-        },
-    });
-    tools.add({
-        name: "courier_subscribe",
-        options: { codemode: false },
-        description: "Wake a session (this one by default) when a webhook arrives for a topic: a GitHub repository, one of its " +
-            "pull requests or issues (reviews, comments, completed CI runs), or a named generic hook. Each matching " +
-            "delivery arrives as a message, queued behind any running turn. End your turn and wait; do not poll.",
-        input: SubscribeInput,
-        execute: async (input, context) => {
-            const sessionID = input.sessionID ?? context.sessionID;
-            const subscription = await subscribe(ports.hooks, sessionID, input.topic).catch(rethrow("courier_subscribe"));
-            const receiving = await ports.receiving();
-            return {
-                content: subscribeText(sessionID, subscription.topic, receiving),
-                metadata: { sessionID, topic: subscription.topic, receiver: receiving },
-            };
-        },
-    });
-    tools.add({
-        name: "courier_unsubscribe",
-        options: { codemode: false },
-        description: "Stop webhook deliveries for a topic, or all of a session's topics, e.g. once its pull request is merged.",
-        input: UnsubscribeInput,
-        execute: async (input, context) => {
-            const sessionID = input.sessionID ?? context.sessionID;
-            const dropped = await unsubscribe(ports.hooks, sessionID, input.topic).catch(rethrow("courier_unsubscribe"));
-            return { content: unsubscribeText(sessionID, dropped), metadata: { sessionID, dropped } };
-        },
-    });
-}

package/dist/version.d.ts

@@ -1,22 +0,0 @@
-import type { App } from "@opencode/plugin/app";
-/** The versions a build of the plugin carries: its own, and the OpenCode it was built and tested against. */
-export interface BuiltVersions {
-    readonly plugin: string;
-    readonly opencode: string;
-}
-/**
- * Reads the versions from the package's own package.json, which sits next to `dist/` in the
- * published package as it does next to `src/` in the repository: `version`, and the exact
- * `@opencode/plugin` version under devDependencies, the one installed for the build and both test
- * suites; the peer dependency names the same exact version, as the copy of the plugin API that
- * `opencode plugin add` installs next to the plugin. Throws when the file cannot be read or does
- * not hold both.
- */
-export declare function builtVersions(): BuiltVersions;
-/**
- * The line for the server log when the running OpenCode is not the one the plugin was built
- * against; undefined when it is. Logged once per plugin load, never in a tool result. An OpenCode
- * whose plugin context does not report a version, as one from before the pinned API or after a
- * change to it may not, is the case the line is for, so it still names the pin then.
- */
-export declare function versionNotice(built: BuiltVersions, app: Partial<Pick<App, "version" | "channel">> | undefined): string | undefined;

package/dist/watch.d.ts

@@ -1,61 +0,0 @@
-import type { Hub, WatchPorts, WatchState } from "./hub.js";
-import { type ExecutionError } from "./notices.js";
-import { type FormCreated, type FormSettled, type PermissionAsked, type PermissionReplied } from "./relay.js";
-export type { FormsTold, WatchPorts, WatchState } from "./hub.js";
-/** How long to wait before subscribing again after the event stream ended or broke. */
-export declare const RESUBSCRIBE_MS = 5000;
-/** The part of OpenCode's `session.execution.failed` event the notice is made from. */
-export interface ExecutionFailed {
-    readonly id: string;
-    readonly data: {
-        readonly sessionID: string;
-        readonly error: ExecutionError;
-    };
-}
-/**
- * Tells the parent of a child whose turn failed, since a child that cannot reach its model cannot
- * call courier_send. Returns the parents told.
- */
-export declare function reportFailure(ports: WatchPorts, seen: Set<string>, event: ExecutionFailed): Promise<string[]>;
-/**
- * Tells the session at the top, the parent of a child or the session a chain of children started
- * from, what a waiting child asks and which answers there are, waking it. Returns the sessions told.
- */
-export declare function reportAsked(ports: WatchPorts, state: WatchState, event: PermissionAsked): Promise<string[]>;
-/**
- * Tells the session that was told about a request that it has been answered some other way, in the
- * child's own session or along with another answer, so it does not pass on a stale question.
- * Requests answered through courier_answer are no longer waiting and are skipped.
- */
-export declare function reportReplied(ports: WatchPorts, state: WatchState, event: PermissionReplied): Promise<string[]>;
-/**
- * Tells the session at the top about a form OpenCode shows in a spawned session, such as web
- * search asking for its provider, which only the person can answer there. Question forms are
- * left to the question relay, which passes every question of a spawned session on.
- */
-export declare function reportForm(ports: WatchPorts, state: WatchState, event: FormCreated): Promise<string[]>;
-/** Tells the session told about a form that it was answered or withdrawn, so it does not send the person to a form that is gone. */
-export declare function reportFormSettled(ports: WatchPorts, state: WatchState, event: FormSettled): Promise<string[]>;
-/**
- * Relays the requests that spawned sessions already wait on, in every loaded location, which the
- * event stream does not repeat: those asked while it was down, before the watcher (re)subscribed.
- */
-export declare function relayPending(ports: WatchPorts, state: WatchState): Promise<void>;
-/**
- * Follows OpenCode's events until `signal` aborts, telling parents when a spawned child's turn
- * fails, when it waits for a permission or on a form and when that is answered without them, and
- * noting for the question relay the question forms shown, which it waits for, and the locations
- * shutting down, whose withdrawn forms must not pass for dismissals. Once `signal` aborts it ends
- * as soon as the event it is handling, and the relay of the requests already pending, are done,
- * without waiting for the stream to close: an unloading instance's leave waits for that.
- */
-export declare function watchChildren(ports: WatchPorts, state: WatchState, signal: AbortSignal, retryMs?: number): Promise<void>;
-/**
- * Makes the hub start its subscriptions to OpenCode's events with this copy's watcher, the copy loaded
- * last's, as after an update; `join` starts them. Every instance in the process is sent every event,
- * so one subscription would serve them all; the second is a standby, already connected when the
- * first one's member leaves, so no event goes unseen then. Both handle every event, and the claim
- * sets tell each once. Like any (re)subscription, a new one relays the requests already pending,
- * which the claim sets tell once too.
- */
-export declare function watchFromHub(hub: Pick<Hub, "subscribe">, state: WatchState, retryMs?: number): void;

package/dist/watch.js

@@ -1,289 +0,0 @@
-import { addBounded, setBounded } from "./bounded.js";
-import { envelope, failureNotice, formNotice, formSettledNotice, kindOf, permissionNotice, permissionSettledNotice, } from "./notices.js";
-import { eventsFollowed, eventsLeft, formShown, formsMayHaveBeenMissed, locationClosing } from "./question/index.js";
-import { listEverywhere, QUESTION_FORM, } from "./relay.js";
-import { allEntries, entriesOf, lineage } from "./roster.js";
-/** How long to wait before subscribing again after the event stream ended or broke. */
-export const RESUBSCRIBE_MS = 5_000;
-/** How many handled event ids, and waiting or answered requests, are remembered. */
-const SEEN_MAX = 1_000;
-/** Claims a value in one of the shared sets; false when it was claimed already. */
-const claim = (set, value) => addBounded(set, value, SEEN_MAX);
-/**
- * Tells the parent of a child whose turn failed, since a child that cannot reach its model cannot
- * call courier_send. Returns the parents told.
- */
-export async function reportFailure(ports, seen, event) {
-    if (!claim(seen, event.id))
-        return [];
-    const { sessionID, error } = event.data;
-    const entries = await entriesOf(ports.storage, sessionID);
-    await Promise.all(entries.map((entry) => ports.session.synthetic({
-        sessionID: entry.parentID,
-        text: envelope(sessionID, failureNotice(entry.title, error), { failed: error.type }),
-        description: `Session ${sessionID} failed`,
-        metadata: { source: "courier", from: sessionID, failed: true },
-        delivery: "steer",
-    })));
-    return entries.map((entry) => entry.parentID);
-}
-/** The session at the top of a lineage: where its permission requests go, since that is where the person is. */
-const topOf = (chain) => chain.at(-1).parentID;
-/**
- * Tells the session at the top, the parent of a child or the session a chain of children started
- * from, what a waiting child asks and which answers there are, waking it. Returns the sessions told.
- */
-export async function reportAsked(ports, state, event) {
-    if (!claim(state.seen, event.id))
-        return [];
-    const request = event.data;
-    const chain = await lineage(ports.storage, request.sessionID);
-    // Claimed only now, after the lookup: a request answered meanwhile is in `answered`, and one
-    // already relayed, from the event or from the pending list, is in `waiting`.
-    if (!chain.length || state.answered.has(request.id) || !claim(state.waiting, request.id))
-        return [];
-    const startedBy = chain.length > 1 ? chain[0].parentID : undefined;
-    await ports.session.synthetic({
-        sessionID: topOf(chain),
-        text: envelope(request.sessionID, permissionNotice(chain[0].title, request, startedBy), {
-            asks: "permission",
-            request: request.id,
-        }),
-        description: `Session ${request.sessionID} asks for permission`,
-        metadata: { source: "courier", from: request.sessionID, asks: "permission", requestID: request.id },
-        delivery: "steer",
-    });
-    return [topOf(chain)];
-}
-/**
- * Tells the session that was told about a request that it has been answered some other way, in the
- * child's own session or along with another answer, so it does not pass on a stale question.
- * Requests answered through courier_answer are no longer waiting and are skipped.
- */
-export async function reportReplied(ports, state, event) {
-    if (!claim(state.seen, event.id))
-        return [];
-    const { sessionID, requestID, reply } = event.data;
-    if (!state.waiting.delete(requestID)) {
-        claim(state.answered, requestID);
-        return [];
-    }
-    const chain = await lineage(ports.storage, sessionID);
-    if (!chain.length)
-        return [];
-    await ports.session.synthetic({
-        sessionID: topOf(chain),
-        text: envelope(sessionID, permissionSettledNotice(chain[0].title, requestID, reply), { answered: reply, request: requestID }),
-        description: `Session ${sessionID} no longer asks for permission`,
-        metadata: { source: "courier", from: sessionID, answered: reply, requestID },
-        delivery: "steer",
-    });
-    return [topOf(chain)];
-}
-/**
- * Tells the session at the top about a form OpenCode shows in a spawned session, such as web
- * search asking for its provider, which only the person can answer there. Question forms are
- * left to the question relay, which passes every question of a spawned session on.
- */
-export async function reportForm(ports, state, event) {
-    if (!claim(state.seen, event.id))
-        return [];
-    const form = event.data.form;
-    if (kindOf(form) === QUESTION_FORM)
-        return [];
-    const chain = await lineage(ports.storage, form.sessionID);
-    // As with a permission request, claimed after the lookup, so a form settled meanwhile is not told.
-    if (!chain.length || state.forms.settled.has(form.id) || state.forms.told.has(form.id))
-        return [];
-    const startedBy = chain.length > 1 ? chain[0].parentID : undefined;
-    const kind = kindOf(form);
-    const telling = ports.session.synthetic({
-        sessionID: topOf(chain),
-        text: envelope(form.sessionID, formNotice(chain[0].title, form, startedBy), {
-            asks: "form",
-            form: form.id,
-            ...(kind ? { kind } : {}),
-        }),
-        description: `Session ${form.sessionID} shows a form`,
-        metadata: { source: "courier", from: form.sessionID, asks: "form", formID: form.id, ...(kind ? { kind } : {}) },
-        delivery: "steer",
-    });
-    setBounded(state.forms.told, form.id, telling, SEEN_MAX);
-    await telling;
-    return [topOf(chain)];
-}
-/** Tells the session told about a form that it was answered or withdrawn, so it does not send the person to a form that is gone. */
-export async function reportFormSettled(ports, state, event) {
-    if (!claim(state.seen, event.id))
-        return [];
-    const { id, sessionID } = event.data;
-    const telling = state.forms.told.get(id);
-    if (!telling) {
-        claim(state.forms.settled, id);
-        return [];
-    }
-    state.forms.told.delete(id);
-    const settled = event.type === "form.replied" ? "answered" : "cancelled";
-    // After the notice that the form is shown, which another instance may still be sending, so the
-    // settling never arrives first; and not at all when that notice did not go out.
-    const [chain, told] = await Promise.all([lineage(ports.storage, sessionID), telling.then(() => true, () => false)]);
-    if (!chain.length || !told)
-        return [];
-    await ports.session.synthetic({
-        sessionID: topOf(chain),
-        text: envelope(sessionID, formSettledNotice(chain[0].title, id, settled), { settled, form: id }),
-        description: `Session ${sessionID} no longer shows a form`,
-        metadata: { source: "courier", from: sessionID, settled, formID: id },
-        delivery: "steer",
-    });
-    return [topOf(chain)];
-}
-/**
- * Relays the requests that spawned sessions already wait on, in every loaded location, which the
- * event stream does not repeat: those asked while it was down, before the watcher (re)subscribed.
- */
-export async function relayPending(ports, state) {
-    const sessions = new Set((await allEntries(ports.storage)).map((entry) => entry.sessionID));
-    const domains = [...ports.permissions()];
-    // Each request is claimed before its notice goes out, so relaying them all at once tells each
-    // once, however many locations list it; a location that cannot be read lists none.
-    const relay = async (sessionID) => {
-        const listed = (await listEverywhere(domains, sessionID)).flatMap((found) => found.requests);
-        await Promise.all(listed.map((request) => reportAsked(ports, state, { id: `pending:${request.id}`, data: request })));
-    };
-    await Promise.all([...sessions].map(relay));
-}
-const pause = (ms, signal) => new Promise((resolve) => {
-    const timer = setTimeout(done, ms);
-    function done() {
-        clearTimeout(timer);
-        signal.removeEventListener("abort", done);
-        resolve();
-    }
-    signal.addEventListener("abort", done);
-});
-/**
- * Handles one event of OpenCode's stream; those that cannot concern a spawned child, or a question
- * relayed for one, are ignored.
- */
-async function handle(ports, state, event) {
-    if (event.type === "session.execution.failed")
-        return reportFailure(ports, state.seen, event);
-    if (event.type === "permission.asked")
-        return reportAsked(ports, state, event);
-    if (event.type === "permission.replied")
-        return reportReplied(ports, state, event);
-    if (event.type === "form.created") {
-        // Not claimed: the hub's other subscription, or another copy's watcher, may resolve the same
-        // waiting call, which is harmless.
-        formShown(event);
-        return reportForm(ports, state, event);
-    }
-    if (event.type === "form.replied" || event.type === "form.cancelled")
-        return reportFormSettled(ports, state, event);
-    // Not claimed either: a location closing withdraws its forms, which must not pass for dismissals.
-    // The event's location is optional; without one, the shutdown counts for every location.
-    if (event.type === "location.shutdown") {
-        const directory = event.location?.directory;
-        locationClosing(ports.now(), typeof directory === "string" ? directory : undefined);
-    }
-    return [];
-}
-const ENDED = { done: true, value: undefined };
-/**
- * The events of `events` until it ends or `signal` aborts, whichever comes first; the stream is not
- * closed. Each wait for the next event listens for the abort only while it waits, so a watcher that
- * follows events for the life of the process holds nothing per event it has seen.
- */
-const until = (events, signal) => ({
-    [Symbol.asyncIterator]: () => ({
-        next: () => new Promise((resolve, reject) => {
-            if (signal.aborted)
-                return resolve(ENDED);
-            const stop = () => resolve(ENDED);
-            signal.addEventListener("abort", stop, { once: true });
-            // Once the signal has aborted, whatever the stream ends this wait with is not wanted.
-            events.next().then((next) => {
-                signal.removeEventListener("abort", stop);
-                resolve(next);
-            }, (error) => {
-                signal.removeEventListener("abort", stop);
-                reject(error);
-            });
-        }),
-    }),
-});
-/** Relays the requests already pending, kept in `relaying` until done, for the watcher's end to wait for. */
-function relayAlongside(ports, state, relaying) {
-    const relayed = relayPending(ports, state)
-        .catch((error) => ports.log(`courier watch: could not relay pending requests: ${String(error)}`))
-        .finally(() => relaying.delete(relayed));
-    relaying.add(relayed);
-}
-/** Handles one event, logging a failure rather than ending the watch. */
-function handleLogged(ports, state, event) {
-    return handle(ports, state, event).catch((error) => {
-        const data = event.data;
-        const sessionID = data?.sessionID ?? data?.form?.sessionID;
-        ports.log(`courier watch: could not handle ${event.type} of ${sessionID}: ${String(error)}`);
-    });
-}
-/**
- * Follows OpenCode's events until `signal` aborts, telling parents when a spawned child's turn
- * fails, when it waits for a permission or on a form and when that is answered without them, and
- * noting for the question relay the question forms shown, which it waits for, and the locations
- * shutting down, whose withdrawn forms must not pass for dismissals. Once `signal` aborts it ends
- * as soon as the event it is handling, and the relay of the requests already pending, are done,
- * without waiting for the stream to close: an unloading instance's leave waits for that.
- */
-export async function watchChildren(ports, state, signal, retryMs = RESUBSCRIBE_MS) {
-    const relaying = new Set();
-    while (!signal.aborted) {
-        let following = false;
-        let events;
-        try {
-            events = ports.event.subscribe({ signal })[Symbol.asyncIterator]();
-            // Question forms shown while no instance followed the events were not seen: released now,
-            // and again on the first event, by when the stream is surely connected.
-            let missed = eventsFollowed();
-            following = true;
-            // Alongside the new subscription; a request both relays see is relayed once.
-            relayAlongside(ports, state, relaying);
-            for await (const event of until(events, signal)) {
-                if (missed)
-                    formsMayHaveBeenMissed();
-                missed = false;
-                await handleLogged(ports, state, event);
-            }
-        }
-        catch (error) {
-            if (!signal.aborted)
-                ports.log(`courier watch: event stream broke: ${String(error)}`);
-        }
-        finally {
-            if (following)
-                eventsLeft();
-            // Closed without waiting: the subscription's own signal has aborted, or the stream ended, and
-            // closing the adapter's stream waits on OpenCode's side, which may not answer while a location
-            // closes; the leave that waits for this watcher must not wait for that too.
-            void events?.return?.().catch(() => { });
-        }
-        if (!signal.aborted)
-            await pause(retryMs, signal);
-    }
-    await Promise.allSettled(relaying);
-}
-/**
- * Makes the hub start its subscriptions to OpenCode's events with this copy's watcher, the copy loaded
- * last's, as after an update; `join` starts them. Every instance in the process is sent every event,
- * so one subscription would serve them all; the second is a standby, already connected when the
- * first one's member leaves, so no event goes unseen then. Both handle every event, and the claim
- * sets tell each once. Like any (re)subscription, a new one relays the requests already pending,
- * which the claim sets tell once too.
- */
-export function watchFromHub(hub, state, retryMs = RESUBSCRIBE_MS) {
-    hub.subscribe = (member) => {
-        const stop = new AbortController();
-        return { member, stop, done: watchChildren(member.watch, state, stop.signal, retryMs) };
-    };
-}