opencode-courier 0.3.0 → 0.4.0

package/dist/tree/rpc.d.ts

@@ -0,0 +1,344 @@
+import { Schema } from "effect";
+/** The sessions started under a session, as the prompt footer's status entry shows them. */
+declare const Summary: Schema.Struct<{
+    /** Running, and waiting on no request. */
+    readonly running: Schema.Int;
+    /** Waiting on a permission request or a question, which go to the person. */
+    readonly waiting: Schema.Int;
+    /** Not running: done, or waiting for a message. */
+    readonly idle: Schema.Int;
+    readonly groups: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly reported: Schema.Int;
+        readonly members: Schema.Int;
+    }>>;
+    /** Set when the subtree had more sessions than `maxTotal`, which were not counted. */
+    readonly truncated: Schema.optionalKey<Schema.Int>;
+}>;
+export type Summary = typeof Summary.Type;
+/** A request a session waits on until the person answers it: a permission request, or its first question. */
+declare const Wait: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"permission">;
+    readonly action: Schema.String;
+    readonly resources: Schema.$Array<Schema.String>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"question">;
+    readonly question: Schema.String;
+}>]>;
+/** One session of the tree panel: what courier_tree shows of it, and what it is doing, in epoch milliseconds. */
+declare const Row: Schema.Struct<{
+    readonly sessionID: Schema.String;
+    readonly parentID: Schema.String;
+    readonly title: Schema.String;
+    /** A child of the panel's session is at depth 1. */
+    readonly depth: Schema.Int;
+    /** `waiting` on a request to the person; `gone` when OpenCode no longer knows it. */
+    readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "gone"]>;
+    /** How its last turn ended. */
+    readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>;
+    /** Its report since its last prompt: still owed, arrived (held with its group or delivered), or its turn ended without one. */
+    readonly report: Schema.optionalKey<Schema.Struct<{
+        readonly state: Schema.Literals<readonly ["owed", "reported", "ended"]>;
+        readonly status: Schema.optionalKey<Schema.String>;
+        readonly progressed: Schema.Boolean;
+    }>>;
+    /** Its join group, and its standing there: `held`, `out`, how it left, or `released`. */
+    readonly group: Schema.optionalKey<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly standing: Schema.String;
+    }>>;
+    readonly isolated: Schema.Boolean;
+    readonly created: Schema.Number;
+    /** When its last turn ended, if it is not running. */
+    readonly idle: Schema.optionalKey<Schema.Number>;
+    /** What it has cost so far, in US dollars. */
+    readonly cost: Schema.optionalKey<Schema.Number>;
+    /** Its last tool call, and when it was made. */
+    readonly tool: Schema.optionalKey<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly at: Schema.Number;
+    }>>;
+    readonly waits: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly type: Schema.Literal<"permission">;
+        readonly action: Schema.String;
+        readonly resources: Schema.$Array<Schema.String>;
+    }>, Schema.Struct<{
+        readonly type: Schema.Literal<"question">;
+        readonly question: Schema.String;
+    }>]>>;
+}>;
+/** The sessions under a session, as courier_tree reads them, in the order a tree is drawn. */
+declare const Tree: Schema.Struct<{
+    readonly rows: Schema.$Array<Schema.Struct<{
+        readonly sessionID: Schema.String;
+        readonly parentID: Schema.String;
+        readonly title: Schema.String;
+        /** A child of the panel's session is at depth 1. */
+        readonly depth: Schema.Int;
+        /** `waiting` on a request to the person; `gone` when OpenCode no longer knows it. */
+        readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "gone"]>;
+        /** How its last turn ended. */
+        readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>;
+        /** Its report since its last prompt: still owed, arrived (held with its group or delivered), or its turn ended without one. */
+        readonly report: Schema.optionalKey<Schema.Struct<{
+            readonly state: Schema.Literals<readonly ["owed", "reported", "ended"]>;
+            readonly status: Schema.optionalKey<Schema.String>;
+            readonly progressed: Schema.Boolean;
+        }>>;
+        /** Its join group, and its standing there: `held`, `out`, how it left, or `released`. */
+        readonly group: Schema.optionalKey<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly standing: Schema.String;
+        }>>;
+        readonly isolated: Schema.Boolean;
+        readonly created: Schema.Number;
+        /** When its last turn ended, if it is not running. */
+        readonly idle: Schema.optionalKey<Schema.Number>;
+        /** What it has cost so far, in US dollars. */
+        readonly cost: Schema.optionalKey<Schema.Number>;
+        /** Its last tool call, and when it was made. */
+        readonly tool: Schema.optionalKey<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly at: Schema.Number;
+        }>>;
+        readonly waits: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly type: Schema.Literal<"permission">;
+            readonly action: Schema.String;
+            readonly resources: Schema.$Array<Schema.String>;
+        }>, Schema.Struct<{
+            readonly type: Schema.Literal<"question">;
+            readonly question: Schema.String;
+        }>]>>;
+    }>>;
+    /** Set when the subtree had more sessions than `maxTotal`, which were left out. */
+    readonly truncated: Schema.optionalKey<Schema.Int>;
+}>;
+export type Row = typeof Row.Type;
+export type Tree = typeof Tree.Type;
+export type Wait = typeof Wait.Type;
+/** What a stop did to each session, deepest first, as courier_stop reports it. */
+declare const Stopped: Schema.Struct<{
+    readonly stopped: Schema.$Array<Schema.Struct<{
+        readonly sessionID: Schema.String;
+        readonly title: Schema.String;
+        readonly outcome: Schema.String;
+    }>>;
+    /** How many scheduled messages were cancelled. */
+    readonly cancelled: Schema.Int;
+}>;
+export type Stopped = typeof Stopped.Type;
+export declare const treeRpc: {
+    readonly id: "courier";
+    readonly methods: {
+        readonly summary: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly sessionID: string;
+            }, {
+                readonly sessionID: string;
+            }> & Schema.Struct<{
+                readonly sessionID: Schema.String;
+            }>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly running: number;
+                readonly idle: number;
+                readonly groups: readonly {
+                    readonly name: string;
+                    readonly reported: number;
+                    readonly members: number;
+                }[];
+                readonly waiting: number;
+                readonly truncated?: number | undefined;
+            }, {
+                readonly running: number;
+                readonly idle: number;
+                readonly groups: readonly {
+                    readonly name: string;
+                    readonly reported: number;
+                    readonly members: number;
+                }[];
+                readonly waiting: number;
+                readonly truncated?: number | undefined;
+            }> & Schema.Struct<{
+                /** Running, and waiting on no request. */
+                readonly running: Schema.Int;
+                /** Waiting on a permission request or a question, which go to the person. */
+                readonly waiting: Schema.Int;
+                /** Not running: done, or waiting for a message. */
+                readonly idle: Schema.Int;
+                readonly groups: Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly reported: Schema.Int;
+                    readonly members: Schema.Int;
+                }>>;
+                /** Set when the subtree had more sessions than `maxTotal`, which were not counted. */
+                readonly truncated: Schema.optionalKey<Schema.Int>;
+            }>;
+        };
+        readonly tree: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly sessionID: string;
+            }, {
+                readonly sessionID: string;
+            }> & Schema.Struct<{
+                readonly sessionID: Schema.String;
+            }>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly rows: readonly {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly parentID: string;
+                    readonly depth: number;
+                    readonly created: number;
+                    readonly isolated: boolean;
+                    readonly state: "running" | "idle" | "gone" | "waiting";
+                    readonly waits: readonly ({
+                        readonly type: "permission";
+                        readonly action: string;
+                        readonly resources: readonly string[];
+                    } | {
+                        readonly type: "question";
+                        readonly question: string;
+                    })[];
+                    readonly group?: {
+                        readonly name: string;
+                        readonly standing: string;
+                    } | undefined;
+                    readonly idle?: number | undefined;
+                    readonly report?: {
+                        readonly progressed: boolean;
+                        readonly state: "reported" | "ended" | "owed";
+                        readonly status?: string | undefined;
+                    } | undefined;
+                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
+                    readonly tool?: {
+                        readonly name: string;
+                        readonly at: number;
+                    } | undefined;
+                    readonly cost?: number | undefined;
+                }[];
+                readonly truncated?: number | undefined;
+            }, {
+                readonly rows: readonly {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly parentID: string;
+                    readonly depth: number;
+                    readonly created: number;
+                    readonly isolated: boolean;
+                    readonly state: "running" | "idle" | "gone" | "waiting";
+                    readonly waits: readonly ({
+                        readonly type: "permission";
+                        readonly action: string;
+                        readonly resources: readonly string[];
+                    } | {
+                        readonly type: "question";
+                        readonly question: string;
+                    })[];
+                    readonly group?: {
+                        readonly name: string;
+                        readonly standing: string;
+                    } | undefined;
+                    readonly idle?: number | undefined;
+                    readonly report?: {
+                        readonly progressed: boolean;
+                        readonly state: "reported" | "ended" | "owed";
+                        readonly status?: string | undefined;
+                    } | undefined;
+                    readonly outcome?: "failed" | "interrupted" | "succeeded" | undefined;
+                    readonly tool?: {
+                        readonly name: string;
+                        readonly at: number;
+                    } | undefined;
+                    readonly cost?: number | undefined;
+                }[];
+                readonly truncated?: number | undefined;
+            }> & Schema.Struct<{
+                readonly rows: Schema.$Array<Schema.Struct<{
+                    readonly sessionID: Schema.String;
+                    readonly parentID: Schema.String;
+                    readonly title: Schema.String;
+                    /** A child of the panel's session is at depth 1. */
+                    readonly depth: Schema.Int;
+                    /** `waiting` on a request to the person; `gone` when OpenCode no longer knows it. */
+                    readonly state: Schema.Literals<readonly ["running", "waiting", "idle", "gone"]>;
+                    /** How its last turn ended. */
+                    readonly outcome: Schema.optionalKey<Schema.Literals<readonly ["succeeded", "failed", "interrupted"]>>;
+                    /** Its report since its last prompt: still owed, arrived (held with its group or delivered), or its turn ended without one. */
+                    readonly report: Schema.optionalKey<Schema.Struct<{
+                        readonly state: Schema.Literals<readonly ["owed", "reported", "ended"]>;
+                        readonly status: Schema.optionalKey<Schema.String>;
+                        readonly progressed: Schema.Boolean;
+                    }>>;
+                    /** Its join group, and its standing there: `held`, `out`, how it left, or `released`. */
+                    readonly group: Schema.optionalKey<Schema.Struct<{
+                        readonly name: Schema.String;
+                        readonly standing: Schema.String;
+                    }>>;
+                    readonly isolated: Schema.Boolean;
+                    readonly created: Schema.Number;
+                    /** When its last turn ended, if it is not running. */
+                    readonly idle: Schema.optionalKey<Schema.Number>;
+                    /** What it has cost so far, in US dollars. */
+                    readonly cost: Schema.optionalKey<Schema.Number>;
+                    /** Its last tool call, and when it was made. */
+                    readonly tool: Schema.optionalKey<Schema.Struct<{
+                        readonly name: Schema.String;
+                        readonly at: Schema.Number;
+                    }>>;
+                    readonly waits: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                        readonly type: Schema.Literal<"permission">;
+                        readonly action: Schema.String;
+                        readonly resources: Schema.$Array<Schema.String>;
+                    }>, Schema.Struct<{
+                        readonly type: Schema.Literal<"question">;
+                        readonly question: Schema.String;
+                    }>]>>;
+                }>>;
+                /** Set when the subtree had more sessions than `maxTotal`, which were left out. */
+                readonly truncated: Schema.optionalKey<Schema.Int>;
+            }>;
+        };
+        /** Stops `sessionID` and everything under it, as courier_stop called from `by`, which must be above it. */
+        readonly stop: {
+            readonly input: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly sessionID: string;
+                readonly by: string;
+            }, {
+                readonly sessionID: string;
+                readonly by: string;
+            }> & Schema.Struct<{
+                readonly sessionID: Schema.String;
+                readonly by: Schema.String;
+            }>;
+            readonly output: import("effect/StandardSchema").StandardSchemaV1<{
+                readonly stopped: readonly {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly outcome: string;
+                }[];
+                readonly cancelled: number;
+            }, {
+                readonly stopped: readonly {
+                    readonly sessionID: string;
+                    readonly title: string;
+                    readonly outcome: string;
+                }[];
+                readonly cancelled: number;
+            }> & Schema.Struct<{
+                readonly stopped: Schema.$Array<Schema.Struct<{
+                    readonly sessionID: Schema.String;
+                    readonly title: Schema.String;
+                    readonly outcome: Schema.String;
+                }>>;
+                /** How many scheduled messages were cancelled. */
+                readonly cancelled: Schema.Int;
+            }>;
+            readonly errors: {
+                readonly refused: import("effect/StandardSchema").StandardSchemaV1<{}, {}> & Schema.Struct<{}>;
+            };
+        };
+    };
+    readonly events: {};
+};
+export type TreeRpc = typeof treeRpc;
+export {};

