opencode-courier 0.2.3 → 0.4.0

package/dist/notices.d.ts

@@ -1,246 +0,0 @@
-/** Closes a tool result after which the caller most likely has nothing left to do. */
-export declare const END_TURN = "If nothing else is left to do now, end your turn by replying without calling more tools.";
-export declare function childBrief(parentID: string, task: string): string;
-export declare function envelope(from: string, message: string, attributes?: Record<string, string>): string;
-export declare function spawnText(child: {
-    readonly sessionID: string;
-    readonly directory: string;
-    readonly rosterError?: string;
-}): string;
-export declare const sendText: (sessionID: string) => string;
-/** courier_status's result: the session's state, as JSON. */
-export declare const statusText: (status: unknown) => string;
-export declare const childrenText: (listed: ReadonlyArray<unknown>) => string;
-/** What courier_cleanup did: removed the worktree, found it gone, or kept it and why. */
-export type CleanupResult = {
-    readonly sessionID: string;
-    readonly directory: string;
-    readonly outcome: "removed";
-} | {
-    readonly sessionID: string;
-    readonly directory: string;
-    readonly outcome: "gone";
-} | {
-    readonly sessionID: string;
-    readonly directory: string;
-    readonly outcome: "kept";
-    readonly reason: string;
-    readonly changes: readonly string[];
-    readonly commits: readonly string[];
-};
-export declare function cleanupText(result: CleanupResult): string;
-/** Why a worktree in this state must be kept, or undefined when removing it loses nothing. */
-export declare function keepReason(state: {
-    readonly changes: readonly string[];
-    readonly commits: readonly string[];
-}): string | undefined;
-/**
- * What courier_answer did: a permission request's result carries the reply, a question's whether its
- * answers went out as the result of its call or, since that call had been cut off, as a message.
- */
-export type AnswerResult = PermissionAnswered | QuestionAnswered;
-/**
- * What answering a permission request did; `answered` is false when no location loaded in this
- * server held the request: it was answered, the session stopped waiting, or it waits in another
- * OpenCode server on the same data directory.
- */
-export interface PermissionAnswered {
-    readonly sessionID: string;
-    readonly requestID: string;
-    readonly reply: Reply;
-    readonly answered: boolean;
-}
-/** What answering a question did; `answered` is false when it no longer waited. */
-export type QuestionAnswered = {
-    readonly sessionID: string;
-    readonly requestID: string;
-    readonly answered: false;
-} | {
-    readonly sessionID: string;
-    readonly requestID: string;
-    readonly answered: true;
-    readonly by: "result" | "message";
-    readonly answers: Answers;
-};
-export declare function answerText(result: AnswerResult): string;
-/** `own` when the message goes to the session that scheduled it. */
-export declare function laterText(entry: {
-    readonly id: string;
-    readonly sessionID: string;
-}, fireAt: string, own: boolean): string;
-export declare const cancelText: (id: string, cancelled: boolean) => string;
-/** `receiving` says whether a webhook receiver runs in this server. */
-export declare function subscribeText(sessionID: string, topic: string, receiving: boolean): string;
-export declare const unsubscribeText: (sessionID: string, dropped: readonly string[]) => string;
-/** The error of OpenCode's `session.execution.failed` event. */
-export interface ExecutionError {
-    readonly type: string;
-    readonly message: string;
-    readonly status?: number;
-}
-export declare function failureNotice(title: string, error: ExecutionError): string;
-/** The answers to a permission request, as OpenCode's own prompt offers them. */
-export declare const REPLIES: readonly ["once", "always", "reject"];
-export type Reply = (typeof REPLIES)[number];
-/** A permission request, as OpenCode's `permission.asked` event carries it. */
-export interface PermissionRequest {
-    readonly id: string;
-    readonly sessionID: string;
-    readonly action: string;
-    readonly resources: ReadonlyArray<string>;
-    readonly save?: ReadonlyArray<string>;
-    readonly message?: string;
-}
-/**
- * Sent with a rejection that has no reason of its own. OpenCode ends the child's turn on a bare
- * rejection, and the child would never report back; with a message, the call fails and it carries on.
- */
-export declare const REJECTED = "Refused by the session that started you. Do without it, or report back why you cannot.";
-/** How a notice names where the asking session came from, to the session at the top of its lineage. */
-export declare const origin: (startedBy?: string) => string;
-/** For a notice that a session's turn ended without it finishing. */
-export declare const STAYS_QUIET = "and then it does not report back on its own: if it stays quiet, message it with courier_send to have it carry on.";
-/**
- * What the session at the top is told. `startedBy` names the session that started the asking one
- * when that is not the top session itself, but one started from it.
- */
-export declare function permissionNotice(title: string, request: PermissionRequest, startedBy?: string): string;
-/** What the session told about a permission request is told once it is answered without courier_answer. */
-export declare function permissionSettledNotice(title: string, requestID: string, reply: Reply): string;
-/** The `metadata.kind` of the forms OpenCode's web search asks its provider with. */
-export declare const WEBSEARCH_FORM = "websearch.provider";
-/** One field of an OpenCode form, as much of it as a notice shows. */
-export interface FormField {
-    readonly key: string;
-    readonly type: string;
-    readonly title?: string;
-    readonly description?: string;
-    readonly options?: ReadonlyArray<{
-        readonly value: string;
-        readonly label: string;
-        readonly description?: string;
-    }>;
-    readonly url?: string;
-    /** Not shown to the person. */
-    readonly hidden?: boolean;
-    /** Conditions on earlier answers; the field is shown only when they hold. */
-    readonly when?: ReadonlyArray<unknown>;
-}
-/** An OpenCode form, as its `form.created` event carries it. */
-export interface Form {
-    readonly id: string;
-    readonly sessionID: string;
-    readonly title: string;
-    readonly metadata?: Readonly<Record<string, unknown>>;
-    readonly fields: ReadonlyArray<FormField>;
-}
-/** A form's `metadata.kind`, when it has one that can go in a notice's envelope. */
-export declare const kindOf: (form: Form) => string | undefined;
-/**
- * What the session at the top is told about a form OpenCode shows in a session started with
- * courier_spawn, which the plugin cannot pass on or answer: only the person can, in that session.
- */
-export declare function formNotice(title: string, form: Form, startedBy?: string): string;
-/** What the session told about a form is told once it is answered or withdrawn. */
-export declare function formSettledNotice(title: string, formID: string, settled: "answered" | "cancelled"): string;
-/** One question of OpenCode's question tool, as the asking model wrote it. */
-export interface Prompt {
-    readonly question: string;
-    readonly header: string;
-    readonly options: ReadonlyArray<{
-        readonly label: string;
-        readonly description: string;
-    }>;
-    readonly multiple?: boolean;
-}
-/** The answers to a question call, as the question tool returns them: one list per question. */
-export type Answers = string[][];
-/** A question a spawned session asked with its question tool, stored until it is answered. */
-export interface Asked {
-    readonly requestID: string;
-    readonly sessionID: string;
-    /** The session told, at the top of the sessions started with courier_spawn; it alone answers. */
-    readonly top: string;
-    readonly title: string;
-    /** The session that started the asking one, when that is not the top session itself. */
-    readonly startedBy?: string;
-    readonly questions: ReadonlyArray<Prompt>;
-    readonly askedAt: number;
-}
-/** How a question was settled without the top session: in the asking session, or not at all. */
-export type Elsewhere = {
-    readonly by: "child";
-    readonly answers: Answers;
-} | {
-    readonly by: "dismissed";
-} | {
-    readonly by: "failed";
-    readonly error: string;
-};
-/** What the top session's answer does to a call that waits: answers it, or dismisses it. */
-export type Outcome = {
-    readonly answers: Answers;
-} | {
-    readonly dismissed: true;
-};
-/**
- * Why a linked call is withdrawn: its question was settled elsewhere, or the top session's outcome
- * reached it another way (courier_answer, or a dismissal through an earlier call linked to it).
- */
-export type Withdrawal = Elsewhere | {
-    readonly by: "top";
-    readonly outcome: Outcome;
-};
-/** What OpenCode's question tool tells the asking model once it has the answers. */
-export declare function answeredText(questions: ReadonlyArray<Prompt>, answers: ReadonlyArray<ReadonlyArray<string>>): string;
-declare const CUT_OFF: {
-    stopped: string;
-    restarted: string;
-};
-/** Why a question's call was cut off: its turn was stopped, or OpenCode restarted or closed its location. */
-export type CutOff = keyof typeof CUT_OFF;
-/** What the top session is told about a question, when it is asked or after its call was cut off. */
-export declare function questionNotice(asked: Asked, cutOff?: CutOff): string;
-/** What the top session is told about a question settled without it. */
-export declare function questionSettledNotice(asked: Asked, how: Elsewhere): string;
-/** The result of a spawned session's question call that the person dismissed through the top session. */
-export declare const DISMISSED = "The person dismissed this question without answering it. Carry on without the answers, or report back with courier_send to the session that started you why you cannot.";
-/** The message a spawned session whose question call was cut off gets, with the top session's outcome. */
-export declare function cutOffAnswer(asked: Asked, outcome: Outcome): string;
-/**
- * What a top session's question call that no waiting question was linked to adds to its result, when
- * questions with the same choices wait: `waiting` lists them.
- */
-export declare function unlinkedNote(waiting: ReadonlyArray<Pick<Asked, "sessionID" | "requestID">>): string;
-/** The result of a linked call withdrawn because its question was settled without it. */
-export declare function withdrawnText(linked: Asked, how: Withdrawal): string;
-/**
- * What a linked call adds to the person's answers about passing them on: `passed` is what passing
- * them on gave ("result", "message", or undefined when it no longer waited), or the error as
- * `error: <message>`.
- */
-export declare function passedNote(linked: Asked, passed: string | undefined): string;
-export declare function clipText(text: string, max?: number): string;
-/** The GitHub CI events, with how a summary names each. */
-export declare const CI_EVENTS: Record<string, string>;
-/** What every GitHub delivery carries, read once for the summary of its event. */
-export interface Delivery {
-    readonly name: string;
-    readonly body: Record<string, any>;
-    readonly repo: string;
-    readonly action: string | undefined;
-    readonly sender: string | undefined;
-    /** ` by <sender>`, or nothing when the delivery names no sender. */
-    readonly by: string;
-    /** The pull request and issue numbers it concerns, which `webhook.ts` reads for its topics. */
-    readonly numbers: readonly number[];
-}
-/** The summary of a GitHub delivery that wakes its subscribers. */
-export declare function githubSummary(delivery: Delivery): string;
-/** The summary of a delivery to `/hook/<name>`: its text, clipped. */
-export declare const hookSummary: (text: string) => string;
-/** Defuses `<courier` and `</courier>` in outside text, so it cannot close the envelope or forge another. */
-export declare function defuse(text: string): string;
-/** The text a subscribed session is woken with for a webhook delivery, before its envelope. */
-export declare const webhookText: (summary: string) => string;
-export {};

