opencode-courier 0.3.0 → 0.4.1

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/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/report.d.ts

@@ -1,48 +0,0 @@
-import { type Status } from "./notices.js";
-import type { Storage } from "./storage.js";
-export declare const promptKey: (sessionID: string) => string;
-export declare const settledKey: (sessionID: string) => string;
-export declare const progressKey: (sessionID: string) => string;
-export declare const toldKey: (sessionID: string) => string;
-export declare const stoppedKey: (sessionID: string) => string;
-/** How a session's wait for a report ended: it reported to its parent, or its turn failed or was interrupted. */
-export type Settled = "report" | "failed" | "interrupted";
-/**
- * Notes that a prompt or message reached a spawned session at `at`, in epoch milliseconds, unless a
- * later one is noted: both of the hub's subscriptions note each event, one of them maybe behind.
- */
-export declare function prompted(storage: Pick<Storage, "get" | "set">, sessionID: string, at: number): Promise<void>;
-/**
- * Notes that a spawned session reported to its parent, with `status` when its report carried one, or
- * its turn failed or was interrupted, at `at`, unless a later end is noted.
- */
-export declare function settled(storage: Pick<Storage, "get" | "set">, sessionID: string, by: Settled, at: number, status?: Status): Promise<void>;
-/** Notes that a spawned session messaged its parent without a status at `at`, which is progress, not its report. */
-export declare function progressed(storage: Pick<Storage, "get" | "set">, sessionID: string, at: number): Promise<void>;
-/** Notes that a spawned session's parent was told, at `at`, that a turn of it ended without a report, unless a later telling is noted. */
-export declare function told(storage: Pick<Storage, "get" | "set">, sessionID: string, at: number): Promise<void>;
-/** Takes back the note `told` made at `at`, whose notice did not go out; a later one stays, and one that cannot be read goes. */
-export declare function untold(storage: Pick<Storage, "get" | "remove">, sessionID: string, at: number): Promise<void>;
-/** Notes that courier_stop stopped a spawned session at `at`, so the failure and silent-end notices stay quiet for it. */
-export declare function stopped(storage: Pick<Storage, "set">, sessionID: string, at: number): Promise<void>;
-/** Whether courier_stop stopped a session after its last prompt, or with none noted, at all. */
-export declare function stoppedSincePrompt(storage: Pick<Storage, "get">, sessionID: string): Promise<boolean>;
-/** The status of a spawned session's last report to its parent, if it has reported with one. */
-export declare function lastStatus(storage: Pick<Storage, "get">, sessionID: string): Promise<Status | undefined>;
-/**
- * What is known of a spawned session's report: when a prompt last reached it, and whether since then it owes one, has
- * messaged its parent without a status, or failed or was interrupted. Undefined for one spawned before this was kept.
- */
-export declare function reportOf(storage: Pick<Storage, "get">, sessionID: string): Promise<{
-    prompt: number;
-    owes: boolean;
-    progressed: boolean;
-    ended: boolean;
-} | undefined>;
-/**
- * Whether its parent still waits on a spawned session's report: it owes one, and the parent has not
- * been told since its last prompt that it ended a turn without one.
- */
-export declare function awaited(storage: Pick<Storage, "get">, sessionID: string): Promise<boolean>;
-/** Drops what is kept about a session, with its roster entry. */
-export declare function forgetReport(storage: Pick<Storage, "remove">, sessionID: string): Promise<void>;

package/dist/report.js

