opencode-courier 0.13.8 → 0.14.0

package/dist/person/ports.d.ts

@@ -5,29 +5,18 @@ import type { Waiting } from "./permission.js";
 export type { PermissionAnswered, PermissionRequest, Reply } from "./permission.js";
 export type { Asked, Elsewhere, Outcome, Prompt, QuestionAnswered, Withdrawal } from "./question/index.js";
 type Context = Plugin.Context;
-/** What the person events need of a member's `watch` ports, which are a `WatchPorts` at runtime. */
 export interface PersonPorts {
     readonly storage: RosterStorage;
     readonly session: Pick<Context["session"], "synthetic">;
     readonly event: Pick<Context["event"], "subscribe">;
-    /**
-     * The permission domains of every loaded location, whose pending requests are relayed when the
-     * watcher (re)subscribes: one watcher serves them all, and an isolated child's are in its worktree's.
-     */
     readonly permissions: () => Iterable<Pick<Context["permission"], "list">>;
-    /** The clock a location shutdown is recorded by: the question relay's, which judges it. */
     readonly now: () => number;
     readonly log: (message: string) => void;
 }
-/** The forms spawned sessions and others show, which only the person can answer, by form id; not the question tool's. */
 export type FormsShown = Map<string, {
     readonly sessionID: string;
     readonly title: string;
 }>;
