opencode-courier 0.5.0 → 0.6.0

package/dist/tree/rpc.d.ts

@@ -1,9 +1,9 @@
 import { Schema } from "effect";
 /** The sessions started under a session, as the prompt footer's status entry shows them. */
 declare const Summary: Schema.Struct<{
-    /** Running, and waiting on no request. */
+    /** Running, and waiting on no request or form. */
     readonly running: Schema.Int;
-    /** Waiting on a permission request or a question, which go to the person. */
+    /** Waiting on a permission request, a question or a form it shows, which go to the person. */
     readonly waiting: Schema.Int;
     /** Not running: done, or waiting for a message. */
     readonly idle: Schema.Int;
@@ -12,11 +12,9 @@ declare const Summary: Schema.Struct<{
         readonly reported: Schema.Int;
         readonly members: Schema.Int;
     }>>;
-    /** Set when the subtree had more sessions than `maxTotal`, which were not counted. */
-    readonly truncated: Schema.optionalKey<Schema.Int>;
 }>;
 export type Summary = typeof Summary.Type;
-/** A request a session waits on until the person answers it: a permission request, or its first question. */
+/** A request a session waits on until the person answers it: a permission request, its first question, or a form it shows. */
 declare const Wait: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"permission">;
     readonly action: Schema.String;
@@ -24,6 +22,9 @@ declare const Wait: Schema.Union<readonly [Schema.Struct<{
 }>, Schema.Struct<{
     readonly type: Schema.Literal<"question">;
     readonly question: Schema.String;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"form">;
+    readonly title: Schema.String;
 }>]>;
 /** One session of the tree panel: what courier_tree shows of it, and what it is doing, in epoch milliseconds. */
 declare const Row: Schema.Struct<{
@@ -32,10 +33,12 @@ declare const Row: Schema.Struct<{
     readonly title: Schema.String;
     /** A child of the panel's session is at depth 1. */
     readonly depth: Schema.Int;
-    /** `waiting` on a request to the person; `gone` when OpenCode no longer knows it. */
+    /** `waiting` on a request to the person or a form it shows them; `gone` when OpenCode no longer knows it. */
     readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "gone"]>;
     /** How its last turn ended. */
     readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>;
+    /** Set when courier_stop stopped it since its last prompt. */
+    readonly stopped: Schema.optionalKey<Schema.Boolean>;
     /** Its report since its last prompt: still owed, arrived (held with its group or delivered), or its turn ended without one. */
     readonly report: Schema.optionalKey<Schema.Struct<{
         readonly state: Schema.Literals<readonly ["owed", "reported", "ended"]>;
@@ -65,9 +68,12 @@ declare const Row: Schema.Struct<{
     }>, Schema.Struct<{
         readonly type: Schema.Literal<"question">;
         readonly question: Schema.String;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"form">;
+        readonly title: Schema.String;
     }>]>>;
 }>;
-/** The sessions under a session, as courier_tree reads them, in the order a tree is drawn. */
+/** The sessions under a session, as courier_tree lists them, in the order a tree is drawn. */
 declare const Tree: Schema.Struct<{
     readonly rows: Schema.$Array<Schema.Struct<{
         readonly sessionID: Schema.String;
@@ -75,10 +81,12 @@ declare const Tree: Schema.Struct<{
         readonly title: Schema.String;
         /** A child of the panel's session is at depth 1. */
         readonly depth: Schema.Int;
-        /** `waiting` on a request to the person; `gone` when OpenCode no longer knows it. */
+        /** `waiting` on a request to the person or a form it shows them; `gone` when OpenCode no longer knows it. */
         readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "gone"]>;
         /** How its last turn ended. */
         readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>;
+        /** Set when courier_stop stopped it since its last prompt. */
+        readonly stopped: Schema.optionalKey<Schema.Boolean>;
         /** Its report since its last prompt: still owed, arrived (held with its group or delivered), or its turn ended without one. */
         readonly report: Schema.optionalKey<Schema.Struct<{
             readonly state: Schema.Literals<readonly ["owed", "reported", "ended"]>;
@@ -108,9 +116,12 @@ declare const Tree: Schema.Struct<{
         }>, Schema.Struct<{
             readonly type: Schema.Literal<"question">;
             readonly question: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"form">;
+            readonly title: Schema.String;
         }>]>>;
     }>>;
-    /** Set when the subtree had more sessions than `maxTotal`, which were left out. */
+    /** How many older sessions the listing left out, when it had more than `maxTotal`: the live ones come first, then the newest. */
     readonly truncated: Schema.optionalKey<Schema.Int>;
 }>;
 export type Row = typeof Row.Type;
