opencode-courier 0.13.7 → 0.14.0

package/README.md

@@ -23,7 +23,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.5   # OpenCode V2, the version courier is tested on
+npm install -g @opencode/cli@2.2.6   # OpenCode V2, the version courier is tested on
 opencode plugin add opencode-courier
 opencode
 ```
@@ -40,12 +40,12 @@ prompt again.
 
 ## Why courier
 
-OpenCode's own [`subagent` tool](https://opencode.ai/v2/docs/agents) hands back a child's final
+OpenCode's own [`subagent` tool](https://opencode.ai/docs/agents) hands back a child's final
 answer. Use it when one result is all you need. Use courier for more:
 
 - **Messages mid-run.** A child reports progress or asks its parent at any time, and its parent
   passes a finding that changes the other parts on to the children it affects.
-- **Waking an idle session.** A message, a schedule or a GitHub webhook starts a new turn.
+- **Waking an idle session.** A message or a schedule starts a new turn.
 - **Parallel edits.** `isolate: true` gives a child its own git worktree and branch to merge.
 - **Asks reach you.** A child's permission requests and questions come to you through the top
   session. Only you approve a request, in OpenCode's own prompt.
@@ -63,15 +63,16 @@ without reporting is reminded once, in the same turn, and its parent is told onl
 not report. A message that does not wake its session is sent once more, then shown as `stalled`. On
 OpenCode 2.2.0 a parent's system prompt carries one line per child with its state, kept current,
 so it need not look. Children, held reports and scheduled messages survive a restart. The `courier-orchestrate` skill, listed in every session, tells a model when to
-split a task and how to check and merge the parts. Every detail: [the reference](docs/reference.md).
+split a task and how to check and merge the parts; how to plan and review them is left to
+your own skills. Every detail: [the reference](docs/reference.md).
 
 ## 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.5** (check with `opencode --version`).
+one OpenCode version; this one is tested on **OpenCode 2.2.6** (check with `opencode --version`).
 
 ```bash
