opencode-courier 0.11.1 → 0.13.0

package/dist/tree/standing.js

@@ -0,0 +1,90 @@
+import { existsSync } from "node:fs";
+import { isStatus } from "../kernel/protocol.js";
+import { isNotFound } from "../platform/json.js";
+import { isExpired, standingOf } from "./domain.js";
+import { childStore, groupStore } from "./store.js";
+import { STANDING_KEY, standingEntry } from "./text.js";
+/** Whether `at` is known and no earlier than the prompt at `prompt`. */
+const since = (at, prompt) => at !== undefined && at >= prompt;
+/** A child's state from its report notes, as `reportOf` and the silent-turn rule read them. */
+export function stateOf(notes) {
+    const prompt = notes.prompt.at;
+    if (notes.stopped.at !== undefined && (prompt === undefined || notes.stopped.at >= prompt))
+        return { kind: "stopped" };
+    if (prompt === undefined)
+        return { kind: "started" };
+    const progressed = since(notes.progress.at, prompt) ? { progressed: true } : {};
+    if (!since(notes.settled.at, prompt))
+        return since(notes.told.at, prompt) ? { kind: "ended", ...progressed } : { kind: "working", ...progressed };
+    const { by, status } = notes.settled;
+    if (by === "failed" || by === "interrupted")
+        return { kind: by };
+    return { kind: "reported", status: isStatus(status) ? status : "done", ...progressed };
+}
+/** The rows of a parent's standing entry: its unexpired children, oldest first, each with its state and group standing. */
+export async function standingRows(storage, parentID, now) {
+    const children = childStore(storage);
+    // The groups read best effort, as courier_children reads them: a member's standing is `unknown` when they cannot be.
+    const [entries, members] = await Promise.all([children.children(parentID), groupStore(storage).ofParent(parentID).catch(() => undefined)]);
+    const current = entries.filter((entry) => !isExpired(entry, now, existsSync));
+    return Promise.all(current.map(async (entry) => {
+        const notes = await children.notes(entry.sessionID, ["prompt", "settled", "progress", "told", "stopped"]);
+        const member = members?.find((one) => one.group === entry.group && one.sessionID === entry.sessionID);
+        const standing = members ? standingOf(member) : "unknown";
+        return {
+            sessionID: entry.sessionID,
+            title: entry.title,
+            state: stateOf(notes),
+            ...(entry.group ? { group: { name: entry.group, standing } } : {}),
+        };
+    }));
+}
+/** The syncs under way in this process, by parent, each run after the one before it: a sync that read earlier never writes last. */
+const inTurn = new Map();
+/**
+ * Writes a parent's `standing` entry once something of it changed: put when its text differs from the entry's, removed when
+ * the parent has no children left; skipped without the keyed entries. A failure is logged, never thrown.
+ */
+export function syncStanding(ports, parentID) {
+    const entries = ports.session?.instructions?.entry;
+    if (!entries)
+        return Promise.resolve("skipped");
+    const before = inTurn.get(parentID) ?? Promise.resolve();
+    const run = before.then(() => sync(ports, parentID, entries));
+    const done = run.finally(() => {
+        if (inTurn.get(parentID) === done)
+            inTurn.delete(parentID);
+    });
+    inTurn.set(parentID, done);
+    return run;
+}
+async function sync(ports, parentID, entries) {
+    try {
+        const rows = await standingRows(ports.storage, parentID, ports.now());
+        const stored = (await entries.list({ sessionID: parentID })).find((entry) => entry.key === STANDING_KEY);
+        if (!rows.length) {
+            if (!stored)
+                return "absent";
+            await entries.remove({ sessionID: parentID, key: STANDING_KEY });
+            return "removed";
+        }
+        const value = standingEntry(rows);
+        if (stored?.value === value)
+            return "unchanged";
+        await entries.put({ sessionID: parentID, key: STANDING_KEY, value });
+        return "put";
+    }
+    catch (error) {
+        // A parent OpenCode no longer knows has no entry to keep: a child deleted after it is a normal path.
+        if (!isNotFound(error))
+            ports.log?.(`courier: the standing entry of ${parentID} could not be written, so it may be behind courier_children: ${String(error)}`);
+        return "skipped";
+    }
+}
+/** Writes `given` entries to a session, each put logged on failure and never thrown: the session gets its task all the same. */
+export async function putEntries(ports, sessionID, given) {
+    const entries = ports.session?.instructions?.entry;
+    if (!entries)
+        return;
+    await Promise.all(given.map(({ key, value }) => entries.put({ sessionID, key, value }).catch((error) => ports.log?.(`courier_spawn: the ${key} entry of ${sessionID} could not be written: ${String(error)}`))));
+}

