opencode-courier 0.13.8 → 0.15.0

package/dist/tree/store.d.ts

@@ -1,9 +1,5 @@
 import { type Storage } from "../platform/storage.js";
 import type { ChildStore, GroupStore, WakeStore } from "./ports.js";
-/**
- * What the reverse index holds for a child: the sessions above it, its parent first and the top
- * session, which courier_spawn did not start, last; each is the parent of the one before it.
- */
 export interface ReverseEntry {
     readonly ancestors: ReadonlyArray<string>;
 }
@@ -16,13 +12,9 @@ export declare const toldKey: (sessionID: string) => string;
 export declare const stoppedKey: (sessionID: string) => string;
 export declare const nudgedKey: (sessionID: string) => string;
 export declare const memberKey: (parentID: string, group: string, sessionID: string) => string;
-/** The key prefix of a parent's groups, and of one group's members. */
 export declare const groupsPrefix: (parentID: string) => string;
 export declare const groupPrefix: (parentID: string, group: string) => string;
 export declare const wakeKey: (sessionID: string, inboxID: string) => string;
-/** The `ChildStore` over the plugin's storage. */
 export declare function childStore(storage: Storage): ChildStore;
-/** The `GroupStore` over the plugin's storage. */
 export declare function groupStore(storage: Storage): GroupStore;
-/** The `WakeStore` over the plugin's storage. */
 export declare function wakeStore(storage: Storage): WakeStore;

package/dist/tree/store.js

@@ -2,24 +2,14 @@ import { num, obj, str } from "../platform/json.js";
 import { isStatus } from "../kernel/protocol.js";
 import { scanAll, scanEntries } from "../platform/storage.js";
 import { lineageIn } from "./domain.js";
-// The tree's storage: the only file that knows its keys and layouts. Older copies and a second server on the same data
-// directory read and write the same keys, so a key or a stored value never changes shape.
-const PREFIX = "roster/";
-/**
- * The reverse index: a child's `ReverseEntry` under `roster-by-child/<sessionID>`, written with its
- * roster entry; only an index, so `roster/` is scanned for entries lacking one, and confirms a hit.
- */
+const ROSTER_PREFIX = "roster/";
 const BY_CHILD = "roster-by-child/";
 export function rosterKey(parentID, sessionID) {
-    return `${PREFIX}${parentID}/${sessionID}`;
+    return `${ROSTER_PREFIX}${parentID}/${sessionID}`;
 }
 export function reverseKey(sessionID) {
     return `${BY_CHILD}${sessionID}`;
 }
-/**
- * Whether a spawned session has reported since its last prompt, under `report/<sessionID>/`: `prompt`, `settled`, `progress`,
- * `told`, `stopped` and `nudged` (the reminder to report); docs/maintainers/architecture.md has each.
- */
 const REPORT_PREFIX = "report/";
 export const promptKey = (sessionID) => `${REPORT_PREFIX}${sessionID}/prompt`;
 export const settledKey = (sessionID) => `${REPORT_PREFIX}${sessionID}/settled`;
@@ -35,26 +25,16 @@ const REPORT_KEYS = {
     stopped: stoppedKey,
     nudged: nudgedKey,
 };
-/**
- * Join groups: each member of a parent's group under `group/<parentID>/<name>/<sessionID>`, with its
- * held report or how it left; released and dropped once none is out. docs/maintainers/architecture.md, § Storage.
- */
 const GROUP_PREFIX = "group/";
 export const memberKey = (parentID, group, sessionID) => `${GROUP_PREFIX}${parentID}/${group}/${sessionID}`;
-/** The key prefix of a parent's groups, and of one group's members. */
 export const groupsPrefix = (parentID) => `${GROUP_PREFIX}${parentID}/`;
 export const groupPrefix = (parentID, group) => `${groupsPrefix(parentID)}${group}/`;
-/**
- * The courier messages waiting in a session's inbox, each under `wake/<sessionID>/<inboxID>` until it is delivered, for
- * the scheduler to wake a session whose wake was missed. docs/maintainers/architecture.md, § Storage.
- */
 const WAKE_PREFIX = "wake/";
 export const wakeKey = (sessionID, inboxID) => `${WAKE_PREFIX}${sessionID}/${inboxID}`;
 function isReverse(value) {
     const ancestors = value?.ancestors;
     return Array.isArray(ancestors) && ancestors.length > 0 && ancestors.every((id) => typeof id === "string");
 }