package/dist/question/index.d.ts

@@ -1,6 +0,0 @@
-export { answerQuestion, noticeCutOff, pendingQuestions } from "./answer.js";
-export { eventsFollowed, eventsLeft, formShown, formsMayHaveBeenMissed, joinRelay, locationClosing, shutdownReportedAt } from "./lifecycle.js";
-export { byCodeUnit, type QuestionAnswerInput } from "./pure.js";
-export { relayQuestions } from "./relay.js";
-export { isQuestion, MAX_STORED, QUESTION_TOOL } from "./shared.js";
-export type { QuestionPorts, QuestionTiming } from "../hub.js";

package/dist/question/lifecycle.d.ts

@@ -1,52 +0,0 @@
-import { Effect } from "effect";
-import type { QuestionPorts } from "../hub.js";
-/**
- * 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. `at` is when, by the watcher's clock (epoch milliseconds).
- */
-export declare function locationClosing(at: number, directory?: string): void;
-/**
- * Whether a dismissal just seen in the location at `directory` was that location closing rather
- * than the person: true when it shut down within the dismissal grace before, or does so, or this
- * instance unloads, within the grace from now, by the clock of `ports`. A shutdown reported without a location counts for every
- * location, and with the directory unknown, any location's shutdown counts.
- */
-export declare const closingSoon: (ports: QuestionPorts, loaded: () => boolean, directory: string | undefined) => Effect.Effect<boolean>;
-/**
- * Adds a plugin instance's ports to `loaded`, which copies of other versions read to tell a cut-off
- * question through it, 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: {
-        readonly form: {
-            readonly sessionID: string;
-            readonly metadata?: unknown;
-        };
-    };
-}): void;
-/**
- * Called when an event stream may have missed forms being shown: every call still waiting for its
- * form is taken as shown. One still waiting for its permission check is relayed early, which is the
- * lesser harm.
- */
-export declare function formsMayHaveBeenMissed(): void;
-/**
- * Called when an instance starts following OpenCode's events. Every instance is sent every event,
- * so a form shown is missed only while none follows them; then the calls waiting are released, and
- * true is returned, for the caller to release them again on its first event, once it is connected.
- */
-export declare function eventsFollowed(): boolean;
-/** Called when an instance's event stream ended or broke. */
-export declare function eventsLeft(): void;

