opencode-courier 0.13.1 → 0.13.2

package/README.md

@@ -18,7 +18,7 @@ A narrated tour of the terminal UI: the tree panel, the asks inbox, failing chil
 ## Quickstart
 
 ```bash
-npm install -g @opencode/cli@2.2.1   # OpenCode V2, the version courier is tested on
+npm install -g @opencode/cli@2.2.2   # OpenCode V2, the version courier is tested on
 opencode plugin add opencode-courier
 opencode
 ```
@@ -62,10 +62,10 @@ split a task and how to check and merge the parts. Every detail: [the reference]
 ## Install
 
 Requires OpenCode V2: the `opencode` command from `@opencode/cli`. Each release is tested against
-one OpenCode version; this one is tested on **OpenCode 2.2.1** (check with `opencode --version`).
+one OpenCode version; this one is tested on **OpenCode 2.2.2** (check with `opencode --version`).
 
 ```bash
-npm install -g @opencode/cli@2.2.1
+npm install -g @opencode/cli@2.2.2
 opencode plugin add opencode-courier
 ```
 
@@ -78,13 +78,13 @@ name, without a version: OpenCode offers updates only for an entry without an ex
 <!-- compat-table:start rows=3: generated by script/compat-table.ts from the release tags -->
 | opencode-courier | OpenCode V2 (`opencode` and `@opencode/plugin`) |
 |---|---|
+| 0.13.2 | 2.2.2 |
 | 0.13.1 | 2.2.1 |
 | 0.13.0 | 2.2.0 |