-/** Whether a reverse key's value leads to this entry. */
 function indexes(value, entry) {
     return isReverse(value) && value.ancestors[0] === entry.parentID;
 }
@@ -63,10 +43,9 @@ const timeOf = (value) => {
     return typeof at === "number" && Number.isFinite(at) ? at : undefined;
 };
 const noteOf = (value) => ({ at: timeOf(value), by: obj(value).by, status: obj(value).status, resumesAt: obj(value).resumesAt });
-/** The `ChildStore` over the plugin's storage. */
 export function childStore(storage) {
     const entry = async (parentID, sessionID) => (await storage.get(rosterKey(parentID, sessionID)));
-    const all = () => scanAll(storage, PREFIX);
+    const all = () => scanAll(storage, ROSTER_PREFIX);
     const indexedAncestors = async (sessionID) => {
         const indexed = await storage.get(reverseKey(sessionID));
         return isReverse(indexed) ? indexed.ancestors : [];
@@ -76,8 +55,6 @@ export function childStore(storage) {
         let indexed = first;
         const chain = [];
         let below = sessionID;
-        // One read per level, all at once, and one more for the top's own reverse key, in case it was
-        // recorded after the key that names it; the chain ends where an entry is gone, as a scan's would.
         for (;;) {
             const { ancestors } = indexed;
             const top = ancestors.at(-1);
@@ -107,10 +84,6 @@ export function childStore(storage) {
         const ancestors = isReverse(above) ? above.ancestors : (await lineage(child.parentID)).map((parent) => parent.parentID);
         await storage.set(reverseKey(child.sessionID), { ancestors: [child.parentID, ...ancestors] });
     };
-    /**
-     * Drops a reverse key whose entry was not in the roster read, unless that entry is there now:
-     * another instance may have recorded the child since, and it writes the entry before the key.
-     */
     const dropDangling = async (sessionID, value) => {
         if (isReverse(value) && (await storage.get(rosterKey(value.ancestors[0], sessionID))) !== undefined)
             return;
@@ -120,7 +93,6 @@ export function childStore(storage) {
         await Promise.all(Object.values(REPORT_KEYS).map((key) => storage.remove(key(sessionID))));
     };
     return {
-        // The entry is what counts: written first, so a failed index write leaves it to be found by a scan.
         async record(child) {
             await storage.set(rosterKey(child.parentID, child.sessionID), { ...child });
             await index(child).catch(() => undefined);
@@ -134,7 +106,7 @@ export function childStore(storage) {
         },
         entry,
         async children(parentID) {
-            const entries = await scanAll(storage, `${PREFIX}${parentID}/`);
+            const entries = await scanAll(storage, `${ROSTER_PREFIX}${parentID}/`);
             return entries.sort((a, b) => a.createdAt - b.createdAt);
         },
         all,
@@ -172,7 +144,6 @@ export function childStore(storage) {
             const values = await Promise.all(fields.map((field) => storage.get(REPORT_KEYS[field](sessionID))));
             return Object.fromEntries(fields.map((field, i) => [field, noteOf(values[i])]));
         },
-        // Both of the hub's subscriptions note each event, one of them maybe behind: an earlier note never replaces a later one.
         async prompted(sessionID, at) {
             if ((timeOf(await storage.get(promptKey(sessionID))) ?? -Infinity) < at)
                 await storage.set(promptKey(sessionID), { at });
@@ -254,11 +225,8 @@ function readReport(value) {
         return undefined;
     return { at, status, message, ...(given.artifacts !== undefined ? { artifacts: given.artifacts } : {}) };
 }
-/** A member as the storage takes it, which asks for an index signature the interface lacks. */
 const stored = (member) => ({ ...member });
-/** The `GroupStore` over the plugin's storage. */
 export function groupStore(storage) {
-    /** The members under `prefix`, a key prefix within `GROUP_PREFIX`; a value that is not a member is left out. */
     const membersUnder = async (prefix) => {
         const entries = await scanEntries(storage, prefix);
         return entries.flatMap(({ key, value }) => {
@@ -280,7 +248,6 @@ export function groupStore(storage) {
         },
     };
 }
-/** A watched message as stored under its key's session and inbox id; one that cannot be read is left out. */
 function readWake(sessionID, inboxID, value) {
     const given = obj(value);
     const at = num(given.at);
@@ -304,7 +271,6 @@ function readWake(sessionID, inboxID, value) {
         ...optional("stalled"),
     };
 }
-/** The `WakeStore` over the plugin's storage. */
 export function wakeStore(storage) {
     const under = async (prefix) => {
         const entries = await scanEntries(storage, prefix);

package/dist/tree/subtree.d.ts

@@ -1,61 +1,39 @@
 import type { Plugin } from "@opencode/plugin";
-import type { CourierPorts, Pending, RosterEntry, RosterStorage, ShownForm } from "./ports.js";
+import type { CourierPorts, Lister, Pending, RosterEntry, RosterStorage, ShownForm } from "./ports.js";
 import { reportOf } from "./report.js";
 import { type Exists } from "./roster.js";
-/** A session below the one a subtree is read from, with how many levels below it is: a child is at depth 1. */
 export interface Below {
     readonly entry: RosterEntry;
     readonly depth: number;
+    readonly subagent?: true;
 }
-/** What a read drops: the entries past retention at `now`, as `courier_children` drops them; `exists` tells a worktree still there. */
 export interface Retention {
     readonly now: number;
     readonly exists?: Exists;
 }
-/**
- * The sessions started from a session, directly or through others, every one of them, read one prefix scan per
- * parent, in the order a tree is drawn; with `retention`, without the expired entries and what is under them.
- */
-export declare function subtree(storage: RosterStorage, rootID: string, retention?: Retention): Promise<{
+export declare function subtree(storage: RosterStorage, rootID: string, retention?: Retention, sessions?: Lister): Promise<{
     nodes: Below[];
 }>;
 type Info = Awaited<ReturnType<Plugin.Context["session"]["get"]>>;
-/** A session of a tree as a read looks it up: OpenCode's info of it, if it still knows it, whether it runs, and what it waits on. */
 export interface Looked extends Below {
     readonly info: Info | undefined;
     readonly running: boolean;
-    /** When its last turn ended, if it does not run and that is known. */
     readonly endedAt?: number;
     readonly pending: ReadonlyArray<Pending>;
     readonly forms: ReadonlyArray<ShownForm>;
 }
-/** A session as a listing looks it up: `Looked` plus its report state, and whether it is live (`isLive`). */
 export interface Listed extends Looked {
     readonly report: Awaited<ReturnType<typeof reportOf>>;
     readonly live: boolean;
 }
 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 lookUp(ports: ReadPorts, rootID: string, subagents?: boolean): Promise<Looked[]>;
 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.
- */
 export declare function readTree(ports: ReadPorts, rootID: string, max?: number): Promise<{
     kept: Listed[];
     leftOut: number;
 }>;
-/**
- * The subtree under a session as courier_tree lists it (`readTree`): each session as courier_children shows it, plus
- * its depth, its parent and its report state; `truncated` counts the older sessions left out.
- */
 export declare function tree(ports: CourierPorts, rootID: string): Promise<{
     truncated?: number | undefined;
     sessionID: string;
@@ -66,6 +44,7 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
             progressed: boolean;
             ended: boolean;
         } | undefined;
+        subagent?: true | undefined;
         parentID: string;
         depth: number;
         group: {
@@ -92,6 +71,7 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
             progressed: boolean;
             ended: boolean;
         } | undefined;
+        subagent?: true | undefined;
         parentID: string;
         depth: number;
         group?: undefined;
@@ -115,6 +95,7 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
             progressed: boolean;
             ended: boolean;
         } | undefined;
+        subagent?: true | undefined;
         parentID: string;
         depth: number;
         error: string;
@@ -136,6 +117,7 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
             progressed: boolean;
             ended: boolean;
         } | undefined;
+        subagent?: true | undefined;
         parentID: string;
         depth: number;
         error: string;

package/dist/tree/subtree.js

@@ -4,42 +4,55 @@ import { isExpired } from "./roster.js";
 import { turnOf } from "./running.js";
 import { described } from "./status.js";
 import { childStore } from "./store.js";
-/**
- * The sessions started from a session, directly or through others, every one of them, read one prefix scan per
- * parent, in the order a tree is drawn; with `retention`, without the expired entries and what is under them.
- */
-export async function subtree(storage, rootID, retention) {
+async function listedUnder(sessions, parentID) {
+    if (!sessions?.list)
+        return [];
+    const listed = await sessions.list({ parentID }).then((page) => page.data, () => []);
+    return listed.map((info) => ({
+        sessionID: info.id,
+        parentID,
+        title: info.title ?? "",
+        directory: info.location.directory,
+        isolated: false,
+        createdAt: info.time.created,
+    }));
+}
+export async function subtree(storage, rootID, retention, sessions) {
     const children = childStore(storage);
     const byParent = new Map();
     const seen = new Set([rootID]);
+    const kept = (entry) => !seen.has(entry.sessionID) && !(retention && isExpired(entry, retention.now, retention.exists));
     const expand = async (level, depth) => {
         if (!level.length)
             return;
-        const found = await Promise.all(level.map((parentID) => children.children(parentID)));
+        const found = await Promise.all(level.map((parentID) => Promise.all([children.children(parentID), listedUnder(sessions, parentID)])));
         const next = [];
-        for (const [index, entries] of found.entries()) {
-            const kept = entries.filter((entry) => !seen.has(entry.sessionID) && !(retention && isExpired(entry, retention.now, retention.exists)));
-            for (const entry of kept)
-                seen.add(entry.sessionID);
-            if (kept.length)
-                byParent.set(level[index], kept.map((entry) => ({ entry, depth })));
-            next.push(...kept.map((entry) => entry.sessionID));
+        for (const [index, [entries, listed]] of found.entries()) {
+            const spawned = entries.filter(kept).map((entry) => ({ entry, depth }));
+            for (const node of spawned)
+                seen.add(node.entry.sessionID);
+            // session.list also lists native courier children
+            const onRoster = new Set(entries.map((entry) => entry.sessionID));
+            const subagents = listed.filter((entry) => !onRoster.has(entry.sessionID) && kept(entry)).map((entry) => ({ entry, depth, subagent: true }));
+            for (const node of subagents)
+                seen.add(node.entry.sessionID);
+            const all = [...spawned, ...subagents].sort((a, b) => a.entry.createdAt - b.entry.createdAt);
+            if (all.length)
+                byParent.set(level[index], all);
+            next.push(...all.map((node) => node.entry.sessionID));
         }
         return expand(next, depth + 1);
     };
     await expand([rootID], 1);
     return { nodes: drawn(byParent, rootID) };
 }
-/** The nodes in the order a tree is drawn: each followed by what it started. */
 function drawn(byParent, parentID) {
     return (byParent.get(parentID) ?? []).flatMap((node) => [node, ...drawn(byParent, node.entry.sessionID)]);
 }
-/** 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() });
+export async function lookUp(ports, rootID, subagents = false) {
+    const { nodes } = await subtree(ports.storage, rootID, { now: ports.now() }, subagents ? ports.session : undefined);
     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),
@@ -48,13 +61,9 @@ export async function look(ports, node, known) {
     ]);
     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.
+    // a form outlives its turn only if its withdrawal event was missed
     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)
@@ -73,32 +82,25 @@ export async function readTop(ports, rootID) {
     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
- * above them, in the order a tree is drawn (`cut`); `leftOut` counts the rest.
- */
 export async function readTree(ports, rootID, max = ports.limits.maxTotal) {
     const children = childStore(ports.storage);
-    const all = await Promise.all((await lookUp(ports, rootID)).map(async (node) => {
-        const report = await reportOf(children, node.entry.sessionID).catch(() => undefined);
+    const all = await Promise.all((await lookUp(ports, rootID, true)).map(async (node) => {
+        const report = node.subagent ? undefined : await reportOf(children, node.entry.sessionID).catch(() => undefined);
         return { ...node, report, live: isLive(node.info ? node.running : undefined, node.pending.length + node.forms.length, report) };
     }));
     const listing = cut(all.map((node) => ({ sessionID: node.entry.sessionID, parentID: node.entry.parentID, createdAt: node.entry.createdAt, live: node.live, node })), max);
     return { kept: listing.kept.map(({ node }) => node), leftOut: listing.leftOut };
 }
-/**
- * The subtree under a session as courier_tree lists it (`readTree`): each session as courier_children shows it, plus
- * its depth, its parent and its report state; `truncated` counts the older sessions left out.
- */
 export async function tree(ports, rootID) {
     const { kept, leftOut } = await readTree(ports, rootID);
     const children = childStore(ports.storage);
-    const listed = await Promise.all(kept.map(async ({ entry, depth, report }) => {
-        const [info, last] = await Promise.all([described(ports, entry), lastStatus(children, entry.sessionID).catch(() => undefined)]);
+    const listed = await Promise.all(kept.map(async ({ entry, depth, report, subagent }) => {
+        const [info, last] = await Promise.all([described(ports, entry), report ? lastStatus(children, entry.sessionID).catch(() => undefined) : undefined]);
         return {
             ...info,
             parentID: entry.parentID,
             depth,
+            ...(subagent ? { subagent } : {}),
             ...(report
                 ? { report: { owes: report.owes, progressed: report.progressed, ended: report.ended, ...(last ? { status: last } : {}) } }
                 : {}),

package/dist/tree/summary.d.ts

@@ -1,7 +1,3 @@
 import type { CourierPorts } from "./ports.js";
 import type { Summary } from "./rpc.js";
-/**
- * Every session started under a session, counted by what it is doing (the session itself too, when it is stalled), and its
- * open join groups, those of its own children, with how far each has reported.
- */
 export declare function summary(ports: CourierPorts, sessionID: string): Promise<Summary>;

package/dist/tree/summary.js

@@ -2,10 +2,6 @@ import { groupStandings } from "./group.js";
 import { groupStore } from "./store.js";
 import { lookUp } from "./subtree.js";
 import { stalledAmong } from "./wake.js";
-/**
- * What a session is doing: waiting on a request it made or a form it shows, stalled, running, or idle; undefined when
- * OpenCode no longer knows it. A message waiting in its inbox is no turn (`runs`); a stalled one reads stalled.
- */
 function activity({ info, running, pending, forms, entry }, stalled) {
     if (!info)
         return undefined;
@@ -15,10 +11,6 @@ function activity({ info, running, pending, forms, entry }, stalled) {
         return "stalled";
     return running ? "running" : "idle";
 }
-/**
- * Every session started under a session, counted by what it is doing (the session itself too, when it is stalled), and its
- * open join groups, those of its own children, with how far each has reported.
- */
 export async function summary(ports, sessionID) {
     const [looked, standings] = await Promise.all([lookUp(ports, sessionID), groupStandings(groupStore(ports.storage), sessionID)]);
     const stalled = await stalledAmong(ports, [sessionID, ...looked.map((one) => one.entry.sessionID)]);

package/dist/tree/text.d.ts

@@ -1,25 +1,13 @@
 import { type ModelRef } from "./domain.js";
 import type { Artifacts, CleanupResult, ExecutionError, HeldReport, LeftMember, Limits, Sent, Standing } from "./ports.js";
-/** The branch an isolated child commits its work on, and names in the `branch` of its report. */
 export declare const childBranch: (sessionID: string) => string;
-/** What a spawned session at `depth` is told; `depth` 1 is a child of a session nobody spawned. `branch` is for an isolated one. */
 export declare function childBrief(parentID: string, task: string, depth: number, limits: Limits, branch?: string): string;
-/** How every role part begins, in the role entry and in the part the context hook adds without one, so no second copy is added. */
 export declare const ROLE_PREFIX = "opencode-courier role:";
-/** The key of the session instruction entry carrying a spawned session's role part, `<context key="role">` in its system prompt. */
 export declare const ROLE_KEY = "role";
-/**
- * The system part naming a session's place in its tree: `depth` 0 for a session nobody spawned that
- * has started one, `null` for one that has started none, which is pointed to the skill. The same on every request.
- */
 export declare function rolePart(depth: number | null, limits: Limits): string;
-/** The key of the session instruction entry on a parent listing the sessions it started, `<context key="standing">`. */
 export declare const STANDING_KEY = "standing";
-/** How every standing entry begins. */
 export declare const STANDING_PREFIX = "opencode-courier standing:";
-/** How many children the entry lists; older ones past that are counted. */
 export declare const STANDING_MAX = 10;
-/** What a child is doing, as its parent's standing entry says it; `reported` carries the status. */
 export type ChildState = {
     readonly kind: "started" | "working" | "ended" | "failed" | "interrupted" | "stopped";
     readonly progressed?: boolean;
@@ -28,37 +16,24 @@ export type ChildState = {
     readonly status: string;
     readonly progressed?: boolean;
 };
-/** One child as the standing entry lists it. */
 export interface StandingRow {
     readonly sessionID: string;
     readonly title: string;
     readonly state: ChildState;
-    /** Its join group and its standing there, `unknown` when that could not be read. */
     readonly group?: {
         readonly name: string;
         readonly standing: Standing | "unknown";
     };
 }
-/**
- * The standing entry: one line per session the parent started, oldest first, with its state and its place in its join group,
- * in the same words for the same state, so an unchanged standing is not put again.
- */
 export declare function standingEntry(rows: ReadonlyArray<StandingRow>): string;
 export declare const depthRefusal: (depth: number, maxDepth: number) => string;
 export declare const childrenRefusal: (running: number, maxChildren: number) => string;
-export declare const totalRefusal: (running: number, maxTotal: number) => string;
+export declare const totalRefusal: (running: number, maxTotal: number, yours: number) => string;
 export declare const modelFormatRefusal: (given: string) => string;
-/** The model is not among those OpenCode lists; `named` says the caller named it, rather than inherited it and named a variant. */
 export declare function unknownModelRefusal(model: ModelRef, known: ReadonlyArray<Pick<ModelRef, "providerID" | "id">>, named: boolean): string;
 export declare function unknownVariantRefusal(model: ModelRef, variants: ReadonlyArray<string>): string;
-/** A variant was named, but the model it would apply to could not be read: the named agent's, else the caller's own or OpenCode's default. */
 export declare function variantWithoutModelRefusal(variant: string, agent?: string): string;
-/**
- * The body of a report: its text, then the artifacts in a fixed layout, the same for every report,
- * so a parent finds the branch, the commits, the files and the checks without reading prose.
- */
 export declare function reportBody(message: string, artifacts: Artifacts | undefined): string;
-/** courier_spawn's refusal of `native: true` with `isolate: true`: OpenCode gives a session a worktree or a parent, never both. */
 export declare const nativeIsolateRefusal: () => string;
 export declare function spawnText(child: {
     readonly sessionID: string;
@@ -68,25 +43,23 @@ export declare function spawnText(child: {
     readonly groupError?: string;
     readonly fromParent?: boolean;
     readonly uncommitted?: boolean;
-    /** The model it runs on, when that is not the caller's own. */
     readonly model?: string;
+    readonly belowTop?: boolean;
 }): string;
-/** courier_send's result: for a message to the session that started the sender, whether it was its report; below it, the status dropped. */
 export declare function sendText(sessionID: string, sent?: Pick<Sent, "status" | "report" | "held" | "dropped">): string;
 export declare const childrenText: (listed: ReadonlyArray<unknown>) => string;
 export declare function cleanupText(result: CleanupResult): string;
-/** courier_tree's result: the sessions under a session, drawn depth first, as JSON. */
 export declare function treeText(tree: {
     readonly sessions: ReadonlyArray<unknown>;
     readonly truncated?: number;
 }): string;
-/** What courier_stop did to each session, and to the messages and worktrees. */
 export declare function stopText(result: {
     readonly sessionID: string;
     readonly stopped: ReadonlyArray<{
         readonly sessionID: string;
         readonly outcome: string;
         readonly error?: string;
+        readonly subagent?: true;
     }>;
     readonly cancelled: ReadonlyArray<string>;
     readonly cleanup?: ReadonlyArray<CleanupResult | {
@@ -96,29 +69,14 @@ export declare function stopText(result: {
     }>;
     readonly told?: string;
 }): string;
-/** What the parent of a stopped session is told when the stop was ordered by a session above both. */
 export declare const stoppedNotice: (title: string, by: string) => string;
-/** Why a worktree in this state must be kept, or undefined when removing it loses nothing. */
 export declare function keepReason(state: {
     readonly changes: readonly string[];
     readonly commits: readonly string[];
 }): string | undefined;
-/**
- * What the parent is told when a session it started failed its turn; `at` is when the failure happened, which the provider's
- * retry time (`retryAfterMs`) counts from. Message the child before that and it fails again, so the notice says to wait.
- */
-export declare function failureNotice(title: string, error: ExecutionError, group?: string, at?: number): string;
-/** The one reminder a spawned session gets as it is about to end its turn owing its parent a report; it carries on in the same turn. */
+export declare function failureNotice(title: string, error: ExecutionError, group?: string, at?: number, below?: ReadonlyArray<string>): string;
 export declare function reportReminder(parentID: string): string;
-/**
- * What the parent is told when a session it started ends its turn without a report to it;
- * `progressed` when it messaged the parent without a status since its last prompt.
- */
 export declare function silentNotice(title: string, lastText: string | undefined, progressed?: boolean, group?: string): string;
-/**
- * What the parent gets when a group it named is released: every report, with its status, text and artifacts in
- * `reportBody`'s layout, and the members that left without one, in the order they joined.
- */
 export declare function groupNotice(group: string, reports: ReadonlyArray<HeldReport & {
     readonly sessionID: string;
     readonly title: string;