package/dist/question/shared.js

@@ -1,24 +0,0 @@
-import { addBounded } from "../bounded.js";
-import { hub } from "../hub.js";
-/** OpenCode's own question tool, which the relay wraps. */
-export const QUESTION_TOOL = "question";
-export const PREFIX = "question/";
-/** At most this many questions are kept in storage; the oldest go first. */
-export const MAX_STORED = 100;
-export const storedOf = ({ directory: _directory, call: _call, link: _link, relaying: _relaying, settling: _settling, ...asked }) => asked;
-export const isPassing = (requestID) => shared.passing.has(requestID) || shared.answered.has(requestID);
-// Shared by every plugin instance in the process, since a child and the session it asks can be in
-// different locations.
-export const shared = hub.questions;
-/**
- * The ports of an instance still loaded, if any: a member of this copy's hub, or else one that a
- * copy of another hub version, or a release before the hub, keeps in `loaded`.
- */
-export const anyLoaded = () => hub.members.values().next().value?.questions ?? shared.loaded.values().next().value;
-export const keyOf = (requestID) => `${PREFIX}${requestID}`;
-/** Whether a request id is a question's rather than a permission request's. */
-export const isQuestion = (requestID) => requestID.startsWith("question_");
-/** How many noticed and answered questions are remembered. */
-const REMEMBERED = 1_000;
-/** Adds to one of the shared bounded sets. */
-export const claim = (set, value) => addBounded(set, value, REMEMBERED);