@@ -1,88 +0,0 @@
-import { obj } from "./json.js";
-import { isStatus } from "./notices.js";
-/**
- * Whether a spawned session has reported since its last prompt, under `report/<sessionID>/`: `prompt`, `settled` (with
- * the report's status), `progress` (a message to its parent without a status) and `told`; docs/reference.md has each.
- */
-const PREFIX = "report/";
-export const promptKey = (sessionID) => `${PREFIX}${sessionID}/prompt`;
-export const settledKey = (sessionID) => `${PREFIX}${sessionID}/settled`;
-export const progressKey = (sessionID) => `${PREFIX}${sessionID}/progress`;
-export const toldKey = (sessionID) => `${PREFIX}${sessionID}/told`;
-export const stoppedKey = (sessionID) => `${PREFIX}${sessionID}/stopped`;
-const timeOf = (value) => {
-    const at = obj(value).at;
-    return typeof at === "number" && Number.isFinite(at) ? at : undefined;
-};
-/**
- * Notes that a prompt or message reached a spawned session at `at`, in epoch milliseconds, unless a
- * later one is noted: both of the hub's subscriptions note each event, one of them maybe behind.
- */
-export async function prompted(storage, sessionID, at) {
-    if ((timeOf(await storage.get(promptKey(sessionID))) ?? -Infinity) < at)
-        await storage.set(promptKey(sessionID), { at });
-}
-/**
- * Notes that a spawned session reported to its parent, with `status` when its report carried one, or
- * its turn failed or was interrupted, at `at`, unless a later end is noted.
- */
-export async function settled(storage, sessionID, by, at, status) {
-    if ((timeOf(await storage.get(settledKey(sessionID))) ?? -Infinity) <= at)
-        await storage.set(settledKey(sessionID), { at, by, ...(status ? { status } : {}) });
-}
-/** Notes that a spawned session messaged its parent without a status at `at`, which is progress, not its report. */
-export async function progressed(storage, sessionID, at) {
-    if ((timeOf(await storage.get(progressKey(sessionID))) ?? -Infinity) <= at)
-        await storage.set(progressKey(sessionID), { at });
-}
-/** Notes that a spawned session's parent was told, at `at`, that a turn of it ended without a report, unless a later telling is noted. */
-export async function told(storage, sessionID, at) {
-    if ((timeOf(await storage.get(toldKey(sessionID))) ?? -Infinity) <= at)
-        await storage.set(toldKey(sessionID), { at });
-}
-/** Takes back the note `told` made at `at`, whose notice did not go out; a later one stays, and one that cannot be read goes. */
-export async function untold(storage, sessionID, at) {
-    const stored = await storage.get(toldKey(sessionID)).then(timeOf, () => at);
-    if (stored === at)
-        await storage.remove(toldKey(sessionID));
-}
-/** Whether `at` is known and no earlier than the prompt at `prompt`. */
-const since = (at, prompt) => at !== undefined && at >= prompt;
-/** Notes that courier_stop stopped a spawned session at `at`, so the failure and silent-end notices stay quiet for it. */
-export async function stopped(storage, sessionID, at) {
-    await storage.set(stoppedKey(sessionID), { at });
-}
-/** Whether courier_stop stopped a session after its last prompt, or with none noted, at all. */
-export async function stoppedSincePrompt(storage, sessionID) {
-    const [stoppedAt, prompt] = await Promise.all([stoppedKey, promptKey].map((key) => storage.get(key(sessionID)).then(timeOf)));
-    return stoppedAt !== undefined && (prompt === undefined || stoppedAt >= prompt);
-}
-/** The status of a spawned session's last report to its parent, if it has reported with one. */
-export async function lastStatus(storage, sessionID) {
-    const status = obj(await storage.get(settledKey(sessionID))).status;
-    return isStatus(status) ? status : undefined;
-}
-/**
- * What is known of a spawned session's report: when a prompt last reached it, and whether since then it owes one, has
- * messaged its parent without a status, or failed or was interrupted. Undefined for one spawned before this was kept.
- */
-export async function reportOf(storage, sessionID) {
-    const [prompt, settledValue, progress] = await Promise.all([promptKey, settledKey, progressKey].map((key) => storage.get(key(sessionID))));
-    const promptAt = timeOf(prompt);
-    if (promptAt === undefined)
-        return undefined;
-    const done = since(timeOf(settledValue), promptAt);
-    return { prompt: promptAt, owes: !done, progressed: since(timeOf(progress), promptAt), ended: done && obj(settledValue).by !== "report" };
-}
-/**
- * Whether its parent still waits on a spawned session's report: it owes one, and the parent has not
- * been told since its last prompt that it ended a turn without one.
- */
-export async function awaited(storage, sessionID) {
-    const [prompt, settledAt, toldAt] = await Promise.all([promptKey, settledKey, toldKey].map((key) => storage.get(key(sessionID)).then(timeOf)));
-    return prompt !== undefined && !since(settledAt, prompt) && !since(toldAt, prompt);
-}
-/** Drops what is kept about a session, with its roster entry. */
-export async function forgetReport(storage, sessionID) {
-    await Promise.all([promptKey, settledKey, progressKey, toldKey, stoppedKey].map((key) => storage.remove(key(sessionID))));
-}