-| 0.11.1, 0.12.0 | 2.1.4 |
 <!-- compat-table:end -->
 
 Every release: [the full table](docs/reference.md#the-opencode-version). The server part loads on
-any V2 host from 2.0.4 on. The terminal part is tested on OpenCode 2.2.1 only.
+any V2 host from 2.0.4 on. The terminal part is tested on OpenCode 2.2.2 only.
 
 ## Options
 
@@ -128,7 +128,7 @@ Parameters and behaviour: [the reference](docs/reference.md#the-tools).
 ## In the terminal
 
 - **Footer:** `courier 1 waiting on you · 2 running · group pair 1/2`.
-- **`/courier tree`:** a panel with the tree. `enter` opens a session, `s` stops it, `q` closes.
+- **`/courier tree`:** a panel with the tree, the session it was opened in as its first row. `enter` opens a session, `s` stops it, `q` closes.
 - **`/courier stop <session>`:** stops a session and everything under it.
 - **`ctrl+x k`** or **`/asks`:** every ask waiting on you in the tree, answered in a dialog.
 - **`/courier memory`:** the project's tree records. `p` pins one, `x` forgets one.

package/dist/tree/domain.d.ts

@@ -24,11 +24,11 @@ export declare function readNativeChildren(options: unknown): {
 };
 /** A session's times, as `session.get` gives them. */
 type Times = Awaited<ReturnType<Context["session"]["get"]>>["time"];
-/** A session's times as `busy` reads them. */
-export type BusyTimes = Pick<Times, "updated" | "idle">;
+/** A session's times as `busy` reads them; `busy`, when its latest execution started, is stamped since OpenCode 2.2.2. */
+export type BusyTimes = Pick<Times, "updated" | "idle" | "busy">;
 /**
- * Whether a session may run by its times: it has never finished a turn, or `updated` was stamped after the last one ended, as
- * a step does, and as much that is no activity does (a rename, an archive, a waiting inbox item), so only its transcript tells.
+ * Whether a session may run by its times: it has never finished a turn, or its latest execution started after the last one ended
+ * (`busy`; without it `updated`, which a rename, an archive or a waiting inbox item also stamp); only its transcript then tells.
  */
 export declare const busy: (time: BusyTimes) => boolean;
 /** A stored message as `turnEnd` reads it: an assistant message's `error` says how its step ended. */

package/dist/tree/domain.js

@@ -24,10 +24,10 @@ export function readNativeChildren(options) {
     return { nativeChildren: false, problems: [`nativeChildren must be true or false, not ${JSON.stringify(value)}; using false`] };
 }
 /**
- * Whether a session may run by its times: it has never finished a turn, or `updated` was stamped after the last one ended, as
- * a step does, and as much that is no activity does (a rename, an archive, a waiting inbox item), so only its transcript tells.
+ * Whether a session may run by its times: it has never finished a turn, or its latest execution started after the last one ended
+ * (`busy`; without it `updated`, which a rename, an archive or a waiting inbox item also stamp); only its transcript then tells.
  */
-export const busy = (time) => time.idle === undefined || millis(time.updated) > millis(time.idle);
+export const busy = (time) => time.idle === undefined || millis(time.busy ?? time.updated) > millis(time.idle);
 /** The messages the person's switch of agent or model, move or shell command appends, at rest or mid-turn alike. */
 const ASIDES = new Set(["agent-switched", "model-switched", "location-switched", "shell"]);
 /**

package/dist/tree/panel.d.ts

@@ -13,8 +13,8 @@ export declare const waitOf: (pending: Pending) => Wait;
 /** A form a session shows, as the panel says what it waits on. */
 export declare const formWait: (form: ShownForm) => Wait;
 /**
- * The tree panel's rows: the sessions under a session as courier_tree lists them, at most `maxTotal`, the live ones
- * first, then the newest, each as `row` reads it; `truncated` counts the older ones left out, and `stalled` says the root is.
+ * The tree panel's rows: the sessions under a session as courier_tree lists them, at most `maxTotal`, live ones first,
+ * then the newest, each as `row` reads it; `top` the session itself, `truncated` the ones left out, `stalled` its stall.
  */
 export declare function panel(ports: CourierPorts, rootID: string): Promise<Tree>;
 export {};

package/dist/tree/panel.js

@@ -2,7 +2,7 @@ import { startedAs } from "./domain.js";
 import { lastStatus, stoppedSincePrompt } from "./report.js";
 import { standingIn } from "./status.js";
 import { childStore } from "./store.js";
-import { readTree } from "./subtree.js";
+import { readTop, readTree } from "./subtree.js";
 import { stalledAmong } from "./wake.js";
 /** The last tool call in a session's messages, and when it was made. */
 export function lastTool(messages) {
@@ -91,14 +91,17 @@ async function row(ports, windows, { entry, depth, info, running, endedAt, pendi
     };
 }
 /**
- * The tree panel's rows: the sessions under a session as courier_tree lists them, at most `maxTotal`, the live ones
- * first, then the newest, each as `row` reads it; `truncated` counts the older ones left out, and `stalled` says the root is.
+ * The tree panel's rows: the sessions under a session as courier_tree lists them, at most `maxTotal`, live ones first,
+ * then the newest, each as `row` reads it; `top` the session itself, `truncated` the ones left out, `stalled` its stall.
  */
 export async function panel(ports, rootID) {
-    const { kept, leftOut } = await readTree(ports, rootID);
+    const [{ kept, leftOut }, root] = await Promise.all([readTree(ports, rootID), readTop(ports, rootID)]);
     const stalled = await stalledAmong(ports, [rootID, ...kept.map((node) => node.entry.sessionID)]);
     const windows = await ports.models().catch(() => []);
-    const rows = await Promise.all(kept.map((node) => row(ports, windows, node, stalled.get(node.entry.sessionID))));
+    const [rows, top] = await Promise.all([
+        Promise.all(kept.map((node) => row(ports, windows, node, stalled.get(node.entry.sessionID)))),
+        root && row(ports, windows, root, stalled.get(rootID)),
+    ]);
     const own = stalled.get(rootID);
-    return { rows, ...(leftOut ? { truncated: leftOut } : {}), ...(own !== undefined ? { stalled: own } : {}) };
+    return { rows, ...(top ? { top } : {}), ...(leftOut ? { truncated: leftOut } : {}), ...(own !== undefined ? { stalled: own } : {}) };
 }

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

@@ -96,6 +96,48 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     readonly resumes?: number | undefined;
                 }[];
                 readonly stalled?: number | undefined;
+                readonly top?: {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly depth: number;
+                    readonly isolated: boolean;
+                    readonly parentID: string;
+                    readonly created: number;
+                    readonly state: "gone" | "stalled" | "running" | "idle" | "waiting";
+                    readonly waits: readonly ({
+                        readonly type: "permission";
+                        readonly action: string;
+                        readonly resources: readonly string[];
+                    } | {
+                        readonly type: "question";
+                        readonly question: string;
+                    } | {
+                        readonly type: "form";
+                        readonly title: string;
+                    })[];
+                    readonly stopped?: boolean | undefined;
+                    readonly stalled?: number | undefined;
+                    readonly group?: {
+                        readonly name: string;
+                        readonly standing: string;
+                    } | undefined;
+                    readonly cost?: number | undefined;
+                    readonly context?: number | undefined;
+                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
+                    readonly report?: {
+                        readonly progressed: boolean;
+                        readonly state: "ended" | "reported" | "owed";
+                        readonly status?: string | undefined;
+                    } | undefined;
+                    readonly idle?: number | undefined;
+                    readonly native?: boolean | undefined;
+                    readonly model?: string | undefined;
+                    readonly tool?: {
+                        readonly name: string;
+                        readonly at: number;
+                    } | undefined;
+                    readonly resumes?: number | undefined;
+                } | undefined;
                 readonly truncated?: number | undefined;
             }, {
                 readonly rows: readonly {
@@ -141,6 +183,48 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     readonly resumes?: number | undefined;
                 }[];
                 readonly stalled?: number | undefined;
+                readonly top?: {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly depth: number;
+                    readonly isolated: boolean;
+                    readonly parentID: string;
+                    readonly created: number;
+                    readonly state: "gone" | "stalled" | "running" | "idle" | "waiting";
+                    readonly waits: readonly ({
+                        readonly type: "permission";
+                        readonly action: string;
+                        readonly resources: readonly string[];
+                    } | {
+                        readonly type: "question";
+                        readonly question: string;
+                    } | {
+                        readonly type: "form";
+                        readonly title: string;
+                    })[];
+                    readonly stopped?: boolean | undefined;
+                    readonly stalled?: number | undefined;
+                    readonly group?: {
+                        readonly name: string;
+                        readonly standing: string;
+                    } | undefined;
+                    readonly cost?: number | undefined;
+                    readonly context?: number | undefined;
+                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
+                    readonly report?: {
+                        readonly progressed: boolean;
+                        readonly state: "ended" | "reported" | "owed";
+                        readonly status?: string | undefined;
+                    } | undefined;
+                    readonly idle?: number | undefined;
+                    readonly native?: boolean | undefined;
+                    readonly model?: string | undefined;
+                    readonly tool?: {
+                        readonly name: string;
+                        readonly at: number;
+                    } | undefined;
+                    readonly resumes?: number | undefined;
+                } | undefined;
                 readonly truncated?: number | undefined;
             }> & import("effect/Schema").Struct<{
                 readonly rows: import("effect/Schema").$Array<import("effect/Schema").Struct<{
@@ -185,6 +269,48 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                         readonly title: import("effect/Schema").String;
                     }>]>>;
                 }>>;
