@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.11

package/dist/runtime/subagents/progress.d.ts

@@ -1,8 +1,8 @@
 import type { Logger } from "@capybara-hq/plugin-sdk";
-import type { KernelDb } from "../../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
 /** A finished step of a sub-agent run, as the loop reports it. */
 export interface SubagentStep {
-    /** The parent conversation, whose topic gets the message. */
+    /** The parent conversation: its topic and those of every conversation above it get the message. */
     parentConversationId: string;
     /** The child conversation (the sub-agent's id). */
     conversationId: string;
@@ -10,17 +10,19 @@ export interface SubagentStep {
     step: number;
 }
 export interface SubagentProgressDeps {
-    db: KernelDb;
+    db: KernelSchemaDb;
     bus: {
         publish(topic: string, payload: unknown): Promise<void>;
     };
     log: Pick<Logger, "warn">;
 }
 /**
- * Publishes `{ kind: "subagent_progress", subagentId, step, toolCalls, lastToolKey? }` on the
- * parent conversation's topic after a child step (sub-agents spec §14.2). Ephemeral: not in any
- * log, lost on reconnect (the summary API has the current numbers). The counts come from the
- * child run's log (its `tool_result` events), never from process memory, so any replica running
- * the step reports the same. Never throws: a lost progress message costs nothing.
+ * Publishes `{ kind: "subagent_progress", subagentId, step, toolCalls, lastToolKey? }` after a
+ * child step on the topic of every ancestor (sub-agents spec §14.2; agent map spec §8: the root's
+ * agent map follows a sub-agent at any depth), `subagentId` naming the progressing agent.
+ * Ephemeral: not in any log, lost on reconnect (the tree and summary APIs have the current
+ * numbers). The counts come from the child run's log (its `tool_result` events), never from
+ * process memory, so any replica running the step reports the same. Never throws: a lost progress
+ * message costs nothing.
  */
 export declare function publishSubagentProgress(d: SubagentProgressDeps, s: SubagentStep): Promise<void>;

package/dist/runtime/subagents/progress.js

@@ -1,11 +1,14 @@
 import { sql } from "kysely";
 import { conversationTopic } from "../../conversations/event-log.js";
+import { conversationAncestors } from "../../conversations/tree.js";
 /**
- * Publishes `{ kind: "subagent_progress", subagentId, step, toolCalls, lastToolKey? }` on the
- * parent conversation's topic after a child step (sub-agents spec §14.2). Ephemeral: not in any
- * log, lost on reconnect (the summary API has the current numbers). The counts come from the
- * child run's log (its `tool_result` events), never from process memory, so any replica running
- * the step reports the same. Never throws: a lost progress message costs nothing.
+ * Publishes `{ kind: "subagent_progress", subagentId, step, toolCalls, lastToolKey? }` after a
+ * child step on the topic of every ancestor (sub-agents spec §14.2; agent map spec §8: the root's
+ * agent map follows a sub-agent at any depth), `subagentId` naming the progressing agent.
+ * Ephemeral: not in any log, lost on reconnect (the tree and summary APIs have the current
+ * numbers). The counts come from the child run's log (its `tool_result` events), never from
+ * process memory, so any replica running the step reports the same. Never throws: a lost progress
+ * message costs nothing.
  */
 export async function publishSubagentProgress(d, s) {
     try {
@@ -24,7 +27,9 @@ export async function publishSubagentProgress(d, s) {
             toolCalls: Number(row?.n ?? 0),
             ...(row?.last != null && { lastToolKey: row.last }),
         };
-        await d.bus.publish(conversationTopic(s.parentConversationId), msg);
+        const ancestors = await conversationAncestors(d.db, s.conversationId);
+        const topics = new Set([s.parentConversationId, ...ancestors]);
+        await Promise.all([...topics].map((id) => d.bus.publish(conversationTopic(id), msg)));
     }
     catch (err) {
         d.log.warn("sub-agent progress publish failed", {

package/dist/runtime/subagents/render.d.ts

@@ -0,0 +1,30 @@
+import type { EventPayload } from "../../conversations/events.js";
+type Delivery = EventPayload<"subagent_delivery">;
+/**
+ * The model-visible text of a `subagent_delivery` event, rendered as a system message in the
+ * parent's request (agent map spec §4.5):
+ *
+ * ```
+ * Sub-agent <id> ("<description>") handed back a report:
+ * <text>
+ * Sub-agent <id> ("<description>") sent a message:
+ * <text>
+ * Sub-agent <id> ("<description>") completed; its report was already delivered.
+ * Sub-agent <id> ("<description>") completed. Final reply:
+ * <text>
+ * Sub-agent <id> ("<description>") failed (<code>): <message>
+ * Sub-agent <id> ("<description>") stopped by the user.
+ * ```
+ *
+ * A finish uses `agentResultText`'s status wording (`subagentStatusText`, with the error code and
+ * who stopped it); after a handback only the status itself (up to its first `;`), and without a
+ * reply `It produced no reply.` A failed finish's `text` is the error message, an aborted one has
+ * none. Read only from the payload, so a replay renders it identically.
+ *
+ * A run that handed back and then `completed` no longer gets a finished delivery (acceptance
+ * 2026-11-07, `SubagentDeliveries.finishIn`); the "already delivered" line stays for the other
+ * statuses after a handback and for the completed ones older logs recorded, which rebuild byte for
+ * byte. The switch is the delivery's absence in the log, so it needs no `DriftReason`.
+ */
+export declare function renderSubagentDelivery(p: Delivery): string;
+export {};

package/dist/runtime/subagents/render.js

@@ -0,0 +1,53 @@
+import { subagentStatusText } from "./status.js";
+/**
+ * The model-visible text of a `subagent_delivery` event, rendered as a system message in the
+ * parent's request (agent map spec §4.5):
+ *
+ * ```
+ * Sub-agent <id> ("<description>") handed back a report:
+ * <text>
+ * Sub-agent <id> ("<description>") sent a message:
+ * <text>
+ * Sub-agent <id> ("<description>") completed; its report was already delivered.
+ * Sub-agent <id> ("<description>") completed. Final reply:
+ * <text>
+ * Sub-agent <id> ("<description>") failed (<code>): <message>
+ * Sub-agent <id> ("<description>") stopped by the user.
+ * ```
+ *
+ * A finish uses `agentResultText`'s status wording (`subagentStatusText`, with the error code and
+ * who stopped it); after a handback only the status itself (up to its first `;`), and without a
+ * reply `It produced no reply.` A failed finish's `text` is the error message, an aborted one has
+ * none. Read only from the payload, so a replay renders it identically.
+ *
+ * A run that handed back and then `completed` no longer gets a finished delivery (acceptance
+ * 2026-11-07, `SubagentDeliveries.finishIn`); the "already delivered" line stays for the other
+ * statuses after a handback and for the completed ones older logs recorded, which rebuild byte for
+ * byte. The switch is the delivery's absence in the log, so it needs no `DriftReason`.
+ */
+export function renderSubagentDelivery(p) {
+    const head = `Sub-agent ${p.subagentId} (${JSON.stringify(p.description)})`;
+    switch (p.kind) {
+        case "report":
+            return `${head} handed back a report:\n${p.text}`;
+        case "note":
+            return `${head} sent a message:\n${p.text}`;
+        case "finished": {
+            const status = subagentStatusText(p.status ?? "completed", {
+                errorCode: p.errorCode,
+                abortedBy: p.abortedBy,
+            });
+            if (p.handedBack === true) {
+                return `${head} ${status.split(";")[0]}; its report was already delivered.`;
+            }
+            const text = p.text.trim();
+            if (p.status === "failed")
+                return text === "" ? `${head} ${status}.` : `${head} ${status}: ${text}`;
+            if (p.status === "aborted" || p.status === "timed_out")
+                return `${head} ${status}.`;
+            return text === ""
+                ? `${head} ${status}. It produced no reply.`
+                : `${head} ${status}. Final reply:\n${p.text}`;
+        }
+    }
+}

package/dist/runtime/subagents/roster.d.ts

@@ -1,5 +1,7 @@
+import type { Logger } from "@capybara-hq/plugin-sdk";
 import type { AgentDefinition } from "../../agents/definition.js";
-import type { KernelDb } from "../../db/kernel-schema.js";
+import { templateTypeOf } from "../../agents/templates.js";
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
 /**
  * The sub-agent roster of an agent version (phase C, spec §4.3, §5.1): the agent types its `agent`
  * tool offers, in the order the description lists them.
@@ -10,8 +12,18 @@ export interface RosterEntry {
     source: "general" | "inline" | "plugin" | "agent";
     /** When to use it (shown in the tool description), cut to {@link ROSTER_DESCRIPTION_MAX}. */
     description: string;
-    /** Plugin templates: the `agent_templates` id. */
+    /**
+     * Plugin templates: the selected id (an org template's, a linked copy's own, or a platform
+     * template's; `subagent_started.template.id`).
+     */
     templateId?: string;
+    /**
+     * Plugin templates: other selected ids this entry stands for: ids resolving to the same platform
+     * template under this type (an org copy linked since the save), or a selected platform id an org
+     * row of the same component shadows (the entry is that row); a follow-up recorded under one of
+     * them finds this entry.
+     */
+    aliasTemplateIds?: string[];
     /** Org agents: the allowlisted agent id. */
     agentId?: string;
     /** Org agents: the agent's current name, when it is still a live agent of the org. */
@@ -22,16 +34,21 @@ export interface RosterEntry {
 export declare const ROSTER_DESCRIPTION_MAX = 1024;
 /** The description of `general-purpose` in the roster (spec §4.3, model-visible). */
 export declare const GENERAL_PURPOSE_DESCRIPTION = "a copy of you with your tools and skills, for multi-step work.";
-/** Plugin template type: `<plugin>:<name>`. */
-export declare const templateType: (plugin: string, name: string) => string;
+/** Plugin template type: `<plugin>:<name>`; the bare `<name>` for a template without a plugin. */
+export declare const templateType: typeof templateTypeOf;
 /**
  * Resolves the roster of `parent` (spec §4.3): `general-purpose` first unless
  * `subagents.general === false`, then the plugin templates, inline templates and allowlisted org
- * agents, each in the owner's order, at most {@link SUBAGENT_ROSTER_MAX} entries. Templates deleted
- * since the save are skipped; allowlisted org agents stay listed (the dispatch checks their gates
- * and refuses with the §4.5 text), with `agentName` only while the agent is live.
+ * agents, each in the owner's order, at most {@link SUBAGENT_ROSTER_MAX} entries. Templates are
+ * the org's and the platform's ({@link loadTemplates}); ones deleted or off since the save are
+ * skipped. A template whose type is taken (`general-purpose`, an earlier template, an inline
+ * template's name; only a bare `<name>` can clash with the last two kinds, and the save refuses
+ * every clash) is skipped with a warning; when it resolves to the same platform template as the
+ * entry kept, its id becomes that entry's alias. Allowlisted org agents stay listed (the dispatch
+ * checks their gates and refuses with the §4.5 text), with `agentName` only while the agent is
+ * live.
  */
-export declare function resolveRoster(db: KernelDb, orgId: string, parent: Pick<AgentDefinition, "subagents">): Promise<RosterEntry[]>;
+export declare function resolveRoster(db: KernelSchemaDb, orgId: string, parent: Pick<AgentDefinition, "subagents">, log?: Pick<Logger, "warn">): Promise<RosterEntry[]>;
 /**
  * The roster entry for a requested `subagent_type`: an exact type first; else a bare `<name>`
  * matches the plugin template `<plugin>:<name>` when exactly one has it (as Claude Code accepts
@@ -45,10 +62,10 @@ export declare const isGeneralAlias: (agent: string) => boolean;
  * `general-purpose` for no `agent` and Claude's built-in types; else a roster type (a bare name
  * prefers the skill's own plugin's template `<plugin>:<name>`, then {@link findType}). An `agent`
  * that does not resolve falls back to `general-purpose` and is returned as `unknown`. `inRoster`:
- * the type is one the parent's `agent` tool offers (`general-purpose` is not when
+ * the type is one the parent's `Agent` tool offers (`general-purpose` is not when
  * `subagents.general === false`, which does not block a person's fork invocation).
  */
-export declare function resolveSkillForkType(db: KernelDb, orgId: string, parent: Pick<AgentDefinition, "subagents">, agent: string | undefined, plugin: string | undefined): Promise<{
+export declare function resolveSkillForkType(db: KernelSchemaDb, orgId: string, parent: Pick<AgentDefinition, "subagents">, agent: string | undefined, plugin: string | undefined): Promise<{
     agentType: string;
     unknown?: string;
     inRoster: boolean;

package/dist/runtime/subagents/roster.js

@@ -1,19 +1,24 @@
-import { SUBAGENT_ROSTER_MAX } from "../../agents/agents.service.js";
-import { loadTemplates } from "../../agents/templates.js";
+import { SUBAGENT_ROSTER_MAX } from "../../agents/definition.js";
+import { loadTemplates, templateTypeOf } from "../../agents/templates.js";
 export const ROSTER_DESCRIPTION_MAX = 1024;
 /** The description of `general-purpose` in the roster (spec §4.3, model-visible). */
 export const GENERAL_PURPOSE_DESCRIPTION = "a copy of you with your tools and skills, for multi-step work.";
 const cut = (s) => s.slice(0, ROSTER_DESCRIPTION_MAX);
-/** Plugin template type: `<plugin>:<name>`. */
-export const templateType = (plugin, name) => `${plugin}:${name}`;
+/** Plugin template type: `<plugin>:<name>`; the bare `<name>` for a template without a plugin. */
+export const templateType = templateTypeOf;
 /**
  * Resolves the roster of `parent` (spec §4.3): `general-purpose` first unless
  * `subagents.general === false`, then the plugin templates, inline templates and allowlisted org
- * agents, each in the owner's order, at most {@link SUBAGENT_ROSTER_MAX} entries. Templates deleted
- * since the save are skipped; allowlisted org agents stay listed (the dispatch checks their gates
- * and refuses with the §4.5 text), with `agentName` only while the agent is live.
+ * agents, each in the owner's order, at most {@link SUBAGENT_ROSTER_MAX} entries. Templates are
+ * the org's and the platform's ({@link loadTemplates}); ones deleted or off since the save are
+ * skipped. A template whose type is taken (`general-purpose`, an earlier template, an inline
+ * template's name; only a bare `<name>` can clash with the last two kinds, and the save refuses
+ * every clash) is skipped with a warning; when it resolves to the same platform template as the
+ * entry kept, its id becomes that entry's alias. Allowlisted org agents stay listed (the dispatch
+ * checks their gates and refuses with the §4.5 text), with `agentName` only while the agent is
+ * live.
  */
-export async function resolveRoster(db, orgId, parent) {
+export async function resolveRoster(db, orgId, parent, log) {
     const sub = parent.subagents;
     const out = [];
     if (sub?.general !== false) {
@@ -24,19 +29,50 @@ export async function resolveRoster(db, orgId, parent) {
         });
     }
     const templateIds = sub?.templates ?? [];
-    const templates = await loadTemplates(db, orgId, templateIds);
+    const templates = await loadTemplates(db, orgId, templateIds, log);
+    const inlineNames = new Set((sub?.inline ?? []).map((t) => t.name));
+    const kept = new Map();
+    const alias = (e, id) => {
+        if (e.templateId !== id && !e.aliasTemplateIds?.includes(id)) {
+            e.aliasTemplateIds = [...(e.aliasTemplateIds ?? []), id];
+        }
+    };
     for (const id of templateIds) {
         const r = templates.get(id);
         if (!r)
             continue;
+        const type = templateType(r.plugin, r.name);
+        const first = kept.get(type);
+        if (first !== undefined || type === "general-purpose" || inlineNames.has(type)) {
+            if (first !== undefined &&
+                (first.entry.templateId === r.id ||
+                    (r.platformTemplateId !== undefined && first.platformTemplateId === r.platformTemplateId))) {
+                alias(first.entry, id);
+                continue;
+            }
+            log?.warn("agent template skipped in the roster: its type is taken", {
+                orgId,
+                type,
+                templateId: r.id,
+            });
+            continue;
+        }
         const description = r.template.description;
-        out.push({
-            type: templateType(r.plugin, r.name),
+        const entry = {
+            type,
             source: "plugin",
             description: cut(typeof description === "string" ? description : ""),
             templateId: r.id,
-            plugin: r.plugin,
+            ...(r.plugin ? { plugin: r.plugin } : {}),
+        };
+        // a selected platform id that an org row of the same component shadows resolves to that row
+        if (r.id !== id)
+            alias(entry, id);
+        kept.set(type, {
+            entry,
+            ...(r.platformTemplateId !== undefined && { platformTemplateId: r.platformTemplateId }),
         });
+        out.push(entry);
     }
     for (const t of sub?.inline ?? []) {
         out.push({ type: t.name, source: "inline", description: cut(t.description) });
@@ -90,7 +126,7 @@ export const isGeneralAlias = (agent) => GENERAL_ALIASES.has(agent);
  * `general-purpose` for no `agent` and Claude's built-in types; else a roster type (a bare name
  * prefers the skill's own plugin's template `<plugin>:<name>`, then {@link findType}). An `agent`
  * that does not resolve falls back to `general-purpose` and is returned as `unknown`. `inRoster`:
- * the type is one the parent's `agent` tool offers (`general-purpose` is not when
+ * the type is one the parent's `Agent` tool offers (`general-purpose` is not when
  * `subagents.general === false`, which does not block a person's fork invocation).
  */
 export async function resolveSkillForkType(db, orgId, parent, agent, plugin) {

package/dist/runtime/subagents/skill-fork.d.ts

@@ -1,21 +1,20 @@
-import type { Transaction } from "kysely";
 import type { EventLog } from "../../conversations/event-log.js";
 import type { ConversationEvent, EventPayload } from "../../conversations/events.js";
-import type { KernelDatabase } from "../../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
 import { ApiError } from "../../errors.js";
 import type { SkillInvoker } from "../../skills/invoke.js";
-import type { LoopContext, WaitingFor } from "../loop.js";
+import { type LoopContext, type WaitingFor } from "../loop.js";
 import { type DispatchDeps } from "./dispatch.js";
 /**
  * Forked skills (phase D spec §6): a person's invocation of a `context: fork` skill starts its own
  * run (the run boundary, {@link forkBoundary}), whose `prepare` node dispatches the sub-agent
- * through phase C's `dispatchSubagent` before any model call and waits on it like an `agent` call
- * (`subagents` wait `sa-<runId>-0`). When the child has ended, `prepare` appends the model-visible
+ * through phase C's `dispatchSubagent` before any model call and waits on it (`subagents` wait
+ * `sa-<runId>-0`; the dispatch row has `for_skill`, agent map spec §5.4: a fork stays in the
+ * foreground while `Agent` calls run in the background). When the child has ended, `prepare` appends the model-visible
  * `skill_fork_result` and the parent's model answers. Every terminal path of the run (and the wait
  * sweep) pairs a fork invocation without a report ({@link pairStoppedForks}), so the log never holds
  * a fork lead whose report is missing before the next model call.
  */
-type KernelTrx = Transaction<KernelDatabase>;
 /** The dispatch's parent call id (no `:`; there is no tool call). */
 export declare const skillCallId: (seq: number) => string;
 /** Idempotency key of a fork invocation's report (one per invocation, whatever the run). */
@@ -109,15 +108,16 @@ export declare const recordedSkillForks: (eventLog: Pick<EventLog, "append" | "f
     payload: unknown;
 }[]) => SkillForks;
 /**
- * In the transaction `t` of a run's terminal path (or the wait sweep): the run's fork invocation
+ * In the transaction of a run's terminal path (or the wait sweep): the run's fork invocation
  * (its trigger message, by the run boundary) without a report gets one now: the ended child's
  * result (and the parent's missing `subagent_finished`), {@link AGENT_STOPPED_WITH_RUN_TEXT} for a
- * child still active (the caller stops it after its commit, as for `agent` calls), or
+ * child still active (the caller stops it after its commit, as for `Agent` calls), or
  * {@link FORK_NOT_STARTED_TEXT} when nothing was dispatched. Returns the call ids written
  * (`skill-<seq>`) and the highest seq; the caller notifies after its commit.
  */
-export declare function pairStoppedForks(t: KernelTrx, eventLog: EventLog, runId: string): Promise<{
+export declare function pairStoppedForks(
+/** The caller's transaction (the context's handle). */
+t: KernelSchemaDb, eventLog: EventLog, runId: string): Promise<{
     callIds: string[];
     toSeq: number | null;
 }>;
-export {};

package/dist/runtime/subagents/skill-fork.js

@@ -1,9 +1,19 @@
 import { ApiError } from "../../errors.js";
 import { AGENT_STOPPED_WITH_RUN_TEXT } from "../../tools/builtins/agent.js";
-import { subagentsWait } from "../../tools/pipeline.js";
+import { subagentsWait } from "../loop.js";
 import { TERMINAL_STATUSES } from "../run-finish.js";
 import { childResult, dispatchOfCall, finishedEvent } from "./child.js";
 import { dispatchSubagent } from "./dispatch.js";
+/**
+ * Forked skills (phase D spec §6): a person's invocation of a `context: fork` skill starts its own
+ * run (the run boundary, {@link forkBoundary}), whose `prepare` node dispatches the sub-agent
+ * through phase C's `dispatchSubagent` before any model call and waits on it (`subagents` wait
+ * `sa-<runId>-0`; the dispatch row has `for_skill`, agent map spec §5.4: a fork stays in the
+ * foreground while `Agent` calls run in the background). When the child has ended, `prepare` appends the model-visible
+ * `skill_fork_result` and the parent's model answers. Every terminal path of the run (and the wait
+ * sweep) pairs a fork invocation without a report ({@link pairStoppedForks}), so the log never holds
+ * a fork lead whose report is missing before the next model call.
+ */
 /** The dispatch's parent call id (no `:`; there is no tool call). */
 export const skillCallId = (seq) => `skill-${seq}`;
 /** Idempotency key of a fork invocation's report (one per invocation, whatever the run). */
@@ -83,7 +93,7 @@ export async function advanceSkillForks(d, a) {
     const callId = skillCallId(seq);
     const row = await dispatchOfCall(d.db, ctx.runId, callId);
     if (row) {
-        const r = await childResult(d.eventLog, row, { forSkill: true });
+        const r = await childResult(d.eventLog, row);
         if (!r)
             return ctx.signal.aborted ? { kind: "aborted" } : suspend(d, ctx);
         await report(r.content, row, [finishedEvent(row, r.finished)]);
@@ -146,7 +156,7 @@ export async function advanceSkillForks(d, a) {
 }
 const suspend = (d, ctx) => ({
     kind: "suspend",
-    waitingFor: subagentsWait(ctx.runId, FORK_STEP, d.config()),
+    waitingFor: subagentsWait(ctx.runId, FORK_STEP, d.config.get()),
 });
 /** The live handler for the loop (`LoopDeps.skillForks`). */
 export const liveSkillForks = (d) => ({
@@ -178,14 +188,16 @@ export const recordedSkillForks = (eventLog, recorded) => ({
     },
 });
 /**
- * In the transaction `t` of a run's terminal path (or the wait sweep): the run's fork invocation
+ * In the transaction of a run's terminal path (or the wait sweep): the run's fork invocation
  * (its trigger message, by the run boundary) without a report gets one now: the ended child's
  * result (and the parent's missing `subagent_finished`), {@link AGENT_STOPPED_WITH_RUN_TEXT} for a
- * child still active (the caller stops it after its commit, as for `agent` calls), or
+ * child still active (the caller stops it after its commit, as for `Agent` calls), or
  * {@link FORK_NOT_STARTED_TEXT} when nothing was dispatched. Returns the call ids written
  * (`skill-<seq>`) and the highest seq; the caller notifies after its commit.
  */
-export async function pairStoppedForks(t, eventLog, runId) {
+export async function pairStoppedForks(
+/** The caller's transaction (the context's handle). */
+t, eventLog, runId) {
     const none = { callIds: [], toSeq: null };
     const run = await t
         .selectFrom("runs as r")
@@ -225,6 +237,7 @@ export async function pairStoppedForks(t, eventLog, runId) {
         "parent_conversation_id",
         "child_conversation_id",
         "child_run_id",
+        "budget_run_id",
     ])
         .where("parent_run_id", "=", runId)
         .where("parent_call_id", "=", callId)
@@ -240,6 +253,8 @@ export async function pairStoppedForks(t, eventLog, runId) {
             parentConversationId: d.parent_conversation_id,
             childConversationId: d.child_conversation_id,
             childRunId: d.child_run_id,
+            budgetRunId: d.budget_run_id,
+            forSkill: true,
         };
         const child = await t
             .selectFrom("runs")
@@ -248,12 +263,12 @@ export async function pairStoppedForks(t, eventLog, runId) {
             .executeTakeFirst();
         // a child that already ended keeps its own result (its log is committed)
         const ended = child !== undefined && TERMINAL_STATUSES.has(child.status)
-            ? await childResult(eventLog, row, { forSkill: true })
+            ? await childResult(eventLog, row)
             : null;
         if (ended)
             events.push(finishedEvent(row, ended.finished));
         events.push(reportEvent(runId, seq, forkReportText(skill.name, ended ? ended.content : AGENT_STOPPED_WITH_RUN_TEXT), row));
     }
-    const out = await eventLog.append(conversationId, events, t);
+    const out = await eventLog.appendIn(conversationId, events);
     return { callIds: [callId], toSeq: Math.max(...out.map((e) => e.seq)) };
 }

package/dist/runtime/subagents/status.d.ts

@@ -0,0 +1,14 @@
+import type { EventPayload } from "../../conversations/events.js";
+/** How a sub-agent's run ended (`subagent_finished.status`, a finished `subagent_delivery`). */
+export type SubagentStatus = EventPayload<"subagent_finished">["status"];
+/** Who stopped an aborted sub-agent: a person, or the kernel on its parent run's behalf. */
+export type SubagentAbortedBy = "user" | "parent";
+/**
+ * How a sub-agent's run ended, as the model reads it: the status of `agentResultText`'s bracket
+ * line (a fork invocation's report) and of a finished `subagent_delivery`
+ * (`renderSubagentDelivery`).
+ */
+export declare function subagentStatusText(status: SubagentStatus, opts?: {
+    errorCode?: string | undefined;
+    abortedBy?: SubagentAbortedBy | undefined;
+}): string;

package/dist/runtime/subagents/status.js

@@ -0,0 +1,23 @@
+/**
+ * How a sub-agent's run ended, as the model reads it: the status of `agentResultText`'s bracket
+ * line (a fork invocation's report) and of a finished `subagent_delivery`
+ * (`renderSubagentDelivery`).
+ */
+export function subagentStatusText(status, opts = {}) {
+    switch (status) {
+        case "completed":
+            return "completed";
+        case "max_steps":
+            return "stopped at the step limit; the reply may be partial";
+        case "max_duration":
+            return "stopped at the time limit; the reply may be partial";
+        case "budget":
+            return "stopped: token budget used up";
+        case "aborted":
+            return opts.abortedBy === "parent" ? "stopped with this run" : "stopped by the user";
+        case "timed_out":
+            return "timed out";
+        case "failed":
+            return opts.errorCode === undefined ? "failed" : `failed (${opts.errorCode})`;
+    }
+}

package/dist/runtime/subagents/subagents.service.d.ts

@@ -0,0 +1,43 @@
+import type { ExtensionContext } from "@capybara-hq/plugin-sdk";
+import { EventLog } from "../../conversations/event-log.js";
+import { KernelConfigService } from "../../infra/config/kernel-config.service.js";
+import { KernelDb } from "../../infra/database/kernel-db.js";
+import { TransactionHost } from "../../infra/database/transaction-host.js";
+import type { KernelLogger } from "../../log.js";
+import { ModelPurposesService } from "../../models/purposes.js";
+import { SkillInvoker } from "../../skills/invoke.js";
+import { ProviderRegistry } from "../providers.js";
+import { RunJobs } from "../run-jobs.js";
+import { type ChildWriter, type DispatchArgs, type DispatchCommit, type DispatchOutcome, type DispatchPlan } from "./dispatch.js";
+import { type SubagentStep } from "./progress.js";
+import { type SkillForkDeps, type SkillForks } from "./skill-fork.js";
+/**
+ * Sub-agents (phase C, spec §7) and forked skills (phase D): the `Agent` tool's dispatch (the
+ * tool pipeline calls {@link dispatch}), a run's fork invocation ({@link skillForks}, the loop's
+ * `prepare`) and a child step's progress on the parent's stream ({@link progress}). Child runs go
+ * to the sub-agent run queue through {@link RunJobs}. The child lifecycle after dispatch is the
+ * waits' (`Waits.childFinished`): a background child's finish is delivered to its parent
+ * ({@link SubagentDeliveries}), a fork invocation's child resumes its waiting parent run.
+ */
+export declare class SubagentsService {
+    private readonly bus;
+    private readonly log;
+    readonly txHost: TransactionHost;
+    /** The dispatch's dependencies (`dispatch.ts`, `skill-fork.ts`). */
+    readonly deps: SkillForkDeps;
+    /** The live fork handler of the loop (`LoopDeps.skillForks`). */
+    readonly skillForks: SkillForks;
+    constructor(kdb: KernelDb, eventLog: EventLog, purposes: ModelPurposesService, registry: ProviderRegistry, config: KernelConfigService, jobs: RunJobs, invoker: SkillInvoker, bus: ExtensionContext["bus"], log: KernelLogger, txHost: TransactionHost);
+    /** Dispatches the sub-agent of one `Agent` call (`dispatchSubagent`). */
+    dispatch(a: DispatchArgs): Promise<DispatchOutcome>;
+    /** The dispatch's writes in a transaction of their own (see `commitDispatchIn`). */
+    commitDispatch(a: DispatchArgs, plan: DispatchPlan, child: ChildWriter): Promise<DispatchCommit | null>;
+    /** A sub-agent's finished step on its parent's stream (sub-agents spec §14.2). Never throws. */
+    progress(s: SubagentStep): Promise<void>;
+}
+/**
+ * Sub-agent dispatch, deliveries and messages (the tools domain's `Agent`, `SendMessage` and
+ * `SubagentHandback`, the run loop, the waits).
+ */
+export declare class SubagentsModule {
+}