@@ -127,6 +138,14 @@ declare const Stopped: Schema.Struct<{
     readonly cancelled: Schema.Int;
 }>;
 export type Stopped = typeof Stopped.Type;
+/** What courier_cleanup did: forgot it, removed its worktree, found that already gone, or kept the worktree, saying why. */
+declare const Forgotten: Schema.Union<readonly [Schema.Struct<{
+    readonly outcome: Schema.Literals<readonly ["forgotten", "removed", "gone"]>;
+}>, Schema.Struct<{
+    readonly outcome: Schema.Literal<"kept">;
+    readonly reason: Schema.String;
+}>]>;
+export type Forgotten = typeof Forgotten.Type;
 export declare const treeRpc: {
     readonly id: "courier";
     readonly methods: {
@@ -140,28 +159,26 @@ export declare const treeRpc: {
             }>;
             readonly output: import("effect/StandardSchema").StandardSchemaV1<{
                 readonly running: number;
+                readonly waiting: number;
                 readonly idle: number;
                 readonly groups: readonly {
                     readonly name: string;
                     readonly reported: number;
                     readonly members: number;
                 }[];
-                readonly waiting: number;
-                readonly truncated?: number | undefined;
             }, {
                 readonly running: number;
+                readonly waiting: number;
                 readonly idle: number;
                 readonly groups: readonly {
                     readonly name: string;
                     readonly reported: number;
                     readonly members: number;
                 }[];
-                readonly waiting: number;
-                readonly truncated?: number | undefined;
             }> & Schema.Struct<{
-                /** Running, and waiting on no request. */
+                /** Running, and waiting on no request or form. */
                 readonly running: Schema.Int;
-                /** Waiting on a permission request or a question, which go to the person. */
+                /** Waiting on a permission request, a question or a form it shows, which go to the person. */
                 readonly waiting: Schema.Int;
                 /** Not running: done, or waiting for a message. */
                 readonly idle: Schema.Int;
@@ -170,8 +187,6 @@ export declare const treeRpc: {
                     readonly reported: Schema.Int;
                     readonly members: Schema.Int;
                 }>>;
-                /** Set when the subtree had more sessions than `maxTotal`, which were not counted. */
-                readonly truncated: Schema.optionalKey<Schema.Int>;
             }>;
         };
         readonly tree: {
@@ -198,11 +213,15 @@ export declare const treeRpc: {
                     } | {
                         readonly type: "question";
                         readonly question: string;
+                    } | {
+                        readonly type: "form";
+                        readonly title: string;
                     })[];
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
                     } | undefined;
+                    readonly stopped?: boolean | undefined;
                     readonly idle?: number | undefined;
                     readonly report?: {
                         readonly progressed: boolean;
@@ -233,11 +252,15 @@ export declare const treeRpc: {
                     } | {
                         readonly type: "question";
                         readonly question: string;
+                    } | {
+                        readonly type: "form";
+                        readonly title: string;
                     })[];
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
                     } | undefined;