package/dist/tree/status.d.ts

@@ -7,7 +7,7 @@ export interface StatusInput {
 export interface ChildrenInput {
     readonly sessionID?: string;
 }
-/** A one-off look at a session, for check-ins; not meant to be called in a loop. */
+/** One session's state and last reply, as courier_children shows each child. */
 export declare function status(ports: CourierPorts, input: StatusInput): Promise<Partial<{
     sessionID: string;
     title: string | undefined;
@@ -22,7 +22,7 @@ export declare function status(ports: CourierPorts, input: StatusInput): Promise
 /** The text of a session's last reply, from its context's messages, or undefined when it has none. */
 export declare function lastReply(messages: Awaited<ReturnType<Context["session"]["context"]>>): string | undefined;
 /**
- * The sessions a parent started, each with what courier_status reports, or the error it gave; a child in a
+ * The sessions a parent started, each with its state and last reply, or the error it gave; a child in a
  * group with the group's name and its standing there: `held`, `out`, how it left, `released` or `unknown`.
  */
 export declare function listChildren(ports: CourierPorts, parentID: string): Promise<({
@@ -30,9 +30,11 @@ export declare function listChildren(ports: CourierPorts, parentID: string): Pro
         name: string;
         report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
     };
-    directory: string;
-    isolated: boolean;
     created: number;
+    model?: string | undefined;
+    native?: true | undefined;
+    isolated: boolean;
+    directory: string;
     sessionID?: string | undefined;
     title?: string | undefined;
     parentID?: string | undefined;
@@ -44,9 +46,11 @@ export declare function listChildren(ports: CourierPorts, parentID: string): Pro
     pending?: readonly import("./ports.js").Pending[] | undefined;
 } | {
     group?: undefined;
-    directory: string;
-    isolated: boolean;
     created: number;
+    model?: string | undefined;
+    native?: true | undefined;
+    isolated: boolean;
+    directory: string;
     sessionID?: string | undefined;
     title?: string | undefined;
     parentID?: string | undefined;
@@ -62,29 +66,35 @@ export declare function listChildren(ports: CourierPorts, parentID: string): Pro
         name: string;
         report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
     };
-    directory: string;
-    isolated: boolean;
     created: number;
+    model?: string | undefined;
+    native?: true | undefined;
+    isolated: boolean;
+    directory: string;
     sessionID: string;
     title: string;
 } | {
     error: string;
     group?: undefined;
-    directory: string;
-    isolated: boolean;
     created: number;
+    model?: string | undefined;
+    native?: true | undefined;
+    isolated: boolean;
+    directory: string;
     sessionID: string;
     title: string;
 })[]>;
-/** One roster entry as courier_children shows it: what courier_status reports with its directory and group standing, or the error it gave. */
+/** One roster entry as courier_children shows it: the session's state with its directory and group standing, or the error it gave. */
 export declare function described(ports: CourierPorts, entry: RosterEntry): Promise<{
     group: {
         name: string;
         report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
     };
-    directory: string;
-    isolated: boolean;
     created: number;
+    model?: string | undefined;
+    native?: true | undefined;
+    isolated: boolean;
+    directory: string;
     sessionID?: string | undefined;
     title?: string | undefined;
     parentID?: string | undefined;
@@ -96,9 +106,11 @@ export declare function described(ports: CourierPorts, entry: RosterEntry): Prom
     pending?: readonly import("./ports.js").Pending[] | undefined;
 } | {
     group?: undefined;
-    directory: string;
-    isolated: boolean;
     created: number;
+    model?: string | undefined;
+    native?: true | undefined;
+    isolated: boolean;
+    directory: string;
     sessionID?: string | undefined;
     title?: string | undefined;
     parentID?: string | undefined;
@@ -114,17 +126,21 @@ export declare function described(ports: CourierPorts, entry: RosterEntry): Prom
         name: string;
         report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
     };
