opencode-courier 0.13.8 → 0.15.0

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

@@ -1,6 +1,5 @@
 import type { Plugin } from "@opencode/plugin";
 import type { StopPorts } from "./ports.js";
-/** Serves the tree's RPC at the plugin's location, through the same use cases as the tools; disposed with the plugin. */
 export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "register">, ports: StopPorts): Promise<import("@opencode/plugin/promise/rpc").RpcRegistration<{
     readonly id: "courier";
     readonly methods: {
@@ -74,6 +73,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     })[];
                     readonly stopped?: boolean | undefined;
                     readonly stalled?: number | undefined;
+                    readonly subagent?: boolean | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
@@ -117,6 +117,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     })[];
                     readonly stopped?: boolean | undefined;
                     readonly stalled?: number | undefined;
+                    readonly subagent?: boolean | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
@@ -161,6 +162,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     })[];
                     readonly stopped?: boolean | undefined;
                     readonly stalled?: number | undefined;
+                    readonly subagent?: boolean | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
@@ -204,6 +206,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     })[];
                     readonly stopped?: boolean | undefined;
                     readonly stalled?: number | undefined;
+                    readonly subagent?: boolean | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
@@ -248,6 +251,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     }>>;
                     readonly isolated: import("effect/Schema").Boolean;
                     readonly native: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+                    readonly subagent: 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>;
@@ -290,6 +294,7 @@ export declare function registerTreeRpc(rpc: Pick<Plugin.Context["rpc"], "regist
                     }>>;
                     readonly isolated: import("effect/Schema").Boolean;
                     readonly native: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
+                    readonly subagent: 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>;

package/dist/tree/rpc-handlers.js

@@ -6,7 +6,6 @@ import { treeRpc } from "./rpc.js";
 import { stop } from "./stop.js";
 import { childStore } from "./store.js";
 import { summary } from "./summary.js";
-/** Serves the tree's RPC at the plugin's location, through the same use cases as the tools; disposed with the plugin. */
 export function registerTreeRpc(rpc, ports) {
     const refused = (cause) => (cause instanceof Error ? cause.message : String(cause));
     return rpc.register(treeRpc, {
@@ -31,10 +30,6 @@ export function registerTreeRpc(rpc, ports) {
         },
     });
 }