package/dist/roster.d.ts

@@ -1,81 +0,0 @@
-import { type Storage } from "./storage.js";
-/**
- * Entries older than this are dropped when their parent's roster is read, and on plugin setup,
- * except isolated children whose worktree is still there: those stay until courier_cleanup.
- */
-export declare const RETENTION_MS: number;
-/** A session started with courier_spawn, recorded under the session that started it. */
-export interface RosterEntry {
-    readonly sessionID: string;
-    readonly parentID: string;
-    readonly title: string;
-    readonly directory: string;
-    readonly isolated: boolean;
-    readonly createdAt: number;
-    /** 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;
-}
-/**
- * What the reverse index holds for a child: the sessions above it, its parent first and the session
- * at the top, which courier_spawn did not start, last. Its roster entry is under the first, and each
- * of the others is the parent of the one before it.
- */
-export interface ReverseEntry {
-    readonly ancestors: ReadonlyArray<string>;
-}
-export type RosterStorage = Storage;
-export declare function rosterKey(parentID: string, sessionID: string): string;
-export declare function reverseKey(sessionID: string): string;
-/**
- * Records a child under its parent, then indexes it. The entry is what counts: a failed index
- * write leaves it to be found by a scan, and to be indexed when the plugin is next loaded.
- */
-export declare function record(storage: RosterStorage, entry: RosterEntry): Promise<void>;
-/**
- * Removes a child's roster entry and its reverse key. Only the entry's removal can fail it: a
- * reverse key left behind leads nowhere, and the next load drops it.
- */
-export declare function remove(storage: RosterStorage, parentID: string, sessionID: string): Promise<void>;
-/** Removes a child from its parent's roster; false when it was not there. */
-export declare function forget(storage: RosterStorage, parentID: string, sessionID: string): Promise<boolean>;
-/** A parent's children, oldest first. */
-export declare function children(storage: RosterStorage, parentID: string): Promise<RosterEntry[]>;
-/** Every parent's children. */
-export declare function allEntries(storage: RosterStorage): Promise<RosterEntry[]>;
-/** A session's roster entries: one for the parent that started it, none if courier_spawn did not. */
-export declare function entriesOf(storage: RosterStorage, sessionID: string): Promise<RosterEntry[]>;
-/**
- * The roster entries from a session up to the top, its own first: the session's, its parent's, and
- * so on, ending with the entry whose parent courier_spawn did not start. Empty when courier_spawn
- * did not start the session.
- */
-export declare function lineage(storage: RosterStorage, sessionID: string): Promise<RosterEntry[]>;
-/** `lineage` over roster entries already read. */
-export declare function lineageIn(entries: ReadonlyArray<RosterEntry>, sessionID: string): RosterEntry[];
-/**
- * The session at the top of a spawned session's lineage, where its permission requests and
- * questions go, since that is where the person is; only it may answer them. Throws when the
- * session was not started with courier_spawn or `callerID` is another session. `what` names
- * what is being answered.
- */
-export declare function answeringTop(storage: RosterStorage, sessionID: string, callerID: string, what: string): Promise<string>;
-/** Whether a directory still exists; tests pass a fake. */
-export type Exists = (directory: string) => boolean;
-/** A parent's children, oldest first, after dropping the expired ones. */
-export declare function current(storage: RosterStorage, parentID: string, now: number, exists?: Exists): Promise<RosterEntry[]>;
-/**
- * On loading: drops expired entries of every parent, so parents that never list their children
- * don't keep them forever, then brings the reverse index in line with what is left (`backfill`).
- */
-export declare function pruneExpired(storage: RosterStorage, now: number, exists?: Exists): Promise<void>;
-/**
- * Writes the reverse keys missing for the given entries, or naming another parent, all of the roster, such as those an older
- * copy of the plugin recorded, and drops the reverse keys whose entry is gone, such as those of an
- * entry an older copy removed. Keys that lead to their entry are left as they are, so running it
- * again changes nothing.
- */
-export declare function backfill(storage: RosterStorage, entries: ReadonlyArray<RosterEntry>): Promise<void>;

package/dist/roster.js

@@ -1,175 +0,0 @@
-import { existsSync } from "node:fs";
-import { scanAll, scanEntries } from "./storage.js";
-/**
- * Entries older than this are dropped when their parent's roster is read, and on plugin setup,
- * except isolated children whose worktree is still there: those stay until courier_cleanup.
- */
-export const RETENTION_MS = 14 * 24 * 60 * 60_000;
-const PREFIX = "roster/";
-/**
- * The reverse index: under `roster-by-child/<sessionID>`, a child's `ReverseEntry`, written with its
- * roster entry. It is only an index: an entry without one, written by an older copy of the plugin,
- * is found by scanning `roster/`, and every entry it leads to is read from `roster/` to check that
- * it is still there.
- */
-const BY_CHILD = "roster-by-child/";
-export function rosterKey(parentID, sessionID) {
-    return `${PREFIX}${parentID}/${sessionID}`;
-}
-export function reverseKey(sessionID) {
-    return `${BY_CHILD}${sessionID}`;
-}
-/**
- * Records a child under its parent, then indexes it. The entry is what counts: a failed index
- * write leaves it to be found by a scan, and to be indexed when the plugin is next loaded.
- */
-export async function record(storage, entry) {
-    await storage.set(rosterKey(entry.parentID, entry.sessionID), { ...entry });
-    await index(storage, entry).catch(() => undefined);
-}
-async function index(storage, entry) {
-    const above = await storage.get(reverseKey(entry.parentID));
-    const ancestors = isReverse(above) ? above.ancestors : (await lineage(storage, entry.parentID)).map((parent) => parent.parentID);
-    await storage.set(reverseKey(entry.sessionID), { ancestors: [entry.parentID, ...ancestors] });
-}
-function isReverse(value) {
-    const ancestors = value?.ancestors;
-    return Array.isArray(ancestors) && ancestors.length > 0 && ancestors.every((id) => typeof id === "string");
-}
-/**
- * Removes a child's roster entry and its reverse key. Only the entry's removal can fail it: a
- * reverse key left behind leads nowhere, and the next load drops it.
- */
-export async function remove(storage, parentID, sessionID) {
-    await Promise.all([storage.remove(rosterKey(parentID, sessionID)), storage.remove(reverseKey(sessionID)).catch(() => undefined)]);
-}
-/** Removes a child from its parent's roster; false when it was not there. */
-export async function forget(storage, parentID, sessionID) {
-    if ((await storage.get(rosterKey(parentID, sessionID))) === undefined)
-        return false;
-    await remove(storage, parentID, sessionID);
-    return true;
-}
-/** A parent's children, oldest first. */
-export async function children(storage, parentID) {
-    const entries = await scanAll(storage, `${PREFIX}${parentID}/`);
-    return entries.sort((a, b) => a.createdAt - b.createdAt);
-}
-/** Every parent's children. */
-export async function allEntries(storage) {
-    return scanAll(storage, PREFIX);
-}
-/** A session's roster entries: one for the parent that started it, none if courier_spawn did not. */
-export async function entriesOf(storage, sessionID) {
-    const indexed = await storage.get(reverseKey(sessionID));
-    if (!isReverse(indexed))
-        return (await scanAll(storage, PREFIX)).filter((entry) => entry.sessionID === sessionID);
-    const entry = await storage.get(rosterKey(indexed.ancestors[0], sessionID));
-    return entry === undefined ? [] : [entry];
-}
-/**
- * The roster entries from a session up to the top, its own first: the session's, its parent's, and
- * so on, ending with the entry whose parent courier_spawn did not start. Empty when courier_spawn
- * did not start the session.
- */
-export async function lineage(storage, sessionID) {
-    const first = await storage.get(reverseKey(sessionID));
-    if (!isReverse(first))
-        return lineageIn(await allEntries(storage), sessionID);
-    let indexed = first;
-    const chain = [];
-    let below = sessionID;
-    // One read per level, all at once, and one more for the top's own reverse key, in case it was
-    // recorded after the key that names it; the chain ends where an entry is gone, as a scan's would.
-    for (;;) {
-        const { ancestors } = indexed;
-        const top = ancestors.at(-1);
-        const [entries, above] = await Promise.all([
-            Promise.all(ancestors.map((parentID, level) => storage.get(rosterKey(parentID, level ? ancestors[level - 1] : below)))),
-            storage.get(reverseKey(top)),
-        ]);
-        for (const entry of entries) {
-            if (!entry || chain.some((known) => known.sessionID === entry.sessionID))
-                return chain;
-            chain.push(entry);
-        }
-        if (!isReverse(above))
-            return chain;
-        below = top;
-        indexed = above;
-    }
-}
-/** `lineage` over roster entries already read. */
-export function lineageIn(entries, sessionID) {
-    const bySession = new Map(entries.map((entry) => [entry.sessionID, entry]));
-    const chain = [];
-    for (let entry = bySession.get(sessionID); entry && !chain.includes(entry); entry = bySession.get(entry.parentID))
-        chain.push(entry);
-    return chain;
-}
-/**
- * The session at the top of a spawned session's lineage, where its permission requests and
- * questions go, since that is where the person is; only it may answer them. Throws when the
- * session was not started with courier_spawn or `callerID` is another session. `what` names
- * what is being answered.
- */
-export async function answeringTop(storage, sessionID, callerID, what) {
-    const chain = await lineage(storage, sessionID);
-    if (!chain.length)
-        throw new Error(`${sessionID} was not started with courier_spawn, so courier_answer cannot answer for it.`);
-    const top = chain.at(-1).parentID;
-    if (top !== callerID)
-        throw new Error(`${sessionID}'s ${what} go to ${top}, the session at the top of the sessions started from it with courier_spawn; ${callerID} cannot answer them.`);
-    return top;
-}
-/**
- * Removes the given entries that were recorded more than `RETENTION_MS` before `now`, and returns
- * the rest. An isolated child is kept while its worktree exists, so it can still be cleaned up.
- */
-async function dropExpired(storage, entries, now, exists) {
-    const expired = new Set(entries.filter((entry) => now - entry.createdAt > RETENTION_MS && !(entry.isolated && exists(entry.directory))));
-    await Promise.all([...expired].map((entry) => remove(storage, entry.parentID, entry.sessionID)));
-    return entries.filter((entry) => !expired.has(entry));
-}
-/** A parent's children, oldest first, after dropping the expired ones. */
-export async function current(storage, parentID, now, exists = existsSync) {
-    return dropExpired(storage, await children(storage, parentID), now, exists);
-}
-/**
- * On loading: drops expired entries of every parent, so parents that never list their children
- * don't keep them forever, then brings the reverse index in line with what is left (`backfill`).
- */
-export async function pruneExpired(storage, now, exists = existsSync) {
-    await backfill(storage, await dropExpired(storage, await scanAll(storage, PREFIX), now, exists));
-}
-/** Whether a reverse key's value leads to this entry. */
-function indexes(value, entry) {
-    return isReverse(value) && value.ancestors[0] === entry.parentID;
-}
-/**
- * Writes the reverse keys missing for the given entries, or naming another parent, all of the roster, such as those an older
- * copy of the plugin recorded, and drops the reverse keys whose entry is gone, such as those of an
- * entry an older copy removed. Keys that lead to their entry are left as they are, so running it
- * again changes nothing.
- */
-export async function backfill(storage, entries) {
-    const indexed = new Map((await scanEntries(storage, BY_CHILD)).map(({ key, value }) => [key, value]));
-    const sessions = new Set(entries.map((entry) => entry.sessionID));
-    await Promise.all([
-        ...entries
-            .filter((entry) => !indexes(indexed.get(entry.sessionID), entry))
-            .map((entry) => storage.set(reverseKey(entry.sessionID), { ancestors: lineageIn(entries, entry.sessionID).map((above) => above.parentID) })),
-        ...[...indexed]
-            .filter(([sessionID]) => !sessions.has(sessionID))
-            .map(([sessionID, value]) => dropDangling(storage, sessionID, value)),
-    ]);
-}
-/**
- * Drops a reverse key whose entry was not in the roster read, unless that entry is there now:
- * another instance may have recorded the child since, and it writes the entry before the key.
- */
-async function dropDangling(storage, sessionID, value) {
-    if (isReverse(value) && (await storage.get(rosterKey(value.ancestors[0], sessionID))) !== undefined)
-        return;
-    await storage.remove(reverseKey(sessionID));
-}

package/dist/tools.d.ts

@@ -1,74 +0,0 @@
-import type { Plugin } from "@opencode/plugin";
-import { Schema } from "effect";
-import { type CleanupPorts } from "./cleanup.js";
-import { type CourierPorts } from "./courier.js";
-import { type LaterPorts } from "./later.js";
-import { type QuestionPorts } from "./question/index.js";
-import { type AnswerPorts, type Waiting } from "./relay.js";
-import { type WebhookPorts } 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 declare const SpawnInput: Schema.Struct<{
-    readonly task: Schema.String;
-    readonly title: Schema.optional<Schema.String>;
-    readonly agent: Schema.optional<Schema.String>;
-    readonly isolate: Schema.optional<Schema.Boolean>;
-}>;
-export declare const SendInput: Schema.Struct<{
-    readonly sessionID: Schema.String;
-    readonly message: Schema.String;
-    readonly queue: Schema.optional<Schema.Boolean>;
-}>;
-export declare const StatusInput: Schema.Struct<{
-    readonly sessionID: Schema.String;
-}>;
-export declare const ChildrenInput: Schema.Struct<{
-    readonly sessionID: Schema.optional<Schema.String>;
-}>;
-export declare const CleanupInput: Schema.Struct<{
-    readonly sessionID: Schema.String;
-    readonly force: Schema.optional<Schema.Boolean>;
-}>;
-export declare const LaterInput: Schema.Struct<{
-    readonly message: Schema.String;
-    readonly delayMinutes: Schema.optional<Schema.Union<readonly [Schema.Number, Schema.String]>>;
-    readonly at: Schema.optional<Schema.String>;
-    readonly sessionID: Schema.optional<Schema.String>;
-}>;
-export declare const AnswerInput: Schema.Struct<{
-    readonly sessionID: Schema.String;
-    readonly requestID: Schema.String;
-    readonly reply: Schema.optional<Schema.Literals<readonly ["once", "always", "reject"]>>;
-    readonly message: Schema.optional<Schema.String>;
-    readonly answers: Schema.optional<Schema.$Array<Schema.Union<readonly [Schema.String, Schema.$Array<Schema.String>]>>>;
-}>;
-export declare const CancelInput: Schema.Struct<{
-    readonly id: Schema.String;
-}>;
-export declare const SubscribeInput: Schema.Struct<{
-    readonly topic: Schema.String;
-    readonly sessionID: Schema.optional<Schema.String>;
-}>;
-export declare const UnsubscribeInput: Schema.Struct<{
-    readonly topic: Schema.optional<Schema.String>;
-    readonly sessionID: Schema.optional<Schema.String>;
-}>;
-/** The editor OpenCode hands a tool transform. */
-export type ToolEditor = Parameters<Parameters<Plugin.Context["tool"]["transform"]>[0]>[0];
-/** What the tools run on: one plugin instance's ports. */
-export interface ToolPorts {
-    readonly courier: CourierPorts;
-    readonly cleanup: CleanupPorts;
-    readonly later: LaterPorts;
-    readonly answer: AnswerPorts;
-    readonly questions: QuestionPorts;
-    readonly hooks: WebhookPorts;
-    /** The permission requests sessions were told about and have not answered. */
-    readonly waiting: Waiting;
-    /** Whether a webhook receiver runs in this server. */
-    readonly receiving: () => Promise<boolean>;
-}
-/** Adds the courier tools, each a direct tool rather than a code-mode one. */
-export declare function addTools(tools: ToolEditor, ports: ToolPorts): void;