+                    readonly stopped?: boolean | undefined;
                     readonly idle?: number | undefined;
                     readonly report?: {
                         readonly progressed: boolean;
@@ -259,10 +282,12 @@ export declare const treeRpc: {
                     readonly title: Schema.String;
                     /** A child of the panel's session is at depth 1. */
                     readonly depth: Schema.Int;
-                    /** `waiting` on a request to the person; `gone` when OpenCode no longer knows it. */
+                    /** `waiting` on a request to the person or a form it shows them; `gone` when OpenCode no longer knows it. */
                     readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "gone"]>;
                     /** How its last turn ended. */
                     readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>;
+                    /** Set when courier_stop stopped it since its last prompt. */
+                    readonly stopped: Schema.optionalKey<Schema.Boolean>;
                     /** Its report since its last prompt: still owed, arrived (held with its group or delivered), or its turn ended without one. */
                     readonly report: Schema.optionalKey<Schema.Struct<{
                         readonly state: Schema.Literals<readonly ["owed", "reported", "ended"]>;
@@ -292,9 +317,12 @@ export declare const treeRpc: {
                     }>, Schema.Struct<{
                         readonly type: Schema.Literal<"question">;
                         readonly question: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"form">;
+                        readonly title: Schema.String;
                     }>]>>;
                 }>>;
-                /** Set when the subtree had more sessions than `maxTotal`, which were left out. */
+                /** How many older sessions the listing left out, when it had more than `maxTotal`: the live ones come first, then the newest. */
                 readonly truncated: Schema.optionalKey<Schema.Int>;
             }>;
         };
@@ -337,6 +365,38 @@ export declare const treeRpc: {
                 readonly refused: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
             };
         };
+        /** Forgets `sessionID` as courier_cleanup called from its parent, without `force`; `by` must be above it. */
+        readonly cleanup: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly sessionID: string;
+                readonly by: string;
+            }, {
+                readonly sessionID: string;
+                readonly by: string;
+            }> & Schema.Struct<{
+                readonly sessionID: Schema.String;
+                readonly by: Schema.String;
+            }>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly outcome: "removed" | "gone" | "forgotten";
+            } | {
+                readonly outcome: "kept";
+                readonly reason: string;
+            }, {
+                readonly outcome: "removed" | "gone" | "forgotten";
+            } | {
+                readonly outcome: "kept";
+                readonly reason: string;
+            }> & Schema.Union<readonly [Schema.Struct<{
+                readonly outcome: Schema.Literals<readonly ["forgotten", "removed", "gone"]>;
+            }>, Schema.Struct<{
+                readonly outcome: Schema.Literal<"kept">;
+                readonly reason: Schema.String;
+            }>]>;
+            readonly errors: {
+                readonly refused: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            };
+        };
     };
     readonly events: {};
 };

package/dist/tree/rpc.js

@@ -9,20 +9,19 @@ const Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
 const Group = Schema.Struct({ name: Schema.String, reported: Count, members: Count });
 /** The sessions started under a session, as the prompt footer's status entry shows them. */
 const Summary = Schema.Struct({
-    /** Running, and waiting on no request. */
+    /** Running, and waiting on no request or form. */
     running: Count,
-    /** Waiting on a permission request or a question, which go to the person. */
+    /** Waiting on a permission request, a question or a form it shows, which go to the person. */
     waiting: Count,
     /** Not running: done, or waiting for a message. */
     idle: Count,
     groups: Schema.Array(Group),
-    /** Set when the subtree had more sessions than `maxTotal`, which were not counted. */
-    truncated: Schema.optionalKey(Count),
 });