-/**
- * What every plugin instance in the process shares of the person events: the handled event ids (the tree's too),
- * the requests and forms told about or answered first, and the forms shown now.
- */
 export interface PersonState {
     readonly seen: Set<string>;
     readonly waiting: Waiting;
@@ -35,9 +24,7 @@ export interface PersonState {
     readonly forms: FormsTold;
     readonly shown: FormsShown;
 }
-/** The session at the top of a lineage: where its permission requests go, since that is where the person is. */
 export declare const topOf: (chain: RosterEntry[]) => string;
-/** One field of an OpenCode form, as much of it as a notice shows. */
 export interface FormField {
     readonly key: string;
     readonly type: string;
@@ -49,12 +36,9 @@ export interface FormField {
         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;

package/dist/person/ports.js

@@ -1,2 +1 @@
-/** The session at the top of a lineage: where its permission requests go, since that is where the person is. */
 export const topOf = (chain) => chain.at(-1).parentID;

package/dist/person/question/answer.d.ts

@@ -3,7 +3,6 @@ import type { Answers, Asked, Outcome, Prompt, QuestionPorts, Withdrawal } from
 import { type CutOff } from "../text.js";
 import { type RosterStorage } from "../../tree/index.js";
 import { type QuestionAnswerInput } from "./pure.js";
-/** What answering a question did; `answered` is false when it no longer waited. */
 export type QuestionAnswered = {
     readonly sessionID: string;
     readonly requestID: string;
@@ -16,49 +15,22 @@ export type QuestionAnswered = {
     readonly answers: Answers;
 };
 export declare function tell(ports: QuestionPorts, asked: Asked, text: string, attributes: Record<string, string>): Promise<void>;
-/** Tells the top session that a question's call was cut off, once per question and process. */
 export declare function tellCutOff(ports: QuestionPorts, asked: Asked, cutOff: CutOff): Promise<void>;
-/**
- * What a linked call of the top session is withdrawn with once an answer is passed on, `withdrawal`, and
- * whether one was: `linked`, set once it is withdrawn.
- */
 export interface Linked {
     readonly withdrawal: Withdrawal;
     linked: boolean;
 }
-/**
- * Passes the top session's answer, or the person's dismissal, to a question: as the result of the
- * call that waits on it, or as a message when that call was cut off. Undefined when it was settled.
- */
 export declare const deliver: (ports: QuestionPorts, asked: Asked, outcome: Outcome, given?: Linked) => Effect.Effect<"result" | "message" | undefined, unknown>;
-/**
- * Drops a stored question whose answer went out. If that fails, it is marked answered instead, so
- * it is neither listed nor answered again, nor told about after a restart.
- */
 export declare function forget(ports: QuestionPorts, asked: Asked): Promise<void>;
-/**
- * Answers a question of a session started, directly or through others, from the caller, which must
- * be the session at the top, as for permission requests. `answered` is false when it no longer waits.
- */
 export declare function answerQuestion(ports: QuestionPorts, callerID: string, input: QuestionAnswerInput): Promise<QuestionAnswered>;
-/**
- * Answers a question for the person, from the TUI's inbox, as courier_answer does; the top session hears it once, as
- * answered by the person: its linked call is withdrawn, or else, if it was told of it, it is told settled.
- */
 export declare function answerForPerson(ports: QuestionPorts, input: QuestionAnswerInput): Promise<QuestionAnswered>;
-/** Whether a session waits on a question of its own, open or cut off and not yet answered. */
 export declare function asksQuestion(ports: {
     readonly storage: RosterStorage;
 }, sessionID: string): Promise<boolean>;
-/** The questions a session waits on, for courier_children; `stopped` when its call was cut off. */
 export declare function pendingQuestions(storage: RosterStorage, sessionID: string): Promise<{
     type: "question";
     requestID: string;
     questions: Prompt[];
     stopped?: true;
 }[]>;
-/**
- * On loading: drops stored questions that are too old, whose session is no longer on a roster, or
- * 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>;

package/dist/person/question/answer.js

@@ -15,12 +15,9 @@ export async function tell(ports, asked, text, attributes) {
         delivery: "steer",
     });
 }
-/** Tells the top session that a question's call was cut off, once per question and process. */
 export async function tellCutOff(ports, asked, cutOff) {
-    // Not while an answer to it is being passed on, which makes the notice moot.
     if (shared.noticed.has(asked.requestID) || isPassing(asked.requestID))
         return;
-    // Claimed first, so two tellers at once send one notice; given back if it did not go out.
     claim(shared.noticed, asked.requestID);
     try {
         await tell(ports, asked, questionNotice(asked, cutOff), { asks: "question", request: asked.requestID, [cutOff]: "true" });
@@ -31,12 +28,7 @@ export async function tellCutOff(ports, asked, cutOff) {
     }
 }
 const busy = (id) => new Error(`another answer to ${id} is still being passed on; try again in a while.`);
-/** This copy's lock per question, kept while an answer to it is passed on or waits its turn. */
 const locks = new Map();
-/**
- * Runs `effect` holding the question's lock, once it is taken; fails if that takes more than `ms`.
- * Only this copy of the plugin takes the lock: another copy's answer shows in `shared.passing`.
- */
 const holding = (id, ms, effect) => Effect.acquireUseRelease(Effect.sync(() => {
     const lock = locks.get(id) ?? { semaphore: Semaphore.makeUnsafe(1), users: 0 };
     lock.users++;
@@ -44,27 +36,19 @@ const holding = (id, ms, effect) => Effect.acquireUseRelease(Effect.sync(() => {
     return lock;
 }), (lock) => {
     const taken = Deferred.makeUnsafe();
-    // Whichever ends first: the effect, or the wait, which fails only if the lock was not taken by then.
     const late = Effect.andThen(Effect.sleep(ms), Effect.suspend(() => (Deferred.isDoneUnsafe(taken) ? Effect.never : Effect.fail(busy(id)))));
     return Effect.raceFirst(lock.semaphore.withPermit(Effect.andThen(Deferred.succeed(taken, undefined), effect)), late);
 }, (lock) => Effect.sync(() => {
     if (--lock.users === 0)
         locks.delete(id);
 }));
-/**
- * Passes the top session's answer, or the person's dismissal, to a question: as the result of the
- * call that waits on it, or as a message when that call was cut off. Undefined when it was settled.
- */
 export const deliver = (ports, asked, outcome, given) => Effect.suspend(() => {
     const linked = given ?? { withdrawal: { by: "top", outcome }, linked: false };
     const id = asked.requestID;
     const wait = ports.timing.passingWaitMs;
-    // One answer at a time, and once, per question in this process, since storage cannot be claimed
-    // atomically: a second waits, going only if the first did not; meanwhile no cut-off notice or link.
     const since = ports.now();
     const left = () => wait - (ports.now() - since);
     const turn = holding(id, wait, Effect.gen(function* () {
-        // An answer that another copy of the plugin, loaded beside this one, passes on.
         for (let under = shared.passing.get(id); under; under = shared.passing.get(id)) {
             if (left() <= 0)
                 return yield* Effect.fail(busy(id));
@@ -74,8 +58,6 @@ export const deliver = (ports, asked, outcome, given) => Effect.suspend(() => {
             return undefined;
         const passing = passOn(ports, asked, outcome, linked);
         shared.passing.set(id, passing);
-        // Held while it is passed on; one that hangs on a notice that never returns gives way after a
-        // while, so the question can be answered again, and the child may then be told twice.
         yield* within(passing, wait).pipe(Effect.ensuring(Effect.sync(() => {
             if (shared.passing.get(id) === passing)
                 shared.passing.delete(id);
@@ -84,7 +66,6 @@ export const deliver = (ports, asked, outcome, given) => Effect.suspend(() => {
     }));
     return Effect.flatMap(turn, (passing) => passing ? Effect.tryPromise({ try: () => passing, catch: (error) => error }) : Effect.succeed(undefined));
 });
-/** Withdraws the top session's call linked to a question, if any, now that it is settled. */
 function withdraw(known, linked) {
     if (!known.link)
         return;
@@ -94,24 +75,18 @@ function withdraw(known, linked) {
 async function passOn(ports, asked, outcome, linked) {
     const id = asked.requestID;
     let known = shared.questions.get(id);
-    // Taken only if the call ends with it: one already ending some other way, its turn being
-    // stopped or the person answering in its session, does not.
     if (known?.call && (await known.call(outcome))) {
         claim(shared.answered, id);
         shared.questions.delete(id);
-        // A call of the top session linked to it, asking the person, is withdrawn: it is settled.
         withdraw(known, linked);
         return "result";
     }
-    // Its call just ended: whether it was cut off and stays or was settled and is dropped is known once
-    // settle is through, from the registry, not storage, which lacks a question whose write failed.
     if (known) {
         await known.settling;
         if (shared.questions.get(id) !== known)
             return undefined;
     }
     else {
-        // Not known to this process: stored by one before it, and not yet loaded here.
         const stored = (await ports.storage.get(keyOf(id)));
         if (!stored || stored.answered)
             return undefined;
@@ -119,18 +94,12 @@ async function passOn(ports, asked, outcome, linked) {
         shared.questions.set(id, known);
     }
     await sendAnswer(ports, asked, outcome);
-    // Dropped only once the message is out, so a failed send leaves it to be answered again; the
-    // linked call, if any, goes then too, not before the answer is out.
     claim(shared.answered, id);
     shared.questions.delete(id);
     withdraw(known, linked);
     await forget(ports, asked);
     return "message";
 }
-/**
- * Drops a stored question whose answer went out. If that fails, it is marked answered instead, so
- * it is neither listed nor answered again, nor told about after a restart.
- */
 export async function forget(ports, asked) {
     try {
         await ports.storage.remove(keyOf(asked.requestID));
@@ -150,10 +119,6 @@ async function sendAnswer(ports, asked, outcome) {
         delivery: "steer",
     });
 }
-/**
- * Answers a question of a session started, directly or through others, from the caller, which must
- * be the session at the top, as for permission requests. `answered` is false when it no longer waits.
- */
 export async function answerQuestion(ports, callerID, input) {
     const { sessionID, requestID } = input;
     await answeringTop(ports.storage, sessionID, callerID, "questions");
@@ -164,10 +129,6 @@ export async function answerQuestion(ports, callerID, input) {
     const by = await run(deliver(ports, asked, { answers }));
     return by ? { sessionID, requestID, answered: true, by, answers } : { sessionID, requestID, answered: false };
 }
-/**
- * Answers a question for the person, from the TUI's inbox, as courier_answer does; the top session hears it once, as
- * answered by the person: its linked call is withdrawn, or else, if it was told of it, it is told settled.
- */
 export async function answerForPerson(ports, input) {
     const { sessionID, requestID } = input;
     const known = shared.questions.get(requestID);
@@ -180,17 +141,14 @@ export async function answerForPerson(ports, input) {
     const by = await run(deliver(ports, asked, { answers }, linked));
     if (!by)
         return { sessionID, requestID, answered: false };
-    // A question whose notice did not go out is not settled with one either; a stored one was told when cut off.
     const told = !known?.relaying || (await run(within(known.relaying, ports.timing.relayWaitMs))) === true;
     if (!linked.linked && told)
         await tell(ports, asked, questionSettledNotice(asked, settled), { answered: "elsewhere", request: requestID }).catch((error) => ports.log(`courier question: could not tell ${asked.top} that ${requestID} is settled: ${String(error)}`));
     return { sessionID, requestID, answered: true, by, answers };
 }
-/** Whether a session waits on a question of its own, open or cut off and not yet answered. */
 export async function asksQuestion(ports, sessionID) {
     return (await pendingQuestions(ports.storage, sessionID)).length > 0;
 }
-/** The questions a session waits on, for courier_children; `stopped` when its call was cut off. */
 export async function pendingQuestions(storage, sessionID) {
     const found = new Map();
     const add = (asked, stopped) => found.set(asked.requestID, {
@@ -207,10 +165,6 @@ export async function pendingQuestions(storage, sessionID) {
             add(asked, true);
     return [...found.values()];
 }
-/**
- * On loading: drops stored questions that are too old, whose session is no longer on a roster, or
- * beyond the newest `MAX_STORED`, and tells the top session about the rest, which a restart cut off.
- */
 export async function noticeCutOff(ports) {
     const stored = (await scanAll(ports.storage, PREFIX)).sort((a, b) => b.askedAt - a.askedAt);
     if (!stored.length)
@@ -218,12 +172,9 @@ export async function noticeCutOff(ports) {
     const roster = await allEntries(ports.storage);
     const now = ports.now();
     let kept = 0;
-    // Which to keep is decided here, newest first; the drops and the notices, one per question, then
-    // go out together.
     const work = [];
     for (const asked of stored) {
         const known = shared.questions.get(asked.requestID);
-        // Its call waits, or its top session is asking the person: nothing to tell.
         if (known?.call || known?.link || known?.settling || shared.passing.has(asked.requestID)) {
             kept++;
             continue;

package/dist/person/question/index.js

@@ -1,5 +1,3 @@
-// The question relay: what the rest of the plugin uses of it. The relay's state is kept in the hub
-// (`../../platform/hub.ts`), under a process-wide key of its own; `types.ts` types it.
 export { answerForPerson, answerQuestion, asksQuestion, noticeCutOff, pendingQuestions } from "./answer.js";
 export { eventsFollowed, eventsLeft, formShown, formsMayHaveBeenMissed, joinRelay, locationClosing, shutdownReportedAt } from "./lifecycle.js";
 export { byCodeUnit } from "./pure.js";

package/dist/person/question/lifecycle.d.ts

@@ -1,26 +1,9 @@
 import { Effect } from "effect";
 import type { QuestionPorts } from "./types.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 `location.shutdown`: the location at `directory` is closing, which withdraws its open
- * forms as if dismissed; with no location it counts for all. `at` is the watcher's clock, epoch ms.
- */
 export declare function locationClosing(at: number, directory?: string): void;
-/**
- * Whether a dismissal just seen at `directory` was the location closing rather than the person: it
- * shut down within the grace, before or after, or this instance unloads in it; unknown matches any.
- */
 export declare const closingSoon: (ports: QuestionPorts, loaded: () => boolean, directory: string | undefined) => Effect.Effect<boolean>;
-/**
- * Adds an instance's ports to `loaded`, which other copies tell cut-off questions through, until the
- * returned function is called. A location loading again forgets the shutdown recorded for it alone.
- */
 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: {
@@ -29,15 +12,6 @@ export declare function formShown(event: {
         };
     };
 }): void;
-/**
- * Called when an event stream may have missed forms shown: every call still waiting for its form is
- * taken as shown; one still waiting for its permission check is relayed early, the lesser harm.
- */
 export declare function formsMayHaveBeenMissed(): void;
-/**
- * Called when an instance starts following OpenCode's events: a shown form is missed only while none
- * follows, so waiting calls are released; true tells the caller to release again once connected.
- */
 export declare function eventsFollowed(): boolean;
-/** Called when an instance's event stream ended or broke. */
 export declare function eventsLeft(): void;

package/dist/person/question/lifecycle.js

@@ -1,51 +1,30 @@
 import { Deferred, Effect, Exit } from "effect";
 import { shared } from "./shared.js";
-/** 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 `location.shutdown`: the location at `directory` is closing, which withdraws its open
- * forms as if dismissed; with no location it counts for all. `at` is the watcher's clock, epoch ms.
- */
 export function locationClosing(at, directory) {
     shared.shutdowns.set(directory ?? ANYWHERE, at);
     for (const wake of shared.closingWaiters)
         wake();
 }
-/**
- * Whether a dismissal just seen at `directory` was the location closing rather than the person: it
- * shut down within the grace, before or after, or this instance unloads in it; unknown matches any.
- */
 export const closingSoon = (ports, loaded, directory) => Effect.suspend(() => {
     const ms = ports.timing.dismissalGraceMs;
     const closing = () => !loaded() || ports.now() - shutdownAt(directory) <= ms;
     if (closing())
         return Effect.succeed(true);
     const closed = Deferred.makeUnsafe();
-    // Woken by any shutdown or unload: only one that answers the question ends the wait.
     const wake = () => {
         if (closing())
             Deferred.doneUnsafe(closed, Exit.succeed(true));
     };
-    return Effect.acquireUseRelease(
-    // Looked at as the waiter is added, so a shutdown cannot come in between unseen.
-    Effect.sync(() => {
+    return Effect.acquireUseRelease(Effect.sync(() => {
         shared.closingWaiters.add(wake);
         wake();
     }), () => (Deferred.isDoneUnsafe(closed) ? Effect.succeed(true) : Effect.raceFirst(Deferred.await(closed), Effect.as(Effect.sleep(ms), false))), () => Effect.sync(() => shared.closingWaiters.delete(wake)));
 });
-/**
- * Adds an instance's ports to `loaded`, which other copies tell cut-off questions through, until the
- * returned function is called. A location loading again forgets the shutdown recorded for it alone.
- */
 export function joinRelay(ports) {
     shared.loaded.add(ports);
     shared.shutdowns.delete(ports.directory);
@@ -55,7 +34,6 @@ export function joinRelay(ports) {
             wake();
     };
 }
-/** Called for OpenCode's `form.created`: a question call's form is shown, so its question can be relayed. */
 export function formShown(event) {
     const call = event.data.form.metadata?.tool?.id;
     if (typeof call !== "string")
@@ -64,19 +42,11 @@ export function formShown(event) {
     shared.shown.get(key)?.();
     shared.shown.delete(key);
 }
-/**
- * Called when an event stream may have missed forms shown: every call still waiting for its form is
- * taken as shown; one still waiting for its permission check is relayed early, the lesser harm.
- */
 export function formsMayHaveBeenMissed() {
     for (const shown of shared.shown.values())
         shown();
     shared.shown.clear();
 }
-/**
- * Called when an instance starts following OpenCode's events: a shown form is missed only while none
- * follows, so waiting calls are released; true tells the caller to release again once connected.
- */
 export function eventsFollowed() {
     const missed = shared.following === 0 && shared.followed;
     shared.following++;
@@ -85,7 +55,6 @@ export function eventsFollowed() {
         formsMayHaveBeenMissed();
     return missed;
 }
-/** Called when an instance's event stream ended or broke. */
 export function eventsLeft() {
     shared.following = Math.max(0, shared.following - 1);
 }

package/dist/person/question/pure.d.ts

@@ -5,35 +5,24 @@ type ToolEditor = Parameters<Parameters<EffectPlugin.Context["tool"]["transform"
 type HostTool = Parameters<Parameters<ToolEditor["update"]>[1]>[0];
 export type Execute = HostTool["execute"];
 export type ToolResult = Effect.Success<ReturnType<Execute>>;
-/** The questions of a call, without anything the tool does not define. */
 export declare function promptsOf(input: unknown): Prompt[];
 export interface QuestionAnswerInput {
     readonly sessionID: string;
     readonly requestID: string;
-    /** One entry per question: a label or the text the person gave, or a list of them. */
     readonly answers: ReadonlyArray<string | ReadonlyArray<string>>;
 }
-/** The answers in the question tool's shape, checked against the questions. */
 export declare function normalize(asked: Asked, answers: QuestionAnswerInput["answers"]): Answers;
-/** OpenCode's question tool dies with this when the person dismisses the question. */
 export declare const isDismissal: (cause: Cause.Cause<unknown>) => boolean;
-/** How a relayed call ended. */
 export type CallExit = Exit.Exit<{
     by: "child";
     result: ToolResult;
 } | {
     by: "top";
 }, unknown>;
-/** How a relayed call that the top session did not answer was settled in the asking session. */
 export declare function settledIn(exit: CallExit): Elsewhere;
-/**
- * Orders strings by UTF-16 code units, the default sort's order, stated: it only has to come out the
- * same on both sides of a comparison; a locale-aware compare may rank two different labels as equal.
- */
 export declare function byCodeUnit(a: string, b: string): 0 | 1 | -1;
 export declare const choices: (questions: ReadonlyArray<Prompt>) => string;
 export declare const wording: (questions: ReadonlyArray<Prompt>) => string;
-/** The result of a linked call withdrawn because its question was settled without it. */
 export declare function withdrawnResult(linked: Question, how: Withdrawal): {
     output: {
         answers: Answers;

package/dist/person/question/pure.js

@@ -1,6 +1,5 @@
 import { Cause, Exit, Result } from "effect";
 import { withdrawnText } from "../text.js";
-/** The questions of a call, without anything the tool does not define. */
 export function promptsOf(input) {
     const questions = input?.questions ?? [];
     return questions.map((prompt) => ({
@@ -10,7 +9,6 @@ export function promptsOf(input) {
         ...(prompt.multiple ? { multiple: true } : {}),
     }));
 }
-/** The answers in the question tool's shape, checked against the questions. */
 export function normalize(asked, answers) {
     if (answers.length !== asked.questions.length)
         throw new Error(`answers needs one entry per question, ${asked.questions.length} in all, not ${answers.length}.`);
@@ -26,9 +24,7 @@ const defectTag = (cause) => {
     const defect = Cause.findDefect(cause);
     return Result.isSuccess(defect) ? defect.success?._tag : undefined;
 };
-/** OpenCode's question tool dies with this when the person dismisses the question. */
 export const isDismissal = (cause) => defectTag(cause) === "QuestionTool.CancelledError";
-/** How a relayed call that the top session did not answer was settled in the asking session. */
 export function settledIn(exit) {
     if (Exit.isSuccess(exit))
         return {
@@ -39,19 +35,13 @@ export function settledIn(exit) {
         return { by: "dismissed" };
     return { by: "failed", error: String(Cause.squash(exit.cause)) };
 }
-/**
- * Orders strings by UTF-16 code units, the default sort's order, stated: it only has to come out the
- * same on both sides of a comparison; a locale-aware compare may rank two different labels as equal.
- */
 export function byCodeUnit(a, b) {
     if (a === b)
         return 0;
     return a < b ? -1 : 1;
 }
-// The labels in any order: the answers are labels, so a top session listing them differently still asks the same.
 export const choices = (questions) => JSON.stringify(questions.map((prompt) => [!!prompt.multiple, prompt.options.map((option) => option.label).sort(byCodeUnit)]));
 export const wording = (questions) => JSON.stringify(questions.map((prompt) => prompt.question.trim().replace(/\s+/g, " ").toLowerCase()));
-/** The answers that count once a linked call's question was settled without it: none unless it was answered. */
 function withdrawnAnswers(linked, how) {
     const none = () => linked.questions.map(() => []);
     switch (how.by) {
@@ -64,7 +54,6 @@ function withdrawnAnswers(linked, how) {
             return none();
     }
 }
-/** The result of a linked call withdrawn because its question was settled without it. */
 export function withdrawnResult(linked, how) {
     return {
         output: { answers: withdrawnAnswers(linked, how) },

package/dist/person/question/relay.d.ts

@@ -1,5 +1,4 @@
 import type { Plugin as EffectPlugin } from "@opencode/plugin/effect";
 import { Effect } from "effect";
 import type { QuestionPorts } from "./types.js";
-/** 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" | "location">, ports: () => QuestionPorts | undefined): Effect.Effect<import("@opencode/plugin/effect/registration").Registration, never, import("effect/Scope").Scope>;