package/dist/tree/rpc.js

@@ -0,0 +1,83 @@
+/**
+ * The tree's RPC, the contract its TUI part and its server half share. Standard Schema values, so the promise
+ * API's `rpc.register` and the TUI's `client.rpc` both type it; imports only `@opencode/plugin/rpc` and `effect`.
+ */
+import { Rpc } from "@opencode/plugin/rpc";
+import { Schema } from "effect";
+const Count = Schema.Int.check(Schema.isGreaterThanOrEqualTo(0));
+/** A join group the session opened, with how many of its members have reported and how many have not left. */
+const Group = Schema.Struct({ name: Schema.String, reported: Count, members: Count });
+/** The sessions started under a session, as the prompt footer's status entry shows them. */
+const Summary = Schema.Struct({
+    /** Running, and waiting on no request. */
+    running: Count,
+    /** Waiting on a permission request or a question, which go to the person. */
+    waiting: Count,
+    /** Not running: done, or waiting for a message. */
+    idle: Count,
+    groups: Schema.Array(Group),
+    /** Set when the subtree had more sessions than `maxTotal`, which were not counted. */
+    truncated: Schema.optionalKey(Count),
+});
+/** A request a session waits on until the person answers it: a permission request, or its first question. */
+const Wait = Schema.Union([
+    Schema.Struct({ type: Schema.Literal("permission"), action: Schema.String, resources: Schema.Array(Schema.String) }),
+    Schema.Struct({ type: Schema.Literal("question"), question: Schema.String }),
+]);
+/** One session of the tree panel: what courier_tree shows of it, and what it is doing, in epoch milliseconds. */
+const Row = Schema.Struct({
+    sessionID: Schema.String,
+    parentID: Schema.String,
+    title: Schema.String,
+    /** A child of the panel's session is at depth 1. */
+    depth: Count,
+    /** `waiting` on a request to the person; `gone` when OpenCode no longer knows it. */
+    state: Schema.Literals(["running", "waiting", "idle", "gone"]),
+    /** How its last turn ended. */
+    outcome: Schema.optionalKey(Schema.Literals(["succeeded", "failed", "interrupted"])),
+    /** Its report since its last prompt: still owed, arrived (held with its group or delivered), or its turn ended without one. */
+    report: Schema.optionalKey(Schema.Struct({ state: Schema.Literals(["owed", "reported", "ended"]), status: Schema.optionalKey(Schema.String), progressed: Schema.Boolean })),
+    /** Its join group, and its standing there: `held`, `out`, how it left, or `released`. */
+    group: Schema.optionalKey(Schema.Struct({ name: Schema.String, standing: Schema.String })),
+    isolated: Schema.Boolean,
+    created: Schema.Number,
+    /** When its last turn ended, if it is not running. */
+    idle: Schema.optionalKey(Schema.Number),
+    /** What it has cost so far, in US dollars. */
+    cost: Schema.optionalKey(Schema.Number),
+    /** Its last tool call, and when it was made. */
+    tool: Schema.optionalKey(Schema.Struct({ name: Schema.String, at: Schema.Number })),
+    waits: Schema.Array(Wait),
+});
+/** The sessions under a session, as courier_tree reads them, in the order a tree is drawn. */
+const Tree = Schema.Struct({
+    rows: Schema.Array(Row),
+    /** Set when the subtree had more sessions than `maxTotal`, which were left out. */
+    truncated: Schema.optionalKey(Count),
+});
+/** What a stop did to each session, deepest first, as courier_stop reports it. */
+const Stopped = Schema.Struct({
+    stopped: Schema.Array(Schema.Struct({ sessionID: Schema.String, title: Schema.String, outcome: Schema.String })),
+    /** How many scheduled messages were cancelled. */
+    cancelled: Count,
+});
+export const treeRpc = Rpc.define({
+    id: "courier",
+    methods: {
+        summary: {
+            input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String })),
+            output: Schema.toStandardSchemaV1(Summary),
+        },
+        tree: {
+            input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String })),
+            output: Schema.toStandardSchemaV1(Tree),
+        },
+        /** Stops `sessionID` and everything under it, as courier_stop called from `by`, which must be above it. */
+        stop: {
+            input: Schema.toStandardSchemaV1(Schema.Struct({ sessionID: Schema.String, by: Schema.String })),
+            output: Schema.toStandardSchemaV1(Stopped),
+            errors: { refused: Schema.toStandardSchemaV1(Schema.Struct({})) },
+        },
+    },
+    events: {},
+});

