opencode-courier 0.5.0 → 0.7.0

package/README.md

@@ -14,10 +14,9 @@ polling.
 [![License: MIT](https://img.shields.io/npm/l/opencode-courier)](LICENSE)
 [![Supported OpenCode V2 version](https://img.shields.io/badge/dynamic/json?url=https%3A%2F%2Fraw.githubusercontent.com%2Fivopogace%2Fopencode-courier%2Fmain%2Fpackage.json&query=%24.peerDependencies%5B%27%40opencode%2Fplugin%27%5D&label=opencode&color=blue)](#supported-opencode-version)
 
-![A parent spawns two slow children, writes a README itself, and is woken by each report](docs/demo-async-tui.gif)
+https://github.com/user-attachments/assets/74a50b9c-462a-43f5-8737-bc7dd1917988
 
-A parent writes a README while two slow children work, and each report wakes it ([the
-prompt](#demos)).
+The edge cases on the live terminal UI, narrated ([what it shows](#demos)).
 
 ## Quickstart
 
@@ -45,8 +44,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?
 
@@ -80,21 +79,18 @@ idle); `queue: true` waits until the current turn ends.
 
 ## Demos
 
-**The parent does not wait.** Prompt: *"Spawn two children: one runs `sleep 30` then lists the
-exports of math.js, the other runs `sleep 45` then lists the exports of text.js. Don't wait for
-them: meanwhile write a short README.md for this folder yourself, and add their reports to it when
-they arrive."* The recording at the top is this run: the parent writes its README and finishes its
-turn 16 seconds in, while both children still sleep; each report (the `Message from ses_…` line)
-then starts a new turn on its own, and the parent folds it into the README.
+The video at the top (1:46, narrated) is the TUI driven in `tmux` on the scripted stand-in model of
+the live test, with `e2e/tui.sh`'s setup, so each scene is real plugin behaviour:
 
-**A child's question reaches you.** Prompt: *"Spawn a child session to add a multiply function to
-math.js. It must ask me first whether to name it multiply, times or product."*
-
-![A child's question opens as a form in the parent's session, times is picked, and the child carries on](docs/demo-question-tui.gif)
-
-The child's question opens in the parent's session as OpenCode's own question form, `times` is
-picked, and the child adds `times` to math.js and reports. Both recordings are real runs with a free
-model on [OpenCode Zen](https://opencode.ai/zen) (Muse Spark 1.3).
+- **A join group:** one member reports and its report is held with the group, while the other waits
+  on a permission request, so the footer says one is waiting on you. You allow it from the asks inbox
+  (`ctrl+x k`), and both reports reach the parent in one message.
+- **A child whose turn fails:** OpenCode shows "Session failed", the parent is told, and the
+  `/courier tree` row reads `failed`.
+- **A child that ends its turn without a report:** the parent is told, and the row says so.
+- **`/courier stop`:** pick the session, confirm, and it is stopped.
+- **A form only you can answer:** a child's web search shows a form; the footer, the panel row and
+  the asks inbox point to it, and answering it there wakes the parent.
 
 ## Recursive orchestration
 
@@ -117,7 +113,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, 0.7.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 |
@@ -213,6 +209,11 @@ Each tool's parameters: [the reference](docs/reference.md#the-tools).
   plugin, with the error or its last reply, waking it if idle; one that waits on a request, its own
   children, a scheduled message or a webhook is not, nor is one that answers what you typed in its
   session. [More](docs/reference.md#a-child-that-fails).
+- **A message that fails to wake its session is sent again.** A report, notice or scheduled message
+  that waits in an idle session's inbox for 30 seconds without a turn starting for it is sent once
+  more under the same inbox id, which OpenCode takes for the same message, not a second one. If the
+  session still does not take it, the footer and the tree panel show it as `stalled`, for you to
+  prompt it. [More](docs/reference.md#a-missed-wake).
 - **Permission requests and questions reach you.** A child's request or question is passed to the
   session at the top of its tree, any number of levels down. For a request, that session proposes an
   answer with `courier_answer`, and OpenCode asks you in its own permission prompt, in that session
@@ -226,7 +227,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 +258,35 @@ 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 wait on you (a
+permission request, a question or a form they show), are [stalled](docs/reference.md#a-missed-wake),
+run 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 stalled one since when its message waits, 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,21 +7,24 @@ 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 { addTreeTools, deliverReleased, wakeMissed, 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";
 /** The spawns under way in the process, outside the hub, so spawns in other locations, copies and hub versions count them. */
 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.
+ * due `courier_later` messages, released join groups, then missed wakes. Every hub-v2 member's `later` is its LaterPorts.
  */
 const jobs = [
     dueJob,
     (owner, claimed) => deliverReleased(owner.later, claimed),
+    (owner, claimed) => wakeMissed(owner.later, claimed),
 ];
 const { join, track, nudge } = openInProcess(jobs);
 /** The permission domains of the loaded instances: every member's is its location's, whichever copy joined it. */
@@ -30,7 +33,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 +96,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 +127,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`. */