opencode-courier 0.13.8 → 0.14.0

package/dist/person/question/relay.js

@@ -6,10 +6,6 @@ import { closingSoon } from "./lifecycle.js";
 import { choices, isDismissal, normalize, promptsOf, settledIn, withdrawnResult, wording, } from "./pure.js";
 import { background, run, within } from "./runtime.js";
 import { anyLoaded, isPassing, keyOf, QUESTION_TOOL, shared, storedOf } from "./shared.js";
-/**
- * Tells the top session about a question its closing location cut off, after the closing grace of
- * `ports`, through any instance still loaded then; without one, the next load tells it.
- */
 function tellLater(ports, question) {
     const tellNow = Effect.suspend(() => {
         const later = anyLoaded();
@@ -19,7 +15,6 @@ function tellLater(ports, question) {
     });
     void background(Effect.andThen(Effect.sleep(ports.timing.closingGraceMs), tellNow), (error) => ports.log(`courier question: could not tell ${question.top} about ${question.requestID}: ${String(error)}`));
 }
-/** Registers a question, stores it and tells the top session; false when storing or telling failed. */
 async function relay(ports, question) {
     shared.questions.set(question.requestID, question);
     try {
@@ -31,55 +26,38 @@ async function relay(ports, question) {
         return true;
     }
     catch (error) {
-        // The question stays registered and the call waits on: courier_children lists it, and an answer
-        // that comes anyway, through a link or courier_answer, still reaches the call.
         ports.log(`courier question: could not tell ${question.top} about ${question.requestID}: ${String(error)}`);
         return false;
     }
 }
-/**
- * After a relayed call ended: tidies up, and tells the top session if it was settled without it.
- * `loaded` says whether the plugin instance that ran the call is still loaded.
- */
 const settle = (ports, question, exit, loaded) => Effect.gen(function* () {
     const unloaded = !loaded();
-    // A dismissal is held from now, alongside the wait below, so the grace is not spent waiting.
     const dismissed = Exit.isFailure(exit) && isDismissal(exit.cause);
     const held = dismissed && !unloaded ? yield* Effect.forkChild(closingSoon(ports, loaded, question.directory), { startImmediately: true }) : undefined;
-    // The top session is told first, for a while only, so what follows neither overtakes the notice
-    // nor waits forever on one that never returns; `told` is false when it was not told, or not yet.
     const told = (yield* within(question.relaying, ports.timing.relayWaitMs)) === true;
-    // Answered by the top session.
     if (Exit.isSuccess(exit) && exit.value.by === "top") {
         if (shared.questions.get(question.requestID) === question)
             shared.questions.delete(question.requestID);
         return yield* Effect.promise(() => forget(ports, question));
     }
-    // Never relayed, or dropped meanwhile.
     if (shared.questions.get(question.requestID) !== question) {
         return yield* Effect.promise(() => forget(ports, question));
     }
-    // Cut off: the turn was stopped, or the closing location withdrew its forms as if dismissed, so a
-    // dismissal is held for a following shutdown or unload; the question stays, answered by message.
+    // a closing location withdraws its forms as if dismissed (api-notes)
     const closing = unloaded || !loaded() || (held !== undefined && (yield* Fiber.join(held)));
     if (Exit.isFailure(exit) && (closing || (!dismissed && Exit.hasInterrupts(exit))))
         return closing ? tellLater(ports, question) : yield* Effect.promise(() => stopped(ports, question));
     yield* Effect.promise(() => settledElsewhere(ports, question, settledIn(exit), told));
 });
-/** A relayed call cut off by its stopped turn: the top session is told now, unless it asks the person. */
 async function stopped(ports, question) {
     if (!question.link)
         await tellCutOff(ports, question, "stopped");
 }
-/** A relayed call settled in the asking session: `told` says whether the top session was told about it. */
 async function settledElsewhere(ports, question, how, told) {
-    // Its record goes before its registration, so an answer that finds the question gone does not
-    // find the record still there and send it on.
     await forget(ports, question);
     shared.questions.delete(question.requestID);
     if (question.link)
         return question.link(how);
-    // A top session never told about the question is not told that it is settled either.
     if (!told)
         return;
     await tell(ports, question, questionSettledNotice(question, how), {
@@ -87,19 +65,11 @@ async function settledElsewhere(ports, question, how, told) {
         request: question.requestID,
     });
 }
-/**
- * Starts settling a relayed call that ended, kept on the question until it is through: an answer
- * the call did not take waits for it.
- */
 function startSettling(ports, question, exit, loaded) {
     question.settling = background(settle(ports, question, exit, loaded), (error) => ports.log(`courier question: could not settle ${question.requestID}: ${String(error)}`)).finally(() => {
         question.settling = undefined;
     });
 }
-/**
- * A spawned session's question call: once its form is shown the top session is told, and whichever
- * answer comes first ends the call, the other side's question withdrawn. Other calls run unchanged.
- */
 function asking(ports, directory, original) {
     return (input, context) => Effect.gen(function* () {
         const current = ports();
@@ -108,10 +78,8 @@ function asking(ports, directory, original) {
             return yield* original(input, context);
         const byTop = Deferred.makeUnsafe();
         const accepted = Deferred.makeUnsafe();
-        // For a copy of the plugin that answers through `call`, which takes promises.
         let acceptancePromise;
         const acceptance = () => (acceptancePromise ??= Effect.runPromise(Deferred.await(accepted)));
-        // Handed one outcome only: a second, while the first still ends the call, is not taken.
         let handed = false;
         const top = chain.at(-1).parentID;
         const question = {
@@ -122,7 +90,7 @@ function asking(ports, directory, original) {
             ...(chain.length > 1 ? { startedBy: chain[0].parentID } : {}),
             questions: promptsOf(input),
             askedAt: current.now(),
-            // OpenCode shows a native child's form in its native root's view: when that is the top's, the person answers there.
+            // a native child's form shows in its native root's view (api-notes)
             ...(nativeRootOf(chain) === top ? { native: true } : {}),
             directory,
             call: (outcome) => {
@@ -133,30 +101,22 @@ function asking(ports, directory, original) {
                 return acceptance();
             },
         };
-        // The form is shown only once OpenCode's permission check for the call has passed; a call
-        // refused there never reaches the top session.
+        // form.created comes only once the call's permission check passed
         const key = `${context.sessionID} ${context.id}`;
         const loaded = () => ports() === current;
         const shown = Deferred.makeUnsafe();
-        // Called as a plain function, by this copy's watcher or another copy's.
         shared.shown.set(key, () => Deferred.doneUnsafe(shown, Exit.void));
         const fromTop = Effect.gen(function* () {
             yield* Deferred.await(shown);
-            // Started, not waited for: a store or a notice that hangs must not keep the top session's
-            // answer from the call. Kept on the question, so settle can wait for it.
             question.relaying = relay(current, question);
             return { by: "top", outcome: yield* Deferred.await(byTop) };
         });
-        const ended = yield* Effect.raceFirst(original(input, context).pipe(Effect.map((result) => ({ by: "child", result }))), fromTop).pipe(
-        // Not waited for, so storing or a notice that hangs cannot hold the call up.
-        Effect.onExit((exit) => Effect.sync(() => {
+        const ended = yield* Effect.raceFirst(original(input, context).pipe(Effect.map((result) => ({ by: "child", result }))), fromTop).pipe(Effect.onExit((exit) => Effect.sync(() => {
             shared.shown.delete(key);
-            // The call no longer waits, whatever settle makes of it: an answer from now on waits for settle.
             const byTopSession = Exit.isSuccess(exit) && exit.value.by === "top";
             if (!byTopSession)
                 question.call = undefined;
             startSettling(current, question, exit, loaded);
-            // After settling is set, which an answer the call did not take then waits for.
             Deferred.doneUnsafe(accepted, Exit.succeed(byTopSession));
         })));
         if (ended.by === "child")
@@ -175,12 +135,7 @@ function asking(ports, directory, original) {
         };
     });
 }
-/** Whether the top session's question call may be linked to a question: not a native child's while its own form is shown. */
 const linkable = (question, sessionID) => question.top === sessionID && !question.link && !isPassing(question.requestID) && !(question.native && question.call);
-/**
- * The waiting question a top session's call asks again, the oldest if several: the same question with
- * the same choices, in any order. Choices alone would let an unrelated yes-or-no answer a child's.
- */
 function linkFor(sessionID, questions) {
     const asked = { choices: choices(questions), wording: wording(questions) };
     return [...shared.questions.values()]
@@ -189,10 +144,6 @@ function linkFor(sessionID, questions) {
         wording(question.questions) === asked.wording)
         .sort((a, b) => a.askedAt - b.askedAt)[0];
 }
-/**
- * The result of a top session's question call that no waiting question was linked to: when one waits
- * with the same choices, reworded or asked earlier, it says how to pass the answers on.
- */
 function unlinkedResult(result, sessionID, questions) {
     if (typeof result.content !== "string")
         return result;
@@ -202,10 +153,6 @@ function unlinkedResult(result, sessionID, questions) {
         return result;
     return { ...result, content: `${result.content}\n${unlinkedNote(similar)}` };
 }
-/**
- * After a linked call failed with its location still loaded: a dismissal by the person dismisses the
- * child's question too, or is logged if answered meanwhile; a stop while cut off tells the top.
- */
 const linkedCallFailed = (ports, linked, cause, loaded, directory) => Effect.gen(function* () {
     if (isDismissal(cause)) {
         if (yield* closingSoon(ports, loaded, directory))
@@ -216,12 +163,7 @@ const linkedCallFailed = (ports, linked, cause, loaded, directory) => Effect.gen
     else if (!linked.call && shared.questions.get(linked.requestID) === linked)
         yield* Effect.promise(() => tellCutOff(ports, linked, "stopped"));
 });
-/** Logs that what happened to a linked call could not be passed on. */
 const notPassedOn = (ports, linked) => (error) => ports.log(`courier question: could not pass on what happened to ${linked.requestID}: ${String(error)}`);
-/**
- * The question call of a session that a waiting question was relayed to, asking the person the
- * same: what they choose is passed on, and the call is withdrawn if the question is settled first.
- */
 function linking(ports, directory, ask) {
     return (input, context) => Effect.gen(function* () {
         const current = ports();
@@ -233,16 +175,14 @@ function linking(ports, directory, ask) {
         }
         const loaded = () => ports() === current;
         const elsewhere = Deferred.makeUnsafe();
-        // Called as a plain function, by this copy or another one.
         const settled = (how) => void Deferred.doneUnsafe(elsewhere, Exit.succeed(how));
         linked.link = settled;
         const ended = yield* Effect.raceFirst(ask(input, context).pipe(Effect.map((result) => ({ by: "person", result }))), Deferred.await(elsewhere).pipe(Effect.map((how) => ({ by: "elsewhere", how })))).pipe(Effect.onExit((exit) => Effect.sync(() => {
             if (linked.link === settled)
                 linked.link = undefined;
-            // Unloaded: OpenCode is closing the location, which withdraws the form; nobody dismissed it.
+            // unloaded: OpenCode withdrew the form as it closed the location
             if (Exit.isSuccess(exit) || !loaded())
                 return;
-            // Not waited for, as in asking.
             void background(linkedCallFailed(current, linked, exit.cause, loaded, directory), notPassedOn(current, linked));
         })));
         if (ended.by === "elsewhere")
@@ -263,9 +203,7 @@ function linking(ports, directory, ask) {
         };
     });
 }
-/** Wraps OpenCode's question tool for the relay. A tool by that id that is missing is left alone. */
 export function relayQuestions(host, ports) {
-    // The wrapped tool runs the calls of the host's location: its shutdown is what withdraws their forms.
     const { directory } = host.location;
     return host.tool.transform((editor) => {
         editor.update(QUESTION_TOOL, (tool) => {

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

@@ -1,20 +1,6 @@
 import { Clock, Effect } from "effect";
-/**
- * Runs a relay effect in its own fiber by the relay's clock (`ports.now`): the promise settles as the
- * effect ends, rejecting on failure or interruption; interrupting the waiter does not stop the fiber.
- */
 export declare function run<A, E>(effect: Effect.Effect<A, E>): Promise<A>;
-/**
- * Runs an effect of the relay in the background, as `run` does; the promise resolves once it ended,
- * however it ended. A failure is logged with `failed`; an interruption, by a test ending, is not.
- */
 export declare function background(effect: Effect.Effect<unknown, unknown>, failed: (error: unknown) => void): Promise<void>;
-/** The promise's value, or undefined once `ms` have passed or it failed. */
 export declare const within: <T>(promise: Promise<T> | undefined, ms: number) => Effect.Effect<T | undefined>;
-/**
- * For tests: the clock the relay runs by from now on, a `TestClock` whose time `ports.now` reads,
- * or the system clock again with none.
- */
 export declare function useClock(next?: Clock.Clock): void;
-/** For tests: interrupts every fiber the relay started, and goes back to the system clock. */
 export declare function stopRelay(): Promise<void>;

package/dist/person/question/runtime.js

@@ -1,13 +1,6 @@
 import { Cause, Clock, Duration, Effect, Exit, Fiber, Option, Scope } from "effect";
-// What the relay's own fibers run with: this copy's state, not the hub's. A copy of the plugin
-// loaded next to this one has its own, and they meet only in the shared fields of the hub.
 const system = Effect.runSync(Clock.clockWith(Effect.succeed));
-/** Largest delay a timer takes; a longer one would fire at once, so it is slept in parts. */
 const MAX_TIMER_MS = 2_147_483_647;
-/**
- * The system clock, whose sleeps do not keep the process running: OpenCode exits without waiting
- * for a dismissal held, a notice told later or an answer waiting its turn.
- */
 const live = {
     currentTimeMillisUnsafe: () => system.currentTimeMillisUnsafe(),
     currentTimeMillis: system.currentTimeMillis,
@@ -25,47 +18,29 @@ function sleep(ms) {
     const rest = ms > MAX_TIMER_MS ? Effect.suspend(() => sleep(ms - MAX_TIMER_MS)) : Effect.void;
     return Effect.callback((resume) => {
         const timer = setTimeout(() => resume(rest), Math.min(ms, MAX_TIMER_MS));
+        // unref'd: OpenCode exits without waiting for the relay's timers
         timer.unref?.();
         return Effect.sync(() => clearTimeout(timer));
     });
 }
 let clock = live;
-/** The fibers the relay starts, which run as long as the process unless a test ends them. */
 let scope = Scope.makeUnsafe();
-/**
- * Starts an effect of the relay in a fiber of its own, by the relay's clock, in the relay's scope:
- * at once, up to its first wait, as an async function would.
- */
 const start = (effect) => Effect.runFork(Effect.provideService(effect, Clock.Clock, clock)).pipe(Fiber.runIn(scope));
-/**
- * Runs a relay effect in its own fiber by the relay's clock (`ports.now`): the promise settles as the
- * effect ends, rejecting on failure or interruption; interrupting the waiter does not stop the fiber.
- */
 export function run(effect) {
     return Effect.runPromise(Fiber.join(start(effect)));
 }
-/**
- * Runs an effect of the relay in the background, as `run` does; the promise resolves once it ended,
- * however it ended. A failure is logged with `failed`; an interruption, by a test ending, is not.
- */
 export function background(effect, failed) {
     return Effect.runPromise(Fiber.await(start(effect))).then((exit) => {
         if (Exit.isFailure(exit) && !Cause.hasInterruptsOnly(exit.cause))
             failed(Cause.squash(exit.cause));
     });
 }
-/** The promise's value, or undefined once `ms` have passed or it failed. */
 export const within = (promise, ms) => promise
     ? Effect.promise(() => promise.then((value) => value, () => undefined)).pipe(Effect.timeoutOption(ms), Effect.map(Option.getOrUndefined))
     : Effect.succeed(undefined);
-/**
- * For tests: the clock the relay runs by from now on, a `TestClock` whose time `ports.now` reads,
- * or the system clock again with none.
- */
 export function useClock(next) {
     clock = next ?? live;
 }
-/** For tests: interrupts every fiber the relay started, and goes back to the system clock. */
 export async function stopRelay() {
     const ended = scope;
     scope = Scope.makeUnsafe();

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

@@ -1,34 +1,17 @@
 import type { Registry } from "../../platform/storage.js";
 import type { Asked, Question, QuestionPorts, QuestionState } from "./types.js";
-/** OpenCode's own question tool, which the relay wraps. */
 export declare const QUESTION_TOOL = "question";
 export declare const PREFIX = "question/";
-/** At most this many questions are kept in storage; the oldest go first. */
 export declare const MAX_STORED = 100;
-/** A question as stored; `answered` marks one whose answer went out but that could not be dropped. */
 export type Stored = Asked & {
     readonly answered?: true;
 };
 export declare const storedOf: ({ directory: _directory, call: _call, link: _link, relaying: _relaying, settling: _settling, ...asked }: Question) => Asked;
 export declare const isPassing: (requestID: string) => boolean;
-/**
- * The relay's state in `registry`, the hub's `questions`, with the fields it lacks made: field by
- * field, since a copy before the hub may have made it without the fields added later.
- */
 export declare function questionState(registry?: Registry): QuestionState;
 export declare const shared: QuestionState;
-/**
- * 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 declare const anyLoaded: () => QuestionPorts | undefined;
-/**
- * The question ports of the member that just joined at `location`, while it is loaded: resolved once,
- * so a later instance at the same location does not take its place while this one is still loaded.
- */
 export declare function portsAt(location: object): () => QuestionPorts | undefined;
 export declare const keyOf: (requestID: string) => string;
-/** Whether a request id is a question's rather than a permission request's. */
 export declare const isQuestion: (requestID: string) => boolean;
-/** Adds to one of the shared bounded sets. */
 export declare const claim: (set: Set<string>, value: string) => boolean;

package/dist/person/question/shared.js

@@ -1,16 +1,10 @@
 import { addBounded } from "../../platform/bounded.js";
 import { hub, memberAt, sharedState } from "../../platform/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);
-/**
- * The relay's state in `registry`, the hub's `questions`, with the fields it lacks made: field by
- * field, since a copy before the hub may have made it without the fields added later.
- */
 export function questionState(registry) {
     const state = sharedState("questions", () => ({}), registry);
     state.questions ??= new Map();
@@ -25,28 +19,14 @@ export function questionState(registry) {
     state.closingWaiters ??= new Set();
     return state;
 }
-// Shared by every plugin instance in the process, since a child and the session it asks can be in
-// different locations.
 export const shared = questionState();
-/** A member's question ports: every hub-v2 member's `questions` are its instance's, whichever copy joined it. */
 const portsOf = (member) => member?.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 = () => portsOf(hub.members.values().next().value) ?? shared.loaded.values().next().value;
-/**
- * The question ports of the member that just joined at `location`, while it is loaded: resolved once,
- * so a later instance at the same location does not take its place while this one is still loaded.
- */
 export function portsAt(location) {
     const own = memberAt(location);
     return () => (own && hub.members.has(own) ? portsOf(own) : undefined);
 }
 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/person/question/types.d.ts

@@ -1,7 +1,6 @@
 import type { Plugin } from "@opencode/plugin";
 import type { Storage } from "../../platform/storage.js";
 type Context = Plugin.Context;
-/** One question of OpenCode's question tool, as the asking model wrote it. */
 export interface Prompt {
     readonly question: string;
     readonly header: string;
@@ -11,26 +10,17 @@ export interface Prompt {
     }>;
     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;
-    /** A native child's, whose form OpenCode shows the person in the top session's own view; not linked while shown. */
     readonly native?: true;
 }
-/**
- * How a question was settled without the top session: in the asking session (or, `via` "inbox", by the
- * person in the TUI's asks inbox), or not at all.
- */
 export type Elsewhere = {
     readonly by: "child";
     readonly answers: Answers;
@@ -41,39 +31,22 @@ export type Elsewhere = {
     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;
 };
-/**
- * A question this process knows: its call waits (`call`), or was cut off and is answered by message.
- * `link` withdraws the top session's call passing the answer on, once settled without that call.
- */
 export interface Question extends Asked {
-    /** The directory of the location the call runs in, whose shutdown withdraws its form. */
     directory?: string;
-    /** Hands the waiting call the top session's outcome; true once the call has ended with it. */
     call?: (outcome: Outcome) => Promise<boolean>;
     link?: (how: Withdrawal) => void;
-    /** Storing the question and telling the top session, while that is under way. */
     relaying?: Promise<boolean>;
-    /** Working out what became of it once its call ended without the top session's answer. */
     settling?: Promise<void>;
 }
-/**
- * The relay's timings, carried by its ports: the closing grace before a cut-off question is told, the
- * wait for an answer still being passed on, the wait for a notice to go out, and the dismissal hold.
- */
 export interface QuestionTiming {
     readonly closingGraceMs: number;
     readonly passingWaitMs: number;
@@ -83,39 +56,22 @@ export interface QuestionTiming {
 export interface QuestionPorts {
     readonly storage: Storage;
     readonly session: Pick<Context["session"], "synthetic">;
-    /** The directory of the instance's location. */
     readonly directory: string;
-    /** The clock, in epoch milliseconds, as OpenCode's location shutdowns are recorded. */
     readonly now: () => number;
     readonly timing: QuestionTiming;
     readonly newID: () => string;
     readonly log: (message: string) => void;
 }
-/**
- * The question relay's state, shared by every instance, as a child and the session it asks can be in
- * different locations: open questions, cut-off ones already told, and calls waiting for their form.
- */
 export interface QuestionState {
     readonly questions: Map<string, Question>;
     readonly noticed: Set<string>;
     readonly shown: Map<string, () => void>;
-    /** The questions whose answer is being passed on, each until that is done, and those whose answer went out. */
     readonly passing: Map<string, Promise<unknown>>;
     readonly answered: Set<string>;
-    /**
-     * The ports of every loaded instance of every copy. A release before the hub picks one here to tell
-     * a cut-off question through, so every copy fills it; this copy reads it only for another copy.
-     */
     readonly loaded: Set<QuestionPorts>;
-    /** How many instances follow OpenCode's events now, and whether any has since the process started. */
     following: number;
     followed: boolean;
-    /**
-     * When OpenCode last reported each location shutting down (`location.shutdown`), by directory
-     * in epoch milliseconds by the clock of the watcher that saw it; under `""` when the event named no location.
-     */
     readonly shutdowns: Map<string, number>;
-    /** Woken when a location shuts down or an instance unloads: dismissals held to see whether one follows. */
     readonly closingWaiters: Set<() => void>;
 }
 export {};

package/dist/person/rpc-handlers.d.ts

@@ -2,23 +2,16 @@ import type { Plugin } from "@opencode/plugin";
 import { type Permissions } from "./permission.js";
 import { type QuestionPorts } from "./question/index.js";
 import { type Answered, type Asks } from "./rpc.js";
-/** What the person's RPC reads and answers through: the relay's ports, which carry the storage, and every location's permissions. */
 export interface PersonRpcPorts {
     readonly questions: QuestionPorts;
     readonly permissions: () => Iterable<Permissions>;
 }
-/**
- * The permission requests and questions waiting in the courier tree a session is in, the top's own requests first, read from the
- * roster from the top of its lineage down, so each session of the tree sees the same inbox.
- */
 export declare function asks(ports: PersonRpcPorts, sessionID: string): Promise<Asks>;
-/** Passes the person's answers to a question on, as courier_answer does; a refusal, such as answers that do not fit, comes back as `problem`. */
 export declare function answer(ports: PersonRpcPorts, input: {
     sessionID: string;
     requestID: string;
     answers: ReadonlyArray<ReadonlyArray<string>>;
 }): Promise<Answered>;
-/** Serves the person's RPC at the plugin's location; disposed with the plugin. */
 export declare function registerPersonRpc(rpc: Pick<Plugin.Context["rpc"], "register">, ports: PersonRpcPorts): Promise<import("@opencode/plugin/promise/rpc").RpcRegistration<{
     readonly id: "courier-person";
     readonly methods: {

package/dist/person/rpc-handlers.js

@@ -2,10 +2,6 @@ import { lineage, subtree } from "../tree/index.js";
 import { ownRequests, pendingOf } from "./permission.js";
 import { answerForPerson, pendingQuestions } from "./question/index.js";
 import { personRpc } from "./rpc.js";
-/**
- * The permission requests and questions waiting in the courier tree a session is in, the top's own requests first, read from the
- * roster from the top of its lineage down, so each session of the tree sees the same inbox.
- */
 export async function asks(ports, sessionID) {
     const { storage } = ports.questions;
     const top = (await lineage(storage, sessionID)).at(-1)?.parentID ?? sessionID;
@@ -53,7 +49,6 @@ export async function asks(ports, sessionID) {
         }))),
     };
 }
-/** Passes the person's answers to a question on, as courier_answer does; a refusal, such as answers that do not fit, comes back as `problem`. */
 export async function answer(ports, input) {
     try {
         const result = await answerForPerson(ports.questions, input);
@@ -63,7 +58,6 @@ export async function answer(ports, input) {
         return { answered: false, problem: error instanceof Error ? error.message : String(error) };
     }
 }
-/** Serves the person's RPC at the plugin's location; disposed with the plugin. */
 export function registerPersonRpc(rpc, ports) {
     return rpc.register(personRpc, {
         asks: ({ sessionID }) => asks(ports, sessionID),

package/dist/person/rpc.d.ts

@@ -1,28 +1,22 @@
 import { Schema } from "effect";
-/** A session of the tree, as the inbox names where an ask comes from. */
 declare const Session: Schema.Struct<{
     readonly sessionID: Schema.String;
     readonly title: Schema.String;
     readonly parentID: Schema.String;
-    /** A child of the tree's top session is at depth 1. */
     readonly depth: Schema.Int;
     readonly group: Schema.optionalKey<Schema.String>;
 }>;
-/** A permission request a session of the tree, the top among them, waits on. */
 declare const Permission: Schema.Struct<{
     readonly sessionID: Schema.String;
     readonly requestID: Schema.String;
     readonly action: Schema.String;
     readonly resources: Schema.$Array<Schema.String>;
-    /** What "always" would allow from now on; absent when it is not offered. */
     readonly save: Schema.optionalKey<Schema.$Array<Schema.String>>;
-    /** The request below that allowing this one passes on: the top's courier_answer prompt. */
     readonly passesOn: Schema.optionalKey<Schema.Struct<{
         readonly sessionID: Schema.String;
         readonly requestID: Schema.String;
     }>>;
 }>;
-/** A question a session of the tree waits on; `stopped` when its call was cut off and the answer goes as a message. */
 declare const Question: Schema.Struct<{
     readonly sessionID: Schema.String;
     readonly requestID: Schema.String;
@@ -37,28 +31,21 @@ declare const Question: Schema.Struct<{
     }>>;
     readonly stopped: Schema.optionalKey<Schema.Boolean>;
 }>;
-/** What the sessions of a courier tree wait on the person for, but forms, which the TUI lists itself. */
 declare const Asks: Schema.Struct<{
-    /** The session at the top of the tree, which the sessions below were started from. */
     readonly top: Schema.String;
-    /** The sessions below the top, in the order a tree is drawn. */
     readonly sessions: Schema.$Array<Schema.Struct<{
         readonly sessionID: Schema.String;
         readonly title: Schema.String;
         readonly parentID: Schema.String;
-        /** A child of the tree's top session is at depth 1. */
         readonly depth: Schema.Int;
         readonly group: Schema.optionalKey<Schema.String>;
     }>>;
-    /** The top session's own requests first, then those of the sessions below. */
     readonly permissions: Schema.$Array<Schema.Struct<{
         readonly sessionID: Schema.String;
         readonly requestID: Schema.String;
         readonly action: Schema.String;
         readonly resources: Schema.$Array<Schema.String>;
-        /** What "always" would allow from now on; absent when it is not offered. */
         readonly save: Schema.optionalKey<Schema.$Array<Schema.String>>;
-        /** The request below that allowing this one passes on: the top's courier_answer prompt. */
         readonly passesOn: Schema.optionalKey<Schema.Struct<{
             readonly sessionID: Schema.String;
             readonly requestID: Schema.String;
@@ -83,7 +70,6 @@ export type Asks = typeof Asks.Type;
 export type AskedQuestion = typeof Question.Type;
 export type AskedPermission = typeof Permission.Type;
 export type TreeSession = typeof Session.Type;
-/** What answering a question did; `problem` says why nothing was passed on, when it was refused. */
 declare const Answered: Schema.Struct<{
     readonly answered: Schema.Boolean;
     readonly by: Schema.optionalKey<Schema.Literals<readonly ["result", "message"]>>;
@@ -170,26 +156,20 @@ export declare const personRpc: {
                     readonly stopped?: boolean | undefined;
                 }[];
             }> & Schema.Struct<{
-                /** The session at the top of the tree, which the sessions below were started from. */
                 readonly top: Schema.String;
-                /** The sessions below the top, in the order a tree is drawn. */
                 readonly sessions: Schema.$Array<Schema.Struct<{
                     readonly sessionID: Schema.String;
                     readonly title: Schema.String;
                     readonly parentID: Schema.String;
-                    /** A child of the tree's top session is at depth 1. */
                     readonly depth: Schema.Int;
                     readonly group: Schema.optionalKey<Schema.String>;
                 }>>;
-                /** The top session's own requests first, then those of the sessions below. */
                 readonly permissions: Schema.$Array<Schema.Struct<{
                     readonly sessionID: Schema.String;
                     readonly requestID: Schema.String;
                     readonly action: Schema.String;
                     readonly resources: Schema.$Array<Schema.String>;
-                    /** What "always" would allow from now on; absent when it is not offered. */
                     readonly save: Schema.optionalKey<Schema.$Array<Schema.String>>;
-                    /** The request below that allowing this one passes on: the top's courier_answer prompt. */
                     readonly passesOn: Schema.optionalKey<Schema.Struct<{
                         readonly sessionID: Schema.String;
                         readonly requestID: Schema.String;