opencode-courier 0.7.1 → 0.7.3

package/README.md

@@ -21,7 +21,7 @@ The edge cases on the live terminal UI, narrated ([what it shows](#demos)).
 ## Quickstart
 
 ```bash
-npm install -g @opencode/cli@2.0.30   # OpenCode V2, at the version courier is tested on
+npm install -g @opencode/cli@2.0.32   # OpenCode V2, at the version courier is tested on
 opencode plugin add opencode-courier  # by name, so OpenCode offers new releases
 opencode                              # in any folder
 ```
@@ -43,9 +43,9 @@ sometimes stall on a request; if nothing moves for a few minutes, send the promp
 
 Courier is built on OpenCode V2's plugin API (`@opencode/plugin`), not the V1 one
 (`@opencode-ai/plugin`), and needs OpenCode V2. Each release is pinned to one V2 version and tested
-against it end to end; the current one is tested on **OpenCode 2.0.30**. CI also runs the live
+against it end to end; the current one is tested on **OpenCode 2.0.32**. CI also runs the live
 suite on the newest OpenCode release, on `main` and nightly, so a host release that breaks the
-plugin shows up there first. Older releases and their versions: [Supported OpenCode version](#supported-opencode-version).
+plugin shows up there first. Older releases and their versions: [every release](docs/reference.md#the-opencode-version).
 
 ## Courier or the built-in subagent tool?
 
@@ -111,24 +111,23 @@ pinned to its version. OpenCode never checks it:
 the plugin installs and loads on any V2 host, and on a version other than the pinned one writes one
 line to the server log naming both ([more](docs/reference.md#the-opencode-version)).
 
+<!-- compat-table:start rows=3: generated by script/compat-table.ts from the release tags -->
 | opencode-courier | OpenCode V2 (`opencode` and `@opencode/plugin`) |
 |---|---|
+| 0.7.3 | 2.0.32 |
+| 0.7.2 | 2.0.31 |
 | 0.7.1 | 2.0.30 |
-| 0.5.0, 0.6.0, 0.7.0 | 2.0.29 |
-| 0.4.0, 0.4.1 | 2.0.28 |
-| 0.2.3, 0.3.0 | 2.0.26 |
-| 0.2.2 | 2.0.24 |
-| 0.2.1 | 2.0.23 |
-| 0.2.0 | 2.0.22 |
-| 0.1.6 | 0.0.0-beta-19271 (the beta line: `opencode2` from `@opencode-ai/cli`, and `@opencode-ai/plugin`) |
+<!-- compat-table:end -->
+
+Older releases and their versions: [every release](docs/reference.md#the-opencode-version).
 
 The [terminal part](#in-the-terminal) relies on the host to provide its UI modules and is tested on
-OpenCode 2.0.30 only; the server part works as before on older V2 hosts from 2.0.4 on.
+OpenCode 2.0.32 only; the server part works as before on older V2 hosts from 2.0.4 on.
 
 Check yours with `opencode --version`, and install the matching CLI with:
 
 ```bash
-npm install -g @opencode/cli@2.0.30
+npm install -g @opencode/cli@2.0.32
 ```
 
 ### The plugin
@@ -271,17 +270,34 @@ courier 1 waiting on you · 2 running · group pair 1/2
 ```
 
 `/courier tree` opens a panel beside the session with the tree under it, a row per session indented
-by depth, with what it does, its report and its group's standing; a session waiting on you gets a line per
+by depth, with a mark and colour from your theme for its state (`✓` reported, a spinner `⠋` while it runs, `●` waiting on you, `!` stalled,
+`✗` failed or interrupted), what it does, its report and its group's standing; a session waiting on you gets a line per
 request or form (`shows a form: Web Search`), a stalled one since when its message waits, a session that started others gets
-a bar of the parts reported, a leaf how long it ran, its last tool call and its cost. A tree that has
+a bar of the parts reported, a leaf how long it ran, its last tool call, how full its context is (`ctx 31%`, in the warning colour past 80%) and its cost. A tree that has
 started more than `maxTotal` sessions over time is listed live ones first, then newest, and the header
 says how many older ones are left out; the footer counts them all. `↑`/`↓` select,
-`enter` opens the session, `s` stops it and everything under it after you confirm, as `courier_stop`
+`enter` or a click opens the session, a row under the pointer is highlighted, `s` stops it and everything under it after you confirm, as `courier_stop`
 would, `x` forgets a `gone` session after you confirm, removing its worktree by `courier_cleanup`'s
 rules, and `q` closes the panel; `/courier stop <session>` stops from the prompt. While open, the panel
 follows you between sessions: into one of its tree it keeps that tree, the session on screen marked
 `(on screen)`; elsewhere it shows that session's tree, or hides while you are in a session without one,
 or on the home screen, and shows again once you are back in one; only `q` closes it for good.
+A row whose report arrives flashes in your theme's success colour and fades back over 1.5 s, and the header's bar
+grows to its new length; nothing in the footer moves. Next to the header's title digs Digby, the courier's mole, drawn
+in your theme's colours, whose state follows the tree's: a breathing mound while all is idle, a trembling one while
+children run, up with a blinking sign while one waits on you, slumped while one is stalled, popping up with a letter
+for a report and raising mounds for a spawn. Where the panel has room the tree does not use, on an empty panel or 10
+rows free below the last row, a larger Digby, 16 by 8, shows the same state there instead, paws, sign, letter and all
+([more](docs/reference.md#in-the-terminal)).
+To keep the panel still (`•` for a running row, no flash, the bar at once, Digby in each state's first frame), give the TUI part `"animations": false` in OpenCode's terminal config, `~/.config/opencode/cli.json`:
+the TUI passes options to its plugins only from there, not from the server's `opencode.json`, and has no animations
+setting a plugin can read ([more](docs/reference.md#in-the-terminal)).
+
+```jsonc
+{
+  "plugins": [{ "package": "opencode-courier", "options": { "animations": false } }]
+}
+```
 
 `ctrl+x k` (the leader key, then `k`), `/asks` (or `/ask`), the palette's "Courier: what waits on you" or a click
 on "waiting on you" opens the asks inbox: every permission request, question and form waiting

package/dist/index.js

@@ -87,6 +87,7 @@ export const courier = () => Plugin.define({
             directory: ctx.location.directory,
             projectID: ctx.location.project.id,
             now: Date.now,
+            windows: async () => (await ctx.model.list()).data.map((model) => ({ providerID: model.providerID, id: model.id, context: model.limit.context })),
             head: headOf,
             dirty: dirtyOf,
             pending: async (sessionID) => {

package/dist/platform/version.js

@@ -1,5 +1,5 @@
 import { readFileSync } from "node:fs";
-const README_TABLE = "https://github.com/ivopogace/opencode-courier#supported-opencode-version";
+const VERSION_TABLE = "https://github.com/ivopogace/opencode-courier/blob/main/docs/reference.md#the-opencode-version";
 /**
  * Reads from the package's own package.json, next to `dist/` as to `src/`: `version` and the exact
  * `@opencode/plugin` devDependency version, which the peer repeats. Throws if either is missing.
@@ -25,5 +25,5 @@ export function versionNotice(built, app) {
     const running = version === undefined ? "this server reports no version" : `this server is ${version}`;
     const channel = typeof app?.channel === "string" ? ` (channel ${app.channel})` : "";
     return (`opencode-courier ${built.plugin} was built and tested against OpenCode ${built.opencode}; ${running}${channel}. ` +
-        `Its tools may fail: see the Supported OpenCode version table in the README, ${README_TABLE}`);
+        `Its tools may fail: see every release and the OpenCode it is pinned to, ${VERSION_TABLE}`);
 }

package/dist/tree/mascot.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A pixel of Digby, the tree panel's mole, as the theme colour it takes: `b` body, `k` background (eyes), `g` mound,
+ * `m` muted (paws, dirt, post, arm), `a` accent (snout, letter), `w`, `e` and `s` warning, error and success (sign, dots, spark).
+ */
+export type Token = "b" | "k" | "g" | "m" | "a" | "w" | "e" | "s";
+/** What Digby shows: the tree's state, or for a while after one arrives, a spawn or a report. */
+export type MascotState = "idle" | "spawn" | "running" | "waiting" | "stalled" | "report" | "gone";
+/** One cell of a drawing: `▀` the top pixel's colour over the bottom's, `▄` only a bottom pixel, `█` both alike, or a character. */
+export type Cell = {
+    readonly char: string;
+    readonly fg?: Token;
+    readonly bg?: Token;
+};
+/** Digby's frames take one panel frame in this many, about every 450 ms. */
+export declare const MASCOT_EVERY = 5;
+/** He blinks on every this-many-th of his frames where his eyes are open. */
+export declare const BLINK_EVERY = 11;
+/**
+ * The 8×4 glyph's frames by state, pixel rows top to bottom; a state with several cycles through them, one per mascot frame.
+ * No muted pixel touches the mound, here or in the 16×16, as `text.muted` is close to `background.raised.max`.
+ */
+export declare const GLYPH: Readonly<Record<MascotState, ReadonlyArray<ReadonlyArray<string>>>>;
+/** The 8×4 glyph's pixels for `state` at mascot frame `frame`, its first frame with none: animations off. */
+export declare function glyph(state: MascotState, frame?: number): ReadonlyArray<string>;
+/** Pixel rows, two to a line of cells, by the half-block rule; an odd last row has nothing under it. */
+export declare function cells(pixels: ReadonlyArray<string>): ReadonlyArray<ReadonlyArray<Cell>>;
+/** How his eyes are drawn: one pixel each, `wide` two tall, `shut` two wide, or `none` (blinking). */
+export type Eyes = "open" | "wide" | "shut" | "none";
+/**
+ * The 16×16 Digby, his head raised by `rise` (0 in the hole, 1 fully up; below 0 out of sight) over a body in the hole,
+ * then the mound (its top row `top` wide, `shift` columns over) and the ground, both `mound`, drawn over it but for the hole.
+ */
+export declare function digby(rise: number, { top, eyes, slump, shift, mound }?: {
+    top?: number;
+    eyes?: Eyes;
+    slump?: boolean;
+    shift?: number;
+    mound?: "g" | "m";
+}): ReadonlyArray<string>;
+/** A spot of `pixels` with its first at row `row`, column `column`; `.` leaves what is under it. */
+type Spot = readonly [row: number, column: number, pixels: string];
+/** `pixels` with `spots` drawn over them. */
+export declare function paint(pixels: ReadonlyArray<string>, spots: ReadonlyArray<Spot>): ReadonlyArray<string>;
+/** The 16×16's frames by state but idle, each its pixels with the eyes open or, for a blink, not; the first reads alone. */
+export declare const ART: Readonly<Record<Exclude<MascotState, "idle">, ReadonlyArray<(open: boolean) => ReadonlyArray<string>>>>;
+/** The 16×16 idle Digby at mascot frame `frame`, its first with none: the mound breathing, a `z` drifting up beside it. */
+export declare function idleArt(frame?: number): ReadonlyArray<ReadonlyArray<Cell>>;
+/** The 16×16 Digby for `state` at mascot frame `frame`, its first frame with none: animations off. */
+export declare function art(state: MascotState, frame?: number): ReadonlyArray<ReadonlyArray<Cell>>;
+export {};

package/dist/tree/mascot.js

@@ -0,0 +1,171 @@
+/** Digby's frames take one panel frame in this many, about every 450 ms. */
+export const MASCOT_EVERY = 5;
+/** He blinks on every this-many-th of his frames where his eyes are open. */
+export const BLINK_EVERY = 11;
+/**
+ * The 8×4 glyph's frames by state, pixel rows top to bottom; a state with several cycles through them, one per mascot frame.
+ * No muted pixel touches the mound, here or in the 16×16, as `text.muted` is close to `background.raised.max`.
+ */
+export const GLYPH = {
+    idle: [["........", "........", "..gggg..", "gggggggg"]],
+    spawn: [
+        ["........", "...bb...", "g.bbbb.g", "gggggggg"],
+        [".g....g.", "...bb...", "ggbbbbgg", "gggggggg"],
+    ],
+    running: [
+        ["..g..g..", "...bb...", ".gbbbbg.", "gggggggg"],
+        [".g....g.", "........", ".gbbbbg.", "gggggggg"],
+    ],
+    waiting: [
+        [".bbbbbbw", ".bkbbkbw", ".bbaabbm", "ggggggg."],
+        [".bbbbbbb", ".bkbbkbb", ".bbaabbm", "ggggggg."],
+    ],
+    stalled: [
+        ["..e.....", ".bbbbbb.", ".bkbbkb.", "gbbaabbg"],
+        ["..e.e...", ".bbbbbb.", ".bkbbkb.", "gbbaabbg"],
+        ["..e.e.e.", ".bbbbbb.", ".bkbbkb.", "gbbaabbg"],
+    ],
+    report: [
+        ["......aa", "bbbbbbaa", "bkbbkbm.", "bbaabbm."],
+        ["s.....aa", "bbbbbbaa", "bkbbkbm.", "bbaabbm."],
+    ],
+    gone: [["........", ".mmmmmm.", ".mkmmkm.", "mmmmmmmm"]],
+};
+/** The states in which his eyes are open, so he blinks. */
+const OPEN_EYES = new Set(["waiting", "report"]);
+/** The 8×4 glyph's pixels for `state` at mascot frame `frame`, its first frame with none: animations off. */
+export function glyph(state, frame) {
+    const frames = GLYPH[state];
+    const pixels = frames[(frame ?? 0) % frames.length];
+    if (frame === undefined)
+        return pixels;
+    if (state === "idle" && breathesOut(frame))
+        return [...pixels.slice(0, 2), ".gggggg.", ...pixels.slice(3)];
+    return OPEN_EYES.has(state) && blinks(frame) ? pixels.map((row) => row.replaceAll("k", "b")) : pixels;
+}
+/** The mound's top row widens for two frames in four. */
+const breathesOut = (frame) => Math.floor(frame / 2) % 2 === 1;
+const blinks = (frame) => frame % BLINK_EVERY === BLINK_EVERY - 1;
+/** Pixel rows, two to a line of cells, by the half-block rule; an odd last row has nothing under it. */
+export function cells(pixels) {
+    const lines = [];
+    for (let row = 0; row < pixels.length; row += 2) {
+        const top = pixels[row];
+        const bottom = pixels[row + 1] ?? "";
+        lines.push([...top].map((pixel, column) => cell(token(pixel), token(bottom[column]))));
+    }
+    return lines;
+}
+const token = (pixel) => (pixel && pixel !== "." ? pixel : undefined);
+function cell(top, bottom) {
+    if (!top && !bottom)
+        return { char: " " };
+    if (!top)
+        return { char: "▄", fg: bottom };
+    if (top === bottom)
+        return { char: "█", fg: top };
+    return bottom ? { char: "▀", fg: top, bg: bottom } : { char: "▀", fg: top };
+}
+/** The 16×16's size, in pixels. */
+const SIZE = 16;
+/** How far each of the head's rows leans right when he slumps. */
+const SLUMP = [2, 2, 2, 1, 1, 0, 0];
+/**
+ * The 16×16 Digby, his head raised by `rise` (0 in the hole, 1 fully up; below 0 out of sight) over a body in the hole,
+ * then the mound (its top row `top` wide, `shift` columns over) and the ground, both `mound`, drawn over it but for the hole.
+ */
+export function digby(rise, { top = 6, eyes = "open", slump = false, shift = 0, mound = "g" } = {}) {
+    const grid = Array.from({ length: SIZE }, () => new Array(SIZE).fill("."));
+    const span = (row, width, pixel, skip = (_column) => false, by = 0) => {
+        if (row < 0 || row >= SIZE)
+            return;
+        for (let column = (SIZE - width) / 2; column < (SIZE + width) / 2; column++)
+            if (!skip(column))
+                grid[row][column + by] = pixel;
+    };
+    const head = Math.round(10 - 8 * rise);
+    const lean = (at) => (slump ? SLUMP[at] : 0);
+    [4, 6, 8, 8, 8, 6, 4].forEach((width, at) => span(head + at, width, "b", undefined, lean(at)));
+    for (let row = head + 7; row <= 11; row++)
+        span(row, 4, "b");
+    const eyeColumns = eyes === "shut" ? [5, 6, 9, 10] : [6, 9];
+    if (eyes !== "none")
+        span(head + 3, 8, "k", (column) => !eyeColumns.includes(column), lean(3));
+    if (eyes === "wide")
+        span(head + 2, 8, "k", (column) => !eyeColumns.includes(column), lean(2));
+    span(head + 4, 2, "a", undefined, lean(4));
+    span(10, SIZE, ".", (column) => column >= 6 && column <= 9);
+    span(10, top, mound, (column) => column >= 6 && column <= 9, shift);
+    span(11, 10, mound, undefined, shift);
+    span(12, 12, mound, undefined, shift);
+    for (const row of [13, 14, 15])
+        span(row, SIZE, mound);
+    return grid.map((row) => row.join(""));
+}
+/** `pixels` with `spots` drawn over them. */
+export function paint(pixels, spots) {
+    const grid = pixels.map((row) => [...row]);
+    for (const [row, column, drawn] of spots)
+        [...drawn].forEach((pixel, at) => {
+            if (pixel !== "." && grid[row]?.[column + at] !== undefined)
+                grid[row][column + at] = pixel;
+        });
+    return grid.map((row) => row.join(""));
+}
+/** A column of `length` pixels of `pixel` from row `row`. */
+const post = (row, column, length, pixel) => Array.from({ length }, (_, at) => [row + at, column, pixel]);
+/** The head's top row at `rise`, where running's snout pokes up. */
+const headTop = (rise) => Math.round(10 - 8 * rise);
+const running = (rise, shift, dirt) => paint(digby(rise, { shift }), [[headTop(rise), 7, "aa"], ...dirt]);
+/** A child's head peeking out of a side mound at columns `column`–`column + 2`, `up` or half sunk. */
+const peek = (column, up) => [
+    ...(up ? [[8, column, ".b."], [9, column, "bkb"]] : [[9, column, ".b."]]),
+    [10, column, "gbg"],
+    [11, column, "ggg"],
+];
+const spawn = (up, dirt) => paint(digby(0.1), [...peek(0, up), ...peek(13, up), [12, 0, "gg"], [12, 14, "gg"], ...dirt]);
+/** The sign on its post, which stops a pixel above the ground so the muted post does not sit on it. */
+const sign = (shown) => [...(shown ? [[2, 13, "www"], [3, 13, "wkw"], [4, 13, "www"]] : []), ...post(5, 14, 7, "m")];
+/** His paws, held a pixel above the mound's rim so the muted pixels do not touch it. */
+const waiting = (shown) => (open) => paint(digby(1, { eyes: open ? "wide" : "none" }), [[8, 4, "mm"], [8, 10, "mm"], ...sign(shown)]);
+const stalled = (dots) => () => paint(digby(0.7, { eyes: "shut", slump: true }), [[5, 0, dots]]);
+/** The letter held up on his arm, which stops a pixel above the mound so it does not touch it, and the spark beside him. */
+const report = (rise, spark) => (open) => paint(digby(rise, { eyes: open ? "open" : "none" }), [
+    [0, 12, "aaaa"],
+    [1, 12, "akka"],
+    [2, 12, "aaaa"],
+    ...post(3, 13, 8, "m"),
+    ...spark.map((row, at) => [1 + at, 0, row]),
+]);
+/** The 16×16's frames by state but idle, each its pixels with the eyes open or, for a blink, not; the first reads alone. */
+export const ART = {
+    spawn: [
+        () => spawn(true, [[3, 1, "m"], [5, 3, "m"], [2, 14, "m"], [5, 12, "m"]]),
+        () => spawn(false, [[1, 0, "m"], [4, 2, "m"], [3, 15, "m"], [6, 13, "m"]]),
+    ],
+    running: [
+        () => running(0.22, 0, [[5, 2, "m"], [7, 1, "m"], [4, 13, "m"], [6, 14, "m"]]),
+        () => running(0.12, 1, [[3, 1, "m"], [6, 3, "m"], [5, 12, "m"], [3, 15, "m"]]),
+    ],
+    waiting: [waiting(true), waiting(false)],
+    stalled: [stalled("e.e.e"), stalled("e"), stalled("e.e")],
+    report: [report(1, [".s.", "sss", ".s."]), report(1.25, ["s.s", ".s.", "s.s"]), report(1.1, [".s.", "sss", ".s."])],
+    gone: [() => digby(-0.3, { mound: "m" })],
+};
+/** Where idle's `z` drifts up, by cell line, one step per mascot frame, then gone a frame. */
+const Z_LINES = [3, 2, 1, undefined];
+/** The 16×16 idle Digby at mascot frame `frame`, its first with none: the mound breathing, a `z` drifting up beside it. */
+export function idleArt(frame) {
+    const lines = cells(digby(-0.3, { top: frame !== undefined && breathesOut(frame) ? 8 : 6 }));
+    const line = Z_LINES[(frame ?? 0) % Z_LINES.length];
+    if (line === undefined)
+        return lines;
+    return lines.map((cellsOf, at) => (at === line ? cellsOf.map((one, column) => (column === 13 ? { char: "z", fg: "m" } : one)) : cellsOf));
+}
+/** The 16×16 Digby for `state` at mascot frame `frame`, its first frame with none: animations off. */
+export function art(state, frame) {
+    if (state === "idle")
+        return idleArt(frame);
+    const frames = ART[state];
+    return cells(frames[(frame ?? 0) % frames.length](!(frame !== undefined && OPEN_EYES.has(state) && blinks(frame))));
+}

package/dist/tree/panel.d.ts

@@ -1,4 +1,4 @@
-import type { CourierPorts, Pending, ShownForm } from "./ports.js";
+import type { CourierPorts, ModelWindow, 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. */
@@ -6,6 +6,8 @@ export declare function lastTool(messages: Messages): {
     name: string;
     at: number;
 } | undefined;
+/** How full a session's context is, as OpenCode's session view reads it (packages/tui/src/util/session.ts, v2.0.32): the last usage since the last compaction over its model's window. */
+export declare function contextOf(messages: Messages, windows: ReadonlyArray<ModelWindow>): number | 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;
 /** A form a session shows, as the panel says what it waits on. */

package/dist/tree/panel.js

@@ -15,6 +15,17 @@ export function lastTool(messages) {
     }
     return undefined;
 }
+/** How full a session's context is, as OpenCode's session view reads it (packages/tui/src/util/session.ts, v2.0.32): the last usage since the last compaction over its model's window. */
+export function contextOf(messages, windows) {
+    const compacted = messages.findLastIndex((message) => message.type === "compaction" && message.status === "completed");
+    const last = messages.findLast((message, index) => index > compacted && message.type === "assistant" && message.tokens !== undefined);
+    if (last?.type !== "assistant" || !last.tokens)
+        return undefined;
+    const { input, output, reasoning, cache } = last.tokens;
+    const used = input + output + reasoning + cache.read + cache.write;
+    const window = windows.find((model) => model.providerID === last.model.providerID && model.id === last.model.id)?.context;
+    return used > 0 && window ? used / window : undefined;
+}
 /** A request as the panel says what a paused session waits on: a permission request, or its first question. */
 export const waitOf = (pending) => pending.type === "permission"
     ? { type: "permission", action: pending.action, resources: [...pending.resources] }
@@ -44,8 +55,8 @@ function stateOf(info, waits, stalled, running) {
         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, info, pending, forms, report }, stalled) {
+/** One session of the panel: what it is doing, its report and group standing, its last tool call, context use and cost. */
+async function row(ports, windows, { entry, depth, info, pending, forms, report }, stalled) {
     const { sessionID } = entry;
     const [messages, status, standing, stopped] = await Promise.all([
         ports.session.context({ sessionID }).catch(() => []),
@@ -55,6 +66,7 @@ async function row(ports, { entry, depth, info, pending, forms, report }, stalle
     ]);
     const running = info !== undefined && busy(info.time);
     const tool = lastTool(messages);
+    const context = contextOf(messages, windows);
     return {
         sessionID,
         parentID: entry.parentID,
@@ -70,6 +82,7 @@ async function row(ports, { entry, depth, info, pending, forms, report }, stalle
         created: info?.time.created ?? entry.createdAt,
         ...(info && !running && info.time.idle !== undefined ? { idle: info.time.idle } : {}),
         ...(info ? { cost: info.cost } : {}),
+        ...(context !== undefined ? { context } : {}),
         ...(tool ? { tool } : {}),
         waits: [...pending.map(waitOf), ...forms.map(formWait)],
     };
@@ -81,7 +94,8 @@ async function row(ports, { entry, depth, info, pending, forms, report }, stalle
 export async function panel(ports, rootID) {
     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 windows = await ports.windows().catch(() => []);
+    const rows = await Promise.all(kept.map((node) => row(ports, windows, 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

@@ -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;

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

@@ -77,6 +77,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                         readonly standing: string;
                     } | undefined;
                     readonly stopped?: boolean | undefined;
+                    readonly context?: number | undefined;
                     readonly idle?: number | undefined;
                     readonly report?: {
                         readonly progressed: boolean;
@@ -118,6 +119,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                         readonly standing: string;
                     } | undefined;
                     readonly stopped?: boolean | undefined;
+                    readonly context?: number | undefined;
                     readonly idle?: number | undefined;
                     readonly report?: {
                         readonly progressed: boolean;
@@ -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;
@@ -240,6 +244,7 @@ export declare const treeRpc: {
                         readonly standing: string;
                     } | undefined;
                     readonly stopped?: boolean | undefined;
+                    readonly context?: number | undefined;
                     readonly idle?: number | undefined;
                     readonly report?: {
                         readonly progressed: boolean;
@@ -281,6 +286,7 @@ export declare const treeRpc: {
                         readonly standing: string;
                     } | undefined;
                     readonly stopped?: boolean | undefined;
+                    readonly context?: number | undefined;
                     readonly idle?: number | undefined;
                     readonly report?: {
                         readonly progressed: boolean;
@@ -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),