package/dist/roster.d.ts

@@ -1,93 +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;
-    /** `"status"` when its brief asked for a report with a status; absent for a child an earlier release briefed. */
-    readonly reports?: "status";
-    /** The join group courier_spawn put it in, whose release holds its report; absent for a child in none. */
-    readonly group?: string;
-}
-/**
- * What the reverse index holds for a child: the sessions above it, its parent first and the top
- * session, which courier_spawn did not start, last; each 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, its reverse key, its report state and, given its group, its membership. 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, group?: string): Promise<{
-    droppedFromGroup: boolean;
-}>;
-/** 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 session that started a session, by the reverse index alone, without scanning the roster. */
-export declare function indexedParent(storage: RosterStorage, sessionID: string): Promise<string | undefined>;
-/** A session's roster entry under a parent, if it is there. */
-export declare function entryUnder(storage: RosterStorage, parentID: string, sessionID: string): Promise<RosterEntry | undefined>;
-/** A session's roster entry, by the reverse index alone, without scanning the roster. */
-export declare function indexedEntry(storage: RosterStorage, sessionID: string): Promise<RosterEntry | undefined>;
-/**
- * The roster entries from a session up to the top, its own first, 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` by the reverse index alone: empty, without scanning the roster, when it does not name the session. */
-export declare function indexedLineage(storage: RosterStorage, sessionID: string): Promise<never[] | RosterEntry[]>;
-/** `lineage` over roster entries already read. */
-export declare function lineageIn(entries: ReadonlyArray<RosterEntry>, sessionID: string): RosterEntry[];
-/** Roster entries by their session, for `lineageBy`. */
-export declare function bySession(entries: ReadonlyArray<RosterEntry>): Map<string, RosterEntry>;
-/** `lineage` over roster entries already read and mapped by `bySession`. */
-export declare function lineageBy(bySession: ReadonlyMap<string, RosterEntry>, sessionID: string): RosterEntry[];
-/**
- * The top of a spawned session's lineage, where its permission requests and questions go, since the
- * person is there. Throws unless the session was spawned and `callerID` is that top; `what` names it.
- */
-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 or stale for the given entries, or the whole roster, and drops those
- * whose entry is gone, as an older copy's writes and removals leave them; a rerun changes nothing.
- */
-export declare function backfill(storage: RosterStorage, entries: ReadonlyArray<RosterEntry>): Promise<void>;

package/dist/roster.js