-npm install -g @opencode/cli@2.2.5
+npm install -g @opencode/cli@2.2.6
 opencode plugin add opencode-courier
 ```
 
@@ -84,13 +85,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.7 | 2.2.5 |
+| 0.14.0 | 2.2.6 |
+| 0.13.7, 0.13.8 | 2.2.5 |
 | 0.13.6 | 2.2.4 |
-| 0.13.5 | 2.2.3 |
 <!-- 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.5 only.
+any V2 host from 2.0.4 on. The terminal part is tested on OpenCode 2.2.6 only.
 
 ## Options
 
@@ -110,7 +111,6 @@ Set the server options on the plugin's entry in the **global** config,
 | `maxTotal` | `30` | Live spawned sessions in one tree. |
 | `memory` | `true` | Keep a record of each session tree for later orchestrators ([memory](docs/reference.md#memory)). |
 | `nativeChildren` | `false` | The default for a spawn that does not set `native`: `true` creates non-isolated children as OpenCode subagents ([native children](docs/reference.md#native-child-sessions)). |
-| `webhook` | off | Start the webhook receiver ([webhooks](docs/reference.md#webhooks)). |
 
 The terminal part reads its options only from `~/.config/opencode/cli.json`, in the same entry
 form. Its one option, `"animations": false`, keeps the tree panel still.
@@ -126,7 +126,6 @@ form. Its one option, `"animations": false`, keeps the tree panel still.
 | `courier_cleanup` | Removes an isolated child's worktree and forgets the child. |
 | `courier_answer` | Proposes an answer to a child's permission request, or passes on your answer to its question. |
 | `courier_later` / `courier_cancel` | Schedules a message for a session, or drops one. |
-| `courier_subscribe` / `courier_unsubscribe` | Subscribes a session to webhook deliveries for a topic, or drops it. |
 | `courier_recall` / `courier_note` | Reads what earlier trees in this project did, or writes this tree's one-line lesson. |
 
 Parameters and behaviour: [the reference](docs/reference.md#the-tools).

package/dist/index.d.ts

@@ -1,13 +1,5 @@
 import { Plugin } from "@opencode/plugin";
 import { Plugin as EffectPlugin } from "@opencode/plugin/effect";
-/**
- * The courier tools and webhook receiver, as a promise plugin joining the hub that runs the scheduler
- * and the watcher; its member carries the location by which the question relay finds its ports.
- */
 export declare const courier: () => Plugin.Plugin;
-/**
- * The plugin OpenCode loads: an Effect plugin, since the question relay wraps OpenCode's question tool
- * and only the Effect API makes its call interruptible; the rest is the promise plugin, adapted.
- */
 declare const _default: EffectPlugin.Plugin<import("effect/Scope").Scope>;
 export default _default;

package/dist/index.js

@@ -10,50 +10,27 @@ import { addSchedulingTools, cancelScheduled, dueJob, isScheduled } from "./sche
 import { addPersonTools, asksPermission, asksQuestion, formsShown, joinRelay, noticeCutOff, pendingOf, pendingQuestions, personEvents, portsAt, registerPersonRpc, relayQuestions, } from "./person/index.js";
 import { addMemoryTools, lessonsOf, memoryEvents, NOTE_TOOL, readMemory, RECALL_TOOL, registerMemoryRpc, sweepRecords } from "./memory/index.js";
 import { addSkill } from "./skill.js";
-import { addTreeTools, deliverReleased, wakeMissed, dirtyOf, headOf, inspectWorktree, onIdle, pruneExpired, readLimits, readNativeChildren, registerTreeRpc, shapeContext, together, treeEvents, waitsOn, } from "./tree/index.js";
-import { addWebhookTools, joinReceiver, readConfig, receiving, subscribedSince, } from "./webhook/index.js";
-/** The spawns under way in the process, outside the hub, so spawns in other locations, copies and hub versions count them. */
+import { addTreeTools, deliverReleased, wakeMissed, dirtyOf, headOf, inspectWorktree, onIdle, pruneExpired, readLimits, readNativeChildren, registerTreeRpc, shapeContext, treeEvents, waitsOn, } from "./tree/index.js";
 const gate = sharedState("spawning", () => ({ reserved: new Set(), turn: Promise.resolve() }));
-/** The type of each item enqueued for a spawned session, outside the hub like the gate. */
 const inbox = sharedState("inbox", () => new Map());
-/** The forms shown now, which the person events keep and the footer and tree panel count; outside the hub like the inbox. */
 const shown = sharedState("formsShown", () => new Map());
-/** What the memory shares: the models' windows, the locations with memory off, the tops that recalled and the turn ends recorded. */
 const memoryState = sharedState("memory", () => ({ windows: new Map(), off: new Set(), tops: new Set(), seen: new Set() }));
-/**
- * What each tick of the scheduler does, in order, through the first loaded member, of whichever copy:
- * due `courier_later` messages, released join groups, then missed wakes. Every hub-v2 member's `later` is its LaterPorts.
- */
 const jobs = [
     dueJob,
     (owner, claimed) => deliverReleased(owner.later, claimed),
     (owner, claimed) => wakeMissed(owner.later, claimed),
 ];
 const { join, track, nudge } = openInProcess(jobs);
-/** The permission domains of the loaded instances: every member's is its location's, whichever copy joined it. */
 const permissions = domains;
-// One set of handled events and of told permission requests for every instance in the process, since
-// several subscriptions and copies see the same events. The scheduler's claim set is the hub's own.
 const { watched } = hub;
 const watchState = { seen: watched.seen, inbox };
 const personState = { ...watched, forms: hub.forms, shown };
-/**
- * What a session waits on outside the tree, for the silent-turn rule, cheapest first: a request of its
- * own to the person, then a scheduled message or a webhook it subscribed to since its last prompt.
- */
-const outside = waitsOn(asksPermission, asksQuestion, together(isScheduled, subscribedSince));
-/** What the hub's subscriptions do with each event of OpenCode's, module by module, in this order. */
+const outside = waitsOn(asksPermission, asksQuestion, isScheduled);
 const eventModules = [treeEvents(watchState, outside), personEvents(personState), memoryEvents(memoryState)];
-/**
- * The courier tools and webhook receiver, as a promise plugin joining the hub that runs the scheduler
- * and the watcher; its member carries the location by which the question relay finds its ports.
- */
 export const courier = () => Plugin.define({
     id: "courier",
     setup: async (ctx) => {
         const log = (message) => console.error(message);
-        // One line per load when this OpenCode is not the version the plugin was built against; the
-        // tools are registered all the same, and no tool result says so.
         try {
             const notice = versionNotice(builtVersions(), ctx.app);
             if (notice)
@@ -85,7 +62,6 @@ export const courier = () => Plugin.define({
             roles,
             nudge,
             log,
-            // What a spawned session gets besides its role: the memory's lessons entry, handed to the tree here as `outside` hands it the `Waits` suppliers.
             entries: () => lessonsOf(memoryPorts),
             session: ctx.session,
             agent: ctx.agent,
@@ -124,36 +100,24 @@ export const courier = () => Plugin.define({
             newID: () => `later_${randomUUID()}`,
             log,
         };
-        const hooks = { storage: ctx.storage, session: ctx.session, now: Date.now, log: later.log };
-        let webhook;
-        try {
-            webhook = readConfig(ctx.options);
-        }
-        catch (error) {
-            later.log(`courier webhook: not started: ${error instanceof Error ? error.message : String(error)}`);
-        }
         const stopPorts = { courier: ports, cancelScheduled: (sessionID) => cancelScheduled(later, sessionID), cleanup: cleanupPorts };
-        // The tools in a fixed order: the tree's, then the person's, the scheduled messages', the webhooks' and the memory's.
         await ctx.tool.transform((tools) => {
             addTreeTools(tools, { courier: ports, cleanup: cleanupPorts, stop: stopPorts });
             addPersonTools(tools, { answer: answerPorts, questions: questionPorts, waiting: watched.waiting });
             addSchedulingTools(tools, later);
-            addWebhookTools(tools, { hooks, receiving });
             addMemoryTools(tools, { memory: memoryPorts, state: memoryState });
         });
         await ctx.skill.transform(addSkill);
-        // What the TUI part reads and its stop; a host that cannot register it still gets the rest, the tools included.
         await Promise.resolve()
             .then(() => registerTreeRpc(ctx.rpc, stopPorts))
             .then(() => registerPersonRpc(ctx.rpc, { questions: questionPorts, permissions }))
             .then(() => registerMemoryRpc(ctx.rpc, memoryPorts))
             .catch((error) => log(`courier rpc: not registered, the TUI part shows nothing and cannot stop: ${String(error)}`));
-        // `instructions` is read off the context as is: a host before 2.2.0 has none, and the hook then adds the role part.
+        // a host before 2.2.0 has no instructions entries (api-notes)
         const instructions = ctx.session.instructions;
         await ctx.session.hook("context", (event) => shapeContext({ storage: ctx.storage, limits, roles, instructions, hiddenFromLeaf: [RECALL_TOOL, NOTE_TOOL], log }, event));
         const pruned = pruneExpired(ctx.storage, Date.now()).catch((error) => log(`courier roster prune: ${String(error)}`));
         const swept = sweepRecords(ctx.storage, Date.now()).catch((error) => log(`courier memory sweep: ${String(error)}`));
-        // The windows the memory reads each part's context use by; a tree whose top runs in a location with memory off is not recorded.
         const windowed = ports
             .models()
             .then((models) => models.forEach(({ providerID, id, context }) => memoryState.windows.set(`${providerID}/${id}`, { providerID, id, context })))
@@ -171,12 +135,10 @@ export const courier = () => Plugin.define({
             log: later.log,
             nudge,
         };
-        // A spawned session about to go idle owing a report is reminded once, in the same execution. The hook is
-        // experimental, and a host before 2.2.4 lacks it: the rest loads all the same, and its parents are told as before.
         await Promise.resolve()
+            // a host before 2.2.4 takes this hook and never runs it (api-notes)
             .then(() => ctx.session.hook("experimental.idle", (event) => onIdle(watchPorts, watchState.seen, outside, event).then(() => undefined)))
             .catch((error) => log(`courier idle: not registered, a child that ends without a report is not reminded: ${String(error)}`));
-        // The hub's subscriptions to OpenCode's events, one and a standby, start with this copy's modules.
         watchFromHub(hub, eventModules);
         const member = {
             directory: ctx.location.directory,
@@ -188,34 +150,25 @@ export const courier = () => Plugin.define({
             log,
         };
         const leaveHub = join(member);
-        // The leave waits for them, so they do not run on against a location that is closing.
         track(member, pruned);
         track(member, noticed);
         track(member, swept);
         track(member, windowed);
-        const leave = webhook ? joinReceiver(webhook, hooks) : undefined;
         return async () => {
-            // Waits, for a moment at most, for the work this instance leaves behind, and on the last
-            // leave for the scheduler's owner key to be released, so another server takes over at once.
             const leftHub = leaveHub();
             if (!memory)
                 memoryState.off.delete(ctx.location.directory);
             leaveRelay();
-            await leave?.();
             await leftHub;
         };
     },
 });
-/**
- * The plugin OpenCode loads: an Effect plugin, since the question relay wraps OpenCode's question tool
- * and only the Effect API makes its call interruptible; the rest is the promise plugin, adapted.
- */
+// an Effect plugin, so the question call can be interrupted (api-notes)
 export default EffectPlugin.define({
     id: "courier",
     effect: (host) => Effect.gen(function* () {
         yield* fromPromise(courier()).effect(host);
-        // The promise plugin's instance is handed this same location and has just joined with it: its
-        // member, bound now, while it stays loaded.
+        // the adapter hands the promise plugin this same location (api-notes)
         yield* relayQuestions(host, portsAt(host.location));
     }),
 });

package/dist/kernel/protocol.d.ts

@@ -1,28 +1,14 @@
-/**
- * What every module of the plugin shares of the protocol with the models: the envelope a message arrives in,
- * the phrase that ends a turn, the statuses of a report, the split line and the skill's id, and how outside
- * text is clipped and defused.
- */
-/** Closes a tool result after which the caller most likely has nothing left to do. */
 export declare const END_TURN = "If nothing else is left to do now, end your turn by replying without calling more tools.";
-/** The statuses a report carries: the task is done, partly done, waits on the parent, or failed. */
 export declare const STATUSES: readonly ["done", "partial", "blocked", "failed"];
 export type Status = (typeof STATUSES)[number];
 export declare const isStatus: (value: unknown) => value is Status;
-/** The one line a session states its split decision in, so a transcript tells a decision from one never made. */
 export declare const SPLIT_LINE = "split: no, because \u2026; considered: <the parts you weighed> or split: <n> parts: \u2026 (one phrase per part)";
-/** The third form, for the root alone: it hands a heavy task whole to one session, to keep its own context. */
 export declare const ONE_PART_LINE = "split: 1 part: <the task>, to keep my context";
-/** `SPLIT_LINE` with the root's third form: the root's pointer offers it, a child's brief and role part never do. */
 export declare const ROOT_SPLIT_LINE = "split: no, because \u2026; considered: <the parts you weighed> or split: <n> parts: \u2026 (one phrase per part) or split: 1 part: <the task>, to keep my context";
 export declare const SKILL_ID = "courier-orchestrate";
 export declare function envelope(from: string, message: string, attributes?: Record<string, string>): string;
 export declare function clipText(text: string, max?: number): string;
-/** `clipText` cut at the last space within `max` instead, so no word is cut in two, unless that keeps less than half of `max`. */
 export declare function clipWords(text: string, max: number): string;
-/** Defuses `<courier` and `</courier>` in outside text, so it cannot close the envelope or forge another. */
 export declare function defuse(text: string): string;
-/** Defuses `<context` and `</context>` in text put in a session instruction entry, so it cannot close the entry's block or open another. */
 export declare function defuseBlock(text: string): string;
-/** A readable message for a failed courier call; OpenCode's own errors can carry an empty message. */
 export declare function describeFailure(tool: string, error: unknown): Error;

package/dist/kernel/protocol.js

@@ -1,18 +1,8 @@
-/**
- * What every module of the plugin shares of the protocol with the models: the envelope a message arrives in,
- * the phrase that ends a turn, the statuses of a report, the split line and the skill's id, and how outside
- * text is clipped and defused.
- */
-/** Closes a tool result after which the caller most likely has nothing left to do. */
 export const END_TURN = "If nothing else is left to do now, end your turn by replying without calling more tools.";
-/** The statuses a report carries: the task is done, partly done, waits on the parent, or failed. */
 export const STATUSES = ["done", "partial", "blocked", "failed"];
 export const isStatus = (value) => typeof value === "string" && STATUSES.includes(value);
-/** The one line a session states its split decision in, so a transcript tells a decision from one never made. */
 export const SPLIT_LINE = "split: no, because …; considered: <the parts you weighed> or split: <n> parts: … (one phrase per part)";
-/** The third form, for the root alone: it hands a heavy task whole to one session, to keep its own context. */
 export const ONE_PART_LINE = "split: 1 part: <the task>, to keep my context";
-/** `SPLIT_LINE` with the root's third form: the root's pointer offers it, a child's brief and role part never do. */
 export const ROOT_SPLIT_LINE = `${SPLIT_LINE} or ${ONE_PART_LINE}`;
 export const SKILL_ID = "courier-orchestrate";
 export function envelope(from, message, attributes = {}) {
@@ -21,29 +11,25 @@ export function envelope(from, message, attributes = {}) {
         .join("");
     return `<courier from="${from}"${extra}>\n${message}\n</courier>`;
 }
-/** Longest piece of free text (a review body, a generic payload) copied into a delivered message. */
 const MAX_TEXT = 1500;
 const clipped = (text, kept) => `${kept}… [${text.length - kept.length} more characters]`;
 export function clipText(text, max = MAX_TEXT) {
     return text.length > max ? clipped(text, text.slice(0, max)) : text;
 }
-/** `clipText` cut at the last space within `max` instead, so no word is cut in two, unless that keeps less than half of `max`. */
 export function clipWords(text, max) {
     if (text.length <= max)
         return text;
     const space = text.lastIndexOf(" ", max);
     return clipped(text, (space >= max / 2 ? text.slice(0, space) : text.slice(0, max)).trimEnd());
 }
-/** Defuses `<courier` and `</courier>` in outside text, so it cannot close the envelope or forge another. */
 export function defuse(text) {
     return text.replace(/<(\/?)(courier)/gi, "&lt;$1$2");
 }
-/** Defuses `<context` and `</context>` in text put in a session instruction entry, so it cannot close the entry's block or open another. */
 export function defuseBlock(text) {
     return text.replace(/<(\/?)(context)/gi, "&lt;$1$2");
 }
-/** A readable message for a failed courier call; OpenCode's own errors can carry an empty message. */
 export function describeFailure(tool, error) {
+    // OpenCode errors can have an empty message (api-notes)
     const tagged = error;
     const message = (typeof tagged?.message === "string" && tagged.message) ||
         [tagged?._tag, tagged?.sessionID].filter((item) => typeof item === "string").join(" ") ||

package/dist/kernel/tool.d.ts

@@ -1,5 +1,3 @@
 import type { Plugin } from "@opencode/plugin";
-/** The editor OpenCode hands a tool transform. */
 export type ToolEditor = Parameters<Parameters<Plugin.Context["tool"]["transform"]>[0]>[0];
-/** A `.catch` handler that rethrows a failure of `tool` as the error the model reads. */
 export declare const rethrow: (tool: string) => (error: unknown) => never;

package/dist/kernel/tool.js

@@ -1,5 +1,4 @@
 import { describeFailure } from "./protocol.js";
-/** A `.catch` handler that rethrows a failure of `tool` as the error the model reads. */
 export const rethrow = (tool) => (error) => {
     throw describeFailure(tool, error);
 };

package/dist/memory/domain.d.ts

@@ -1,143 +1,81 @@
-/**
- * The memory's pure rules, on plain data: the option, a record's shape, each part's status, the split line and its revisions,
- * its reads and pin, the retention and how a refresh keeps the parts the roster has forgotten. Imports nothing of the plugin's but `kernel/` and `platform/json.ts`.
- */
 import { type Status } from "../kernel/protocol.js";
-/** How many unpinned records a project keeps: those with a lesson first, then the newest by `movedAt`. */
 export declare const MAX_RECORDS = 30;
-/** Unpinned records that last moved longer ago than this are dropped when the plugin loads. */
 export declare const RETENTION_MS: number;
-/** A record's `split` while its top has stated no split line. */
 export declare const NOT_STATED = "not stated";
-/** The most characters a lesson holds: courier_note refuses what is longer, and a record written by hand is clipped when read. */
 export declare const LESSON_MAX = 300;
-/**
- * How a part stands: its last report's status, how its wait ended without one (`failed`, `interrupted`), `stopped` by
- * courier_stop, `gone` before it settled, `stalled` on a message it will not take, or `out`: it owes a report.
- */
 export declare const PART_STATUSES: readonly ["done", "partial", "blocked", "failed", "interrupted", "stopped", "gone", "stalled", "out"];
 export type PartStatus = (typeof PART_STATUSES)[number];
 export declare const isPartStatus: (value: unknown) => value is PartStatus;
-/** Whether a part has settled, as every part of a finished tree has: it neither owes a report nor is stalled. */
 export declare const isSettled: (status: PartStatus) => status is "done" | "partial" | "blocked" | "failed" | "interrupted" | "stopped" | "gone";
-/** One session started in a tree, as its record keeps it; `duration` is in milliseconds, `context` a share of its model's window. */
 export interface PartRecord {
     readonly sessionID: string;
     readonly title: string;
-    /** 1 for a session the top started. */
     readonly depth: number;
     readonly isolated: boolean;
+    readonly subagent?: true;
     readonly group?: string;
     readonly status: PartStatus;
-    /** From its start to the end of its last turn, or to the refresh while it runs. */
     readonly duration?: number;
     readonly cost?: number;
-    /** How full its context was at the end, 0 to 1, when its model's window is known. */
     readonly context?: number;
-    /** How many courier_spawn calls of its own failed, refused by a limit mostly. */
     readonly refused?: number;
 }
-/** Whether and when the top called courier_recall (`at`, its first call), and how many calls the tree made in all. */
 export interface Recalled {
     readonly at?: number;
     readonly calls: number;
 }
-/**
- * The one line the tree's orchestrator wrote for the next one with courier_note: when, and from which depth when it was
- * not the top's own session (1 for a session the top started).
- */
 export interface Lesson {
     readonly text: string;
     readonly at: number;
     readonly depth?: number;
 }
-/**
- * How often other trees' courier_recall calls listed the record (`shown`) or gave it in full (`read`), and when one last
- * did (`at`). Kept per reader tree and summed when read; a listing to the tree's own sessions counts nothing.
- */
 export interface Reads {
     readonly shown: number;
     readonly read: number;
     readonly at: number;
 }
-/** What a courier_recall call did with a record: listed it, or gave it in full. */
 export type ReadKind = "shown" | "read";
-/** The person's pin, set in the memory view: when. A pinned record is listed first and never swept. */
 export interface Pinned {
     readonly at: number;
 }
-/** How many revisions of the split line a record keeps, the newest. */
 export declare const MAX_REVISIONS = 3;
-/** A later split line the top stated, worded otherwise than the one before it: when, and how many parts the tree had then. */
 export interface Revision {
     readonly text: string;
     readonly at: number;
     readonly parts: number;
 }
-/** What is remembered of one tree: its top session and each session started in it, never a report's body or artifacts. */
 export interface TreeRecord {
-    /** When the top session was created, epoch milliseconds. */
     readonly startedAt: number;
-    /** When a turn in the tree last ended, or the record was first written. */
     readonly movedAt: number;
     readonly title: string;
-    /**
-     * The top's first split line, as `e2e/real-model-recursive.mjs` reads it, or `not stated`; a stated line takes precedence over a
-     * mention, which it replaces once, and is never replaced.
-     */
     readonly split: string;
-    /** Absent until the top states a split line worded otherwise than `split`; newest last, at most `MAX_REVISIONS`. */
     readonly revisions?: ReadonlyArray<Revision>;
-    /**
-     * Whether, at the last refresh, no session in the tree ran or had a courier message waiting in its inbox for a turn, and
-     * every part had settled: none was out or stalled.
-     */
     readonly finished: boolean;
     readonly recalled?: Recalled;
-    /** Absent until a session of the tree that is not a leaf wrote one; a second note replaces the first. */
     readonly lesson?: Lesson;
-    /** Absent until another tree's courier_recall listed or read the record; kept beside the record, never written with it. */
     readonly reads?: Reads;
-    /** Absent until the person pinned the record in the memory view; kept beside the record, never written with it. */
     readonly pinned?: Pinned;
     readonly parts: ReadonlyArray<PartRecord>;
 }
-/** A record with where it is kept: its project and its top session. */
 export interface StoredRecord extends TreeRecord {
     readonly projectID: string;
     readonly sessionID: string;
 }
-/** The `memory` option: whether records are kept and listed; on unless `false`. */
 export declare function readMemory(options: unknown): {
     memory: boolean;
     problems: string[];
 };
-/** The split line a text states, as the real-model checker reads it: a line beginning with `split:` after any markdown, else one holding it. */
 export declare function splitLineOf(text: string): string | undefined;
-/** Whether a split line is stated, beginning with `split:` after any markdown, not a passing mention nor `not stated`. */
 export declare const isStated: (line: string) => boolean;
-/** The record's `split` once `text` is read: kept once stated; a mention gives way to the first stated line; `not stated` to either. */
 export declare function splitOf(recorded: string, text: string): string;
-/** Every line of a text that begins with `split:` after any markdown, trimmed: a passing mention of a split is none. */
 export declare const splitLinesOf: (text: string) => string[];
-/** A split line the top's replies state, with when its reply was created when the message says. */
 export interface Stated {
     readonly text: string;
     readonly at?: number;
 }
-/**
- * The revisions once the split lines `stated` are read at a refresh at `at` with `parts` parts: those `statedSince` the line recorded
- * last, each appended when its words differ from the line before, so a re-read appends nothing.
- */
 export declare function revise(previous: Pick<TreeRecord, "split" | "revisions">, stated: ReadonlyArray<Stated>, at: number, parts: number): Revision[] | undefined;
-/**
- * The split and revisions once the stated line `found` replaces a mention: when `found` is among the revisions (recorded beside the
- * mention before #294), the first of them was stated first and is `split`, the rest stay; else `found` is, beside them all.
- */
 export declare function replacingMention(found: string, revisions: ReadonlyArray<Revision> | undefined): Pick<TreeRecord, "split" | "revisions">;
-/** A split line as the listing shows it: one line, without its block marks, the asterisks wrapping it or a span in it, nor an underscore or code span wrapping it. */
 export declare function splitProse(split: string): string;
-/** What a part's status is read from: whether courier_stop stopped it, whether it is stalled, and its report state. */
 export interface Standing {
     readonly stopped: boolean;
     readonly stalled: boolean;
@@ -148,26 +86,16 @@ export interface Standing {
         readonly status?: Status;
     };
 }
-/** A part's status by `Standing`; one whose report state is not known is still out. */
 export declare function partStatus({ stopped, stalled, report }: Standing): PartStatus;
-/**
- * A part whose session could not be read, from what was read of it and its last record: its title, duration and cost as
- * last recorded; once OpenCode no longer knows it (`gone`), settled as read, else as last recorded, else `gone`.
- */
+export declare function subagentStatus({ running, stalled, outcome }: {
+    readonly running: boolean;
+    readonly stalled: boolean;
+    readonly outcome?: string;
+}): PartStatus;
 export declare function unreadPart(read: PartRecord, last: PartRecord | undefined, gone: boolean): PartRecord;
-/**
- * The parts of a refreshed record: those recorded before, in their order, each as `current` has it (read now, or found
- * gone), else as last recorded, then those first seen now, in the order the tree is drawn.
- */
 export declare function mergeParts(previous: ReadonlyArray<PartRecord>, current: ReadonlyArray<PartRecord>): PartRecord[];
-/** `recalled` after one more call at `at`, the top's first call noted when `byTop`. */
 export declare function noteRecall(recalled: Recalled | undefined, byTop: boolean, at: number): Recalled;
-/** A text as the one line a lesson is: whitespace and line breaks collapsed to spaces, trimmed. */
 export declare const oneLine: (text: string) => string;
-/**
- * A hand-written lesson's text as one line, clipped at `LESSON_MAX`; `clipped` is the length it had when it was clipped.
- * courier_note does not clip: it refuses a line over `LESSON_MAX` (`note.ts`).
- */
 export declare function lessonText(text: string): {
     text: string;
     clipped?: undefined;
@@ -175,17 +103,10 @@ export declare function lessonText(text: string): {
     text: string;
     clipped: number;
 };
-/** One reader tree's `reads` after courier_recall listed the record or gave it in full at `at`. */
 export declare function noteRead(reads: Reads | undefined, kind: ReadKind, at: number): Reads;
-/** The reads of every reader tree as one: the counts summed, `at` the latest; none without a reader. */
 export declare function sumReads(reads: ReadonlyArray<Reads>): Reads | undefined;
-/**
- * The records a project keeps at `now`: every pinned one, whatever its age, and of the rest the first `MAX_RECORDS` by
- * whether each has a lesson, then by `movedAt`, none older than `RETENTION_MS`; the rest are dropped.
- */
 export declare function keep<T extends Pick<StoredRecord, "movedAt" | "lesson" | "pinned">>(records: ReadonlyArray<T>, now: number): {
     kept: T[];
     dropped: T[];
 };
-/** Records as courier_recall and the memory view list them: the pinned first, then by when each last moved, newest first. */
 export declare const pinnedFirst: <T extends Pick<StoredRecord, "movedAt" | "pinned">>(records: ReadonlyArray<T>) => T[];