-    directory: string;
-    isolated: boolean;
     created: number;
+    model?: string | undefined;
+    native?: true | undefined;
+    isolated: boolean;
+    directory: string;
     sessionID: string;
     title: string;
 } | {
     error: string;
     group?: undefined;
-    directory: string;
-    isolated: boolean;
     created: number;
+    model?: string | undefined;
+    native?: true | undefined;
+    isolated: boolean;
+    directory: string;
     sessionID: string;
     title: string;
 }>;

package/dist/tree/status.js

@@ -1,8 +1,8 @@
 import { describeFailure } from "../kernel/protocol.js";
-import { standingOf } from "./domain.js";
+import { standingOf, startedAs } from "./domain.js";
 import { current } from "./roster.js";
 import { groupStore } from "./store.js";
-/** A one-off look at a session, for check-ins; not meant to be called in a loop. */
+/** One session's state and last reply, as courier_children shows each child. */
 export async function status(ports, input) {
     const [info, messages, pending] = await Promise.all([
         ports.session.get({ sessionID: input.sessionID }),
@@ -30,17 +30,17 @@ export function lastReply(messages) {
         : undefined;
 }
 /**
- * The sessions a parent started, each with what courier_status reports, or the error it gave; a child in a
+ * The sessions a parent started, each with its state and last reply, or the error it gave; a child in a
  * group with the group's name and its standing there: `held`, `out`, how it left, `released` or `unknown`.
  */
 export async function listChildren(ports, parentID) {
     const entries = await current(ports.storage, parentID, ports.now());
     return Promise.all(entries.map((entry) => described(ports, entry)));
 }
-/** One roster entry as courier_children shows it: what courier_status reports with its directory and group standing, or the error it gave. */
+/** One roster entry as courier_children shows it: the session's state with its directory and group standing, or the error it gave. */
 export async function described(ports, entry) {
     const group = entry.group ? { group: { name: entry.group, report: await standingIn(ports, entry, entry.group) } } : {};
-    const roster = { directory: entry.directory, isolated: entry.isolated, created: entry.createdAt, ...group };
+    const roster = { directory: entry.directory, ...startedAs(entry), created: entry.createdAt, ...group };
     try {
         return { ...(await status(ports, { sessionID: entry.sessionID })), ...roster };
     }
@@ -49,7 +49,7 @@ export async function described(ports, entry) {
             sessionID: entry.sessionID,
             title: entry.title,
             ...roster,
-            error: describeFailure("courier_status", error).message,
+            error: describeFailure("reading the session", error).message,
         };
     }
 }

package/dist/tree/stop.js

@@ -1,6 +1,7 @@
 import { isNotFound } from "../platform/json.js";
 import { describeFailure, envelope } from "../kernel/protocol.js";
 import { cleanup } from "./cleanup.js";
+import { syncStanding } from "./standing.js";
 import { childStore } from "./store.js";
 import { subtree } from "./subtree.js";
 import { stoppedNotice } from "./text.js";
@@ -37,6 +38,8 @@ export async function stop(ports, callerID, input) {
         return round(meanwhile, left - 1);
     };
     await round([{ entry: target, depth: 0 }, ...(await subtree(storage, sessionID)).nodes], ROUNDS);
+    // Each parent among them reads its stopped children at its next step; the caller's own entry, when it is the target's parent, too.
+    await Promise.all([...new Set(nodes.map((node) => node.entry.parentID))].map((parentID) => syncStanding(ports.courier, parentID)));
     const told = target.parentID !== callerID && results.find((one) => one.sessionID === sessionID)?.outcome === "interrupted"
         ? await tell(ports, callerID, target)
         : undefined;

package/dist/tree/store.js

@@ -65,10 +65,11 @@ const noteOf = (value) => ({ at: timeOf(value), by: obj(value).by, status: obj(v
 export function childStore(storage) {
     const entry = async (parentID, sessionID) => (await storage.get(rosterKey(parentID, sessionID)));
     const all = () => scanAll(storage, PREFIX);
-    const indexedParent = async (sessionID) => {
+    const indexedAncestors = async (sessionID) => {
         const indexed = await storage.get(reverseKey(sessionID));
-        return isReverse(indexed) ? indexed.ancestors[0] : undefined;
+        return isReverse(indexed) ? indexed.ancestors : [];
     };
+    const indexedParent = async (sessionID) => (await indexedAncestors(sessionID))[0];
     const walkIndex = async (sessionID, first) => {
         let indexed = first;
         const chain = [];
@@ -143,6 +144,7 @@ export function childStore(storage) {
             return found === undefined ? [] : [found];
         },
         indexedParent,
+        indexedAncestors,
         async indexedEntry(sessionID) {
             const parentID = await indexedParent(sessionID);
             return parentID === undefined ? undefined : entry(parentID, sessionID);

package/dist/tree/subtree.d.ts

@@ -65,9 +65,11 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
             name: string;
             report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
         };
-        directory: string;
-        isolated: boolean;
         created: number;
+        model?: string | undefined;
+        native?: true | undefined;
+        isolated: boolean;
+        directory: string;
         sessionID?: string | undefined;
         title?: string | undefined;
         outcome?: "failed" | "interrupted" | "succeeded" | undefined;
@@ -86,9 +88,11 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
         parentID: string;
         depth: number;
         group?: undefined;
-        directory: string;
-        isolated: boolean;
         created: number;
+        model?: string | undefined;
+        native?: true | undefined;
+        isolated: boolean;
+        directory: string;
         sessionID?: string | undefined;
         title?: string | undefined;
         outcome?: "failed" | "interrupted" | "succeeded" | undefined;
@@ -111,9 +115,11 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
             name: string;
             report: "failed" | "interrupted" | "out" | "unknown" | "deleted" | "dropped" | "held" | "released";
         };
-        directory: string;
-        isolated: boolean;
         created: number;
+        model?: string | undefined;
+        native?: true | undefined;
+        isolated: boolean;
+        directory: string;
         sessionID: string;
         title: string;
     } | {
@@ -127,9 +133,11 @@ export declare function tree(ports: CourierPorts, rootID: string): Promise<{
         depth: number;
         error: string;
         group?: undefined;
-        directory: string;
-        isolated: boolean;
         created: number;
+        model?: string | undefined;
+        native?: true | undefined;
+        isolated: boolean;
+        directory: string;
         sessionID: string;
         title: string;
     })[];

package/dist/tree/text.d.ts

@@ -1,23 +1,65 @@
-import type { Artifacts, CleanupResult, ExecutionError, HeldReport, LeftMember, Limits, Sent } from "./ports.js";
+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 part the context hook adds begins, so a second copy of the plugin does not add its own. */
+/** 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;
+} | {
+    readonly kind: "reported";
+    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 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;
     readonly directory: string;
@@ -26,11 +68,11 @@ 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;
 }): string;
-/** courier_send's result: for a message to the session that started the sender, whether it was its report. */
-export declare function sendText(sessionID: string, sent?: Pick<Sent, "status" | "report" | "held">): string;
-/** courier_status's result: the session's state, as JSON. */
-export declare const statusText: (status: unknown) => 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. */

package/dist/tree/text.js

@@ -1,6 +1,6 @@
 /** The tree's model-facing texts: the child brief, the role part, refusals, reports, notices and tool results. */
 import { obj, str } from "../platform/json.js";
-import { clipText, defuse, END_TURN, ROOT_SPLIT_LINE, SKILL_ID, SPLIT_LINE, STATUSES } from "../kernel/protocol.js";
+import { clipText, defuse, defuseBlock, END_TURN, ROOT_SPLIT_LINE, SKILL_ID, SPLIT_LINE, STATUSES } from "../kernel/protocol.js";
 import { retryDelay } from "./domain.js";
 // The envelope and the child brief.
 /** How a text names the statuses a report may carry. */
@@ -19,6 +19,11 @@ export function childBrief(parentID, task, depth, limits, branch) {
             "concrete ask, then end your turn and wait for its answer; never end quietly.",
         "A report with a status wakes the parent and is the only way it hears from you, so do not end without sending one. " +
             "A message without a status is progress, not your report: if you end your turn without a report, the parent is told so.",
+        "If you find something the other parts of the job need (an assumption of the split that is wrong, a shared file or API " +
+            "that behaves otherwise), send it to the parent at once with courier_send without a status, then carry on: it passes " +
+            "it on to the sessions it affects. Progress alone is not worth a message.",
+        "A message the person writes in your session, outside a <courier> envelope, is for the whole job: before you act on it, " +
+            "send it to the parent at once with courier_send without a status, quoting it as the person's, then carry on.",
         "If you need the person to decide something, use your question tool; it reaches them through the session that started you.",
         "",
         ...(branch ? [...isolationRule(branch, depth < limits.maxDepth), ""] : []),
@@ -48,16 +53,20 @@ function splitRule(parentID, depth, limits) {
         `You are at depth ${depth} of a session tree that goes at most ${limits.maxDepth} deep. Split your task or do it yourself:`,
         "- Split it when it has 2 or more independent parts, each substantial and touching separate files or areas: start one " +
             `session per part with courier_spawn, at most ${limits.maxChildren} of yours running at once and ${limits.maxTotal} in the whole tree.`,
-        "- Do it yourself when it is small, sequential or tightly coupled. Never start exactly one session for the whole task; a core you stage before the rest is one part of it, not the whole, when 2 or more parts follow it.",
+        "- Do it yourself when it is small, sequential or tightly coupled. Never start exactly one session for the whole task. One session for one stage is a part, not the whole: " +
+            "a core you stage before the rest, when 2 or more parts follow it; a review of the parts once you have merged them; the fixing of what a review found once you have verified it. " +
+            "One session alone, with nothing of the task done before it by you or by 2 or more parts, and fewer than 2 parts after it, is the whole task.",
         `- Say which in one line of your reply: ${SPLIT_LINE}.`,
         "- If you split, you orchestrate: start the parts that run at once in one group, with the same group name for each, " +
-            "then end your turn while they work. Do not poll with courier_status, courier_children, courier_tree or sleep: the group's " +
+            "then end your turn while they work. Do not poll with courier_children, courier_tree or sleep: the group's " +
             "reports wake you. Check and integrate each part yourself when it reports (never hand that checking to another " +
             `session), then send ${parentID} one combined report.`,
     ];
 }
-/** How every part the context hook adds begins, so a second copy of the plugin does not add its own. */
+/** 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 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 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.
@@ -80,6 +89,67 @@ export function rolePart(depth, limits) {
     return (`${ROLE_PREFIX} leaf, at depth ${depth}, the deepest the session tree goes. You cannot start sessions: do your ` +
         "task yourself and report with courier_send to the session that started you.");
 }
+// The standing entry: what a parent's system prompt says of the sessions it started.
+/** The key of the session instruction entry on a parent listing the sessions it started, `<context key="standing">`. */
+export const STANDING_KEY = "standing";
+/** How every standing entry begins. */
+export const STANDING_PREFIX = "opencode-courier standing:";
+/** How many children the entry lists; older ones past that are counted. */
+export const STANDING_MAX = 10;
+/** The most characters of a child's title the entry shows. */
+const TITLE_MAX = 40;
+function stateWords(state) {
+    const progressed = state.progressed ? ", sent progress" : "";
+    switch (state.kind) {
+        case "started":
+            return "started";
+        case "working":
+            return `working${progressed}`;
+        case "ended":
+            return `ended its turn without a report${progressed}`;
+        case "failed":
+            return "its turn failed";
+        case "interrupted":
+            return "its turn was interrupted";
+        case "stopped":
+            return "stopped";
+        case "reported":
+            return `reported ${state.status}`;
+    }
+}
+function groupWords(name, standing) {
+    const group = `group "${name}"`;
+    switch (standing) {
+        case "held":
+            return `its report is held with ${group}`;
+        case "out":
+            return `${group} waits for it`;
+        case "released":
+            return `${group} was delivered`;
+        case "unknown":
+            return `in ${group}`;
+        default:
+            return `out of ${group} (${LEFT_HOW[standing]})`;
+    }
+}
+/**
+ * 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 function standingEntry(rows) {
+    const shown = rows.slice(-STANDING_MAX);
+    const older = rows.length - shown.length;
+    return [
+        `${STANDING_PREFIX} the sessions you started with courier_spawn, each with its state, kept current as it changes, so you need ` +
+            "not look with courier_children or courier_tree; a report, a group's reports or a notice still reach you as a message.",
+        ...shown.map((row) => {
+            const title = defuseBlock(row.title.replace(/\s+/g, " ").trim());
+            const group = row.group ? `; ${groupWords(row.group.name, row.group.standing)}` : "";
+            return `- ${row.sessionID} "${clipText(title, TITLE_MAX)}": ${stateWords(row.state)}${group}`;
+        }),
+        ...(older ? [`${count(older, "older session")} not listed; courier_children lists them.`] : []),
+    ].join("\n");
+}
 // courier_spawn's refusals, one per limit.
 export const depthRefusal = (depth, maxDepth) => `Not started: this session is at depth ${depth} of its session tree, and the tree goes at most ${maxDepth} deep ` +
     "(maxDepth), so it cannot start sessions. Do the task yourself, and report with courier_send.";
@@ -89,6 +159,36 @@ export const childrenRefusal = (running, maxChildren) => `Not started: ${count(r
     `(maxChildren ${maxChildren}). Do this part yourself, or end your turn and start it once one of them has reported.`;
 export const totalRefusal = (running, maxTotal) => `Not started: ${count(running, "session")} in this session tree ${live(running)}, the most allowed at once ` +
     `(maxTotal ${maxTotal}). Do this part yourself, or end your turn and try again once a report has arrived.`;
+// courier_spawn's refusals of a model or a variant OpenCode does not list.
+/** How many models, or providers, a refusal names before it counts the rest. */
+const NAMED = 12;
+const some = (items) => (items.length > NAMED ? `${items.slice(0, NAMED).join(", ")} and ${items.length - NAMED} more` : items.join(", "));
+export const modelFormatRefusal = (given) => `Not started: model must be provider/model, as OpenCode names them (opencode/gpt-5-nano, anthropic/claude-sonnet-4-5), not ${JSON.stringify(given)}. ` +
+    "Leave it unset to run the session on your own model.";
+/** The model is not among those OpenCode lists; `named` says the caller named it, rather than inherited it and named a variant. */
+export function unknownModelRefusal(model, known, named) {
+    const name = `${model.providerID}/${model.id}`;
+    const ids = known.filter((item) => item.providerID === model.providerID).map((item) => item.id);
+    const providers = [...new Set(known.map((item) => item.providerID))];
+    let hint = "No model is listed here at all.";
+    if (ids.length)
+        hint = `The models of ${model.providerID} here are ${some(ids)}.`;
+    else if (providers.length)
+        hint = `The providers here are ${some(providers)}.`;
+    return named
+        ? `Not started: OpenCode lists no model ${name} here. ${hint} Leave model unset to run the session on your own model.`
+        : `Not started: the variant cannot be checked, since OpenCode lists no model ${name} here, the one the session would run on. ${hint}`;
+}
+export function unknownVariantRefusal(model, variants) {
+    const listed = variants.length ? `${variants.join(", ")} and default` : "default alone";
+    return (`Not started: the model ${model.providerID}/${model.id} has no variant ${JSON.stringify(model.variant)}. ` +
+        `Its variants are ${listed}; leave variant unset for the model's default.`);
+}
+/** 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 function variantWithoutModelRefusal(variant, agent) {
+    const why = agent ? `the agent ${agent} could not be looked up` : "neither your own model nor OpenCode's default could be read";
+    return `Not started: variant ${JSON.stringify(variant)} needs a model to apply to, and ${why}. Name a model as provider/model, or leave variant unset.`;
+}
 /** The strings of a list given as artifacts, whatever else the model put in it. */
 const strings = (value) => (Array.isArray(value) ? value.flatMap((item) => (typeof item === "string" ? [item.trim()] : [])) : []).filter(Boolean);
 /** A list's line in the artifacts block, or none when it is empty. */
@@ -112,6 +212,9 @@ export function reportBody(message, artifacts) {
     return lines.length ? [message, "", "Artifacts:", ...lines].join("\n") : message;
 }
 // Tool results.
+/** courier_spawn's refusal of `native: true` with `isolate: true`: OpenCode gives a session a worktree or a parent, never both. */
+export const nativeIsolateRefusal = () => "Not started: native: true and isolate: true cannot go together. OpenCode runs a session in a worktree of its own or as a " +
+    "subagent of its parent, never both. Start it with isolate: true alone for a worktree of its own, or with native: true alone for a subagent in your directory.";
 export function spawnText(child) {
     const warning = (child.fromParent ? " Its worktree starts from the commit your own worktree is on." : "") +
         (child.uncommitted
@@ -124,11 +227,15 @@ export function spawnText(child) {
             "turn has ended, you get their reports in one message, which starts a new turn for you; a blocked report, a question " +
             "or a failed turn still reaches you at once."
         : "It will report back with courier_send, which starts a new turn for you.";
-    return (`Started session ${child.sessionID} in ${child.directory}. ${reports} Once you have started every session you need, ` +
+    const on = child.model ? `, on ${child.model}` : "";
+    return (`Started session ${child.sessionID} in ${child.directory}${on}. ${reports} Once you have started every session you need, ` +
         `end your turn: reply without calling more tools. That does not drop the task; you carry on with it when the reports arrive.${warning}`);
 }
-/** courier_send's result: for a message to the session that started the sender, whether it was its report. */
+/** 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 function sendText(sessionID, sent = {}) {
+    if (sent.dropped)
+        return (`Delivered to ${sessionID}, without the status ${sent.dropped}: a status belongs on a report to the session that ` +
+            "started you, and means nothing on a message to a session you started.");
     const status = sent.status ? `, status ${sent.status}` : "";
     if (sent.held) {
         const { group, reported, members } = sent.held;
@@ -146,8 +253,6 @@ export function sendText(sessionID, sent = {}) {
         return `Delivered to ${sessionID}. Without a status it is progress, not your report: when you finish, send one with status ${STATUS_LIST}.`;
     return `Delivered to ${sessionID}.`;
 }
-/** courier_status's result: the session's state, as JSON. */
-export const statusText = (status) => JSON.stringify(status, null, 2);
 export const childrenText = (listed) => listed.length ? JSON.stringify(listed, null, 2) : "No sessions started with courier_spawn.";
 export function cleanupText(result) {
     if (result.outcome === "kept")

package/dist/tree/tools.d.ts

@@ -9,7 +9,10 @@ export declare const SpawnInput: Schema.Struct<{
     readonly task: Schema.String;
     readonly title: Schema.optional<Schema.String>;
     readonly agent: Schema.optional<Schema.String>;
+    readonly model: Schema.optional<Schema.String>;
+    readonly variant: Schema.optional<Schema.String>;
     readonly isolate: Schema.optional<Schema.Boolean>;
+    readonly native: Schema.optional<Schema.Boolean>;
     readonly group: Schema.optional<Schema.String>;
 }>;
 export declare const SendInput: Schema.Struct<{
@@ -27,9 +30,6 @@ export declare const SendInput: Schema.Struct<{
     }>>;
     readonly queue: Schema.optional<Schema.Boolean>;
 }>;
-export declare const StatusInput: Schema.Struct<{
-    readonly sessionID: Schema.String;
-}>;
 export declare const ChildrenInput: Schema.Struct<{
     readonly sessionID: Schema.optional<Schema.String>;
 }>;