opencode-courier 0.7.2 → 0.8.0

package/dist/tree/ports.d.ts

@@ -164,6 +164,8 @@ export interface CourierPorts {
     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>>;
+    /** The context windows of the models available, by provider and model id, as the panel reads a session's context use. */
+    readonly windows: () => Promise<ReadonlyArray<ModelWindow>>;
     readonly limits: Limits;
     /** The `nativeChildren` option: a child started without isolate is created with OpenCode's own `parentID`. */
     readonly nativeChildren?: boolean;
@@ -174,6 +176,12 @@ export interface CourierPorts {
     readonly nudge: () => void;
     readonly log: (message: string) => void;
 }
+/** A model's context window in tokens, as `CourierPorts.windows` lists it. */
+export interface ModelWindow {
+    readonly providerID: string;
+    readonly id: string;
+    readonly context: number;
+}
 /** A form a session shows, as `CourierPorts.forms` lists it; `person/` keeps them. */
 export interface ShownForm {
     readonly id: string;
@@ -278,8 +286,8 @@ export interface ExecutionError {
 }
 export interface WatchPorts {
     readonly storage: RosterStorage;
-    /** `context` reads the last reply of a session that ended its turn without reporting. */
-    readonly session: Pick<Context["session"], "synthetic" | "context">;
+    /** `context` reads the last reply of a session that ended its turn without reporting; `get` is what every member joins with too. */
+    readonly session: Pick<Context["session"], "synthetic" | "context" | "get">;
     readonly event: Pick<Context["event"], "subscribe">;
     /** The permission domains of every loaded location, which the `Waits` suppliers ask; an isolated child's are in its worktree's. */
     readonly permissions: () => Iterable<Pick<Context["permission"], "list">>;
@@ -308,5 +316,7 @@ export interface ContextPorts {
     readonly limits: Limits;
     /** Each session's depth once looked up: null for one nobody spawned that has started none, until it starts one. */
     readonly roles: Map<string, number | null>;
+    /** Tools of other modules hidden from a leaf alongside courier_spawn; `src/index.ts` names courier_recall and courier_note. */
+    readonly hiddenFromLeaf?: ReadonlyArray<string>;
     readonly log: (message: string) => void;
 }

package/dist/tree/roster.d.ts

@@ -1,3 +1,4 @@
+import { type Status } from "../kernel/protocol.js";
 import type { RosterEntry, RosterStorage } from "./ports.js";
 /**
  * Entries older than this are dropped when their parent's roster is read, and on plugin setup,
@@ -11,6 +12,22 @@ export declare function allEntries(storage: RosterStorage): Promise<RosterEntry[
  * courier_spawn did not start; empty when courier_spawn did not start the session.
  */
 export declare function lineage(storage: RosterStorage, sessionID: string): Promise<RosterEntry[]>;
+/** `lineage` by the reverse index alone: empty, without scanning the roster, when it does not name the session. */
+export declare function indexedLineage(storage: RosterStorage, sessionID: string): Promise<RosterEntry[]>;
+/** The sessions a session started, oldest first, expired entries included. */
+export declare function childrenOf(storage: RosterStorage, parentID: string): Promise<RosterEntry[]>;
+/**
+ * What another module reads of a spawned session's report: `known` once a prompt was noted, whether it `owes` one, how
+ * its wait `ended` when not by a report, the `status` of its last report, and whether courier_stop `stopped` it since its last prompt.
+ */
+export interface ReportState {
+    readonly known: boolean;
+    readonly owes: boolean;
+    readonly ended?: "failed" | "interrupted";
+    readonly status?: Status;
+    readonly stopped: boolean;
+}
+export declare function reportState(storage: RosterStorage, sessionID: string): Promise<ReportState>;
 /**
  * The top of a spawned session's lineage, where its permission requests and questions go, since the
  * person is there. Throws unless the session was spawned and `callerID` is that top; `what` names it.

package/dist/tree/roster.js

@@ -1,5 +1,7 @@
 import { existsSync } from "node:fs";
+import { isStatus } from "../kernel/protocol.js";
 import { forgetChild, forgetReports } from "./forget.js";
+import { stoppedSincePrompt } from "./report.js";
 import { childStore } from "./store.js";
 /**
  * Entries older than this are dropped when their parent's roster is read, and on plugin setup,
@@ -17,6 +19,28 @@ export async function allEntries(storage) {
 export async function lineage(storage, sessionID) {
     return childStore(storage).lineage(sessionID);
 }
+/** `lineage` by the reverse index alone: empty, without scanning the roster, when it does not name the session. */
+export async function indexedLineage(storage, sessionID) {
+    return childStore(storage).indexedLineage(sessionID);
+}
+/** The sessions a session started, oldest first, expired entries included. */
+export async function childrenOf(storage, parentID) {
+    return childStore(storage).children(parentID);
+}
+export async function reportState(storage, sessionID) {
+    const children = childStore(storage);
+    const [{ prompt, settled }, stopped] = await Promise.all([children.notes(sessionID, ["prompt", "settled"]), stoppedSincePrompt(children, sessionID)]);
+    const known = prompt.at !== undefined;
+    const done = known && settled.at !== undefined && settled.at >= prompt.at;
+    const by = settled.by;
+    return {
+        known,
+        owes: known && !done,
+        ...(done && (by === "failed" || by === "interrupted") ? { ended: by } : {}),
+        ...(isStatus(settled.status) ? { status: settled.status } : {}),
+        stopped,
+    };
+}
 /**
  * The top of a spawned session's lineage, where its permission requests and questions go, since the
  * person is there. Throws unless the session was spawned and `callerID` is that top; `what` names it.

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

@@ -56,11 +56,11 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                 readonly rows: readonly {
                     readonly sessionID: string;
                     readonly title: string;
-                    readonly parentID: string;
                     readonly depth: number;
-                    readonly created: number;
                     readonly isolated: boolean;
-                    readonly state: "running" | "idle" | "gone" | "stalled" | "waiting";
+                    readonly parentID: string;
+                    readonly created: number;
+                    readonly state: "stalled" | "running" | "idle" | "gone" | "waiting";
                     readonly waits: readonly ({
                         readonly type: "permission";
                         readonly action: string;
@@ -72,24 +72,25 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                         readonly type: "form";
                         readonly title: string;
                     })[];
+                    readonly stopped?: boolean | undefined;
+                    readonly stalled?: number | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
                     } | undefined;
-                    readonly stopped?: boolean | undefined;
-                    readonly idle?: number | undefined;
+                    readonly cost?: number | undefined;
+                    readonly context?: number | undefined;
+                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
                     readonly report?: {
                         readonly progressed: boolean;
-                        readonly state: "reported" | "ended" | "owed";
+                        readonly state: "ended" | "reported" | "owed";
                         readonly status?: string | undefined;
                     } | undefined;
-                    readonly stalled?: number | undefined;
-                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
+                    readonly idle?: number | undefined;
                     readonly tool?: {
                         readonly name: string;
                         readonly at: number;
                     } | undefined;
-                    readonly cost?: number | undefined;
                 }[];
                 readonly stalled?: number | undefined;
                 readonly truncated?: number | undefined;
@@ -97,11 +98,11 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                 readonly rows: readonly {
                     readonly sessionID: string;
                     readonly title: string;
-                    readonly parentID: string;
                     readonly depth: number;
-                    readonly created: number;
                     readonly isolated: boolean;
-                    readonly state: "running" | "idle" | "gone" | "stalled" | "waiting";
+                    readonly parentID: string;
+                    readonly created: number;
+                    readonly state: "stalled" | "running" | "idle" | "gone" | "waiting";
                     readonly waits: readonly ({
                         readonly type: "permission";
                         readonly action: string;
@@ -113,24 +114,25 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                         readonly type: "form";
                         readonly title: string;
                     })[];
+                    readonly stopped?: boolean | undefined;
+                    readonly stalled?: number | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
                     } | undefined;
-                    readonly stopped?: boolean | undefined;
-                    readonly idle?: number | undefined;
+                    readonly cost?: number | undefined;
+                    readonly context?: number | undefined;
+                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
                     readonly report?: {
                         readonly progressed: boolean;
-                        readonly state: "reported" | "ended" | "owed";
+                        readonly state: "ended" | "reported" | "owed";
                         readonly status?: string | undefined;
                     } | undefined;
-                    readonly stalled?: number | undefined;
-                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
+                    readonly idle?: number | undefined;
                     readonly tool?: {
                         readonly name: string;
                         readonly at: number;
                     } | undefined;
-                    readonly cost?: number | undefined;
                 }[];
                 readonly stalled?: number | undefined;
                 readonly truncated?: number | undefined;
@@ -157,6 +159,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     readonly created: import("effect/Schema").Number;
                     readonly idle: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
                     readonly cost: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+                    readonly context: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
                     readonly tool: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
                         readonly name: import("effect/Schema").String;
                         readonly at: import("effect/Schema").Number;

package/dist/tree/rpc.d.ts

@@ -63,6 +63,8 @@ declare const Row: Schema.Struct<{
     readonly idle: Schema.optionalKey<Schema.Number>;
     /** What it has cost so far, in US dollars. */
     readonly cost: Schema.optionalKey<Schema.Number>;
+    /** How full its context is, as a fraction of the model's window; left out when the model or its limit cannot be read. */
+    readonly context: Schema.optionalKey<Schema.Number>;
     /** Its last tool call, and when it was made. */
     readonly tool: Schema.optionalKey<Schema.Struct<{
         readonly name: Schema.String;
@@ -116,6 +118,8 @@ declare const Tree: Schema.Struct<{
         readonly idle: Schema.optionalKey<Schema.Number>;
         /** What it has cost so far, in US dollars. */
         readonly cost: Schema.optionalKey<Schema.Number>;
+        /** How full its context is, as a fraction of the model's window; left out when the model or its limit cannot be read. */
+        readonly context: Schema.optionalKey<Schema.Number>;
         /** Its last tool call, and when it was made. */
         readonly tool: Schema.optionalKey<Schema.Struct<{
             readonly name: Schema.String;
@@ -219,11 +223,11 @@ export declare const treeRpc: {
                 readonly rows: readonly {
                     readonly sessionID: string;
                     readonly title: string;
-                    readonly parentID: string;
                     readonly depth: number;
-                    readonly created: number;
                     readonly isolated: boolean;
-                    readonly state: "running" | "idle" | "gone" | "stalled" | "waiting";
+                    readonly parentID: string;
+                    readonly created: number;
+                    readonly state: "stalled" | "running" | "idle" | "gone" | "waiting";
                     readonly waits: readonly ({
                         readonly type: "permission";
                         readonly action: string;
@@ -235,24 +239,25 @@ export declare const treeRpc: {
                         readonly type: "form";
                         readonly title: string;
                     })[];
+                    readonly stopped?: boolean | undefined;
+                    readonly stalled?: number | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
                     } | undefined;
-                    readonly stopped?: boolean | undefined;
-                    readonly idle?: number | undefined;
+                    readonly cost?: number | undefined;
+                    readonly context?: number | undefined;
+                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
                     readonly report?: {
                         readonly progressed: boolean;
-                        readonly state: "reported" | "ended" | "owed";
+                        readonly state: "ended" | "reported" | "owed";
                         readonly status?: string | undefined;
                     } | undefined;
-                    readonly stalled?: number | undefined;
-                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
+                    readonly idle?: number | undefined;
                     readonly tool?: {
                         readonly name: string;
                         readonly at: number;
                     } | undefined;
-                    readonly cost?: number | undefined;
                 }[];
                 readonly stalled?: number | undefined;
                 readonly truncated?: number | undefined;
@@ -260,11 +265,11 @@ export declare const treeRpc: {
                 readonly rows: readonly {
                     readonly sessionID: string;
                     readonly title: string;
-                    readonly parentID: string;
                     readonly depth: number;
-                    readonly created: number;
                     readonly isolated: boolean;
-                    readonly state: "running" | "idle" | "gone" | "stalled" | "waiting";
+                    readonly parentID: string;
+                    readonly created: number;
+                    readonly state: "stalled" | "running" | "idle" | "gone" | "waiting";
                     readonly waits: readonly ({
                         readonly type: "permission";
                         readonly action: string;
@@ -276,24 +281,25 @@ export declare const treeRpc: {
                         readonly type: "form";
                         readonly title: string;
                     })[];
+                    readonly stopped?: boolean | undefined;
+                    readonly stalled?: number | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
                     } | undefined;
-                    readonly stopped?: boolean | undefined;
-                    readonly idle?: number | undefined;
+                    readonly cost?: number | undefined;
+                    readonly context?: number | undefined;
+                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
                     readonly report?: {
                         readonly progressed: boolean;
-                        readonly state: "reported" | "ended" | "owed";
+                        readonly state: "ended" | "reported" | "owed";
                         readonly status?: string | undefined;
                     } | undefined;
-                    readonly stalled?: number | undefined;
-                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
+                    readonly idle?: number | undefined;
                     readonly tool?: {
                         readonly name: string;
                         readonly at: number;
                     } | undefined;
-                    readonly cost?: number | undefined;
                 }[];
                 readonly stalled?: number | undefined;
                 readonly truncated?: number | undefined;
@@ -332,6 +338,8 @@ export declare const treeRpc: {
                     readonly idle: Schema.optionalKey<Schema.Number>;
                     /** What it has cost so far, in US dollars. */
                     readonly cost: Schema.optionalKey<Schema.Number>;
+                    /** How full its context is, as a fraction of the model's window; left out when the model or its limit cannot be read. */
+                    readonly context: Schema.optionalKey<Schema.Number>;
                     /** Its last tool call, and when it was made. */
                     readonly tool: Schema.optionalKey<Schema.Struct<{
                         readonly name: Schema.String;

package/dist/tree/rpc.js

@@ -53,6 +53,8 @@ const Row = Schema.Struct({
     idle: Schema.optionalKey(Schema.Number),
     /** What it has cost so far, in US dollars. */
     cost: Schema.optionalKey(Schema.Number),
+    /** How full its context is, as a fraction of the model's window; left out when the model or its limit cannot be read. */
+    context: Schema.optionalKey(Schema.Number),
     /** Its last tool call, and when it was made. */
     tool: Schema.optionalKey(Schema.Struct({ name: Schema.String, at: Schema.Number })),
     waits: Schema.Array(Wait),

package/dist/tree/status.d.ts

@@ -27,7 +27,7 @@ export declare function lastReply(messages: Awaited<ReturnType<Context["session"
 export declare function listChildren(ports: CourierPorts, parentID: string): Promise<({
     group: {
         name: string;
-        report: "failed" | "interrupted" | "deleted" | "dropped" | "held" | "out" | "released" | "unknown";
+        report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
     };
     directory: string;
     isolated: boolean;
@@ -57,7 +57,7 @@ export declare function listChildren(ports: CourierPorts, parentID: string): Pro
     error: string;
     group: {
         name: string;
-        report: "failed" | "interrupted" | "deleted" | "dropped" | "held" | "out" | "released" | "unknown";
+        report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
     };
     directory: string;
     isolated: boolean;
@@ -77,7 +77,7 @@ export declare function listChildren(ports: CourierPorts, parentID: string): Pro
 export declare function described(ports: CourierPorts, entry: RosterEntry): Promise<{
     group: {
         name: string;
-        report: "failed" | "interrupted" | "deleted" | "dropped" | "held" | "out" | "released" | "unknown";
+        report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
     };
     directory: string;
     isolated: boolean;
@@ -107,7 +107,7 @@ export declare function described(ports: CourierPorts, entry: RosterEntry): Prom
     error: string;
     group: {
         name: string;
-        report: "failed" | "interrupted" | "deleted" | "dropped" | "held" | "out" | "released" | "unknown";
+        report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
     };
     directory: string;
     isolated: boolean;
@@ -124,5 +124,5 @@ export declare function described(ports: CourierPorts, entry: RosterEntry): Prom
     title: string;
 }>;
 /** A child's standing in the join group its roster entry names, `unknown` when that cannot be read. */
-export declare function standingIn(ports: Pick<CourierPorts, "storage">, entry: RosterEntry, group: string): Promise<"failed" | "interrupted" | "deleted" | "dropped" | "held" | "out" | "released" | "unknown">;
+export declare function standingIn(ports: Pick<CourierPorts, "storage">, entry: RosterEntry, group: string): Promise<"failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released">;
 export {};

package/dist/tree/subtree.d.ts

@@ -60,7 +60,7 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
         depth: number;
         group: {
             name: string;
-            report: "failed" | "interrupted" | "deleted" | "dropped" | "held" | "out" | "released" | "unknown";
+            report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
         };
         directory: string;
         isolated: boolean;
@@ -104,7 +104,7 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
         error: string;
         group: {
             name: string;
-            report: "failed" | "interrupted" | "deleted" | "dropped" | "held" | "out" | "released" | "unknown";
+            report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
         };
         directory: string;
         isolated: boolean;

package/dist/tree/text.js

@@ -64,7 +64,8 @@ export function rolePart(depth, limits) {
     const budget = `At most ${maxChildren} of the sessions you start run at once, and ${maxTotal} in the whole tree.`;
     if (depth === null)
         return (`${ROLE_PREFIX} root, no sessions started yet. Before a task that touches several files or areas, load the ` +
-            `${SKILL_ID} skill and decide whether to split it across sessions (doing it yourself is fine), and say ` +
+            `${SKILL_ID} skill, call courier_recall once for how earlier trees in this project were split and how they went, ` +
+            `and decide whether to split it across sessions (doing it yourself is fine), and say ` +
             `which in one line of your reply: ${SPLIT_LINE}`);
     if (depth === 0)
         return (`${ROLE_PREFIX} root orchestrator. You started sessions with courier_spawn, and they may start their own, ` +

package/dist/tree/tui.d.ts

@@ -1,4 +1,7 @@
 import type { Plugin } from "@opencode/plugin/tui";
+import { RGBA, type EasingFunctions } from "@opentui/core";
+import { type Accessor } from "solid-js";
+import { type MascotState, type Token } from "./mascot.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. */
@@ -11,6 +14,62 @@ 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 panel's animation frame: the spinner's step, and how often a flash or the bar's easing moves. */
+export declare const FRAME_MS = 90;
+/** How long a row's background takes to fade back from its flash after its report arrives: the report's hold. */
+export declare const FLASH_MS = 1500;
+/** How long the header's bar takes to grow, or shrink, to its new length. */
+export declare const BAR_MS = 450;
+/** Whether the panel animates: unless the TUI part's options say `"animations": false`, as the plugin API has no TUI setting for it. */
+export declare function animationsOn(options: Readonly<Record<string, unknown>> | undefined): boolean;
+/** A value eased over the panel's frames by OpenTUI's `Timeline`; reading it in a computation follows the frames. */
+export type Tween = {
+    readonly value: () => number;
+    readonly done: () => boolean;
+};
+/**
+ * The panel's one timer: a frame every `FRAME_MS` while a tween moves or an `animates` predicate holds, every `every` while
+ * only slower ones do, none otherwise, with animations off or once the panel is gone. `frame` counts in `FRAME_MS`.
+ */
+export type Motion = {
+    readonly enabled: boolean;
+    readonly frame: Accessor<number>;
+    readonly animates: (when: Accessor<boolean>, every?: number) => void;
+    readonly tween: (from: number, to: number, duration: number, ease: EasingFunctions) => Tween;
+};
+/** The panel's `Motion`, owned by the computation it is made in. */
+export declare function createMotion(enabled: boolean): Motion;
+/**
+ * Each row's flash, by session, from a read of the rows to the next that finds its report turned to `reported`; not on
+ * the first read. `strength` is a row's, 1 when its report arrives down to 0; `reported` holds for `FLASH_MS` after one.
+ */
+export declare function createFlashes(motion: Motion, rows: Accessor<ReadonlyArray<Row>>): {
+    strength: (sessionID: string) => number;
+    reported: () => boolean;
+};
+/** The header bar's filled cells, eased over `BAR_MS` to its new length once it is shown, at once when it first is. */
+export declare function createBarFill(motion: Motion, counts: Accessor<{
+    reported: number;
+    started: number;
+}>): () => number;
+/** True for `FLASH_MS` after a read of the tree finds a session the one before it did not have; not on the first read. */
+export declare function createSpawns(motion: Motion, rows: Accessor<ReadonlyArray<Row> | undefined>): () => boolean;
+/** Digby's state for the tree's rows, by `summaryLine`'s priority, unless a report or a spawn just arrived. */
+export declare function mascotState(rows: ReadonlyArray<Row>, { reported, spawned }?: {
+    reported?: boolean | undefined;
+    spawned?: boolean | undefined;
+}): MascotState;
+/** What the tree's sessions do, as the header's second line says it: "1 waiting on you · 2 running"; empty with none live. */
+export declare function countsLine(rows: ReadonlyArray<Row>): string;
+/** The panel's size below which it shows no header glyph, so the header keeps to one line and its bar is not cut. */
+export declare const GLYPH_ROWS = 12;
+export declare const GLYPH_COLUMNS = 54;
+/** The empty panel's height from which it shows the 16×16. */
+export declare const ART_ROWS = 14;
+/** The rows left free below the tree's last row from which the 16×16 shows there. */
+export declare const BELOW_ROWS = 10;
+/** `tint` over `rest` by `amount`, from 0 (all `rest`) to 1 (all `tint`). */
+export declare function blend(tint: RGBA, rest: RGBA, amount: number): RGBA;
 /**
  * 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".
@@ -23,17 +82,47 @@ export declare function parts(rows: ReadonlyArray<Row>, parentID: string): {
     reported: number;
     started: number;
 };
-/** A bar of parts reported, `width` cells wide: "[████░░░░░░] 2/5 reported". */
-export declare function bar({ reported, started }: {
+/** How many of a bar's `width` cells are filled for the parts reported. */
+export declare function filledCells({ reported, started }: {
     reported: number;
     started: number;
-}, width?: number): string;
+}, width?: number): number;
+/** A bar of parts reported, `width` cells wide: "[████░░░░░░] 2/5 reported"; `filled` cells of it while it eases to its length. */
+export declare function bar(counts: {
+    reported: number;
+    started: number;
+}, width?: number, filled?: number): string;
 /** 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;
-/** A leaf's activity: how long it has run, its last tool call and how long ago, and its cost. */
-export declare function activityLine(row: Row, now: number): string;
+/** The parts of `statusLine`, each with the row part the panel colours it as. */
+export declare function statusParts(row: Row): {
+    text: string;
+    kind: "state" | "report" | "plain";
+}[];
+type Feedback<Color> = {
+    text: {
+        feedback: Record<"error" | "warning" | "success" | "info", {
+            base: Color;
+        }>;
+    };
+};
+/** The running mark's frames, one every `FRAME_MS`. */
+export declare const SPINNER: string[];
+/**
+ * The one cell a row's state shows and its theme colour, the blank cell of one with no mark: this is the only place that
+ * chooses them. A running row spins through `SPINNER` at the panel's `frame`, and shows `•` with none (animations off).
+ */
+export declare function rowMark<Color>(row: Row, theme: Feedback<Color>, frame?: number): {
+    mark: string;
+    color: Color | undefined;
+};
+/** Past this fraction of its window, a session's context use is shown in the warning colour. */
+export declare const CONTEXT_WARN = 0.8;
+/** A leaf's activity: how long it has run, its last tool call and how long ago, its context use and its cost. */
+export declare function activityParts(row: Row, now: number): string[];
+export declare const activityLine: (row: Row, now: number) => string;
 /** What a stalled session's row, or the panel of one, says of it: "a message waits in its inbox since 2m 05s, woken again in vain". */
 export declare function stalledLine(since: number, now: number): string;
 /** The lines a row shows under its title: an orchestrator's bar, a paused or stalled session's wait, or else a live leaf's activity. */
@@ -49,13 +138,31 @@ export declare function addTreeStatus(ctx: Context, onWaiting?: (sessionID: stri
 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. */
+/** The one place Digby's pixel tokens take a theme colour. */
+export declare const digbyColours: (theme: Context["theme"]) => Record<Token, RGBA>;
+/**
+ * A row's background at rest: the selection's while the panel has the keyboard, else one step quieter under the pointer,
+ * else none, the panel's.
+ */
+export declare function restBackground(theme: Context["theme"], { selected, hovered }: {
+    selected: boolean;
+    hovered: boolean;
+}): RGBA | undefined;
+/** The usage the `/courier` command shows for an input it does not know, before the further verbs' lines. */
 export declare const USAGE = "/courier tree opens the session tree; /courier stop [session] stops a session and those under it";
+/** A further verb of the `/courier` command, which another module's TUI part supplies: what it runs, and its line of the usage. */
+export type Verb = {
+    readonly run: () => void;
+    readonly usage: string;
+};
+/** The usage with the further verbs' lines. */
+export declare const usageWith: (verbs: Readonly<Record<string, Verb>>) => string;
 /**
  * Adds the tree panel to the `session.panel` slot, opened by `/courier tree` or the palette, which follows the person
- * between sessions until closed, and `/courier stop <session>`, which stops a session under the open one once confirmed.
+ * between sessions until closed, and `/courier stop <session>`, which stops a session under the open one once confirmed;
+ * `verbs` are the command's further verbs, by name.
  */
-export declare function addTreePanel(ctx: Context): () => void;
+export declare function addTreePanel(ctx: Context, verbs?: Readonly<Record<string, Verb>>): () => void;
 /**
  * Draws the person's attention when reports arrive: a join group's reports, released to the session that started them,
  * and a child's report to its parent, with the `subagent_done` sound. Read from the courier's own delivery metadata.