-/** A request a session waits on until the person answers it: a permission request, or its first question. */
+/** A request a session waits on until the person answers it: a permission request, its first question, or a form it shows. */
 const Wait = Schema.Union([
     Schema.Struct({ type: Schema.Literal("permission"), action: Schema.String, resources: Schema.Array(Schema.String) }),
     Schema.Struct({ type: Schema.Literal("question"), question: Schema.String }),
+    Schema.Struct({ type: Schema.Literal("form"), title: Schema.String }),
 ]);
 /** One session of the tree panel: what courier_tree shows of it, and what it is doing, in epoch milliseconds. */
 const Row = Schema.Struct({
@@ -31,10 +30,12 @@ const Row = Schema.Struct({
     title: Schema.String,
     /** A child of the panel's session is at depth 1. */
     depth: Count,
-    /** `waiting` on a request to the person; `gone` when OpenCode no longer knows it. */
+    /** `waiting` on a request to the person or a form it shows them; `gone` when OpenCode no longer knows it. */
     state: Schema.Literals(["running", "waiting", "idle", "gone"]),
     /** How its last turn ended. */
     outcome: Schema.optionalKey(Schema.Literals(["succeeded", "failed", "interrupted"])),
+    /** Set when courier_stop stopped it since its last prompt. */
+    stopped: Schema.optionalKey(Schema.Boolean),
     /** Its report since its last prompt: still owed, arrived (held with its group or delivered), or its turn ended without one. */
     report: Schema.optionalKey(Schema.Struct({ state: Schema.Literals(["owed", "reported", "ended"]), status: Schema.optionalKey(Schema.String), progressed: Schema.Boolean })),
     /** Its join group, and its standing there: `held`, `out`, how it left, or `released`. */
@@ -49,10 +50,10 @@ const Row = Schema.Struct({
     tool: Schema.optionalKey(Schema.Struct({ name: Schema.String, at: Schema.Number })),
     waits: Schema.Array(Wait),
 });
-/** The sessions under a session, as courier_tree reads them, in the order a tree is drawn. */
+/** The sessions under a session, as courier_tree lists them, in the order a tree is drawn. */
 const Tree = Schema.Struct({
     rows: Schema.Array(Row),
-    /** Set when the subtree had more sessions than `maxTotal`, which were left out. */
+    /** How many older sessions the listing left out, when it had more than `maxTotal`: the live ones come first, then the newest. */
     truncated: Schema.optionalKey(Count),
 });
 /** What a stop did to each session, deepest first, as courier_stop reports it. */
@@ -61,6 +62,11 @@ const Stopped = Schema.Struct({
     /** How many scheduled messages were cancelled. */
     cancelled: Count,
 });
+/** What courier_cleanup did: forgot it, removed its worktree, found that already gone, or kept the worktree, saying why. */
+const Forgotten = Schema.Union([
+    Schema.Struct({ outcome: Schema.Literals(["forgotten", "removed", "gone"]) }),
+    Schema.Struct({ outcome: Schema.Literal("kept"), reason: Schema.String }),
+]);
 export const treeRpc = Rpc.define({
     id: "courier",
     methods: {
@@ -78,6 +84,12 @@ export const treeRpc = Rpc.define({
             output: Schema.toStandardSchemaV1(Stopped),
             errors: { refused: Schema.toStandardSchemaV1(Schema.Struct({})) },
         },
+        /** Forgets `sessionID` as courier_cleanup called from its parent, without `force`; `by` must be above it. */
+        cleanup: {
+            input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String, by: Schema.String })),
+            output: Schema.toStandardSchemaV1(Forgotten),
+            errors: { refused: Schema.toStandardSchemaV1(Schema.Struct({})) },
+        },
     },
     events: {},
 });

package/dist/tree/subtree.d.ts

@@ -1,20 +1,50 @@
-import type { CourierPorts, RosterEntry, RosterStorage } from "./ports.js";
+import type { Plugin } from "@opencode/plugin";
+import type { CourierPorts, Pending, RosterEntry, RosterStorage, ShownForm } from "./ports.js";
+import { reportOf } from "./report.js";
+import { type Exists } from "./roster.js";
 /** A session below the one a subtree is read from, with how many levels below it is: a child is at depth 1. */
 export interface Below {
     readonly entry: RosterEntry;
     readonly depth: number;
 }
+/** What a read drops: the entries past retention at `now`, as `courier_children` drops them; `exists` tells a worktree still there. */
+export interface Retention {
+    readonly now: number;
+    readonly exists?: Exists;
+}
 /**
- * The sessions started from a session, directly or through others, read one prefix scan per parent, at most `max`
- * (`truncated` if more), in the order a tree is drawn.
+ * The sessions started from a session, directly or through others, every one of them, read one prefix scan per
+ * parent, in the order a tree is drawn; with `retention`, without the expired entries and what is under them.
  */
-export declare function subtree(storage: RosterStorage, rootID: string, max?: number): Promise<{
+export declare function subtree(storage: RosterStorage, rootID: string, retention?: Retention): Promise<{
     nodes: Below[];
-    truncated: boolean;
+}>;
+type Info = Awaited<ReturnType<Plugin.Context["session"]["get"]>>;
+/** A session of a tree as a read looks it up: OpenCode's info of it, if it still knows it, and what it waits on. */
+export interface Looked extends Below {
+    readonly info: Info | undefined;
+    readonly pending: ReadonlyArray<Pending>;
+    readonly forms: ReadonlyArray<ShownForm>;
+}
+/** A session as a listing looks it up: `Looked` plus its report state, and whether it is live (`isLive`). */
+export interface Listed extends Looked {
+    readonly report: Awaited<ReturnType<typeof reportOf>>;
+    readonly live: boolean;
+}
+export type ReadPorts = Pick<CourierPorts, "storage" | "session" | "pending" | "forms" | "now" | "limits">;
+/** Every session under a session, without those past retention, each looked up, in the order a tree is drawn. */
+export declare function lookUp(ports: ReadPorts, rootID: string): Promise<Looked[]>;
+/**
+ * The listing of at most `max` of the sessions under a session: the live ones first, then the newest, with what is
+ * above them, in the order a tree is drawn (`cut`); `leftOut` counts the rest.
+ */
+export declare function readTree(ports: ReadPorts, rootID: string, max?: number): Promise<{
+    kept: Listed[];
+    leftOut: number;
 }>;
 /**
- * The subtree under a session, at most `maxTotal` sessions: what courier_children shows of each, plus its depth,
- * its parent and its report state.
+ * The subtree under a session as courier_tree lists it (`readTree`): each session as courier_children shows it, plus
+ * its depth, its parent and its report state; `truncated` counts the older sessions left out.
  */
 export declare function tree(ports: CourierPorts, rootID: string): Promise<{
     truncated?: number | undefined;
@@ -41,7 +71,7 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
         updated?: number | undefined;
         idle?: number | undefined;
         lastText?: string | undefined;
-        pending?: readonly import("./ports.js").Pending[] | undefined;
+        pending?: readonly Pending[] | undefined;
     } | {
         report?: {
             status?: "done" | "partial" | "blocked" | "failed" | undefined;
@@ -61,7 +91,7 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
         updated?: number | undefined;
         idle?: number | undefined;
         lastText?: string | undefined;
-        pending?: readonly import("./ports.js").Pending[] | undefined;
+        pending?: readonly Pending[] | undefined;
     } | {
         report?: {
             status?: "done" | "partial" | "blocked" | "failed" | undefined;
@@ -99,3 +129,4 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
         title: string;
     })[];
 }>;
+export {};

package/dist/tree/subtree.js

@@ -1,24 +1,23 @@
+import { busy, cut, isLive } from "./domain.js";
 import { lastStatus, reportOf } from "./report.js";
+import { isExpired } from "./roster.js";
 import { described } from "./status.js";
 import { childStore } from "./store.js";
 /**
- * The sessions started from a session, directly or through others, read one prefix scan per parent, at most `max`
- * (`truncated` if more), in the order a tree is drawn.
+ * The sessions started from a session, directly or through others, every one of them, read one prefix scan per
+ * parent, in the order a tree is drawn; with `retention`, without the expired entries and what is under them.
  */
-export async function subtree(storage, rootID, max = Number.POSITIVE_INFINITY) {
+export async function subtree(storage, rootID, retention) {
     const children = childStore(storage);
     const byParent = new Map();
     const seen = new Set([rootID]);
-    let truncated = false;
     const expand = async (level, depth) => {
-        if (!level.length || truncated)
+        if (!level.length)
             return;
         const found = await Promise.all(level.map((parentID) => children.children(parentID)));
         const next = [];
         for (const [index, entries] of found.entries()) {
-            const fresh = entries.filter((entry) => !seen.has(entry.sessionID));
-            const kept = fresh.slice(0, Math.max(0, max - (seen.size - 1)));
-            truncated ||= kept.length < fresh.length;
+            const kept = entries.filter((entry) => !seen.has(entry.sessionID) && !(retention && isExpired(entry, retention.now, retention.exists)));
             for (const entry of kept)
                 seen.add(entry.sessionID);
             if (kept.length)
@@ -28,25 +27,47 @@ export async function subtree(storage, rootID, max = Number.POSITIVE_INFINITY) {
         return expand(next, depth + 1);
     };
     await expand([rootID], 1);
-    return { nodes: drawn(byParent, rootID), truncated };
+    return { nodes: drawn(byParent, rootID) };
 }
 /** The nodes in the order a tree is drawn: each followed by what it started. */
 function drawn(byParent, parentID) {
     return (byParent.get(parentID) ?? []).flatMap((node) => [node, ...drawn(byParent, node.entry.sessionID)]);
 }
+/** Every session under a session, without those past retention, each looked up, in the order a tree is drawn. */
+export async function lookUp(ports, rootID) {
+    const { nodes } = await subtree(ports.storage, rootID, { now: ports.now() });
+    return Promise.all(nodes.map(async (node) => {
+        const [info, pending, forms] = await Promise.all([
+            ports.session.get({ sessionID: node.entry.sessionID }).catch(() => undefined),
+            ports.pending(node.entry.sessionID).catch(() => []),
+            ports.forms(node.entry.sessionID).catch(() => []),
+        ]);
+        // A form outlives its session's turn only when its withdrawal was missed, as while no instance followed the events.
+        return { ...node, info, pending, forms: info && busy(info.time) ? forms : [] };
+    }));
+}
 /**
- * The subtree under a session, at most `maxTotal` sessions: what courier_children shows of each, plus its depth,
- * its parent and its report state.
+ * The listing of at most `max` of the sessions under a session: the live ones first, then the newest, with what is
+ * above them, in the order a tree is drawn (`cut`); `leftOut` counts the rest.
+ */
+export async function readTree(ports, rootID, max = ports.limits.maxTotal) {
+    const children = childStore(ports.storage);
+    const all = await Promise.all((await lookUp(ports, rootID)).map(async (node) => {
+        const report = await reportOf(children, node.entry.sessionID).catch(() => undefined);
+        return { ...node, report, live: isLive(node.info?.time, node.pending.length + node.forms.length, report) };
+    }));
+    const listing = cut(all.map((node) => ({ sessionID: node.entry.sessionID, parentID: node.entry.parentID, createdAt: node.entry.createdAt, live: node.live, node })), max);
+    return { kept: listing.kept.map(({ node }) => node), leftOut: listing.leftOut };
+}
+/**
+ * The subtree under a session as courier_tree lists it (`readTree`): each session as courier_children shows it, plus
+ * its depth, its parent and its report state; `truncated` counts the older sessions left out.
  */
 export async function tree(ports, rootID) {
-    const { nodes, truncated } = await subtree(ports.storage, rootID, ports.limits.maxTotal);
+    const { kept, leftOut } = await readTree(ports, rootID);
     const children = childStore(ports.storage);
-    const listed = await Promise.all(nodes.map(async ({ entry, depth }) => {
-        const [info, report, last] = await Promise.all([
-            described(ports, entry),
-            reportOf(children, entry.sessionID).catch(() => undefined),
-            lastStatus(children, entry.sessionID).catch(() => undefined),
-        ]);
+    const listed = await Promise.all(kept.map(async ({ entry, depth, report }) => {
+        const [info, last] = await Promise.all([described(ports, entry), lastStatus(children, entry.sessionID).catch(() => undefined)]);
         return {
             ...info,
             parentID: entry.parentID,
@@ -56,5 +77,5 @@ export async function tree(ports, rootID) {
                 : {}),
         };
     }));
-    return { sessionID: rootID, sessions: listed, ...(truncated ? { truncated: ports.limits.maxTotal } : {}) };
+    return { sessionID: rootID, sessions: listed, ...(leftOut ? { truncated: leftOut } : {}) };
 }

package/dist/tree/summary.d.ts

@@ -1,7 +1,7 @@
 import type { CourierPorts } from "./ports.js";
 import type { Summary } from "./rpc.js";
 /**
- * The sessions started under a session, at most `maxTotal` as courier_tree reads them, counted by what they
- * are doing, and its open join groups, those of its own children, with how far each has reported.
+ * Every session started under a session, counted by what it is doing, and its open join groups, those of its own
+ * children, with how far each has reported.
  */
 export declare function summary(ports: CourierPorts, sessionID: string): Promise<Summary>;

package/dist/tree/summary.js

@@ -1,35 +1,27 @@
 import { busy } from "./domain.js";
 import { groupStandings } from "./group.js";
 import { groupStore } from "./store.js";
-import { subtree } from "./subtree.js";
-/** What a session is doing: waiting on a request it made, running, or idle; undefined when OpenCode no longer knows it. */
-async function activity(ports, sessionID) {
-    const [info, pending] = await Promise.all([
-        ports.session.get({ sessionID }).catch(() => undefined),
-        ports.pending(sessionID).catch(() => []),
-    ]);
+import { lookUp } from "./subtree.js";
+/** What a session is doing: waiting on a request it made or a form it shows, running, or idle; undefined when OpenCode no longer knows it. */
+function activity({ info, pending, forms }) {
     if (!info)
         return undefined;
-    if (pending.length)
+    if (pending.length || forms.length)
         return "waiting";
     return busy(info.time) ? "running" : "idle";
 }
 /**
- * The sessions started under a session, at most `maxTotal` as courier_tree reads them, counted by what they
- * are doing, and its open join groups, those of its own children, with how far each has reported.
+ * Every session started under a session, counted by what it is doing, and its open join groups, those of its own
+ * children, with how far each has reported.
  */
 export async function summary(ports, sessionID) {
-    const counted = async () => {
-        const { nodes, truncated } = await subtree(ports.storage, sessionID, ports.limits.maxTotal);
-        return { activities: await Promise.all(nodes.map(({ entry }) => activity(ports, entry.sessionID))), truncated };
-    };
-    const [{ activities, truncated }, standings] = await Promise.all([counted(), groupStandings(groupStore(ports.storage), sessionID)]);
+    const [looked, standings] = await Promise.all([lookUp(ports, sessionID), groupStandings(groupStore(ports.storage), sessionID)]);
+    const activities = looked.map(activity);
     const count = (kind) => activities.filter((item) => item === kind).length;
     return {
         running: count("running"),
         waiting: count("waiting"),
         idle: count("idle"),
         groups: standings.map(({ name, reported, members }) => ({ name, reported, members })),
-        ...(truncated ? { truncated: ports.limits.maxTotal } : {}),
     };
 }

package/dist/tree/text.js

@@ -160,7 +160,10 @@ export function cleanupText(result) {
 export function treeText(tree) {
     if (!tree.sessions.length)
         return "No sessions started with courier_spawn.";
-    const note = tree.truncated === undefined ? "" : `\nOnly the first ${tree.truncated} sessions are listed (maxTotal); courier_tree on one of them lists what is under it.`;
+    if (tree.truncated === undefined)
+        return JSON.stringify(tree, null, 2);
+    const older = tree.truncated === 1 ? "1 older session is" : `${tree.truncated} older sessions are`;
+    const note = `\n${older} not listed: at most maxTotal are, the live ones first, then the newest; courier_tree on a listed session lists what is under it.`;
     return JSON.stringify(tree, null, 2) + note;
 }
 /** What courier_stop did to each session, and to the messages and worktrees. */

package/dist/tree/tools.js

@@ -128,7 +128,8 @@ export function addTreeTools(tools, ports) {
         options: { codemode: false },
         description: "List the whole tree of sessions under this one (or under sessionID): every session started with courier_spawn " +
             "from it, directly or through others, each with its depth, what courier_children shows, and whether it still " +
-            "owes a report, sent progress, or ended without one. For a one-off look, not for waiting; long trees are cut at maxTotal sessions.",
+            "owes a report, sent progress, or ended without one. For a one-off look, not for waiting. A long tree lists at most " +
+            "maxTotal sessions, the live ones first, then the newest, and says how many older ones are left out.",
         input: TreeInput,
         execute: async (input, context) => {
             const result = await tree(ports.courier, input.sessionID || context.sessionID).catch(rethrow("courier_tree"));

package/dist/tree/tui.d.ts

@@ -1,6 +1,8 @@
 import type { Plugin } from "@opencode/plugin/tui";
-import { type Row, type Stopped, type Summary, type Wait } from "./rpc.js";
+import { type Forgotten, type Row, type Stopped, type Summary, type Wait } from "./rpc.js";
 type Context = Plugin.Context;
+/** The events after which a summary may read differently: a turn started or ended, a request or form, a session made or removed. */
+export declare const CHANGES: Set<string>;
 /** How long after the first of a burst of changes the entry asks the server again. */
 export declare const SETTLE_MS = 250;
 /** The panel's settle: each of its asks reads every row's messages, so a busy tree is asked at most once a second. */
@@ -9,8 +11,11 @@ export declare const PANEL_SETTLE_MS = 1000;
 export declare const PANEL = "courier-tree";
 /** How often the panel redraws its running times and how long ago each last tool call was. */
 export declare const TICK_MS = 1000;
-/** The status entry's text, such as "courier 2 running · 1 waiting on you · group pair 1/2"; empty when there is nothing to show. */
-export declare function summaryLine(summary: Summary): string;
+/**
+ * The status entry's text, such as "courier 1 waiting on you · 2 running · group pair 1/2"; empty when there is nothing to show.
+ * Within `maxWidth` it keeps whole parts, most important first, and counts the groups it drops: "· +2 groups".
+ */
+export declare function summaryLine(summary: Summary, maxWidth?: number): string;
 /** A span of time, coarsest first: "45s", "3m 05s", "2h 07m". */
 export declare function duration(ms: number): string;
 /** How many of a session's children have reported, out of those it started, among the rows read. */
@@ -23,7 +28,7 @@ export declare function bar({ reported, started }: {
     reported: number;
     started: number;
 }, width?: number): string;
-/** What a paused session waits on, such as "asks permission: shell echo hi". */
+/** What a paused session waits on, such as "asks permission: shell echo hi" or "shows a form: Web Search". */
 export declare function waitLine(wait: Wait): string;
 /** What a row's session is doing, its report and its group standing: "idle · reported done · group pair held". */
 export declare function statusLine(row: Row): string;
@@ -38,6 +43,8 @@ export declare function detailLines(row: Row, rows: ReadonlyArray<Row>, now: num
 export declare function addTreeStatus(ctx: Context, onWaiting?: (sessionID: string) => void): () => void;
 /** The toast after a stop: how many sessions were interrupted, and how many scheduled messages were cancelled. */
 export declare function stoppedLine({ stopped, cancelled }: Stopped): string;
+/** The toast after a forget, as courier_cleanup reports it: forgotten, its worktree removed or already gone, or kept and why. */
+export declare function forgottenLine(title: string, result: Forgotten): string;
 /** The usage the `/courier` command shows for an input it does not know. */
 export declare const USAGE = "/courier tree opens the session tree; /courier stop [session] stops a session and those under it";
 /**