opencode-courier 0.5.0 → 0.7.0

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({

package/dist/person/tui.d.ts

@@ -1,17 +1,21 @@
 import type { Plugin } from "@opencode/plugin/tui";
-import type { AttentionSoundName } from "@opencode/plugin/tui/context";
 import { type AskedPermission, type AskedQuestion, type Asks, type TreeSession } from "./rpc.js";
 type Context = Plugin.Context;
 type FormInfo = NonNullable<ReturnType<Context["data"]["session"]["form"]["list"]>>[number];
 type FormField = FormInfo["fields"][number];
 type FormAnswer = Parameters<Context["data"]["session"]["form"]["reply"]>[0]["answer"];
-/** Something a session of the tree waits on the person for; `key` is unique across kinds. */
+type FormValue = FormAnswer[string];
+/**
+ * Something a session of the tree waits on the person for; `key` is unique across kinds. `prompted` marks a permission
+ * request the top session's courier_answer prompt asks about.
+ */
 export type Ask = {
     readonly key: string;
     readonly session: TreeSession;
 } & ({
     readonly kind: "permission";
     readonly request: AskedPermission;
+    readonly prompted?: boolean;
 } | {
     readonly kind: "question";
     readonly question: AskedQuestion;
@@ -23,23 +27,30 @@ export type Ask = {
 export declare const INBOX_COMMAND = "courier.asks";
 /** How long after the first of a burst of asks the inbox reads the tree again, to sound the new ones. */
 export declare const SETTLE_MS = 250;
-/** The asks of a tree in the order the inbox lists them: by the tree's order, each session's permissions, questions, then forms. */
+/** The top session, at depth 0, as its own permission requests name it. */
+export declare const topSession: (asks: Asks) => TreeSession;
+/**
+ * The asks of a tree in the order the inbox lists them: the top session's own permission requests, then by the tree's
+ * order, each session's permissions, questions, then forms.
+ */
 export declare function asksOf(asks: Asks, forms: ReadonlyMap<string, ReadonlyArray<FormInfo>>): Ask[];
-/** Where an ask comes from: the titles from the top session down to the asking one, as "root › child › grandchild". */
-export declare function pathOf(asks: Asks, sessionID: string, topTitle: string): string;
+/** Where an ask comes from: the titles from the top session down to the asking one, as "root › child › grandchild", each as the TUI knows it now, else as spawned. */
+export declare function pathOf(asks: Asks, sessionID: string, topTitle: string, currentTitle?: (sessionID: string) => string | undefined): string;
 /** What an ask is, in one line. */
 export declare function askTitle(ask: Ask): string;
-/** The line under an ask: its depth and group, and that a question's call was cut off. */
+/** The line under an ask: its depth (the top's own say so) and group, that a question's call was cut off, or that the top's courier_answer prompt asks for it. */
 export declare function askFooter(ask: Ask): string;
-/** The sound an ask arriving plays: a permission request's, or a question's for questions and forms. */
-export declare const soundOf: (ask: Ask) => AttentionSoundName;
-/** Whether a form field is shown, given the answers so far: hidden ones never, conditional ones when their conditions hold. */
-export declare function shown(field: FormField, answers: FormAnswer): boolean;
+/** Whether a form field applies, given the answers so far (a hidden field's default among them): its `when` conditions hold, as OpenCode reads them (a condition on an unanswered field is false; on a multiselect, `eq` means includes). */
+export declare function active(field: FormField, answers: FormAnswer): boolean;
+/** What is wrong with a field's answer by the limits OpenCode's form service checks on reply, worded as its form view does; undefined when it fits. */
+export declare function misfit(field: FormField, value: FormValue): string | undefined;
+/** The limits of a typed field as a prompt's placeholder: "1-5", "at least 3 characters", "email"; undefined without any. */
+export declare function limitsOf(field: FormField): string | undefined;
 /**
  * Adds the asks inbox: what the open session's courier tree waits on the person for, read through the person's RPC and
- * answered in dialogs, opened by its command; a sound for each new ask. Returns its opener and its cleanup.
+ * answered in dialogs, opened by its command, its open list read again on `follows`; a sound for each new ask.
  */
-export declare function addAsksInbox(ctx: Context): {
+export declare function addAsksInbox(ctx: Context, follows: ReadonlySet<string>): {
     open: (sessionID?: string | undefined) => Promise<void>;
     cleanup: () => void;
 };

package/dist/tree/domain.d.ts

@@ -26,6 +26,29 @@ export declare function readNativeChildren(options: unknown): {
 type Times = Awaited<ReturnType<Context["session"]["get"]>>["time"];
 /** Whether a session with these times runs: it has never finished a turn, or something reached it after the last one ended. */
 export declare const busy: (time: Pick<Times, "updated" | "idle">) => boolean;
+/**
+ * Whether a session a tree is read of is live: it runs (as the limits count it: busy, and its turn has not failed or
+ * been interrupted since its last prompt), waits on a request or form, or owes a report; one OpenCode no longer knows is not.
+ */
+export declare const isLive: (time: Pick<Times, "updated" | "idle"> | undefined, waits: number, report: {
+    readonly owes: boolean;
+    readonly ended: boolean;
+} | undefined) => boolean;
+/** A session of a tree read, as `cut` takes it: where it is in the tree, when it was started, and whether it is live. */
+export interface Cuttable {
+    readonly sessionID: string;
+    readonly parentID: string;
+    readonly createdAt: number;
+    readonly live: boolean;
+}
+/**
+ * Which sessions a listing of at most `max` keeps, of a tree read in the order it is drawn: the live ones first, then
+ * the newest, each with the sessions above it so the tree still draws; `leftOut` counts the rest.
+ */
+export declare function cut<T extends Cuttable>(nodes: ReadonlyArray<T>, max: number): {
+    kept: T[];
+    leftOut: number;
+};
 /** A session started with courier_spawn, recorded under the session that started it. */
 export interface RosterEntry {
     readonly sessionID: string;

package/dist/tree/domain.js

@@ -25,6 +25,32 @@ export function readNativeChildren(options) {
 }
 /** Whether a session with these times runs: it has never finished a turn, or something reached it after the last one ended. */
 export const busy = (time) => time.idle === undefined || millis(time.updated) > millis(time.idle);
+/**
+ * Whether a session a tree is read of is live: it runs (as the limits count it: busy, and its turn has not failed or
+ * been interrupted since its last prompt), waits on a request or form, or owes a report; one OpenCode no longer knows is not.
+ */
+export const isLive = (time, waits, report) => time !== undefined && ((busy(time) && !report?.ended) || waits > 0 || (report?.owes ?? false));
+/**
+ * Which sessions a listing of at most `max` keeps, of a tree read in the order it is drawn: the live ones first, then
+ * the newest, each with the sessions above it so the tree still draws; `leftOut` counts the rest.
+ */
+export function cut(nodes, max) {
+    const byID = new Map(nodes.map((node) => [node.sessionID, node]));
+    const ranked = nodes
+        .map((node, order) => ({ node, order }))
+        .sort((a, b) => Number(b.node.live) - Number(a.node.live) || b.node.createdAt - a.node.createdAt || a.order - b.order);
+    const kept = new Set();
+    for (const { node } of ranked) {
+        const chain = [];
+        for (let above = node; above && !kept.has(above.sessionID); above = byID.get(above.parentID))
+            chain.push(above.sessionID);
+        if (kept.size + chain.length > max)
+            continue;
+        for (const sessionID of chain)
+            kept.add(sessionID);
+    }
+    return { kept: nodes.filter((node) => kept.has(node.sessionID)), leftOut: nodes.length - kept.size };
+}
 /** `lineage` over roster entries already read. */
 export function lineageIn(entries, sessionID) {
     return lineageBy(bySession(entries), sessionID);

package/dist/tree/events.d.ts

@@ -51,8 +51,8 @@ export declare function notePrompt(ports: WatchPorts, event: SessionEvent & {
  */
 export declare function noteInterrupted(ports: WatchPorts, event: SessionEvent): Promise<boolean>;
 /**
- * Drops the report state, and the groups, of a session OpenCode deleted, and the report state of the sessions it
- * started, whose reports can no longer be delivered; it leaves its own group. Returns the sessions forgotten.
+ * Forgets what a deleted session leaves (report state, groups) and, unless isolated or a parent on the roster, its
+ * entry. Returns the sessions forgotten.
  */
 export declare function noteDeleted(ports: WatchPorts, event: SessionEvent): Promise<string[]>;
 /** A `Waits` asking `suppliers` one after another, cheapest first: the first that waits answers. */

package/dist/tree/events.js

@@ -1,11 +1,12 @@
 import { envelope } from "../kernel/protocol.js";
 import { claim, SEEN_MAX, setBounded } from "../platform/bounded.js";
-import { forgetDeleted } from "./forget.js";
+import { forgetChild, forgetDeleted } from "./forget.js";
 import { hasCompleteGroup, leave, outIn } from "./group.js";
 import { awaited, reportOf, stoppedSincePrompt } from "./report.js";
 import { childStore, groupStore } from "./store.js";
 import { lastReply } from "./status.js";
 import { failureNotice, silentNotice } from "./text.js";
+import { forgetWakes, settleWake, wakeEnded, wakeStarted, watchWake } from "./wake.js";
 /**
  * Tells the parent of a child whose turn failed, since a child that cannot reach its model cannot
  * call courier_send. Returns the parents told.
@@ -88,8 +89,8 @@ export async function noteInterrupted(ports, event) {
     return true;
 }
 /**
- * Drops the report state, and the groups, of a session OpenCode deleted, and the report state of the sessions it
- * started, whose reports can no longer be delivered; it leaves its own group. Returns the sessions forgotten.
+ * Forgets what a deleted session leaves (report state, groups) and, unless isolated or a parent on the roster, its
+ * entry. Returns the sessions forgotten.
  */
 export async function noteDeleted(ports, event) {
     const { sessionID } = event.data;
@@ -99,6 +100,8 @@ export async function noteDeleted(ports, event) {
     const entry = parentID === undefined ? undefined : await children.entry(parentID, sessionID);
     const member = entry && (await outIn(ports, entry));
     await forgetDeleted(ports, sessionID, forgotten, member, event.created);
+    if (parentID !== undefined && entry && !entry.isolated && started.length === 0)
+        await forgetChild(ports.storage, parentID, sessionID);
     return forgotten;
 }
 /** A `Waits` asking `suppliers` one after another, cheapest first: the first that waits answers. */
@@ -191,13 +194,37 @@ function routeTree(ports, state, outside, event) {
         return noteDeleted(ports, event);
     return undefined;
 }
+/** The events that move a courier message waiting in a session's inbox: enqueued, taken, cancelled, and the turns around it. */
+function routeWake(ports, event) {
+    if (event.type === "session.inbox.enqueued")
+        return watchWake(ports, event);
+    if (event.type === "session.inbox.delivered" || event.type === "session.inbox.cancelled")
+        return settleWake(ports, event);
+    if (event.type === "session.execution.started")
+        return wakeStarted(ports, event);
+    if (TURN_ENDS.has(event.type))
+        return wakeEnded(ports, event);
+    if (event.type === "session.deleted")
+        return forgetWakes(ports, event.data.sessionID);
+    return undefined;
+}
+/** The tree's handling of an event alongside the wake watch's, which touches other keys and never fails the tree's. */
+async function route(ports, state, outside, event) {
+    const watched = routeWake(ports, event)?.catch((error) => ports.log(`courier watch: wake of ${event.type}: ${String(error)}`));
+    try {
+        return await routeTree(ports, state, outside, event);
+    }
+    finally {
+        await watched;
+    }
+}
 /**
  * Tells parents of a child's failed or silent turn, unless it waits on what `outside` says, and notes
  * its prompts, interruptions and deletion; `after` a turn's end, seals the groups of its session.
  */
 export function treeEvents(state, outside) {
     return {
-        handle: (ports, event) => routeTree(ports, state, outside, event),
+        handle: (ports, event) => route(ports, state, outside, event),
         // After: a silent end is judged while the group the nudge may deliver is still there to wait on.
         after: (ports, event) => (TURN_ENDS.has(event.type) ? sealGroups(ports, event) : undefined),
     };

package/dist/tree/index.d.ts

@@ -3,8 +3,9 @@ export { shapeContext } from "./context.js";
 export { lineageIn, nativeRootOf, readLimits, readNativeChildren } from "./domain.js";
 export { together, treeEvents, waitsOn } from "./events.js";
 export { deliverReleased } from "./group.js";
-export type { CleanupPorts, CourierPorts, Pending, PendingPrompt, RosterEntry, RosterStorage, SpawnGate, Waits, WatchPorts, WatchState, } from "./ports.js";
+export type { CleanupPorts, CourierPorts, Pending, PendingPrompt, RosterEntry, RosterStorage, ShownForm, SpawnGate, Waits, WatchPorts, WatchState, } from "./ports.js";
 export { allEntries, answeringTop, lineage, pruneExpired, RETENTION_MS } from "./roster.js";
 export { subtree } from "./subtree.js";
 export { registerTreeRpc } from "./rpc-handlers.js";
 export { addTreeTools } from "./tools.js";
+export { wakeMissed } from "./wake.js";

package/dist/tree/index.js

@@ -1,4 +1,4 @@
-// What the rest of the plugin uses of the session tree: its tools, RPC, event module, context hook and tick job
+// What the rest of the plugin uses of the session tree: its tools, RPC, event module, context hook and tick jobs
 // for `src/index.ts`, and the lineage and subtree queries and types `person/` reads.
 export { dirtyOf, headOf, inspectWorktree } from "./cleanup.js";
 export { shapeContext } from "./context.js";
@@ -9,3 +9,4 @@ export { allEntries, answeringTop, lineage, pruneExpired, RETENTION_MS } from ".
 export { subtree } from "./subtree.js";
 export { registerTreeRpc } from "./rpc-handlers.js";
 export { addTreeTools } from "./tools.js";
+export { wakeMissed } from "./wake.js";

package/dist/tree/panel.d.ts

@@ -1,4 +1,4 @@
-import type { CourierPorts, Pending } from "./ports.js";
+import type { CourierPorts, Pending, ShownForm } from "./ports.js";
 import type { Tree, Wait } from "./rpc.js";
 type Messages = Awaited<ReturnType<CourierPorts["session"]["context"]>>;
 /** The last tool call in a session's messages, and when it was made. */
@@ -8,6 +8,11 @@ export declare function lastTool(messages: Messages): {
 } | undefined;
 /** A request as the panel says what a paused session waits on: a permission request, or its first question. */
 export declare const waitOf: (pending: Pending) => Wait;
-/** The tree panel's rows: the sessions courier_tree reads under a session, at most `maxTotal`, each as `row` reads it. */
+/** A form a session shows, as the panel says what it waits on. */
+export declare const formWait: (form: ShownForm) => Wait;
+/**
+ * The tree panel's rows: the sessions under a session as courier_tree lists them, at most `maxTotal`, the live ones
+ * first, then the newest, each as `row` reads it; `truncated` counts the older ones left out, and `stalled` says the root is.
+ */
 export declare function panel(ports: CourierPorts, rootID: string): Promise<Tree>;
 export {};

package/dist/tree/panel.js

@@ -1,8 +1,9 @@
 import { busy } from "./domain.js";
-import { lastStatus, reportOf } from "./report.js";
+import { lastStatus, stoppedSincePrompt } from "./report.js";
 import { standingIn } from "./status.js";
 import { childStore } from "./store.js";
-import { subtree } from "./subtree.js";
+import { readTree } from "./subtree.js";
+import { stalledAmong } from "./wake.js";
 /** The last tool call in a session's messages, and when it was made. */
 export function lastTool(messages) {
     for (const message of messages.toReversed()) {
@@ -18,6 +19,8 @@ export function lastTool(messages) {
 export const waitOf = (pending) => pending.type === "permission"
     ? { type: "permission", action: pending.action, resources: [...pending.resources] }
     : { type: "question", question: pending.questions[0]?.question ?? "" };
+/** A form a session shows, as the panel says what it waits on. */
+export const formWait = (form) => ({ type: "form", title: form.title });
 /** A session's report since its last prompt, as the panel shows it; none for one spawned before this was kept. */
 function reportRow(report, status) {
     if (!report)
@@ -28,25 +31,27 @@ function reportRow(report, status) {
         return { report: { state: "ended", progressed: report.progressed } };
     return { report: { state: "reported", progressed: report.progressed, ...(status ? { status } : {}) } };
 }
-/** What a session does: waiting on a request to the person, running, idle, or gone when OpenCode no longer knows it. */
-function stateOf(info, waits, running) {
+/**
+ * What a session does: waiting on a request to the person or a form it shows them, stalled, running, idle, or gone when
+ * OpenCode no longer knows it. A message waiting in its inbox makes a stalled session look busy.
+ */
+function stateOf(info, waits, stalled, running) {
     if (!info)
         return "gone";
     if (waits)
         return "waiting";
+    if (stalled)
+        return "stalled";
     return running ? "running" : "idle";
 }
 /** One session of the panel: what it is doing, its report and group standing, its last tool call and its cost. */
-async function row(ports, entry, depth) {
+async function row(ports, { entry, depth, info, pending, forms, report }, stalled) {
     const { sessionID } = entry;
-    const children = childStore(ports.storage);
-    const [info, messages, pending, report, status, standing] = await Promise.all([
-        ports.session.get({ sessionID }).catch(() => undefined),
+    const [messages, status, standing, stopped] = await Promise.all([
         ports.session.context({ sessionID }).catch(() => []),
-        ports.pending(sessionID).catch(() => []),
-        reportOf(children, sessionID).catch(() => undefined),
-        lastStatus(children, sessionID).catch(() => undefined),
+        lastStatus(childStore(ports.storage), sessionID).catch(() => undefined),
         entry.group ? standingIn(ports, entry, entry.group) : undefined,
+        stoppedSincePrompt(childStore(ports.storage), sessionID).catch(() => false),
     ]);
     const running = info !== undefined && busy(info.time);
     const tool = lastTool(messages);
@@ -55,8 +60,10 @@ async function row(ports, entry, depth) {
         parentID: entry.parentID,
         title: info?.title ?? entry.title,
         depth,
-        state: stateOf(info, pending.length, running),
+        state: stateOf(info, pending.length + forms.length, stalled !== undefined, running),
+        ...(stalled !== undefined ? { stalled } : {}),
         ...(info?.outcome ? { outcome: info.outcome } : {}),
+        ...(stopped ? { stopped } : {}),
         ...reportRow(report, status),
         ...(entry.group && standing ? { group: { name: entry.group, standing } } : {}),
         isolated: entry.isolated,
@@ -64,12 +71,17 @@ async function row(ports, entry, depth) {
         ...(info && !running && info.time.idle !== undefined ? { idle: info.time.idle } : {}),
         ...(info ? { cost: info.cost } : {}),
         ...(tool ? { tool } : {}),
-        waits: pending.map(waitOf),
+        waits: [...pending.map(waitOf), ...forms.map(formWait)],
     };
 }
-/** The tree panel's rows: the sessions courier_tree reads under a session, at most `maxTotal`, each as `row` reads it. */
+/**
+ * The tree panel's rows: the sessions under a session as courier_tree lists them, at most `maxTotal`, the live ones
+ * first, then the newest, each as `row` reads it; `truncated` counts the older ones left out, and `stalled` says the root is.
+ */
 export async function panel(ports, rootID) {
-    const { nodes, truncated } = await subtree(ports.storage, rootID, ports.limits.maxTotal);
-    const rows = await Promise.all(nodes.map(({ entry, depth }) => row(ports, entry, depth)));
-    return { rows, ...(truncated ? { truncated: ports.limits.maxTotal } : {}) };
+    const { kept, leftOut } = await readTree(ports, rootID);
+    const stalled = await stalledAmong(ports, [rootID, ...kept.map((node) => node.entry.sessionID)]);
+    const rows = await Promise.all(kept.map((node) => row(ports, node, stalled.get(node.entry.sessionID))));
+    const own = stalled.get(rootID);
+    return { rows, ...(leftOut ? { truncated: leftOut } : {}), ...(own !== undefined ? { stalled: own } : {}) };
 }

package/dist/tree/ports.d.ts

@@ -80,6 +80,35 @@ export interface ChildStore {
     /** Removes report keys `reported` found, each best effort. */
     dropReported(keys: ReadonlyArray<string>): Promise<void>;
 }
+/**
+ * A courier message waiting in a session's inbox, watched until it is delivered: `running` while the session runs a
+ * turn, which takes it at its next step; `idleAt` since the session was last seen idle with it waiting.
+ */
+export interface Wake {
+    readonly sessionID: string;
+    readonly inboxID: string;
+    /** When OpenCode enqueued it. */
+    readonly at: number;
+    /** Its text and description, which waking the session again sends under the same inbox id. */
+    readonly text: string;
+    readonly description?: string;
+    readonly running: boolean;
+    readonly idleAt?: number;
+    /** When the scheduler woke the session again, the message still waiting. */
+    readonly rewoken?: number;
+    /** When the session was found still not woken after that: it is stalled. */
+    readonly stalled?: number;
+}
+export interface WakeStore {
+    /** Writes a watched message, replacing what was kept of it. */
+    put(wake: Wake): Promise<void>;
+    /** The messages watched in a session's inbox. */
+    of(sessionID: string): Promise<Wake[]>;
+    /** Every message watched. */
+    all(): Promise<Wake[]>;
+    /** Stops watching a message: delivered, cancelled, or its session gone. */
+    remove(sessionID: string, inboxID: string): Promise<void>;
+}
 /** A member of a join group with where it is kept. */
 export interface Membership extends Member {
     readonly parentID: string;
@@ -133,6 +162,8 @@ export interface CourierPorts {
     readonly now: () => number;
     /** The permission requests and questions a session waits on, wherever they are pending. */
     readonly pending: (sessionID: string) => Promise<ReadonlyArray<Pending>>;
+    /** The forms a session shows, which only the person can answer: web search's, a plugin's; not the question tool's. */
+    readonly forms: (sessionID: string) => Promise<ReadonlyArray<ShownForm>>;
     readonly limits: Limits;
     /** The `nativeChildren` option: a child started without isolate is created with OpenCode's own `parentID`. */
     readonly nativeChildren?: boolean;
@@ -143,6 +174,11 @@ export interface CourierPorts {
     readonly nudge: () => void;
     readonly log: (message: string) => void;
 }
+/** A form a session shows, as `CourierPorts.forms` lists it; `person/` keeps them. */
+export interface ShownForm {
+    readonly id: string;
+    readonly title: string;
+}
 /** One question a session waits on, as `Pending` shows it; `person/`'s `Prompt` has these fields. */
 export interface PendingPrompt {
     readonly question: string;

package/dist/tree/roster.d.ts

@@ -18,6 +18,11 @@ export declare function lineage(storage: RosterStorage, sessionID: string): Prom
 export declare function answeringTop(storage: RosterStorage, sessionID: string, callerID: string, what: string): Promise<string>;
 /** Whether a directory still exists; tests pass a fake. */
 export type Exists = (directory: string) => boolean;
+/**
+ * Whether an entry is past retention at `now`: recorded more than `RETENTION_MS` before, unless it is an isolated
+ * child whose worktree exists, which is kept so it can still be cleaned up.
+ */
+export declare const isExpired: (entry: RosterEntry, now: number, exists?: Exists) => boolean;
 /** A parent's children, oldest first, after dropping the expired ones. */
 export declare function current(storage: RosterStorage, parentID: string, now: number, exists?: Exists): Promise<RosterEntry[]>;
 /**

package/dist/tree/roster.js

@@ -31,11 +31,13 @@ export async function answeringTop(storage, sessionID, callerID, what) {
     return top;
 }
 /**
- * Forgets the given entries that were recorded more than `RETENTION_MS` before `now`, and returns
- * the rest. An isolated child is kept while its worktree exists, so it can still be cleaned up.
+ * Whether an entry is past retention at `now`: recorded more than `RETENTION_MS` before, unless it is an isolated
+ * child whose worktree exists, which is kept so it can still be cleaned up.
  */
+export const isExpired = (entry, now, exists = existsSync) => now - entry.createdAt > RETENTION_MS && !(entry.isolated && exists(entry.directory));
+/** Forgets the given entries that are expired at `now`, and returns the rest. */
 async function dropExpired(storage, entries, now, exists) {
-    const expired = new Set(entries.filter((entry) => now - entry.createdAt > RETENTION_MS && !(entry.isolated && exists(entry.directory))));
+    const expired = new Set(entries.filter((entry) => isExpired(entry, now, exists)));
     await Promise.all([...expired].map((entry) => forgetChild(storage, entry.parentID, entry.sessionID, entry.group)));
     return entries.filter((entry) => !expired.has(entry));
 }