+                readonly top: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                    readonly sessionID: import("effect/Schema").String;
+                    readonly parentID: import("effect/Schema").String;
+                    readonly title: import("effect/Schema").String;
+                    readonly depth: import("effect/Schema").Int;
+                    readonly state: import("effect/Schema").Literals<readonly ["running", "waiting", "idle", "stalled", "gone"]>;
+                    readonly stalled: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+                    readonly outcome: import("effect/Schema").optionalKey<import("effect/Schema").Literals<readonly ["succeeded", "failed", "interrupted"]>>;
+                    readonly resumes: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
+                    readonly stopped: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+                    readonly report: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                        readonly state: import("effect/Schema").Literals<readonly ["owed", "reported", "ended"]>;
+                        readonly status: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+                        readonly progressed: import("effect/Schema").Boolean;
+                    }>>;
+                    readonly group: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
+                        readonly name: import("effect/Schema").String;
+                        readonly standing: import("effect/Schema").String;
+                    }>>;
+                    readonly isolated: import("effect/Schema").Boolean;
+                    readonly native: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+                    readonly model: import("effect/Schema").optionalKey<import("effect/Schema").String>;
+                    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;
+                    }>>;
+                    readonly waits: import("effect/Schema").$Array<import("effect/Schema").Union<readonly [import("effect/Schema").Struct<{
+                        readonly type: import("effect/Schema").Literal<"permission">;
+                        readonly action: import("effect/Schema").String;
+                        readonly resources: import("effect/Schema").$Array<import("effect/Schema").String>;
+                    }>, import("effect/Schema").Struct<{
+                        readonly type: import("effect/Schema").Literal<"question">;
+                        readonly question: import("effect/Schema").String;
+                    }>, import("effect/Schema").Struct<{
+                        readonly type: import("effect/Schema").Literal<"form">;
+                        readonly title: import("effect/Schema").String;
+                    }>]>>;
+                }>>;
                 readonly truncated: import("effect/Schema").optionalKey<import("effect/Schema").Int>;
                 readonly stalled: import("effect/Schema").optionalKey<import("effect/Schema").Number>;
             }>;

package/dist/tree/rpc.d.ts

@@ -149,6 +149,66 @@ declare const Tree: Schema.Struct<{
             readonly title: Schema.String;
         }>]>>;
     }>>;
+    /** The panel's own session, at depth 0; absent when OpenCode no longer knows it, and from an older server. */
+    readonly top: Schema.optionalKey<Schema.Struct<{
+        readonly sessionID: Schema.String;
+        readonly parentID: Schema.String;
+        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 or a form it shows them; `stalled` when a courier message waits in its inbox and
+         * waking it again did not start a turn; `gone` when OpenCode no longer knows it.
+         */
+        readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "stalled", "gone"]>;
+        /** Since when its oldest message that did not wake it has waited, when it is stalled. */
+        readonly stalled: Schema.optionalKey<Schema.Number>;
+        /** How its last turn ended. */
+        readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>;
+        /** When the provider limit that failed its last turn lifts; left out once that has passed, or when it runs again or was stopped. */
+        readonly resumes: Schema.optionalKey<Schema.Number>;
+        /** 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"]>;
+            readonly status: Schema.optionalKey<Schema.String>;
+            readonly progressed: Schema.Boolean;
+        }>>;
+        /** Its join group, and its standing there: `held`, `out`, how it left, or `released`. */
+        readonly group: Schema.optionalKey<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly standing: Schema.String;
+        }>>;
+        readonly isolated: Schema.Boolean;
+        /** Set when it is OpenCode's subagent of its parent (a native child), which OpenCode's session lists leave out. */
+        readonly native: Schema.optionalKey<Schema.Boolean>;
+        /** The model it was started on, `provider/model` with `#variant` when one is set, when that is not its parent's. */
+        readonly model: Schema.optionalKey<Schema.String>;
+        readonly created: Schema.Number;
+        /** When its last turn ended, if it is not running. */
+        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;
+            readonly at: Schema.Number;
+        }>>;
+        readonly waits: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"permission">;
+            readonly action: Schema.String;
+            readonly resources: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"question">;
+            readonly question: Schema.String;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"form">;
+            readonly title: Schema.String;
+        }>]>>;
+    }>>;
     /** 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>;
     /** Since when a courier message has waited in the panel's own session, when that session is stalled. */
@@ -275,6 +335,48 @@ export declare const treeRpc: {
                     readonly resumes?: number | undefined;
                 }[];
                 readonly stalled?: number | undefined;
