opencode-courier 0.1.6 → 0.2.0

package/dist/cleanup.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "@opencode-ai/plugin";
+import type { Plugin } from "@opencode/plugin";
 import { type RosterStorage } from "./roster.js";
 type Context = Plugin.Context;
 /** What would be lost by removing a worktree. */
@@ -14,8 +14,8 @@ export interface WorktreeState {
 export interface CleanupPorts {
     readonly storage: RosterStorage;
     readonly worktree: Pick<Context["worktree"], "remove">;
-    /** The plugin's own location, for roster entries recorded before they carried their source. */
-    readonly directory: string;
+    /** The project of the plugin's location, for roster entries recorded before they carried their project. */
+    readonly projectID: string;
     /** The worktree's state, or undefined when its directory no longer exists; `base` is the commit it was made from. */
     readonly inspect: (directory: string, base?: string) => Promise<WorktreeState | undefined>;
 }

package/dist/cleanup.js

@@ -52,7 +52,7 @@ export async function cleanup(ports, parentID, input) {
             commits: state.commits.slice(0, MAX_LISTED),
         };
     await ports.worktree.remove({
-        location: { directory: entry.source ?? ports.directory },
+        projectID: entry.project ?? ports.projectID,
         directory,
         force: input.force === true,
     });

package/dist/courier.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "@opencode-ai/plugin";
+import type { Plugin } from "@opencode/plugin";
 import type { Prompt } from "./question.js";
 import { type RosterStorage } from "./roster.js";
 type Context = Plugin.Context;
@@ -7,6 +7,8 @@ export interface CourierPorts {
     readonly session: Pick<Context["session"], "create" | "prompt" | "synthetic" | "get" | "context">;
     readonly agent: Pick<Context["agent"], "get">;
     readonly worktree: Pick<Context["worktree"], "create" | "remove">;
+    /** The project of the plugin's location; an isolated child's worktree is made in it, and removed from it. */
+    readonly projectID: string;
     /** The commit a directory's checkout is on, or undefined; recorded as an isolated child's base. */
     readonly head: (directory: string) => Promise<string | undefined>;
     readonly storage: RosterStorage;

package/dist/courier.js

@@ -39,7 +39,7 @@ export async function spawn(ports, parentID, input) {
     // A failed lookup must not keep the child from starting; it then runs on OpenCode's default.
     const model = await inheritedModel(ports, parentID, input.agent).catch(() => undefined);
     const directory = input.isolate
-        ? (await ports.worktree.create({ location: { directory: ports.directory } })).directory
+        ? (await ports.worktree.create({ projectID: ports.projectID })).directory
         : undefined;
     const base = directory ? await ports.head(directory) : undefined;
     const title = input.title ?? titleOf(input.task);
@@ -55,7 +55,7 @@ export async function spawn(ports, parentID, input) {
         // No session will ever use the fresh worktree, and nothing records it, so it goes now.
         if (directory)
             await ports.worktree
-                .remove({ location: { directory: ports.directory }, directory, force: false })
+                .remove({ projectID: ports.projectID, directory, force: false })
                 .catch(() => undefined);
         throw error;
     });
@@ -68,7 +68,7 @@ export async function spawn(ports, parentID, input) {
         directory: directory ?? child.location.directory,
         isolated: directory !== undefined,
         createdAt: ports.now(),
-        ...(directory ? { source: ports.directory } : {}),
+        ...(directory ? { source: ports.directory, project: ports.projectID } : {}),
         ...(base ? { base } : {}),
     }).then(() => undefined, (error) => describeFailure("roster", error).message);
     await ports.session.prompt({ sessionID: child.id, text: childBrief(parentID, input.task) });

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { Plugin } from "@opencode-ai/plugin";
-import { Plugin as EffectPlugin } from "@opencode-ai/plugin/effect";
+import { Plugin } from "@opencode/plugin";
+import { Plugin as EffectPlugin } from "@opencode/plugin/effect";
 import { type QuestionPorts } from "./question.js";
 /** What a question relay needs from the plugin instance that wraps the question tool. */
 export interface RelaySlot {

package/dist/index.js

@@ -1,6 +1,6 @@
-import { Plugin } from "@opencode-ai/plugin";
-import { Plugin as EffectPlugin } from "@opencode-ai/plugin/effect";
-import { fromPromise } from "@opencode-ai/plugin/promise/adapter";
+import { Plugin } from "@opencode/plugin";
+import { Plugin as EffectPlugin } from "@opencode/plugin/effect";
+import { fromPromise } from "@opencode/plugin/promise/adapter";
 import { Effect, Schema } from "effect";
 import { randomUUID } from "node:crypto";
 import { describeFailure, END_TURN, listChildren, send, spawn, status } from "./courier.js";
@@ -10,6 +10,7 @@ import { answer, pendingOf } from "./relay.js";
 import { answerQuestion, isQuestion, joinRelay, noticeCutOff, pendingQuestions, relayQuestions } from "./question.js";
 import { pruneExpired } from "./roster.js";
 import { watchChildren } from "./watch.js";
+import { builtVersions, versionNotice } from "./version.js";
 import { listen, readConfig, subscribe, unsubscribe } from "./webhook.js";
 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." }),
@@ -159,12 +160,24 @@ function describeAnswer(result) {
 export const courier = (relay = {}) => Plugin.define({
     id: "courier",
     setup: async (ctx) => {
+        const log = (message) => console.error(message);
+        // One line per load when this OpenCode is not the version the plugin was built against; the
+        // tools are registered all the same, and no tool result says so.
+        try {
+            const notice = versionNotice(builtVersions(), ctx.app);
+            if (notice)
+                log(notice);
+        }
+        catch (error) {
+            log(`courier: cannot compare the OpenCode version with the one it was built against: ${String(error)}`);
+        }
         const questionPorts = {
             storage: ctx.storage,
             session: ctx.session,
+            directory: ctx.location.directory,
             now: Date.now,
             newID: () => `question_${randomUUID()}`,
-            log: (message) => console.error(message),
+            log,
         };
         const ports = {
             session: ctx.session,
@@ -172,6 +185,7 @@ export const courier = (relay = {}) => Plugin.define({
             worktree: ctx.worktree,
             storage: ctx.storage,
             directory: ctx.location.directory,
+            projectID: ctx.location.project.id,
             now: Date.now,
             head: headOf,
             pending: async (sessionID) => {
@@ -210,7 +224,7 @@ export const courier = (relay = {}) => Plugin.define({
             session: ctx.session,
             now: Date.now,
             newID: () => `later_${randomUUID()}`,
-            log: (message) => console.error(message),
+            log,
         };
         const hooks = { storage: ctx.storage, session: ctx.session, now: Date.now, log: later.log };
         let webhook;
@@ -374,7 +388,7 @@ export const courier = (relay = {}) => Plugin.define({
                 },
             });
         });
-        void pruneExpired(ctx.storage, Date.now()).catch((error) => console.error(`courier roster prune: ${String(error)}`));
+        void pruneExpired(ctx.storage, Date.now()).catch((error) => log(`courier roster prune: ${String(error)}`));
         relay.ports = questionPorts;
         const leaveRelay = joinRelay(questionPorts);
         void noticeCutOff(questionPorts).catch((error) => questionPorts.log(`courier question: stored questions: ${String(error)}`));

package/dist/later.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "@opencode-ai/plugin";
+import type { Plugin } from "@opencode/plugin";
 import { type Storage } from "./storage.js";
 type Context = Plugin.Context;
 /** How often each plugin instance looks for due messages; a delivery can be this late. */

package/dist/question.d.ts

@@ -1,5 +1,5 @@
-import type { Plugin } from "@opencode-ai/plugin";
-import type { Plugin as EffectPlugin } from "@opencode-ai/plugin/effect";
+import type { Plugin } from "@opencode/plugin";
+import type { Plugin as EffectPlugin } from "@opencode/plugin/effect";
 import { Effect } from "effect";
 import { type RosterStorage } from "./roster.js";
 type Context = Plugin.Context;
@@ -44,17 +44,32 @@ export type Elsewhere = {
 /**
  * Timings, changed by the tests: how long a question cut off by a closing location waits before an
  * instance still loaded tells its top session, how long an answer waits for another one to it that
- * is still being passed on, and how long what follows a call's end waits for the notice of the
- * question to go out.
+ * is still being passed on, how long what follows a call's end waits for the notice of the
+ * question to go out, and how long a dismissal is held to see whether the location is shutting down.
  */
 export declare const timing: {
     closingGraceMs: number;
     passingWaitMs: number;
     relayWaitMs: number;
+    dismissalGraceMs: number;
 };
+/**
+ * For tests: when the location at `directory` was last reported shutting down, if at all; a shutdown
+ * reported without a location counts for every directory, and with none given, any location's counts.
+ */
+export declare const shutdownReportedAt: (directory?: string) => number | undefined;
+/**
+ * Called for OpenCode's `location.shutdown`: the location at `directory` is closing, which
+ * withdraws its open forms as if the person had dismissed them (before unloading the plugin
+ * there, since OpenCode 2.0.22). The event's location is optional in the schema; without it,
+ * the shutdown counts for every location.
+ */
+export declare function locationClosing(directory?: string): void;
 export interface QuestionPorts {
     readonly storage: RosterStorage;
     readonly session: Pick<Context["session"], "synthetic">;
+    /** The directory of the instance's location. */
+    readonly directory: string;
     readonly now: () => number;
     readonly newID: () => string;
     readonly log: (message: string) => void;
@@ -106,8 +121,13 @@ export declare function pendingQuestions(storage: RosterStorage, sessionID: stri
  * beyond the newest `MAX_STORED`, and tells the top session about the rest, which a restart cut off.
  */
 export declare function noticeCutOff(ports: QuestionPorts): Promise<void>;
-/** A plugin instance whose ports the relay may use, until the returned function is called. */
-export declare function joinRelay(ports: QuestionPorts): () => undefined;
+/**
+ * A plugin instance whose ports the relay may use, until the returned function is called. A
+ * location loading again forgets the shutdown recorded for it, so a dismissal there is not
+ * mistaken for that shutdown. One recorded for every location is left alone, since a dismissal
+ * held in another location may still need it; it ages out with the grace.
+ */
+export declare function joinRelay(ports: QuestionPorts): () => void;
 /** Called for OpenCode's `form.created`: a question call's form is shown, so its question can be relayed. */
 export declare function formShown(event: {
     readonly data: {
@@ -132,7 +152,7 @@ export declare function eventsFollowed(): boolean;
 /** Called when an instance's event stream ended or broke. */
 export declare function eventsLeft(): void;
 /** Wraps OpenCode's question tool for the relay. A tool by that id that is missing is left alone. */
-export declare function relayQuestions(host: Pick<EffectPlugin.Context, "tool">, ports: () => QuestionPorts | undefined): Effect.Effect<import("@opencode-ai/plugin/effect/registration").Registration, never, import("effect/Scope").Scope>;
+export declare function relayQuestions(host: Pick<EffectPlugin.Context, "tool" | "location">, ports: () => QuestionPorts | undefined): Effect.Effect<import("@opencode/plugin/effect/registration").Registration, never, import("effect/Scope").Scope>;
 /** For tests: forgets every question this process knows. */
 export declare function forgetQuestions(): void;
 export {};

package/dist/question.js

@@ -8,7 +8,7 @@ export const QUESTION_TOOL = "question";
 const PREFIX = "question/";
 /** At most this many questions are kept in storage; the oldest go first. */
 export const MAX_STORED = 100;
-const storedOf = ({ call: _call, link: _link, relaying: _relaying, settling: _settling, ...asked }) => asked;
+const storedOf = ({ directory: _directory, call: _call, link: _link, relaying: _relaying, settling: _settling, ...asked }) => asked;
 const isPassing = (requestID) => shared.passing.has(requestID) || shared.answered.has(requestID);
 // Field by field, so a copy of the plugin loaded later in the process gets what an older copy lacks.
 const sharedState = (globalThis[Symbol.for("opencode-courier.questions")] ??= {});
@@ -20,14 +20,61 @@ sharedState.answered ??= new Set();
 sharedState.loaded ??= new Set();
 sharedState.following ??= 0;
 sharedState.followed ??= false;
+sharedState.shutdowns ??= new Map();
+sharedState.closingWaiters ??= new Set();
 const shared = sharedState;
 /**
  * Timings, changed by the tests: how long a question cut off by a closing location waits before an
  * instance still loaded tells its top session, how long an answer waits for another one to it that
- * is still being passed on, and how long what follows a call's end waits for the notice of the
- * question to go out.
+ * is still being passed on, how long what follows a call's end waits for the notice of the
+ * question to go out, and how long a dismissal is held to see whether the location is shutting down.
  */
-export const timing = { closingGraceMs: 30_000, passingWaitMs: 30_000, relayWaitMs: 30_000 };
+export const timing = { closingGraceMs: 30_000, passingWaitMs: 30_000, relayWaitMs: 30_000, dismissalGraceMs: 2_000 };
+/** The key of a shutdown reported without a location: it counts for every location. */
+const ANYWHERE = "";
+/** When the location at `directory` (any location, with none) was last reported shutting down; 0 if never. */
+const shutdownAt = (directory) => directory === undefined
+    ? Math.max(0, ...shared.shutdowns.values())
+    : Math.max(shared.shutdowns.get(directory) ?? 0, shared.shutdowns.get(ANYWHERE) ?? 0);
+/**
+ * For tests: when the location at `directory` was last reported shutting down, if at all; a shutdown
+ * reported without a location counts for every directory, and with none given, any location's counts.
+ */
+export const shutdownReportedAt = (directory) => shutdownAt(directory) || undefined;
+/**
+ * Called for OpenCode's `location.shutdown`: the location at `directory` is closing, which
+ * withdraws its open forms as if the person had dismissed them (before unloading the plugin
+ * there, since OpenCode 2.0.22). The event's location is optional in the schema; without it,
+ * the shutdown counts for every location.
+ */
+export function locationClosing(directory) {
+    shared.shutdowns.set(directory ?? ANYWHERE, Date.now());
+    for (const wake of shared.closingWaiters)
+        wake();
+}
+/**
+ * Whether a dismissal just seen in the location at `directory` was that location closing rather
+ * than the person: true when it shut down within `ms` before, or does so, or this instance
+ * unloads, within `ms` from now. A shutdown reported without a location counts for every
+ * location, and with the directory unknown, any location's shutdown counts.
+ */
+function closingSoon(loaded, directory, ms) {
+    const closing = () => !loaded() || Date.now() - shutdownAt(directory) <= ms;
+    if (closing())
+        return Promise.resolve(true);
+    return new Promise((resolve) => {
+        const done = (result) => {
+            clearTimeout(timer);
+            shared.closingWaiters.delete(wake);
+            resolve(result);
+        };
+        // Woken by any shutdown or unload: only one that answers the question ends the wait.
+        const wake = () => void (closing() && done(true));
+        const timer = setTimeout(() => done(false), ms);
+        timer.unref?.();
+        shared.closingWaiters.add(wake);
+    });
+}
 /** The promise's value, or undefined once `ms` have passed or it failed. */
 function within(promise, ms) {
     if (!promise)
@@ -296,10 +343,20 @@ export async function noticeCutOff(ports) {
         await tellCutOff(ports, known ?? asked, "restarted").catch((error) => ports.log(`courier question: could not tell ${asked.top} about ${asked.requestID}: ${String(error)}`));
     }
 }
-/** A plugin instance whose ports the relay may use, until the returned function is called. */
+/**
+ * A plugin instance whose ports the relay may use, until the returned function is called. A
+ * location loading again forgets the shutdown recorded for it, so a dismissal there is not
+ * mistaken for that shutdown. One recorded for every location is left alone, since a dismissal
+ * held in another location may still need it; it ages out with the grace.
+ */
 export function joinRelay(ports) {
     shared.loaded.add(ports);
-    return () => void shared.loaded.delete(ports);
+    shared.shutdowns.delete(ports.directory);
+    return () => {
+        shared.loaded.delete(ports);
+        for (const wake of shared.closingWaiters)
+            wake();
+    };
 }
 /**
  * Tells the top session about a question its closing location cut off, a little later, through an
@@ -374,9 +431,13 @@ async function relay(ports, question) {
 }
 /**
  * After a relayed call ended: tidies up, and tells the top session if it was settled without it.
- * `unloaded` when the plugin instance that ran the call had been unloaded by then.
+ * `loaded` says whether the plugin instance that ran the call is still loaded.
  */
-async function settle(ports, question, exit, unloaded) {
+async function settle(ports, question, exit, loaded) {
+    const unloaded = !loaded();
+    // A dismissal is held from now, alongside the wait below, so the grace is not spent waiting.
+    const dismissed = Exit.isFailure(exit) && isDismissal(exit.cause);
+    const held = dismissed && !unloaded ? closingSoon(loaded, question.directory, timing.dismissalGraceMs) : undefined;
     // Telling the top session first, so what follows does not overtake the notice or come before it
     // is stored; for a while only, so a notice that never returns does not hold everything else up.
     // `told` is false when the top session was not told, or not yet.
@@ -393,14 +454,18 @@ async function settle(ports, question, exit, unloaded) {
         await forget(ports, question);
         return;
     }
-    // Cut off: the turn was stopped, or OpenCode is closing the location, which unloads the plugin
-    // and then withdraws every open form there as if the person had dismissed it (on a server
-    // shutdown, say). The question stays, answered by message from now on; a top session already
-    // asking the person passes their answer on that way. A closing location is not told now: the
-    // next load tells it, in this process or after a restart, or an instance still loaded does, a
-    // little later, when the process is still running then.
-    if (Exit.isFailure(exit) && (unloaded || (!isDismissal(exit.cause) && Exit.hasInterrupts(exit)))) {
-        if (unloaded)
+    // Cut off: the turn was stopped, or OpenCode is closing the location, which withdraws every open
+    // form there as if the person had dismissed it (on a server shutdown, say), before unloading the
+    // plugin there (since 2.0.22) or after (the beta). So a dismissal is held for a moment, to see
+    // whether the location's shutdown or this instance's unload follows it. The question stays,
+    // answered by message from now on; a top session already asking the person passes their answer
+    // on that way. A closing location is not told now: the next load tells it, in this process or
+    // after a restart, or an instance still loaded does, a little later, when the process is still
+    // running then. The unload is looked at again here: it may have come during the wait above, after
+    // a held dismissal had already been taken for the person's.
+    const closing = unloaded || !loaded() || (held !== undefined && (await held));
+    if (Exit.isFailure(exit) && (closing || (!dismissed && Exit.hasInterrupts(exit)))) {
+        if (closing)
             tellLater(question);
         else if (!question.link)
             await tellCutOff(ports, question, "stopped");
@@ -433,7 +498,7 @@ async function settle(ports, question, exit, unloaded) {
  * the top is told, and whichever answer comes first ends the call, the other side's question being
  * withdrawn. Other sessions' calls run unchanged.
  */
-function asking(ports, original) {
+function asking(ports, directory, original) {
     return (input, context) => Effect.gen(function* () {
         const current = ports();
         const chain = current ? yield* Effect.promise(() => lineage(current.storage, context.sessionID).catch(() => [])) : [];
@@ -453,6 +518,7 @@ function asking(ports, original) {
             ...(chain.length > 1 ? { startedBy: chain[0].parentID } : {}),
             questions: promptsOf(input),
             askedAt: current.now(),
+            directory,
             call: (outcome) => {
                 if (handed)
                     return accepted.then(() => false);
@@ -480,7 +546,7 @@ function asking(ports, original) {
             const byTopSession = Exit.isSuccess(exit) && exit.value.by === "top";
             if (!byTopSession)
                 question.call = undefined;
-            question.settling = settle(current, question, exit, ports() !== current)
+            question.settling = settle(current, question, exit, () => ports() === current)
                 .catch((error) => current.log(`courier question: could not settle ${question.requestID}: ${String(error)}`))
                 .finally(() => (question.settling = undefined));
             // After settling is set, which an answer the call did not take then waits for.
@@ -524,7 +590,7 @@ function linkFor(sessionID, questions) {
  * The question call of a session that a waiting question was relayed to, asking the person the
  * same: what they choose is passed on, and the call is withdrawn if the question is settled first.
  */
-function linking(ports, ask) {
+function linking(ports, directory, ask) {
     return (input, context) => Effect.gen(function* () {
         const current = ports();
         const questions = promptsOf(input);
@@ -556,9 +622,12 @@ function linking(ports, ask) {
                 return;
             // Not waited for, as in asking.
             void (async () => {
-                // Dismissed by the person: so is the question they were asked for.
-                if (isDismissal(exit.cause))
+                // Dismissed by the person, unless the location is closing (see settle): so is the question they were asked for.
+                if (isDismissal(exit.cause)) {
+                    if (await closingSoon(() => ports() === current, directory, timing.dismissalGraceMs))
+                        return;
                     await deliver(current, linked, { dismissed: true });
+                }
                 // Stopped while the asking call was cut off as well: nobody has been told yet.
                 else if (!linked.call && shared.questions.get(linked.requestID) === linked)
                     await tellCutOff(current, linked, "stopped");
@@ -601,9 +670,11 @@ function linking(ports, ask) {
 }
 /** Wraps OpenCode's question tool for the relay. A tool by that id that is missing is left alone. */
 export function relayQuestions(host, ports) {
+    // The wrapped tool runs the calls of the host's location: its shutdown is what withdraws their forms.
+    const { directory } = host.location;
     return host.tool.transform((editor) => {
         editor.update(QUESTION_TOOL, (tool) => {
-            tool.execute = linking(ports, asking(ports, tool.execute));
+            tool.execute = linking(ports, directory, asking(ports, directory, tool.execute));
         });
     });
 }
@@ -617,4 +688,6 @@ export function forgetQuestions() {
     shared.loaded.clear();
     shared.following = 0;
     shared.followed = false;
+    shared.shutdowns.clear();
+    shared.closingWaiters.clear();
 }

package/dist/relay.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "@opencode-ai/plugin";
+import type { Plugin } from "@opencode/plugin";
 import { type Pending } from "./courier.js";
 import { type RosterStorage } from "./roster.js";
 type Context = Plugin.Context;

package/dist/relay.js

@@ -91,7 +91,7 @@ export async function answer(ports, waiting, callerID, input) {
     waiting.delete(requestID);
     const message = reply === "reject" ? input.message || REJECTED : undefined;
     try {
-        await found.domain.reply({ sessionID, requestID, reply, ...(message ? { message } : {}) });
+        await found.domain.reply({ sessionID, requestID, decision: reply, ...(message ? { message } : {}) });
     }
     catch (error) {
         if (await locate(ports, sessionID, requestID).catch(() => found)) {

package/dist/roster.d.ts

@@ -12,8 +12,10 @@ export interface RosterEntry {
     readonly directory: string;
     readonly isolated: boolean;
     readonly createdAt: number;
-    /** For an isolated child, the directory its worktree was made from; courier_cleanup removes it through there. */
+    /** For an isolated child, the directory its worktree was made from; for the record, nothing acts on it. */
     readonly source?: string;
+    /** For an isolated child, the project its worktree belongs to; courier_cleanup removes it from there. */
+    readonly project?: string;
     /** For an isolated child, the commit its worktree was made from; its own work is what came after. */
     readonly base?: string;
 }

package/dist/storage.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "@opencode-ai/plugin";
+import type { Plugin } from "@opencode/plugin";
 type Context = Plugin.Context;
 export type Storage = Pick<Context["storage"], "get" | "set" | "remove" | "scan">;
 /** Every value stored under `prefix`, following the scan's pages. */

package/dist/version.d.ts

@@ -0,0 +1,22 @@
+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/version.js

@@ -0,0 +1,35 @@
+import { readFileSync } from "node:fs";
+const README_TABLE = "https://github.com/ivopogace/opencode-courier#supported-opencode-version";
+/**
+ * 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 function builtVersions() {
+    const pkg = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+    const plugin = pkg.version;
+    const opencode = pkg.devDependencies?.["@opencode/plugin"];
+    if (typeof plugin !== "string")
+        throw new Error("package.json has no version");
+    if (typeof opencode !== "string")
+        throw new Error("package.json pins no @opencode/plugin under devDependencies");
+    return { plugin, opencode };
+}
+/**
+ * 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 function versionNotice(built, app) {
+    const version = typeof app?.version === "string" ? app.version : undefined;
+    if (version === built.opencode)
+        return undefined;
+    const running = version === undefined ? "this server reports no version" : `this server is ${version}`;
+    const channel = typeof app?.channel === "string" ? ` (channel ${app.channel})` : "";
+    return (`opencode-courier ${built.plugin} was built and tested against OpenCode ${built.opencode}; ${running}${channel}. ` +
+        `Its tools may fail: see the Supported OpenCode version table in the README, ${README_TABLE}`);
+}

package/dist/watch.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "@opencode-ai/plugin";
+import type { Plugin } from "@opencode/plugin";
 import { type PermissionAsked, type PermissionReplied, type Waiting } from "./relay.js";
 import { type RosterStorage } from "./roster.js";
 type Context = Plugin.Context;
@@ -63,7 +63,8 @@ export declare function relayPending(ports: WatchPorts, state: WatchState): Prom
 /**
  * Follows OpenCode's events until `signal` aborts, telling parents when a spawned child's turn
  * fails, when it waits for a permission and when that request is answered without them, and
- * noting the question forms shown, which the question relay waits for.
+ * 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.
  */
 export declare function watchChildren(ports: WatchPorts, state: WatchState, signal: AbortSignal, retryMs?: number): Promise<void>;
 export {};

package/dist/watch.js

@@ -1,5 +1,5 @@
 import { envelope } from "./courier.js";
-import { eventsFollowed, eventsLeft, formShown, formsMayHaveBeenMissed } from "./question.js";
+import { eventsFollowed, eventsLeft, formShown, formsMayHaveBeenMissed, locationClosing } from "./question.js";
 import { permissionNotice, settledNotice } from "./relay.js";
 import { allEntries, entriesOf, lineage } from "./roster.js";
 /** How long to wait before subscribing again after the event stream ended or broke. */
@@ -114,7 +114,10 @@ const pause = (ms, signal) => new Promise((resolve) => {
     }
     signal.addEventListener("abort", done);
 });
-/** Handles one event of OpenCode's stream; those that cannot concern a spawned child are ignored. */
+/**
+ * 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);
@@ -125,12 +128,19 @@ async function handle(ports, state, event) {
     // Not claimed: every instance may resolve the same waiting call, which is harmless.
     if (event.type === "form.created")
         formShown(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(typeof directory === "string" ? directory : undefined);
+    }
     return [];
 }
 /**
  * Follows OpenCode's events until `signal` aborts, telling parents when a spawned child's turn
  * fails, when it waits for a permission and when that request is answered without them, and
- * noting the question forms shown, which the question relay waits for.
+ * 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.
  */
 export async function watchChildren(ports, state, signal, retryMs = RESUBSCRIBE_MS) {
     while (!signal.aborted) {

package/dist/webhook.d.ts

@@ -1,4 +1,4 @@
-import type { Plugin } from "@opencode-ai/plugin";
+import type { Plugin } from "@opencode/plugin";
 import { type IncomingMessage, type Server } from "node:http";
 type Context = Plugin.Context;
 /** Bodies above this are refused; GitHub's own deliveries are capped at 25 MB, real ones are far smaller. */

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "opencode-courier",
-  "version": "0.1.6",
-  "description": "OpenCode V2 plugin: spawn sessions, message them, and wake idle sessions without polling.",
+  "version": "0.2.0",
+  "description": "An OpenCode V2 plugin that lets one session start other sessions, message them, and be woken by them, without polling.",
   "license": "MIT",
+  "author": "Ivo Pogace <71701666+ivopogace@users.noreply.github.com>",
+  "homepage": "https://github.com/ivopogace/opencode-courier#readme",
+  "bugs": {
+    "url": "https://github.com/ivopogace/opencode-courier/issues"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ivopogace/opencode-courier.git"
@@ -35,10 +40,10 @@
     "effect": "4.0.0-rc.112"
   },
   "peerDependencies": {
-    "@opencode-ai/plugin": "0.0.0-beta-19271"
+    "@opencode/plugin": "2.0.22"
   },
   "devDependencies": {
-    "@opencode-ai/plugin": "0.0.0-beta-19271",
+    "@opencode/plugin": "2.0.22",
     "@types/bun": "1.3.14",
     "@types/node": "26.6.4",
     "typescript": "5.9.3"