@@ -1,206 +0,0 @@
-import { existsSync } from "node:fs";
-import { dropMember } from "./group.js";
-import { forgetReport } from "./report.js";
-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: a child's `ReverseEntry` under `roster-by-child/<sessionID>`, written with its
- * roster entry; only an index, so `roster/` is scanned for entries lacking one, and confirms a hit.
- */
-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, its reverse key, its report state and, given its group, its membership. 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, group) {
-    const [, , , dropped] = await Promise.all([
-        storage.remove(rosterKey(parentID, sessionID)),
-        storage.remove(reverseKey(sessionID)).catch(() => undefined),
-        forgetReport(storage, sessionID).catch(() => undefined),
-        group ? dropMember(storage, parentID, group, sessionID).catch(() => false) : false,
-    ]);
-    return { droppedFromGroup: dropped };
-}
-/** Removes a child from its parent's roster; false when it was not there. */
-export async function forget(storage, parentID, sessionID) {
-    const entry = (await storage.get(rosterKey(parentID, sessionID)));
-    if (entry === undefined)
-        return false;
-    await remove(storage, parentID, sessionID, entry.group);
-    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 parentID = await indexedParent(storage, sessionID);
-    if (parentID === undefined)
-        return (await scanAll(storage, PREFIX)).filter((entry) => entry.sessionID === sessionID);
-    const entry = await storage.get(rosterKey(parentID, sessionID));
-    return entry === undefined ? [] : [entry];
-}
-/** The session that started a session, by the reverse index alone, without scanning the roster. */
-export async function indexedParent(storage, sessionID) {
-    const indexed = await storage.get(reverseKey(sessionID));
-    return isReverse(indexed) ? indexed.ancestors[0] : undefined;
-}
-/** A session's roster entry under a parent, if it is there. */
-export async function entryUnder(storage, parentID, sessionID) {
-    return (await storage.get(rosterKey(parentID, sessionID)));
-}
-/** A session's roster entry, by the reverse index alone, without scanning the roster. */
-export async function indexedEntry(storage, sessionID) {
-    const parentID = await indexedParent(storage, sessionID);
-    return parentID === undefined ? undefined : entryUnder(storage, parentID, sessionID);
-}
-/**
- * The roster entries from a session up to the top, its own first, 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);
-    return walkIndex(storage, sessionID, first);
-}
-/** `lineage` by the reverse index alone: empty, without scanning the roster, when it does not name the session. */
-export async function indexedLineage(storage, sessionID) {
-    const first = await storage.get(reverseKey(sessionID));
-    return isReverse(first) ? walkIndex(storage, sessionID, first) : [];
-}
-async function walkIndex(storage, sessionID, first) {
-    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) {
-    return lineageBy(bySession(entries), sessionID);
-}
-/** Roster entries by their session, for `lineageBy`. */
-export function bySession(entries) {
-    return new Map(entries.map((entry) => [entry.sessionID, entry]));
-}
-/** `lineage` over roster entries already read and mapped by `bySession`. */
-export function lineageBy(bySession, sessionID) {
-    const chain = [];
-    for (let entry = bySession.get(sessionID); entry && !chain.includes(entry); entry = bySession.get(entry.parentID))
-        chain.push(entry);
-    return chain;
-}
-/**
- * The top of a spawned session's lineage, where its permission requests and questions go, since the
- * person is there. Throws unless the session was spawned and `callerID` is that top; `what` names it.
- */
-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, entry.group)));
-    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 or stale for the given entries, or the whole roster, and drops those
- * whose entry is gone, as an older copy's writes and removals leave them; a rerun 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,94 +0,0 @@
-import type { Plugin } from "@opencode/plugin";
-import { Schema } from "effect";
-import { type CleanupPorts } from "./cleanup.js";
-import { type StopPorts } from "./stop.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>;
-    readonly group: Schema.optional<Schema.String>;
-}>;
-export declare const SendInput: Schema.Struct<{
-    readonly sessionID: Schema.String;
-    readonly message: Schema.String;
-    readonly status: Schema.optional<Schema.Literals<readonly ["done", "partial", "blocked", "failed"]>>;
-    readonly artifacts: Schema.optional<Schema.Struct<{
-        readonly branch: Schema.optional<Schema.String>;
-        readonly commits: Schema.optional<Schema.$Array<Schema.String>>;
-        readonly files: Schema.optional<Schema.$Array<Schema.String>>;
-        readonly checks: Schema.optional<Schema.$Array<Schema.Struct<{
-            readonly command: Schema.String;
-            readonly result: 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 TreeInput: Schema.Struct<{
-    readonly sessionID: Schema.optional<Schema.String>;
-}>;
-export declare const StopInput: Schema.Struct<{
-    readonly sessionID: Schema.String;
-    readonly cleanup: Schema.optional<Schema.Boolean>;
-}>;
-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 stop: StopPorts;
-    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;