+                readonly top?: {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly depth: number;
+                    readonly isolated: boolean;
+                    readonly parentID: string;
+                    readonly created: number;
+                    readonly state: "gone" | "stalled" | "running" | "idle" | "waiting";
+                    readonly waits: readonly ({
+                        readonly type: "permission";
+                        readonly action: string;
+                        readonly resources: readonly string[];
+                    } | {
+                        readonly type: "question";
+                        readonly question: string;
+                    } | {
+                        readonly type: "form";
+                        readonly title: string;
+                    })[];
+                    readonly stopped?: boolean | undefined;
+                    readonly stalled?: number | undefined;
+                    readonly group?: {
+                        readonly name: string;
+                        readonly standing: string;
+                    } | undefined;
+                    readonly cost?: number | undefined;
+                    readonly context?: number | undefined;
+                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
+                    readonly report?: {
+                        readonly progressed: boolean;
+                        readonly state: "ended" | "reported" | "owed";
+                        readonly status?: string | undefined;
+                    } | undefined;
+                    readonly idle?: number | undefined;
+                    readonly native?: boolean | undefined;
+                    readonly model?: string | undefined;
+                    readonly tool?: {
+                        readonly name: string;
+                        readonly at: number;
+                    } | undefined;
+                    readonly resumes?: number | undefined;
+                } | undefined;
                 readonly truncated?: number | undefined;
             }, {
                 readonly rows: readonly {
@@ -320,6 +422,48 @@ export declare const treeRpc: {
                     readonly resumes?: number | undefined;
                 }[];
                 readonly stalled?: number | undefined;
+                readonly top?: {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly depth: number;
+                    readonly isolated: boolean;
+                    readonly parentID: string;
+                    readonly created: number;
+                    readonly state: "gone" | "stalled" | "running" | "idle" | "waiting";
+                    readonly waits: readonly ({
+                        readonly type: "permission";
+                        readonly action: string;
+                        readonly resources: readonly string[];
+                    } | {
+                        readonly type: "question";
+                        readonly question: string;
+                    } | {
+                        readonly type: "form";
+                        readonly title: string;
+                    })[];
+                    readonly stopped?: boolean | undefined;
+                    readonly stalled?: number | undefined;
+                    readonly group?: {
+                        readonly name: string;
+                        readonly standing: string;
+                    } | undefined;
+                    readonly cost?: number | undefined;
+                    readonly context?: number | undefined;
+                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
+                    readonly report?: {
+                        readonly progressed: boolean;
+                        readonly state: "ended" | "reported" | "owed";
+                        readonly status?: string | undefined;
+                    } | undefined;
+                    readonly idle?: number | undefined;
+                    readonly native?: boolean | undefined;
+                    readonly model?: string | undefined;
+                    readonly tool?: {
+                        readonly name: string;
+                        readonly at: number;
+                    } | undefined;
+                    readonly resumes?: number | undefined;
+                } | undefined;
                 readonly truncated?: number | undefined;
             }> & Schema.Struct<{
                 readonly rows: Schema.$Array<Schema.Struct<{
@@ -381,6 +525,66 @@ export declare const treeRpc: {
                         readonly title: Schema.String;
                     }>]>>;
                 }>>;
+                /** The panel's own session, at depth 0; absent when OpenCode no longer knows it, and from an older server. */
+                readonly top: Schema.optionalKey<Schema.Struct<{
+                    readonly sessionID: Schema.String;
+                    readonly parentID: Schema.String;
+                    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 or a form it shows them; `stalled` when a courier message waits in its inbox and
+                     * waking it again did not start a turn; `gone` when OpenCode no longer knows it.
+                     */
+                    readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "stalled", "gone"]>;
+                    /** Since when its oldest message that did not wake it has waited, when it is stalled. */
+                    readonly stalled: Schema.optionalKey<Schema.Number>;
+                    /** How its last turn ended. */
+                    readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>;
+                    /** When the provider limit that failed its last turn lifts; left out once that has passed, or when it runs again or was stopped. */
+                    readonly resumes: Schema.optionalKey<Schema.Number>;
+                    /** 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"]>;
+                        readonly status: Schema.optionalKey<Schema.String>;
+                        readonly progressed: Schema.Boolean;
+                    }>>;
+                    /** Its join group, and its standing there: `held`, `out`, how it left, or `released`. */
+                    readonly group: Schema.optionalKey<Schema.Struct<{
+                        readonly name: Schema.String;
+                        readonly standing: Schema.String;
+                    }>>;
+                    readonly isolated: Schema.Boolean;
+                    /** Set when it is OpenCode's subagent of its parent (a native child), which OpenCode's session lists leave out. */
+                    readonly native: Schema.optionalKey<Schema.Boolean>;
+                    /** The model it was started on, `provider/model` with `#variant` when one is set, when that is not its parent's. */
+                    readonly model: Schema.optionalKey<Schema.String>;
+                    readonly created: Schema.Number;
+                    /** When its last turn ended, if it is not running. */
+                    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;
+                        readonly at: Schema.Number;
+                    }>>;
+                    readonly waits: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly type: Schema.Literal<"permission">;
+                        readonly action: Schema.String;
+                        readonly resources: Schema.$Array<Schema.String>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"question">;
+                        readonly question: Schema.String;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"form">;
+                        readonly title: Schema.String;
+                    }>]>>;
+                }>>;
                 /** 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>;
                 /** Since when a courier message has waited in the panel's own session, when that session is stalled. */

package/dist/tree/rpc.js