package/dist/tree/send.d.ts

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

package/dist/tree/send.js

@@ -0,0 +1,99 @@
+import { envelope, isStatus, STATUSES } from "../kernel/protocol.js";
+import { groupStanding, holdReport, membershipFor, unholdForBlocked } from "./group.js";
+import { childStore, groupStore } from "./store.js";
+import { reportBody } from "./text.js";
+/**
+ * Drops a message into another session's inbox; OpenCode wakes that session if it is idle. From a spawned session
+ * to the one that started it, it is its report or its progress (`noteReport`); a group member's final report is held (`hold`).
+ */
+export async function send(ports, from, input) {
+    // Some models send null for an optional field they leave out.
+    const status = input.status ?? undefined;
+    if (status !== undefined && !isStatus(status))
+        throw new Error(`status must be one of ${STATUSES.join(", ")}, not ${JSON.stringify(status)}.`);
+    // Noted first: the delivery may wake the parent, whose turn may end before a later note.
+    const noted = await noteReport(ports, from, input.sessionID, status).catch(() => undefined);
+    try {
+        const held = noted?.member && status && status !== "blocked" ? await hold(ports, noted.member, { at: noted.at, status, message: input.message, ...(input.artifacts ? { artifacts: input.artifacts } : {}) }) : undefined;
+        if (held)
+            return { status, report: true, held };
+        const delivered = await ports.session.synthetic({
+            sessionID: input.sessionID,
+            text: envelope(from, reportBody(input.message, input.artifacts), status ? { status } : {}),
+            description: `Message from ${from}`,
+            metadata: { source: "courier", from, ...(status ? { status } : {}) },
+            delivery: input.queue ? "queue" : "steer",
+        });
+        // A blocked report, once delivered, is the member's latest word: an earlier report held for it would be stale.
+        if (noted?.member && status === "blocked")
+            await unholdForBlocked(groupStore(ports.storage), noted.member).catch(() => undefined);
+        return { messageID: delivered.id, ...(status ? { status } : {}), ...(noted ? { report: noted.report } : {}) };
+    }
+    catch (error) {
+        await noted?.undo().catch(() => undefined);
+        throw error;
+    }
+}
+/**
+ * Notes `from`'s message to `to` when `to` started it: as its report when it carries a status, or when an earlier
+ * release briefed `from`, else as progress. Returns which, when, how to take the note back, and `from`'s group membership.
+ */
+async function noteReport(ports, from, to, status) {
+    const children = childStore(ports.storage);
+    const entry = await children.indexedEntry(from);
+    if (entry?.parentID !== to)
+        return undefined;
+    const report = status !== undefined || entry.reports !== "status";
+    const field = report ? "settled" : "progress";
+    const before = await children.peek(from, field);
+    const at = ports.now();
+    await (report ? children.settled(from, "report", at, status) : children.progressed(from, at));
+    // Only its own note: another courier_send of the session's may have noted its report since.
+    const undo = async () => {
+        const now = (await children.peek(from, field));
+        if (now?.at !== at || (report && now.by !== "report"))
+            return;
+        await children.restore(from, field, before);
+    };
+    return { report, at, undo, member: status !== undefined ? await memberIn(ports, entry) : undefined };
+}
+/**
+ * A child's membership of an open group of its parent's, by its roster entry; none once courier_cleanup dropped it. One that
+ * cannot be read is dropped from the group, best effort, as the report then goes on its own and the group must not wait for it.
+ */
+async function memberIn(ports, entry) {
+    const groups = groupStore(ports.storage);
+    try {
+        const member = await membershipFor(groups, entry);
+        return member?.left?.by === "dropped" ? undefined : member;
+    }
+    catch (error) {
+        ports.log(`courier_send: ${entry.sessionID}'s place in group ${entry.group} could not be read, so its report goes on its own: ${String(error)}`);
+        if (entry.group)
+            await groups.remove(entry.parentID, entry.group, entry.sessionID).then(() => ports.nudge(), () => undefined);
+        return undefined;
+    }
+}
+/**
+ * Holds a member's report with its group, and nudges the scheduler if that completes the group. Undefined
+ * when it could not be held: the member is dropped from the group, which releases without it, and reports on its own.
+ */
+async function hold(ports, member, report) {
+    const groups = groupStore(ports.storage);
+    try {
+        await holdReport(groups, member, report);
+    }
+    catch (error) {
+        // Neither held nor dropped, the group would wait for ever: the call fails, and the sender sends it again.
+        await groups.remove(member.parentID, member.group, member.sessionID).catch((dropError) => {
+            throw new Error(`the report could not be held with group ${member.group} (${String(error)}), nor the member dropped from it (${String(dropError)}); send it again.`);
+        });
+        ports.nudge();
+        return undefined;
+    }
+    // Held whatever the count gives; a count that cannot be read gets the nudge, as a tick that finds nothing due is cheap.
+    const standing = await groupStanding(groups, member.parentID, member.group).catch(() => undefined);
+    if (standing?.complete !== false)
+        ports.nudge();
+    return { group: member.group, ...(standing ? { reported: standing.reported, members: standing.members } : {}) };
+}

package/dist/tree/spawn.d.ts

@@ -0,0 +1,21 @@
+import type { CourierPorts } from "./ports.js";
+export interface SpawnInput {
+    readonly task: string;
+    readonly title?: string;
+    readonly agent?: string;
+    readonly isolate?: boolean;
+    readonly group?: string;
+}
+/**
+ * Creates a child session, hands it the task and returns at once; the child reports back with
+ * courier_send. Refused past a limit, whether or not the `context` hook hid the tool.
+ */
+export declare function spawn(ports: CourierPorts, parentID: string, input: SpawnInput): Promise<{
+    uncommitted?: boolean | undefined;
+    fromParent?: boolean | undefined;
+    groupError?: string | undefined;
+    rosterError?: string | undefined;
+    group?: string | undefined;
+    sessionID: string;
+    directory: string;
+}>;