-/**
- * Forgets a session OpenCode no longer knows as courier_cleanup called from its own parent, once `by` is found above it,
- * as courier_stop checks. A session OpenCode still has, or cannot say it lost, is refused: forgetting it loses its report.
- */
 async function forget(ports, by, sessionID) {
     const chain = await childStore(ports.courier.storage).lineage(sessionID);
     if (!chain.length)

package/dist/tree/rpc.d.ts

@@ -1,13 +1,8 @@
 import { Schema } from "effect";
-/** The sessions started under a session, as the prompt footer's status entry shows them. */
 declare const Summary: Schema.Struct<{
-    /** Running, and waiting on no request or form. */
     readonly running: Schema.Int;
-    /** Waiting on a permission request, a question or a form it shows, which go to the person. */
     readonly waiting: Schema.Int;
-    /** Not running: done, or waiting for a message. */
     readonly idle: Schema.Int;
-    /** Left a courier message waiting while idle, and did not take it once woken again; the session itself counts too. Absent at 0. */
     readonly stalled: Schema.optionalKey<Schema.Int>;
     readonly groups: Schema.$Array<Schema.Struct<{
         readonly name: Schema.String;
@@ -16,7 +11,6 @@ declare const Summary: Schema.Struct<{
     }>>;
 }>;
 export type Summary = typeof Summary.Type;
-/** A request a session waits on until the person answers it: a permission request, its first question, or a form it shows. */
 declare const Wait: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"permission">;
     readonly action: Schema.String;
@@ -28,50 +22,33 @@ declare const Wait: Schema.Union<readonly [Schema.Struct<{
     readonly type: Schema.Literal<"form">;
     readonly title: Schema.String;
 }>]>;
-/** One session of the tree panel: what courier_tree shows of it, and what it is doing, in epoch milliseconds. */
 declare const Row: Schema.Struct<{
     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 subagent: Schema.optionalKey<Schema.Boolean>;
     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;
@@ -88,51 +65,34 @@ declare const Row: Schema.Struct<{
         readonly title: Schema.String;
     }>]>>;
 }>;
-/** The sessions under a session, as courier_tree lists them, in the order a tree is drawn. */
 declare const Tree: Schema.Struct<{
     readonly rows: Schema.$Array<Schema.Struct<{
         readonly sessionID: Schema.String;
         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 subagent: Schema.optionalKey<Schema.Boolean>;
         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;
@@ -149,50 +109,33 @@ 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 subagent: Schema.optionalKey<Schema.Boolean>;
         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;
@@ -209,26 +152,21 @@ declare const Tree: Schema.Struct<{
             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. */
     readonly stalled: Schema.optionalKey<Schema.Number>;
 }>;
 export type Row = typeof Row.Type;
 export type Tree = typeof Tree.Type;
 export type Wait = typeof Wait.Type;
-/** What a stop did to each session, deepest first, as courier_stop reports it. */
 declare const Stopped: Schema.Struct<{
     readonly stopped: Schema.$Array<Schema.Struct<{
         readonly sessionID: Schema.String;
         readonly title: Schema.String;
         readonly outcome: Schema.String;
     }>>;
-    /** How many scheduled messages were cancelled. */
     readonly cancelled: Schema.Int;
 }>;
 export type Stopped = typeof Stopped.Type;
-/** What courier_cleanup did: forgot it, removed its worktree, found that already gone, or kept the worktree, saying why. */
 declare const Forgotten: Schema.Union<readonly [Schema.Struct<{
     readonly outcome: Schema.Literals<readonly ["forgotten", "removed", "gone"]>;
 }>, Schema.Struct<{
@@ -268,13 +206,9 @@ export declare const treeRpc: {
                 readonly waiting: number;
                 readonly stalled?: number | undefined;
             }> & Schema.Struct<{
-                /** Running, and waiting on no request or form. */
                 readonly running: Schema.Int;
-                /** Waiting on a permission request, a question or a form it shows, which go to the person. */
                 readonly waiting: Schema.Int;
-                /** Not running: done, or waiting for a message. */
                 readonly idle: Schema.Int;
-                /** Left a courier message waiting while idle, and did not take it once woken again; the session itself counts too. Absent at 0. */
                 readonly stalled: Schema.optionalKey<Schema.Int>;
                 readonly groups: Schema.$Array<Schema.Struct<{
                     readonly name: Schema.String;
@@ -313,6 +247,7 @@ export declare const treeRpc: {
                     })[];
                     readonly stopped?: boolean | undefined;
                     readonly stalled?: number | undefined;
+                    readonly subagent?: boolean | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
@@ -356,6 +291,7 @@ export declare const treeRpc: {
                     })[];
                     readonly stopped?: boolean | undefined;
                     readonly stalled?: number | undefined;
+                    readonly subagent?: boolean | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
@@ -400,6 +336,7 @@ export declare const treeRpc: {
                     })[];
                     readonly stopped?: boolean | undefined;
                     readonly stalled?: number | undefined;
+                    readonly subagent?: boolean | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
@@ -443,6 +380,7 @@ export declare const treeRpc: {
                     })[];
                     readonly stopped?: boolean | undefined;
                     readonly stalled?: number | undefined;
+                    readonly subagent?: boolean | undefined;
                     readonly group?: {
                         readonly name: string;
                         readonly standing: string;
@@ -470,45 +408,29 @@ export declare const treeRpc: {
                     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 subagent: Schema.optionalKey<Schema.Boolean>;
                     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;
@@ -525,50 +447,33 @@ 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 subagent: Schema.optionalKey<Schema.Boolean>;
                     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;
@@ -585,13 +490,10 @@ export declare const treeRpc: {
                         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. */
                 readonly stalled: Schema.optionalKey<Schema.Number>;
             }>;
         };
-        /** Stops `sessionID` and everything under it, as courier_stop called from `by`, which must be above it. */
         readonly stop: {
             readonly input: import("effect/StandardSchema").StandardSchemaV1<{
                 readonly sessionID: string;
@@ -623,14 +525,12 @@ export declare const treeRpc: {
                     readonly title: Schema.String;
                     readonly outcome: Schema.String;
                 }>>;
-                /** How many scheduled messages were cancelled. */
                 readonly cancelled: Schema.Int;
             }>;
             readonly errors: {
                 readonly refused: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
             };
         };
-        /** Forgets `sessionID` as courier_cleanup called from its parent, without `force`; `by` must be above it. */
         readonly cleanup: {
             readonly input: import("effect/StandardSchema").StandardSchemaV1<{
                 readonly sessionID: string;

package/dist/tree/rpc.js

@@ -1,87 +1,53 @@
-/**
- * The tree's RPC, the contract its TUI part and its server half share. Standard Schema values, so the promise
- * API's `rpc.register` and the TUI's `client.rpc` both type it; imports only `@opencode/plugin/rpc` and `effect`.
- */
+// rpc.register and client.rpc both take Standard Schema (api-notes)
 import { Rpc } from "@opencode/plugin/rpc";
 import { Schema } from "effect";
 const Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
-/** A join group the session opened, with how many of its members have reported and how many have not left. */
 const Group = Schema.Struct({ name: Schema.String, reported: Count, members: Count });
-/** The sessions started under a session, as the prompt footer's status entry shows them. */
 const Summary = Schema.Struct({
-    /** Running, and waiting on no request or form. */
     running: Count,
-    /** Waiting on a permission request, a question or a form it shows, which go to the person. */
     waiting: Count,
-    /** Not running: done, or waiting for a message. */
     idle: Count,
-    /** Left a courier message waiting while idle, and did not take it once woken again; the session itself counts too. Absent at 0. */
     stalled: Schema.optionalKey(Count),
     groups: Schema.Array(Group),
 });
-/** A request a session waits on until the person answers it: a permission request, its first question, or a form it shows. */
 const Wait = Schema.Union([
     Schema.Struct({ type: Schema.Literal("permission"), action: Schema.String, resources: Schema.Array(Schema.String) }),
     Schema.Struct({ type: Schema.Literal("question"), question: Schema.String }),
     Schema.Struct({ type: Schema.Literal("form"), title: Schema.String }),
 ]);
-/** One session of the tree panel: what courier_tree shows of it, and what it is doing, in epoch milliseconds. */
 const Row = Schema.Struct({
     sessionID: Schema.String,
     parentID: Schema.String,
     title: Schema.String,
-    /** A child of the panel's session is at depth 1. */
     depth: Count,
-    /**
-     * `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.
-     */
     state: Schema.Literals(["running", "waiting", "idle", "stalled", "gone"]),
-    /** Since when its oldest message that did not wake it has waited, when it is stalled. */
     stalled: Schema.optionalKey(Schema.Number),
-    /** How its last turn ended. */
     outcome: Schema.optionalKey(Schema.Literals(["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. */
     resumes: Schema.optionalKey(Schema.Number),
-    /** Set when courier_stop stopped it since its last prompt. */
     stopped: Schema.optionalKey(Schema.Boolean),
-    /** Its report since its last prompt: still owed, arrived (held with its group or delivered), or its turn ended without one. */
     report: Schema.optionalKey(Schema.Struct({ state: Schema.Literals(["owed", "reported", "ended"]), status: Schema.optionalKey(Schema.String), progressed: Schema.Boolean })),
-    /** Its join group, and its standing there: `held`, `out`, how it left, or `released`. */
     group: Schema.optionalKey(Schema.Struct({ name: Schema.String, standing: Schema.String })),
     isolated: Schema.Boolean,
-    /** Set when it is OpenCode's subagent of its parent (a native child), which OpenCode's session lists leave out. */
     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. */
+    subagent: Schema.optionalKey(Schema.Boolean),
     model: Schema.optionalKey(Schema.String),
     created: Schema.Number,
-    /** When its last turn ended, if it is not running. */
     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),
 });
-/** 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. */
     stalled: Schema.optionalKey(Schema.Number),
 });
-/** What a stop did to each session, deepest first, as courier_stop reports it. */
 const Stopped = Schema.Struct({
     stopped: Schema.Array(Schema.Struct({ sessionID: Schema.String, title: Schema.String, outcome: Schema.String })),
-    /** How many scheduled messages were cancelled. */
     cancelled: Count,
 });
-/** What courier_cleanup did: forgot it, removed its worktree, found that already gone, or kept the worktree, saying why. */
 const Forgotten = Schema.Union([
     Schema.Struct({ outcome: Schema.Literals(["forgotten", "removed", "gone"]) }),
     Schema.Struct({ outcome: Schema.Literal("kept"), reason: Schema.String }),
@@ -97,13 +63,11 @@ export const treeRpc = Rpc.define({
             input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String })),
             output: Schema.toStandardSchemaV1(Tree),
         },
-        /** Stops `sessionID` and everything under it, as courier_stop called from `by`, which must be above it. */
         stop: {
             input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String, by: Schema.String })),
             output: Schema.toStandardSchemaV1(Stopped),
             errors: { refused: Schema.toStandardSchemaV1(Schema.Struct({})) },
         },
-        /** Forgets `sessionID` as courier_cleanup called from its parent, without `force`; `by` must be above it. */
         cleanup: {
             input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String, by: Schema.String })),
             output: Schema.toStandardSchemaV1(Forgotten),

package/dist/tree/running.d.ts

@@ -1,18 +1,12 @@
 import type { Plugin } from "@opencode/plugin";
 import { type BusyTimes } from "./domain.js";
 type Session = Pick<Plugin.Context["session"], "context">;
-/** Whether a session runs and, when it does not, when its last turn ended, where known. */
 export interface Turn {
     readonly running: boolean;
     readonly endedAt?: number;
 }
 type Messages = Awaited<ReturnType<Session["context"]>>;
-/**
- * Whether a session runs and, at rest, when its last turn ended: by its times when they show rest, else by its transcript
- * (#324, #326), kept until the next stamp, a rest for `REST_MS` and not within `FRESH_MS` of it; one unread or empty runs.
- */
 export declare function turnOf(session: Session, sessionID: string, time: BusyTimes, now?: number): Promise<Turn>;
-/** `turnOf` for a caller that reads the transcript itself: it answers from these `messages`, read just now, and keeps the answer. */
 export declare function turnIn(session: Session, sessionID: string, time: BusyTimes, messages: Promise<Messages>, now?: number): Promise<Turn>;
 export declare const runs: (session: Session, sessionID: string, time: BusyTimes, now?: number) => Promise<boolean>;
 export {};

package/dist/tree/running.js

@@ -1,24 +1,17 @@
 import { millis } from "../platform/json.js";
 import { setBounded } from "../platform/bounded.js";
 import { busy, endedAt, turnEnd } from "./domain.js";
-/** How many sessions' answers each session port remembers. */
 const ANSWERS_MAX = 500;
-/** How long after its stamp an answer of rest is read again: an item enqueued then may be delivered, stamping nothing until its step. */
+// a delivered item stamps nothing until its first step (api-notes)
 const FRESH_MS = 10_000;
-/** How long an answer of rest is kept: an item waiting since a lost wake is delivered on the wake sent again, which stamps nothing. */
+// a re-sent wake's delivery stamps nothing until its step (api-notes)
 const REST_MS = 30_000;
 const RUNNING = { running: true };
 const rest = (at) => (at === undefined ? { running: false } : { running: false, endedAt: at });
-/** Each session port's last answer per session, which holds until the next stamp, but for those `turnOf` drops or keeps `until`. */
 const answers = new WeakMap();
-/**
- * Whether a session runs and, at rest, when its last turn ended: by its times when they show rest, else by its transcript
- * (#324, #326), kept until the next stamp, a rest for `REST_MS` and not within `FRESH_MS` of it; one unread or empty runs.
- */
 export function turnOf(session, sessionID, time, now = Date.now()) {
     return resolve(session, sessionID, time, now, () => session.context({ sessionID }), true);
 }
-/** `turnOf` for a caller that reads the transcript itself: it answers from these `messages`, read just now, and keeps the answer. */
 export function turnIn(session, sessionID, time, messages, now = Date.now()) {
     return resolve(session, sessionID, time, now, () => messages, false);
 }
@@ -31,7 +24,6 @@ function resolve(session, sessionID, time, now, load, cached) {
     const found = known.get(sessionID);
     if (cached && found?.stamp === stamp && now < found.until)
         return found.turn;
-    // Only its own answer: a newer read of the session may have taken its place meanwhile.
     const forget = () => {
         if (known.get(sessionID) === answer)
             known.delete(sessionID);

package/dist/tree/send.d.ts

@@ -7,8 +7,4 @@ export interface SendInput {
     readonly artifacts?: Artifacts;
     readonly queue?: boolean;
 }
-/**
- * Drops a message into another session's inbox; OpenCode wakes that session if it is idle. From a spawned session
- * to the one that started it, it is its report or its progress (`noteReport`); a group member's final report is held (`hold`).
- */
 export declare function send(ports: CourierPorts, from: string, input: SendInput): Promise<Sent>;