@@ -68,6 +68,8 @@ const Row = Schema.Struct({
 /** 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),
+    /** The panel's own session, at depth 0; absent when OpenCode no longer knows it, and from an older server. */
+    top: Schema.optionalKey(Row),
     /** 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),
     /** Since when a courier message has waited in the panel's own session, when that session is stalled. */

package/dist/tree/running.js

@@ -27,7 +27,7 @@ function resolve(session, sessionID, time, now, load, cached) {
         return Promise.resolve(rest(millis(time.idle)));
     const known = answers.get(session) ?? new Map();
     answers.set(session, known);
-    const stamp = `${millis(time.updated)} ${millis(time.idle)}`;
+    const stamp = [time.updated, time.idle, time.busy].map(millis).join(" ");
     const found = known.get(sessionID);
     if (cached && found?.stamp === stamp && now < found.until)
         return found.turn;

package/dist/tree/subtree.d.ts

@@ -37,6 +37,13 @@ export interface Listed extends Looked {
 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[]>;
+/** One session looked up, as `lookUp` does each; `info` when the caller already has it. */
+export declare function look(ports: ReadPorts, node: Below, known?: Info): Promise<Looked>;
+/**
+ * The session a subtree is read from, looked up and listed as its own sessions are, at depth 0: its roster entry when it
+ * was spawned, else one made of OpenCode's info of it; none when OpenCode does not know it.
+ */
+export declare function readTop(ports: ReadPorts, rootID: string): Promise<Listed | undefined>;
 /**
  * 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.

package/dist/tree/subtree.js

@@ -37,17 +37,41 @@ function drawn(byParent, parentID) {
 /** 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(() => []),
-        ]);
-        const turn = info === undefined ? undefined : await turnOf(ports.session, node.entry.sessionID, info.time);
-        const running = turn?.running ?? false;
-        // A form outlives its session's turn only when its withdrawal was missed, as while no instance followed the events.
-        return { ...node, info, running, ...(turn?.endedAt !== undefined ? { endedAt: turn.endedAt } : {}), pending, forms: running ? forms : [] };
-    }));
+    return Promise.all(nodes.map((node) => look(ports, node)));
+}
+/** One session looked up, as `lookUp` does each; `info` when the caller already has it. */
+export async function look(ports, node, known) {
+    const [info, pending, forms] = await Promise.all([
+        known ?? ports.session.get({ sessionID: node.entry.sessionID }).catch(() => undefined),
+        ports.pending(node.entry.sessionID).catch(() => []),
+        ports.forms(node.entry.sessionID).catch(() => []),
+    ]);
+    const turn = info === undefined ? undefined : await turnOf(ports.session, node.entry.sessionID, info.time);
+    const running = turn?.running ?? false;
+    // A form outlives its session's turn only when its withdrawal was missed, as while no instance followed the events.
+    return { ...node, info, running, ...(turn?.endedAt !== undefined ? { endedAt: turn.endedAt } : {}), pending, forms: running ? forms : [] };
+}
+/**
+ * The session a subtree is read from, looked up and listed as its own sessions are, at depth 0: its roster entry when it
+ * was spawned, else one made of OpenCode's info of it; none when OpenCode does not know it.
+ */
+export async function readTop(ports, rootID) {
+    const info = await ports.session.get({ sessionID: rootID }).catch(() => undefined);
+    if (!info)
+        return undefined;
+    const children = childStore(ports.storage);
+    const spawned = await children.indexedEntry(rootID).catch(() => undefined);
+    const entry = spawned ?? {
+        sessionID: rootID,
+        parentID: info.parentID ?? "",
+        title: info.title ?? "",
+        directory: info.location.directory,
+        isolated: false,
+        createdAt: info.time.created,
+    };
+    const looked = await look(ports, { entry, depth: 0 }, info);
+    const report = await reportOf(children, rootID).catch(() => undefined);
+    return { ...looked, report, live: isLive(looked.running, looked.pending.length + looked.forms.length, report) };
 }
 /**
  * The listing of at most `max` of the sessions under a session: the live ones first, then the newest, with what is

package/dist/tree/tui.d.ts

@@ -130,6 +130,14 @@ export declare const activityLine: (row: Row, now: number) => string;
 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. */
 export declare function detailLines(row: Row, rows: ReadonlyArray<Row>, now: number): string[];
+/**
+ * Each row's tree guides, by session, for rows in the order a tree is drawn, below depth `base`: before its mark ("│ ├ "),
+ * and before its detail lines, which carry a line down to its first child ("│ │ ").
+ */
+export declare function guides(rows: ReadonlyArray<Row>, base: number): Map<string, {
+    row: string;
+    detail: string;
+}>;
 /** How often the footer and the panel ask again with no event: the scheduler flags a stalled session without one. */
 export declare const REREAD_MS = 15000;
 /**

package/dist/tree/wake.js

@@ -1,3 +1,4 @@
+import { millis } from "../platform/json.js";
 import { busy, endsIdle } from "./domain.js";
 import { wakeStore } from "./store.js";
 /** How long a courier message may wait in an idle session's inbox before its wake counts as missed. */
@@ -86,12 +87,13 @@ export async function wakeMissed(ports, claimed) {
     await Promise.all(due.map((wake) => wakeAgain(ports, store, wake, now).finally(() => claimed.delete(claimOf(wake)))));
 }
 const claimOf = (wake) => `wake ${wake.sessionID} ${wake.inboxID}`;
+/** Since when a message has waited in an idle session: it was enqueued, seen waiting as the turn ended, or sent again, whichever is last. */
+const waitingSince = (wake) => Math.max(wake.idleAt ?? wake.at, wake.rewoken ?? 0);
 /** Whether a message has waited in an idle session past `WAKE_MS`, and since a wake again, if one was sent; a stalled one is done. */
 export function missed(wake, now) {
     if (wake.running || wake.stalled !== undefined)
         return false;
-    const since = Math.max(wake.idleAt ?? wake.at, wake.rewoken ?? 0);
-    return now - since >= WAKE_MS;
+    return now - waitingSince(wake) >= WAKE_MS;
 }
 async function wakeAgain(ports, store, wake, now) {
     try {
@@ -100,7 +102,7 @@ async function wakeAgain(ports, store, wake, now) {
         if (!current || !missed(current, now))
             return;
         // A shutdown during a step reads as an end, and the turn the next boot resumes may start unseen: that turn takes the message.
-        if (await runsNow(ports, wake.sessionID)) {
+        if (await runsNow(ports, current)) {
             const { idleAt: _, ...running } = current;
             return await store.put({ ...running, running: true });
         }
@@ -127,10 +129,18 @@ async function wakeAgain(ports, store, wake, now) {
         ports.log(`courier wake: could not wake ${wake.sessionID} again for ${wake.inboxID}: ${String(error)}`);
     }
 }
-/** Whether a session shows a turn running, by its times and its transcript read now; one that cannot be read does not, and is woken again. */
-async function runsNow(ports, sessionID) {
+/**
+ * Whether a session shows a turn running that takes the message: by `time.busy` (2.2.2), an execution started since the message was
+ * last left waiting and not ended; without it, by its times and its transcript read now. One that cannot be read does not, and is woken again.
+ */
+async function runsNow(ports, wake) {
+    const { sessionID } = wake;
     const info = await ports.session.get({ sessionID }).catch(() => undefined);
-    if (!info || !busy(info.time))
+    if (!info)
+        return false;
+    if (info.time.busy !== undefined)
+        return busy(info.time) && millis(info.time.busy) >= waitingSince(wake);
+    if (!busy(info.time))
         return false;
     const messages = await ports.session.context({ sessionID }).catch(() => []);
     return messages.length > 0 && !endsIdle(messages);

package/dist/tui.js

@@ -1468,6 +1468,7 @@ var Row = Schema3.Struct({
 });
 var Tree = Schema3.Struct({
   rows: Schema3.Array(Row),
+  top: Schema3.optionalKey(Row),
   truncated: Schema3.optionalKey(Count3),
   stalled: Schema3.optionalKey(Schema3.Number)
 });
@@ -1841,6 +1842,31 @@ function detailLines(row, rows, now) {
     return [bar(started)];
   return row.state === "gone" ? [] : [activityLine(row, now)];
 }
+function guides(rows, base) {
+  const byID = new Map(rows.map((row) => [row.sessionID, row]));
+  const later = new Set;
+  const parents = new Set;
+  rows.forEach((row, index) => {
+    if (rows.slice(index + 1).some((next) => next.parentID === row.parentID))
+      later.add(row.sessionID);
+    parents.add(row.parentID);
+  });
+  const above = (row) => {
+    const parent = row.depth > base + 1 ? byID.get(row.parentID) : undefined;
+    return parent ? [...above(parent), parent] : [];
+  };
+  const line = (row) => later.has(row.sessionID) ? "\u2502 " : "  ";
+  const branch = (row) => later.has(row.sessionID) ? "\u251C " : "\u2514 ";
+  return new Map(rows.map((row) => {
+    const through = above(row).map(line).join("");
+    const below = row.depth > base;
+    const down = parents.has(row.sessionID) ? "\u2502 " : "  ";
+    return [row.sessionID, {
+      row: through + (below ? branch(row) : ""),
+      detail: through + (below ? line(row) : "") + down
+    }];
+  }));
+}
 function courierOf(ctx) {
   const courier = ctx.client.rpc(treeRpc);
   const location = (sessionID) => ctx.data.session.get(sessionID)?.location ?? ctx.location ?? ctx.data.location.default();
@@ -2084,6 +2110,11 @@ function TreePanel(props) {
     tree: view.tree
   };
   const rows = () => latest()?.tree?.rows ?? [];
+  const top = () => latest()?.tree?.top;
+  const listed = () => {
+    const own = top();
+    return own ? [own, ...rows()] : rows();
+  };
   createEffect(() => {
     const tree = latest()?.tree;
     if (tree)
@@ -2115,7 +2146,7 @@ function TreePanel(props) {
   const [selectedID, setSelectedID] = createSignal();
   let placed = false;
   createEffect(() => {
-    const found = placed ? undefined : rows().find((row) => row.sessionID === input.sessionID);
+    const found = placed ? undefined : listed().find((row) => row.sessionID === input.sessionID);
     if (!found)
       return;
     placed = true;
@@ -2124,24 +2155,24 @@ function TreePanel(props) {
   let at = 0;
   const selected = createMemo(() => {
     const id = selectedID();
-    const found = rows().findIndex((row) => row.sessionID === id);
-    const index = found >= 0 ? found : Math.min(at, rows().length - 1);
+    const found = listed().findIndex((row) => row.sessionID === id);
+    const index = found >= 0 ? found : Math.min(at, listed().length - 1);
     at = Math.max(index, 0);
     return index;
   });
   createEffect(() => {
-    const row = rows()[selected()];
+    const row = listed()[selected()];
     if (row && row.sessionID !== selectedID())
       setSelectedID(row.sessionID);
   });
-  const current = () => rows()[selected()];
+  const current = () => listed()[selected()];
   let scroll;
   createEffect(() => {
     if (selected() >= 0)
       scroll?.scrollChildIntoView(`courier-row-${selected()}`);
   });
   const move = (by) => {
-    const next = rows()[Math.max(0, Math.min(rows().length - 1, selected() + by))];
+    const next = listed()[Math.max(0, Math.min(listed().length - 1, selected() + by))];
     if (next)
       setSelectedID(next.sessionID);
   };
@@ -2157,7 +2188,7 @@ function TreePanel(props) {
   const [hovered, setHovered] = createSignal();
   createEffect(() => {
     const id = hovered();
-    if (id !== undefined && !rows().some((row) => row.sessionID === id))
+    if (id !== undefined && !listed().some((row) => row.sessionID === id))
       setHovered(undefined);
   });
   let pressed;
@@ -2165,9 +2196,19 @@ function TreePanel(props) {
     setSelectedID(row.sessionID);
     openRow(row);
   };
+  const ownRow = (row, key) => {
+    if (row.sessionID !== view.root)
+      return false;
+    ctx.ui.toast.show({
+      title: "courier",
+      message: `${key} acts on a session under "${oneLine3(row.title)}", the panel's own.`,
+      variant: "warning"
+    });
+    return true;
+  };
   const stopSelected = () => {
     const row = current();
-    if (row)
+    if (row && !ownRow(row, "s"))
       confirmStop(ctx, courier, location, view.root, {
         sessionID: row.sessionID,
         title: row.title,
@@ -2176,7 +2217,7 @@ function TreePanel(props) {
   };
   const forgetSelected = () => {
     const row = current();
-    if (!row)
+    if (!row || ownRow(row, "x"))
       return;
     if (row.state !== "gone")
       return ctx.ui.toast.show({
@@ -2261,7 +2302,9 @@ function TreePanel(props) {
   const glyphShown = () => height() >= GLYPH_ROWS && size().width >= GLYPH_COLUMNS;
   const artShown = () => empty() && height() >= ART_ROWS;
   const [listHeight, setListHeight] = createSignal(0);
-  const treeLines = () => rows().reduce((lines, row) => lines + 1 + detailLines(row, rows(), now()).length, 0);
+  const lines = (row) => detailLines(row, row.depth ? rows() : [], now());
+  const guided = createMemo(() => guides(listed(), top() ? 0 : 1));
+  const treeLines = () => listed().reduce((count, row) => count + 1 + lines(row).length, 0);
   const belowShown = () => rows().length > 0 && listHeight() - treeLines() >= BELOW_ROWS;
   const headerGlyph = () => glyphShown() && !artShown() && !belowShown();
   const mascot = createMemo(() => mascotState(rows(), {
@@ -2317,9 +2360,9 @@ function TreePanel(props) {
     return theme.text.muted;
   };
   return (() => {
-    var _el$6 = _$createElement("box"), _el$7 = _$createElement("box"), _el$8 = _$createElement("text"), _el$20 = _$createElement("scrollbox"), _el$22 = _$createElement("text");
+    var _el$6 = _$createElement("box"), _el$7 = _$createElement("box"), _el$8 = _$createElement("text"), _el$17 = _$createElement("scrollbox"), _el$22 = _$createElement("text");
     _$insertNode(_el$6, _el$7);
-    _$insertNode(_el$6, _el$20);
+    _$insertNode(_el$6, _el$17);
     _$insertNode(_el$6, _el$22);
     _$setProp(_el$6, "flexDirection", "column");
     _$setProp(_el$6, "flexGrow", 1);
@@ -2394,7 +2437,7 @@ function TreePanel(props) {
         _$effect((_$p) => _$setProp(_el$12, "fg", theme.text.muted, _$p));
         return _el$11;
       }
-    }), _el$20);
+    }), _el$17);
     _$insert(_el$6, _$createComponent(Show, {
       get when() {
         return latest()?.error;
@@ -2406,10 +2449,10 @@ function TreePanel(props) {
         _$effect((_$p) => _$setProp(_el$13, "fg", theme.text.feedback.error.base, _$p));
         return _el$13;
       }
-    }), _el$20);
+    }), _el$17);
     _$insert(_el$6, _$createComponent(Show, {
       get when() {
-        return latest()?.tree?.stalled;
+        return _$memo(() => !!!top())() && latest()?.tree?.stalled;
       },
       get children() {
         var _el$15 = _$createElement("text"), _el$16 = _$createTextNode(`This session is stalled: `);
@@ -2418,49 +2461,18 @@ function TreePanel(props) {
         _$effect((_$p) => _$setProp(_el$15, "fg", theme.text.feedback.error.base, _$p));
         return _el$15;
       }
-    }), _el$20);
-    _$insert(_el$6, _$createComponent(Show, {
-      get when() {
-        return _$memo(() => !!latest()?.tree)() && !rows().length;
-      },
-      get children() {
-        return [(() => {
-          var _el$17 = _$createElement("text");
-          _$insertNode(_el$17, _$createTextNode(`No session started with courier_spawn under this one.`));
-          _$effect((_$p) => _$setProp(_el$17, "fg", theme.text.muted, _$p));
-          return _el$17;
-        })(), _$createComponent(Show, {
-          get when() {
-            return artShown();
-          },
-          get children() {
-            var _el$19 = _$createElement("box");
-            _$setProp(_el$19, "flexDirection", "column");
-            _$setProp(_el$19, "flexShrink", 0);
-            _$setProp(_el$19, "paddingTop", 1);
-            _$insert(_el$19, _$createComponent(Index, {
-              get each() {
-                return art2();
-              },
-              children: (line) => drawn(line)
-            }));
-            return _el$19;
-          }
-        })];
-      }
-    }), _el$20);
-    _$use((value) => scroll = value, _el$20);
-    _$setProp(_el$20, "flexGrow", 1);
-    _$setProp(_el$20, "onSizeChange", function() {
+    }), _el$17);
+    _$use((value) => scroll = value, _el$17);
+    _$setProp(_el$17, "flexGrow", 1);
+    _$setProp(_el$17, "onSizeChange", function() {
       setListHeight(this.height);
     });
-    _$insert(_el$20, _$createComponent(For, {
+    _$insert(_el$17, _$createComponent(For, {
       get each() {
-        return rows();
+        return listed();
       },
       children: (row, index) => {
         const chosen = () => index() === selected();
-        const indent = "  ".repeat(row.depth - 1);
         return (() => {
           var _el$24 = _$createElement("box"), _el$25 = _$createElement("box"), _el$26 = _$createElement("text"), _el$27 = _$createElement("text"), _el$28 = _$createTextNode(` `), _el$29 = _$createElement("text"), _el$30 = _$createElement("text");
           _$insertNode(_el$24, _el$25);
@@ -2486,8 +2498,20 @@ function TreePanel(props) {
           _$setProp(_el$25, "flexShrink", 0);
           _$setProp(_el$26, "wrapMode", "none");
           _$setProp(_el$26, "flexShrink", 0);
-          _$insert(_el$26, indent, null);
-          _$insert(_el$26, () => chosen() ? "\u25B8 " : "  ", null);
+          _$insert(_el$26, () => chosen() ? "\u25B8 " : "  ");
+          _$insert(_el$25, _$createComponent(Show, {
+            get when() {
+              return guided().get(row.sessionID)?.row;
+            },
+            children: (guide) => (() => {
+              var _el$32 = _$createElement("text");
+              _$setProp(_el$32, "wrapMode", "none");
+              _$setProp(_el$32, "flexShrink", 0);
+              _$insert(_el$32, guide);
+              _$effect((_$p) => _$setProp(_el$32, "fg", theme.text.muted, _$p));
+              return _el$32;
+            })()
+          }), _el$27);
           _$insertNode(_el$27, _el$28);
           _$setProp(_el$27, "wrapMode", "none");
           _$setProp(_el$27, "flexShrink", 0);
@@ -2509,32 +2533,32 @@ function TreePanel(props) {
                 return at();
               },
               get children() {
-                var _el$32 = _$createElement("text");
-                _$insertNode(_el$32, _$createTextNode(` \xB7 `));
-                _$setProp(_el$32, "wrapMode", "none");
-                _$setProp(_el$32, "flexShrink", 0);
-                _$effect((_$p) => _$setProp(_el$32, "fg", theme.text.muted, _$p));
-                return _el$32;
+                var _el$33 = _$createElement("text");
+                _$insertNode(_el$33, _$createTextNode(` \xB7 `));
+                _$setProp(_el$33, "wrapMode", "none");
+                _$setProp(_el$33, "flexShrink", 0);
+                _$effect((_$p) => _$setProp(_el$33, "fg", theme.text.muted, _$p));
+                return _el$33;
               }
             }), (() => {
-              var _el$34 = _$createElement("text");
-              _$setProp(_el$34, "wrapMode", "none");
-              _$setProp(_el$34, "flexShrink", 0);
-              _$insert(_el$34, () => part.text);
-              _$effect((_$p) => _$setProp(_el$34, "fg", partColor(row, part.kind), _$p));
-              return _el$34;
+              var _el$35 = _$createElement("text");
+              _$setProp(_el$35, "wrapMode", "none");
+              _$setProp(_el$35, "flexShrink", 0);
+              _$insert(_el$35, () => part.text);
+              _$effect((_$p) => _$setProp(_el$35, "fg", partColor(row, part.kind), _$p));
+              return _el$35;
             })()]
           }), null);
           _$insert(_el$24, _$createComponent(For, {
             get each() {
-              return detailLines(row, rows(), now());
+              return lines(row);
             },
             children: (line) => (() => {
-              var _el$35 = _$createElement("text"), _el$36 = _$createTextNode(`    `);
-              _$insertNode(_el$35, _el$36);
-              _$setProp(_el$35, "wrapMode", "none");
-              _$insert(_el$35, indent, _el$36);
-              _$insert(_el$35, _$createComponent(Show, {
+              var _el$36 = _$createElement("text"), _el$37 = _$createTextNode(`  `);
+              _$insertNode(_el$36, _el$37);
+              _$setProp(_el$36, "wrapMode", "none");
+              _$insert(_el$36, () => guided().get(row.sessionID)?.detail ?? "  ", null);
+              _$insert(_el$36, _$createComponent(Show, {
                 get when() {
                   return _$memo(() => row.context !== undefined)() && Math.round(row.context * 100) > CONTEXT_WARN * 100;
                 },
@@ -2545,18 +2569,18 @@ function TreePanel(props) {
                       return line.split(" \xB7 ");
                     },
                     children: (part, at) => [_$memo(() => at() ? " \xB7 " : ""), _$memo(() => _$memo(() => part === `ctx ${Math.round(row.context * 100)}%`)() ? (() => {
-                      var _el$37 = _$createElement("span");
-                      _$insert(_el$37, part);
-                      _$effect((_$p) => _$setProp(_el$37, "style", {
+                      var _el$38 = _$createElement("span");
+                      _$insert(_el$38, part);
+                      _$effect((_$p) => _$setProp(_el$38, "style", {
                         fg: theme.text.feedback.warning.base
                       }, _$p));
-                      return _el$37;
+                      return _el$38;
                     })() : part)]
                   });
                 }
               }), null);
-              _$effect((_$p) => _$setProp(_el$35, "fg", theme.text.muted, _$p));
-              return _el$35;
+              _$effect((_$p) => _$setProp(_el$36, "fg", theme.text.muted, _$p));
+              return _el$36;
             })()
           }), null);
           _$effect((_p$) => {
@@ -2580,7 +2604,38 @@ function TreePanel(props) {
         })();
       }
     }), null);
-    _$insert(_el$20, _$createComponent(Show, {
+    _$insert(_el$17, _$createComponent(Show, {
+      get when() {
+        return _$memo(() => !!latest()?.tree)() && !rows().length;
+      },
+      get children() {
+        return [(() => {
+          var _el$18 = _$createElement("text"), _el$19 = _$createTextNode(`No session started with courier_spawn under this one.`);
+          _$insertNode(_el$18, _el$19);
+          _$insert(_el$18, () => top() ? "    " : "", _el$19);
+          _$effect((_$p) => _$setProp(_el$18, "fg", theme.text.muted, _$p));
+          return _el$18;
+        })(), _$createComponent(Show, {
+          get when() {
+            return artShown();
+          },
+          get children() {
+            var _el$20 = _$createElement("box");
+            _$setProp(_el$20, "flexDirection", "column");
+            _$setProp(_el$20, "flexShrink", 0);
+            _$setProp(_el$20, "paddingTop", 1);
+            _$insert(_el$20, _$createComponent(Index, {
+              get each() {
+                return art2();
+              },
+              children: (line) => drawn(line)
+            }));
+            return _el$20;
+          }
+        })];
+      }
+    }), null);
+    _$insert(_el$17, _$createComponent(Show, {
       get when() {
         return belowShown();
       },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-courier",
-  "version": "0.13.1",
+  "version": "0.13.2",
   "description": "Multi-session orchestration for OpenCode V2: spawn child sessions, be woken by them. No polling.",
   "license": "MIT",
   "author": "Ivo Pogace <71701666+ivopogace@users.noreply.github.com>",
@@ -56,17 +56,17 @@
     "test:e2e": "e2e/run.sh"
   },
   "peerDependencies": {
-    "@opencode/plugin": "2.2.1",
-    "effect": "4.0.1"
+    "@opencode/plugin": "2.2.2",
+    "effect": "4.0.6"
   },
   "devDependencies": {
-    "@opencode/plugin": "2.2.1",
-    "@opencode/theme": "2.2.1",
+    "@opencode/plugin": "2.2.2",
+    "@opencode/theme": "2.2.2",
     "@opentui/core": "0.7.0",
     "@opentui/solid": "0.7.0",
     "@types/bun": "1.4.2",
     "@types/node": "26.6.4",
-    "effect": "4.0.1",
+    "effect": "4.0.6",
     "solid-js": "1.9.17",
     "typescript": "5.9.3"
   }