opencode-courier 0.5.0 → 0.6.0

package/README.md

@@ -45,8 +45,8 @@ sometimes stall on a request; if nothing moves for a few minutes, send the promp
 Courier is built on OpenCode V2's plugin API (`@opencode/plugin`), not the V1 one
 (`@opencode-ai/plugin`), and needs OpenCode V2. Each release is pinned to one V2 version and tested
 against it end to end; the current one is tested on **OpenCode 2.0.29**. CI also runs the live
-suite on the newest OpenCode release, so a host release that breaks the plugin shows up there
-first. Older releases and their versions: [Supported OpenCode version](#supported-opencode-version).
+suite on the newest OpenCode release, on `main` and nightly, so a host release that breaks the
+plugin shows up there first. Older releases and their versions: [Supported OpenCode version](#supported-opencode-version).
 
 ## Courier or the built-in subagent tool?
 
@@ -117,7 +117,7 @@ line to the server log naming both ([more](docs/reference.md#the-opencode-versio
 
 | opencode-courier | OpenCode V2 (`opencode` and `@opencode/plugin`) |
 |---|---|
-| 0.5.0 | 2.0.29 |
+| 0.5.0, 0.6.0 | 2.0.29 |
 | 0.4.0, 0.4.1 | 2.0.28 |
 | 0.2.3, 0.3.0 | 2.0.26 |
 | 0.2.2 | 2.0.24 |
@@ -226,7 +226,8 @@ Each tool's parameters: [the reference](docs/reference.md#the-tools).
   [terminal](#in-the-terminal). [More](docs/reference.md#seeing-and-stopping-a-subtree).
 
 Children, held reports, scheduled messages and open questions survive a compaction or a restart;
-entries are dropped after 14 days ([roster](docs/reference.md#roster)).
+entries are dropped after 14 days, or at once when OpenCode deletes the child, unless it is isolated
+([roster](docs/reference.md#roster)).
 
 ## Session trees
 
@@ -256,28 +257,34 @@ does not. Each spawned session's brief says when to split its task and when to d
 
 The package ships a part for OpenCode's terminal UI, which the TUI loads from the server's plugin
 list; the server half behaves the same whether or not a TUI is attached. In a session that started
-sessions, the prompt's footer shows what the tree under it is doing: how many run, wait on you or
-are idle, and for each [join group](docs/reference.md#join-groups) how many of its members have
+sessions, the prompt's footer shows what the tree under it is doing: how many run, wait on you (a
+permission request, a question or a form they show) or are idle, and for each [join group](docs/reference.md#join-groups) how many of its members have
 reported:
 
 ```
-courier 2 running · 1 waiting on you · group pair 1/2
+courier 1 waiting on you · 2 running · group pair 1/2
 ```
 
 `/courier tree` opens a panel beside the session with the tree under it, a row per session indented
-by depth, with what it does, its report and its group's standing; a session that started others gets
-a bar of the parts reported, a leaf how long it ran, its last tool call and its cost. `↑`/`↓` select,
+by depth, with what it does, its report and its group's standing; a session waiting on you gets a line per
+request or form (`shows a form: Web Search`), a session that started others gets
+a bar of the parts reported, a leaf how long it ran, its last tool call and its cost. A tree that has
+started more than `maxTotal` sessions over time is listed live ones first, then newest, and the header
+says how many older ones are left out; the footer counts them all. `↑`/`↓` select,
 `enter` opens the session, `s` stops it and everything under it after you confirm, as `courier_stop`
-would, and `q` closes the panel; `/courier stop <session>` stops from the prompt. While open, the panel
+would, `x` forgets a `gone` session after you confirm, removing its worktree by `courier_cleanup`'s
+rules, and `q` closes the panel; `/courier stop <session>` stops from the prompt. While open, the panel
 follows you between sessions: into one of its tree it keeps that tree, the session on screen marked
 `(on screen)`; elsewhere it shows that session's tree, or hides while you are in a session without one,
 or on the home screen, and shows again once you are back in one; only `q` closes it for good.
 
 `ctrl+x k` (the leader key, then `k`), `/asks` (or `/ask`), the palette's "Courier: what waits on you" or a click
 on "waiting on you" opens the asks inbox: every permission request, question and form waiting
-anywhere in the tree, oldest first, with where it comes from, answered in a dialog with no model in
-between; the session that started the tree hears once that you settled it. The TUI plays OpenCode's
-sounds for a child's report, a group's release and a new ask ([more](docs/reference.md#in-the-terminal)).
+anywhere in the tree, however many sessions it has, oldest first, after the top session's own permission
+requests, such as the prompt `courier_answer` has OpenCode show there, with where it comes from, kept current
+while it is open as asks arrive or are settled elsewhere, answered in a dialog with no model in between; the session that started the tree hears once that you settled it. The TUI plays OpenCode's
+sounds for a child's report and a group's release, and OpenCode's own for a new ask, which the courier
+adds a notification to for a native child ([more](docs/reference.md#in-the-terminal)).
 
 While a permission prompt or form is shown in the session, OpenCode hides the footer, so open the
 inbox with `ctrl+x k` (or `/asks` once the prompt is back).

package/dist/index.js

@@ -7,7 +7,7 @@ import { watchFromHub } from "./platform/events.js";
 import { hub, openInProcess, permissions as domains, sharedState } from "./platform/hub.js";
 import { builtVersions, versionNotice } from "./platform/version.js";
 import { addSchedulingTools, cancelScheduled, dueJob, isScheduled } from "./scheduling/index.js";
-import { addPersonTools, asksPermission, asksQuestion, joinRelay, noticeCutOff, pendingOf, pendingQuestions, personEvents, portsAt, registerPersonRpc, relayQuestions, } from "./person/index.js";
+import { addPersonTools, asksPermission, asksQuestion, formsShown, joinRelay, noticeCutOff, pendingOf, pendingQuestions, personEvents, portsAt, registerPersonRpc, relayQuestions, } from "./person/index.js";
 import { addSkill } from "./skill.js";
 import { addTreeTools, deliverReleased, dirtyOf, headOf, inspectWorktree, pruneExpired, readLimits, readNativeChildren, registerTreeRpc, shapeContext, together, treeEvents, waitsOn, } from "./tree/index.js";
 import { addWebhookTools, joinReceiver, readConfig, receiving, subscribedSince, } from "./webhook/index.js";
@@ -15,6 +15,8 @@ import { addWebhookTools, joinReceiver, readConfig, receiving, subscribedSince,
 const gate = sharedState("spawning", () => ({ reserved: new Set(), turn: Promise.resolve() }));
 /** The type of each item enqueued for a spawned session, outside the hub like the gate. */
 const inbox = sharedState("inbox", () => new Map());
+/** The forms shown now, which the person events keep and the footer and tree panel count; outside the hub like the inbox. */
+const shown = sharedState("formsShown", () => new Map());
 /**
  * What each tick of the scheduler does, in order, through the first loaded member, of whichever copy:
  * due `courier_later` messages, then released join groups. Every hub-v2 member's `later` is its LaterPorts.
@@ -30,7 +32,7 @@ const permissions = domains;
 // several subscriptions and copies see the same events. The scheduler's claim set is the hub's own.
 const { watched } = hub;
 const watchState = { seen: watched.seen, inbox };
-const personState = { ...watched, forms: hub.forms };
+const personState = { ...watched, forms: hub.forms, shown };
 /**
  * What a session waits on outside the tree, for the silent-turn rule, cheapest first: a request of its
  * own to the person, then a scheduled message or a webhook it subscribed to since its last prompt.
@@ -93,6 +95,7 @@ export const courier = () => Plugin.define({
                 ]);
                 return [...requests, ...questions];
             },
+            forms: (sessionID) => Promise.resolve(formsShown(shown, sessionID)),
         };
         const cleanupPorts = { ...ports, inspect: inspectWorktree };
         const answerPorts = { storage: ctx.storage, permissions, assert: (input) => ctx.permission.assert(input) };
@@ -123,7 +126,7 @@ export const courier = () => Plugin.define({
         // What the TUI part reads and its stop; a host that cannot register it still gets the rest, the tools included.
         await Promise.resolve()
             .then(() => registerTreeRpc(ctx.rpc, stopPorts))
-            .then(() => registerPersonRpc(ctx.rpc, { questions: questionPorts, permissions, maxTotal: limits.maxTotal }))
+            .then(() => registerPersonRpc(ctx.rpc, { questions: questionPorts, permissions }))
             .catch((error) => log(`courier rpc: not registered, the TUI part shows nothing and cannot stop: ${String(error)}`));
         await ctx.session.hook("context", (event) => shapeContext({ storage: ctx.storage, limits, roles, log }, event));
         const pruned = pruneExpired(ctx.storage, Date.now()).catch((error) => log(`courier roster prune: ${String(error)}`));

package/dist/person/form.d.ts

@@ -1,4 +1,5 @@
-import { type Form, type PersonPorts, type PersonState } from "./ports.js";
+import { type ShownForm } from "../tree/index.js";
+import { type Form, type FormsShown, type PersonPorts, type PersonState } from "./ports.js";
 /** The `metadata.kind` of the forms OpenCode's question tool asks with; the question relay passes those on. */
 export declare const QUESTION_FORM = "question";
 /** The part of OpenCode's `form.created` event the notice is made from. */
@@ -24,3 +25,5 @@ export interface FormSettled {
 export declare function reportForm(ports: PersonPorts, state: PersonState, event: FormCreated): Promise<string[]>;
 /** Tells the session told about a form that it was answered or withdrawn, so it does not send the person to a form that is gone. */
 export declare function reportFormSettled(ports: PersonPorts, state: PersonState, event: FormSettled): Promise<string[]>;
+/** The forms a session shows now, oldest first, as the tree's `forms` port lists them. */
+export declare const formsShown: (shown: FormsShown, sessionID: string) => ShownForm[];

package/dist/person/form.js

@@ -15,6 +15,8 @@ export async function reportForm(ports, state, event) {
     const form = event.data.form;
     if (kindOf(form) === QUESTION_FORM)
         return [];
+    if (!state.forms.settled.has(form.id))
+        setBounded(state.shown, form.id, { sessionID: form.sessionID, title: form.title }, SEEN_MAX);
     const chain = await lineage(ports.storage, form.sessionID);
     // As with a permission request, claimed after the lookup, so a form settled meanwhile is not told.
     if (!chain.length || state.forms.settled.has(form.id) || state.forms.told.has(form.id))
@@ -41,6 +43,7 @@ export async function reportFormSettled(ports, state, event) {
     if (!claim(state.seen, event.id))
         return [];
     const { id, sessionID } = event.data;
+    state.shown.delete(id);
     const telling = state.forms.told.get(id);
     if (!telling) {
         claim(state.forms.settled, id);
@@ -62,3 +65,5 @@ export async function reportFormSettled(ports, state, event) {
     });
     return [topOf(chain)];
 }
+/** The forms a session shows now, oldest first, as the tree's `forms` port lists them. */
+export const formsShown = (shown, sessionID) => [...shown].flatMap(([id, form]) => (form.sessionID === sessionID ? [{ id, title: form.title }] : []));

package/dist/person/index.d.ts

@@ -2,9 +2,10 @@ import type { PendingPrompt, WatchPorts } from "../tree/index.js";
 import type { PersonPorts } from "./ports.js";
 import type { Prompt } from "./question/index.js";
 export { personEvents } from "./events.js";
+export { formsShown } from "./form.js";
 export { asksPermission, pendingOf } from "./permission.js";
 export type { AnswerPorts, Permissions, Waiting } from "./permission.js";
-export type { PersonPorts, PersonState } from "./ports.js";
+export type { FormsShown, PersonPorts, PersonState } from "./ports.js";
 export { registerPersonRpc } from "./rpc-handlers.js";
 export { asksQuestion, joinRelay, noticeCutOff, pendingQuestions, portsAt, relayQuestions } from "./question/index.js";
 export type { QuestionPorts } from "./question/index.js";

package/dist/person/index.js

@@ -1,4 +1,5 @@
 export { personEvents } from "./events.js";
+export { formsShown } from "./form.js";
 export { asksPermission, pendingOf } from "./permission.js";
 export { registerPersonRpc } from "./rpc-handlers.js";
 export { asksQuestion, joinRelay, noticeCutOff, pendingQuestions, portsAt, relayQuestions } from "./question/index.js";

package/dist/person/permission.d.ts

@@ -17,6 +17,7 @@ export interface PermissionRequest {
     readonly resources: ReadonlyArray<string>;
     readonly save?: ReadonlyArray<string>;
     readonly message?: string;
+    readonly metadata?: Readonly<Record<string, unknown>>;
 }
 /**
  * What answering a permission request did; `answered` is false when no location loaded here held the
@@ -94,6 +95,19 @@ export declare const isDeclined: (error: unknown) => boolean;
  * session, a proposed `once` only once OpenCode allowed it there; `answered` is false when no location loaded here holds it.
  */
 export declare function answer(ports: AnswerPorts, waiting: Waiting, callerID: string, input: AnswerInput): Promise<PermissionAnswered>;
+/** The child's request a prompt of courier_answer's asks about, read from the metadata `askCaller` gives it; undefined for any other request. */
+export declare function passedOn(metadata: Readonly<Record<string, unknown>> | undefined): {
+    sessionID: string;
+    requestID: string;
+} | undefined;
+/** The requests a session waits on of its own, in whichever location holds them, each with the child's request it passes on when courier_answer asks it. */
+export declare function ownRequests(permissions: Iterable<Permissions>, sessionID: string): Promise<{
+    request: PermissionRequest;
+    passesOn: {
+        sessionID: string;
+        requestID: string;
+    } | undefined;
+}[]>;
 /** The requests a session waits on, in whichever location holds them, for courier_status. */
 export declare function pendingOf(permissions: Iterable<Permissions>, sessionID: string): Promise<Pending[]>;
 export {};

package/dist/person/permission.js

@@ -115,6 +115,21 @@ export async function answer(ports, waiting, callerID, input) {
         throw new Error(refusedText(sessionID, requestID, refused));
     return { sessionID, requestID, reply, answered: true };
 }
+/** The child's request a prompt of courier_answer's asks about, read from the metadata `askCaller` gives it; undefined for any other request. */
+export function passedOn(metadata) {
+    const { source, asks, from, requestID } = metadata ?? {};
+    if (source !== "courier" || asks !== "permission" || typeof from !== "string" || typeof requestID !== "string")
+        return undefined;
+    return { sessionID: from, requestID };
+}
+/** The requests a session waits on of its own, in whichever location holds them, each with the child's request it passes on when courier_answer asks it. */
+export async function ownRequests(permissions, sessionID) {
+    const found = new Map();
+    for (const { requests } of await listEverywhere(permissions, sessionID))
+        for (const request of requests)
+            found.set(request.id, request);
+    return [...found.values()].map((request) => ({ request, passesOn: passedOn(request.metadata) }));
+}
 /** The requests a session waits on, in whichever location holds them, for courier_status. */
 export async function pendingOf(permissions, sessionID) {
     const found = new Map();

package/dist/person/ports.d.ts

@@ -19,15 +19,21 @@ export interface PersonPorts {
     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, shared
- * with the tree's, and the requests and forms the top sessions were told about or that were answered first.
+ * 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;
     readonly answered: Set<string>;
     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;

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

@@ -6,12 +6,10 @@ import { type Answered, type Asks } from "./rpc.js";
 export interface PersonRpcPorts {
     readonly questions: QuestionPorts;
     readonly permissions: () => Iterable<Permissions>;
-    /** At most this many sessions of a tree are read, as courier_tree reads them. */
-    readonly maxTotal: number;
 }
 /**
- * The permission requests and questions waiting in the courier tree a session is in, from the roster: read from the
- * top of its lineage down, so each session of the tree sees the same inbox.
+ * 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`. */
@@ -33,6 +31,25 @@ export declare function registerPersonRpc(rpc: Pick<Plugin.Context["rpc"], "regi
                 readonly sessionID: import("effect/Schema").String;
             }>;
             readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly top: string;
+                readonly sessions: readonly {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly parentID: string;
+                    readonly depth: number;
+                    readonly group?: string | undefined;
+                }[];
+                readonly permissions: readonly {
+                    readonly sessionID: string;
+                    readonly resources: readonly string[];
+                    readonly action: string;
+                    readonly requestID: string;
+                    readonly save?: readonly string[] | undefined;
+                    readonly passesOn?: {
+                        readonly sessionID: string;
+                        readonly requestID: string;
+                    } | undefined;
+                }[];
                 readonly questions: readonly {
                     readonly questions: readonly {
                         readonly options: readonly {
@@ -47,13 +64,7 @@ export declare function registerPersonRpc(rpc: Pick<Plugin.Context["rpc"], "regi
                     readonly requestID: string;
                     readonly stopped?: boolean | undefined;
                 }[];
-                readonly permissions: readonly {
-                    readonly sessionID: string;
-                    readonly resources: readonly string[];
-                    readonly action: string;
-                    readonly requestID: string;
-                    readonly save?: readonly string[] | undefined;
-                }[];
+            }, {
                 readonly top: string;
                 readonly sessions: readonly {
                     readonly sessionID: string;
@@ -62,8 +73,17 @@ export declare function registerPersonRpc(rpc: Pick<Plugin.Context["rpc"], "regi
                     readonly depth: number;
                     readonly group?: string | undefined;
                 }[];
-                readonly truncated?: number | undefined;
-            }, {
+                readonly permissions: readonly {
+                    readonly sessionID: string;
+                    readonly resources: readonly string[];
+                    readonly action: string;
+                    readonly requestID: string;
+                    readonly save?: readonly string[] | undefined;
+                    readonly passesOn?: {
+                        readonly sessionID: string;
+                        readonly requestID: string;
+                    } | undefined;
+                }[];
                 readonly questions: readonly {
                     readonly questions: readonly {
                         readonly options: readonly {
@@ -78,22 +98,6 @@ export declare function registerPersonRpc(rpc: Pick<Plugin.Context["rpc"], "regi
                     readonly requestID: string;
                     readonly stopped?: boolean | undefined;
                 }[];
-                readonly permissions: readonly {
-                    readonly sessionID: string;
-                    readonly resources: readonly string[];
-                    readonly action: string;
-                    readonly requestID: string;
-                    readonly save?: readonly string[] | undefined;
-                }[];
-                readonly top: string;
-                readonly sessions: readonly {
-                    readonly sessionID: string;
-                    readonly title: string;
-                    readonly parentID: string;
-                    readonly depth: number;
-                    readonly group?: string | undefined;
-                }[];
-                readonly truncated?: number | undefined;
             }> & import("effect/Schema").Struct<{
                 readonly top: import("effect/Schema").String;
                 readonly sessions: import("effect/Schema").$Array<import("effect/Schema").Struct<{
@@ -109,6 +113,10 @@ export declare function registerPersonRpc(rpc: Pick<Plugin.Context["rpc"], "regi
                     readonly action: import("effect/Schema").String;
                     readonly resources: import("effect/Schema").$Array<import("effect/Schema").String>;
                     readonly save: import("effect/Schema").optionalKey<import("effect/Schema").$Array<import("effect/Schema").String>>;
+                    readonly passesOn: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                        readonly sessionID: import("effect/Schema").String;
+                        readonly requestID: import("effect/Schema").String;
+                    }>>;
                 }>>;
                 readonly questions: import("effect/Schema").$Array<import("effect/Schema").Struct<{
                     readonly sessionID: import("effect/Schema").String;
@@ -124,7 +132,6 @@ export declare function registerPersonRpc(rpc: Pick<Plugin.Context["rpc"], "regi
                     }>>;
                     readonly stopped: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
                 }>>;
-                readonly truncated: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
             }>;
         };
         readonly answer: {

package/dist/person/rpc-handlers.js

@@ -1,15 +1,16 @@
 import { lineage, subtree } from "../tree/index.js";
-import { pendingOf } from "./permission.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, from the roster: read from the
- * top of its lineage down, so each session of the tree sees the same inbox.
+ * 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;
-    const { nodes, truncated } = await subtree(storage, top, ports.maxTotal);
+    const { nodes } = await subtree(storage, top, { now: ports.questions.now() });
+    const own = nodes.length ? await ownRequests(ports.permissions(), top).catch(() => []) : [];
     const waiting = await Promise.all(nodes.map(({ entry }) => Promise.all([
         pendingOf(ports.permissions(), entry.sessionID).catch(() => []),
         pendingQuestions(storage, entry.sessionID).catch(() => []),
@@ -23,24 +24,33 @@ export async function asks(ports, sessionID) {
             depth,
             ...(entry.group ? { group: entry.group } : {}),
         })),
-        permissions: nodes.flatMap(({ entry }, index) => waiting[index][0].flatMap((pending) => pending.type === "permission"
-            ? [
-                {
-                    sessionID: entry.sessionID,
-                    requestID: pending.requestID,
-                    action: pending.action,
-                    resources: pending.resources,
-                    ...(pending.save ? { save: pending.save } : {}),
-                },
-            ]
-            : [])),
+        permissions: [
+            ...own.map(({ request, passesOn }) => ({
+                sessionID: top,
+                requestID: request.id,
+                action: request.action,
+                resources: [...request.resources],
+                ...(request.save?.length ? { save: [...request.save] } : {}),
+                ...(passesOn ? { passesOn } : {}),
+            })),
+            ...nodes.flatMap(({ entry }, index) => waiting[index][0].flatMap((pending) => pending.type === "permission"
+                ? [
+                    {
+                        sessionID: entry.sessionID,
+                        requestID: pending.requestID,
+                        action: pending.action,
+                        resources: pending.resources,
+                        ...(pending.save ? { save: pending.save } : {}),
+                    },
+                ]
+                : [])),
+        ],
         questions: nodes.flatMap(({ entry }, index) => waiting[index][1].map(({ requestID, questions, stopped }) => ({
             sessionID: entry.sessionID,
             requestID,
             questions,
             ...(stopped ? { stopped } : {}),
         }))),
-        ...(truncated ? { truncated: ports.maxTotal } : {}),
     };
 }
 /** 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`. */

package/dist/person/rpc.d.ts

@@ -8,7 +8,7 @@ declare const Session: Schema.Struct<{
     readonly depth: Schema.Int;
     readonly group: Schema.optionalKey<Schema.String>;
 }>;
-/** A permission request a session of the tree waits on. */
+/** 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;
@@ -16,6 +16,11 @@ declare const Permission: Schema.Struct<{
     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<{
@@ -45,6 +50,7 @@ declare const Asks: Schema.Struct<{
         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;
@@ -52,6 +58,11 @@ declare const Asks: Schema.Struct<{
         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;
+        }>>;
     }>>;
     readonly questions: Schema.$Array<Schema.Struct<{
         readonly sessionID: Schema.String;
@@ -67,8 +78,6 @@ declare const Asks: Schema.Struct<{
         }>>;
         readonly stopped: Schema.optionalKey<Schema.Boolean>;
     }>>;
-    /** Set when the tree had more sessions than `maxTotal`, which were not read. */
-    readonly truncated: Schema.optionalKey<Schema.Int>;
 }>;
 export type Asks = typeof Asks.Type;
 export type AskedQuestion = typeof Question.Type;
@@ -93,20 +102,7 @@ export declare const personRpc: {
                 readonly sessionID: Schema.String;
             }>;
             readonly output: import("effect/StandardSchema").StandardSchemaV1<{
-                readonly questions: readonly {
-                    readonly sessionID: string;
-                    readonly requestID: string;
-                    readonly questions: readonly {
-                        readonly options: readonly {
-                            readonly label: string;
-                            readonly description: string;
-                        }[];
-                        readonly question: string;
-                        readonly header: string;
-                        readonly multiple?: boolean | undefined;
-                    }[];
-                    readonly stopped?: boolean | undefined;
-                }[];
+                readonly top: string;
                 readonly sessions: readonly {
                     readonly sessionID: string;
                     readonly title: string;
@@ -120,10 +116,11 @@ export declare const personRpc: {
                     readonly requestID: string;
                     readonly action: string;
                     readonly save?: readonly string[] | undefined;
+                    readonly passesOn?: {
+                        readonly sessionID: string;
+                        readonly requestID: string;
+                    } | undefined;
                 }[];
-                readonly top: string;
-                readonly truncated?: number | undefined;
-            }, {
                 readonly questions: readonly {
                     readonly sessionID: string;
                     readonly requestID: string;
@@ -138,6 +135,8 @@ export declare const personRpc: {
                     }[];
                     readonly stopped?: boolean | undefined;
                 }[];
+            }, {
+                readonly top: string;
                 readonly sessions: readonly {
                     readonly sessionID: string;
                     readonly title: string;
@@ -151,9 +150,25 @@ export declare const personRpc: {
                     readonly requestID: string;
                     readonly action: string;
                     readonly save?: readonly string[] | undefined;
+                    readonly passesOn?: {
+                        readonly sessionID: string;
+                        readonly requestID: string;
+                    } | undefined;
+                }[];
+                readonly questions: readonly {
+                    readonly sessionID: string;
+                    readonly requestID: string;
+                    readonly questions: readonly {
+                        readonly options: readonly {
+                            readonly label: string;
+                            readonly description: string;
+                        }[];
+                        readonly question: string;
+                        readonly header: string;
+                        readonly multiple?: boolean | undefined;
+                    }[];
+                    readonly stopped?: boolean | undefined;
                 }[];
-                readonly top: string;
-                readonly truncated?: number | undefined;
             }> & Schema.Struct<{
                 /** The session at the top of the tree, which the sessions below were started from. */
                 readonly top: Schema.String;
@@ -166,6 +181,7 @@ export declare const personRpc: {
                     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;
@@ -173,6 +189,11 @@ export declare const personRpc: {
                     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;
+                    }>>;
                 }>>;
                 readonly questions: Schema.$Array<Schema.Struct<{
                     readonly sessionID: Schema.String;
@@ -188,8 +209,6 @@ export declare const personRpc: {
                     }>>;
                     readonly stopped: Schema.optionalKey<Schema.Boolean>;
                 }>>;
-                /** Set when the tree had more sessions than `maxTotal`, which were not read. */
-                readonly truncated: Schema.optionalKey<Schema.Int>;
             }>;
         };
         readonly answer: {

package/dist/person/rpc.js

@@ -14,7 +14,7 @@ const Session = Schema.Struct({
     depth: Count,
     group: Schema.optionalKey(Schema.String),
 });
-/** A permission request a session of the tree waits on. */
+/** A permission request a session of the tree, the top among them, waits on. */
 const Permission = Schema.Struct({
     sessionID: Schema.String,
     requestID: Schema.String,
@@ -22,6 +22,8 @@ const Permission = Schema.Struct({
     resources: Schema.Array(Schema.String),
     /** What "always" would allow from now on; absent when it is not offered. */
     save: Schema.optionalKey(Schema.Array(Schema.String)),
+    /** The request below that allowing this one passes on: the top's courier_answer prompt. */
+    passesOn: Schema.optionalKey(Schema.Struct({ sessionID: Schema.String, requestID: Schema.String })),
 });
 /** One question of OpenCode's question tool. */
 const Prompt = Schema.Struct({
@@ -43,10 +45,9 @@ const Asks = Schema.Struct({
     top: Schema.String,
     /** The sessions below the top, in the order a tree is drawn. */
     sessions: Schema.Array(Session),
+    /** The top session's own requests first, then those of the sessions below. */
     permissions: Schema.Array(Permission),
     questions: Schema.Array(Question),
-    /** Set when the tree had more sessions than `maxTotal`, which were not read. */
-    truncated: Schema.optionalKey(Count),
 });
 /** What answering a question did; `problem` says why nothing was passed on, when it was refused. */
 const Answered = Schema.Struct({