@capybara-hq/kernel 0.1.0-rc.0 → 0.1.0-rc.2

package/dist/runtime/subagents/child.js

@@ -1,7 +1,5 @@
 import { usageTokens } from "../../evals/budget.js";
 import { agentResultText } from "../../tools/builtins/agent.js";
-import { TERMINAL_STATUSES } from "../run-finish.js";
-import { ACTIVE_RUN_STATUSES } from "../run-queue.js";
 /** Idempotency key of the parent's `subagent_finished` event. */
 export const finishedIdemKey = (childRunId) => `subagent_finished:${childRunId}`;
 const DISPATCH_COLUMNS = [
@@ -146,80 +144,3 @@ export const finishedEvent = (row, finished) => ({
     idemKey: finishedIdemKey(row.childRunId),
     payload: finished,
 });
-/**
- * After a child run's terminal state committed (spec §7.3): appends `subagent_finished` to the
- * parent log (idempotent; allowed while the parent waits, it is not model-visible) and tries
- * `Waits.resume(parentRunId, childRunId)`. Every finishing child tries; the conditional resume lets
- * exactly one succeed, the last to see all its siblings terminal. A run that is not a dispatched
- * child, or not terminal yet, is left alone. A crash in between is repaired by the wait sweep and
- * by the parent's tools node, which writes a missing `subagent_finished` itself.
- */
-export async function onChildFinished(d, childRunId) {
-    const row = await dispatchOfChildRun(d.db, childRunId);
-    if (!row)
-        return;
-    const run = await d.db
-        .selectFrom("runs")
-        .select("status")
-        .where("id", "=", childRunId)
-        .executeTakeFirst();
-    if (!run || !TERMINAL_STATUSES.has(run.status))
-        return;
-    const r = await childResult(d.eventLog, row);
-    if (!r) {
-        d.log.warn("sub-agent run is terminal without a terminal event", { childRunId });
-        return;
-    }
-    await d.eventLog.append(row.parentConversationId, [finishedEvent(row, r.finished)]);
-    await d.waits.resume(row.parentRunId, childRunId);
-}
-/**
- * Stops the active children of a parent run (sub-agents spec §12), or only those dispatched in
- * `opts.step`: a `waiting` child through its own `abortWaiting`, a `queued` / `running` one that
- * no worker holds directly (`abortIfOrphaned`), any other through `RunAbort.request` (the
- * cross-replica broadcast plus the marker key, so a child that starts later still sees it), after
- * which a child found `waiting` is stopped through `abortWaiting` too. A child stopped here is
- * reported to the parent at once (by `abortWaiting` itself, or {@link onChildFinished} after
- * `abortIfOrphaned`); one stopped by its worker is reported by that worker. Returns the number of
- * children asked to stop.
- *
- * `byAccountId` is the person whose action stops them, or null when the kernel stops them on the
- * parent's behalf; a child stopped with null reports the §4.4 "parent's stop" text.
- */
-export async function stopChildren(d, parentRunId, byAccountId, opts = {}) {
-    let q = d.db
-        .selectFrom("subagent_dispatches as sd")
-        .innerJoin("runs as cr", "cr.id", "sd.child_run_id")
-        .select(["sd.child_conversation_id", "sd.child_run_id", "cr.status"])
-        .where("sd.parent_run_id", "=", parentRunId)
-        .where("cr.status", "in", ACTIVE_RUN_STATUSES);
-    if (opts.step !== undefined)
-        q = q.where("sd.step", "=", opts.step);
-    const children = await q.execute();
-    for (const c of children) {
-        const conv = c.child_conversation_id;
-        const runId = c.child_run_id;
-        // abortWaiting reports the stopped child to the parent itself (Waits.subagents.finished)
-        if (c.status === "waiting" &&
-            (await d.waits.abortWaiting(conv, runId, byAccountId, opts.detail))) {
-            continue;
-        }
-        if (await d.runQueue.abortIfOrphaned(conv, runId, byAccountId, opts.detail)) {
-            await onChildFinished(d, runId);
-            continue;
-        }
-        await d.abort.request(runId, byAccountId, opts.detail);
-        // the suspend handshake (see Waits.suspend): a child that became `waiting` after the read
-        // above may have checked the marker before it was set, so check `waiting` again after setting
-        // it (review M1)
-        const now = await d.db
-            .selectFrom("runs")
-            .select("status")
-            .where("id", "=", runId)
-            .executeTakeFirst();
-        if (now?.status === "waiting") {
-            await d.waits.abortWaiting(conv, runId, byAccountId, opts.detail);
-        }
-    }
-    return children.length;
-}

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

@@ -1,8 +1,8 @@
 import { type AgentTemplateTier } from "@capybara-hq/plugin-sdk";
 import type { AgentDefinition, AgentToolRef, ModelRef } from "../../agents/definition.js";
-import type { KernelConfig } from "../../config/schema.js";
 import type { EventPayload } from "../../conversations/events.js";
-import type { KernelDb } from "../../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
+import type { KernelConfigService } from "../../infra/config/kernel-config.service.js";
 import type { ModelPurposesService } from "../../models/purposes.js";
 import type { ProviderRegistry } from "../providers.js";
 import type { RosterEntry } from "./roster.js";
@@ -29,11 +29,11 @@ export interface EffectiveDefinition {
     warnings: string[];
 }
 export interface EffectiveDefinitionDeps {
-    db: KernelDb;
+    db: KernelSchemaDb;
     purposes: Pick<ModelPurposesService, "resolve">;
     /** Reads the resolved model's parameter declarations (a template `effort`). */
     registry: Pick<ProviderRegistry, "resolve">;
-    config: () => KernelConfig;
+    config: Pick<KernelConfigService, "get">;
 }
 type Policy = "ask" | "deny";
 /**

package/dist/runtime/subagents/definition.js

@@ -246,7 +246,7 @@ function orgAgentDefinition(d, a) {
     return {
         definition,
         template: { source: "agent", id: agentId, version: a.orgAgent.version },
-        maxSteps: d.config().runtime.maxSteps,
+        maxSteps: d.config.get().runtime.maxSteps,
         warnings: [],
         model: own.model,
         tierFallback: false,
@@ -268,7 +268,7 @@ function orgAgentDefinition(d, a) {
 export async function effectiveDefinition(d, a) {
     if (a.entry.source === "agent")
         return orgAgentDefinition(d, a);
-    const runtimeMax = d.config().runtime.maxSteps;
+    const runtimeMax = d.config.get().runtime.maxSteps;
     const { parent, entry } = a;
     let template = null;
     let ref = { source: entry.source };

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

@@ -1,24 +1,44 @@
 import type { Logger } from "@capybara-hq/plugin-sdk";
 import { type AgentDefinition } from "../../agents/definition.js";
-import type { KernelConfig } from "../../config/schema.js";
 import type { EventLog } from "../../conversations/event-log.js";
-import type { EventPayload } from "../../conversations/events.js";
-import type { ConversationKind, KernelDb } from "../../db/kernel-schema.js";
+import type { ConversationEvent, EventPayload } from "../../conversations/events.js";
+import type { ConversationKind, KernelSchemaDb } from "../../db/kernel-schema.js";
+import type { KernelConfigService } from "../../infra/config/kernel-config.service.js";
 import type { ModelPurposesService } from "../../models/purposes.js";
 import { type AgentToolInputT } from "../../tools/builtins/agent.js";
 import type { ToolStepContext } from "../../tools/pipeline.js";
 import type { ProviderRegistry } from "../providers.js";
-import { type RunJobData } from "../run-queue.js";
+import { type RunJobData } from "../run-jobs.js";
+import { type CheckedOrgAgent } from "./definition.js";
+import { type RosterEntry } from "./roster.js";
 export interface DispatchDeps {
-    db: KernelDb;
+    /** The context's handle: inside {@link commitDispatchIn} it is the dispatch's transaction. */
+    db: KernelSchemaDb;
     eventLog: EventLog;
     purposes: Pick<ModelPurposesService, "resolve">;
     registry: Pick<ProviderRegistry, "resolve">;
-    config: () => KernelConfig;
+    config: Pick<KernelConfigService, "get">;
     /** Enqueues a child run (on the sub-agent run queue: `kind` is always `subagent`). */
     enqueue: (data: RunJobData, jobId: string, kind: ConversationKind) => Promise<void>;
     log: Pick<Logger, "error" | "warn">;
+    /**
+     * Runs {@link commitDispatchIn} in a transaction of its own (`SubagentsService.commitDispatch`,
+     * a `@Transactional` method).
+     */
+    commitDispatch: (a: DispatchArgs, plan: DispatchPlan, child: ChildWriter) => Promise<DispatchCommit | null>;
 }
+/** One dispatch's call. */
+export interface DispatchArgs {
+    ctx: ToolStepContext;
+    callId: string;
+    input: AgentToolInputT;
+    forSkill?: SkillForkDispatch;
+}
+/**
+ * Writes the child's events in the dispatch's transaction (`db` is its handle); `checked` is the
+ * org agent version the in-lock gates passed. Null refuses.
+ */
+export type ChildWriter = (db: KernelSchemaDb, checked?: CheckedOrgAgent) => Promise<ConversationEvent | null>;
 export type DispatchOutcome = {
     kind: "dispatched";
     childRunId: string;
@@ -44,6 +64,24 @@ export interface SkillForkDispatch {
 }
 /** Idempotency key of the parent's `subagent_dispatched` event. */
 export declare const dispatchedIdemKey: (runId: string, callId: string) => string;
+/** What one dispatch writes, decided before its transaction. */
+export interface DispatchPlan {
+    childConversationId: string;
+    agentType: string;
+    source: RosterEntry["source"];
+    /**
+     * The child conversation's agent and its run's `agent_version`: the parent's for
+     * general-purpose and templates, the dispatched agent's frozen version for an org agent (§5.5).
+     */
+    agentId: string;
+    agentVersion: number;
+    resumed: boolean;
+    model: {
+        provider: string;
+        model: string;
+    };
+    tierFallback: boolean;
+}
 /**
  * Dispatches the sub-agent of one `agent` call (spec §7.1), after the pipeline's validation,
  * policy, approval and `tool.preExecute` stages. A new sub-agent: resolves its type and effective
@@ -67,3 +105,46 @@ export declare function dispatchSubagent(d: DispatchDeps, a: {
     /** Phase D: a person's fork invocation (see {@link SkillForkDispatch}). */
     forSkill?: SkillForkDispatch;
 }): Promise<DispatchOutcome>;
+/**
+ * The dispatch transaction shared by new sub-agents and follow-ups: locks the parent conversation
+ * row, then the parent run row (the order every terminal path uses),
+ * runs `child` (writes the child conversation's first events and returns the task message, or
+ * null to refuse), then inserts the child run and the dispatch row, appends `subagent_dispatched`
+ * and the audit row. After commit: notifies both conversations and enqueues the child run.
+ * Returns null when `child` refused.
+ *
+ * Under the parent run's row lock it first re-checks what the pipeline checked without it: a call
+ * already dispatched (a second holder of the same step, e.g. after a stalled-job takeover) gets
+ * the existing child run back and writes nothing, and a parent run that is no longer `running`
+ * (stopped, orphaned) dispatches nothing. Then the run's limits (§8.2, {@link subagentLimits}),
+ * read fresh: its children's token counter at or over the cap, its dispatches (follow-ups
+ * included) at the cap, or as many active children as may run at once each refuse with the §4.5
+ * text. The lock serializes the dispatches of one run, so the counts cannot race.
+ */
+/** What the dispatch transaction did. */
+export type DispatchCommit = {
+    kind: "existing";
+    childRunId: string;
+    requeue: {
+        conversationId: string;
+        seq: number;
+    } | null;
+} | {
+    kind: "stopped";
+} | {
+    kind: "limit";
+    content: string;
+} | {
+    kind: "gate";
+    outcome: DispatchOutcome;
+} | {
+    kind: "written";
+    childRunId: string;
+    childSeq: number;
+    parentSeq: number;
+};
+/**
+ * {@link commit}'s transaction (run by `SubagentsService.commitDispatch`, `d.db` its handle).
+ * Null when `child` refused.
+ */
+export declare function commitDispatchIn(d: Pick<DispatchDeps, "db" | "eventLog" | "config">, a: DispatchArgs, plan: DispatchPlan, child: ChildWriter): Promise<DispatchCommit | null>;

package/dist/runtime/subagents/dispatch.js

@@ -4,7 +4,7 @@ import { normalizeStoredDefinition } from "../../agents/definition.js";
 import { audit } from "../../identity/audit.js";
 import { forkAgentUnknownText } from "../../skills/invoke.js";
 import { AGENT_REFUSALS } from "../../tools/builtins/agent.js";
-import { ACTIVE_RUN_STATUSES, runJobId } from "../run-queue.js";
+import { ACTIVE_RUN_STATUSES, runJobId } from "../run-jobs.js";
 import { effectiveDefinition, narrowFollowUp, SubagentTypeGoneError, } from "./definition.js";
 import { subagentLimits } from "./limits.js";
 import { auditRefusal, checkOrgAgent, currentAgentDefinition } from "./org-agents.js";
@@ -118,7 +118,7 @@ export async function dispatchSubagent(d, a) {
             subagent_type: entry.type,
         })
             .execute();
-        const [, task] = await d.eventLog.append(childId, [
+        const [, task] = await d.eventLog.appendIn(childId, [
             {
                 type: "subagent_started",
                 idemKey: "subagent_started",
@@ -149,7 +149,7 @@ export async function dispatchSubagent(d, a) {
                 },
             },
             taskMessage(ctx, a.callId, fork === undefined ? input.prompt : fork.task(eff.definition), undefined, fork?.skill),
-        ], t);
+        ]);
         return task;
     });
     // a new sub-agent's writer never refuses
@@ -234,7 +234,9 @@ async function resume(d, a) {
             .executeTakeFirst();
         if (await activeRun())
             return null;
-        const [task] = await d.eventLog.append(child.id, [taskMessage(ctx, a.callId, a.input.prompt, narrowFollowUp(frozen, current))], t);
+        const [task] = await d.eventLog.appendIn(child.id, [
+            taskMessage(ctx, a.callId, a.input.prompt, narrowFollowUp(frozen, current)),
+        ]);
         return task;
     }).then((r) => r ?? refused(AGENT_REFUSALS.stillRunning(a.id)));
 }
@@ -290,153 +292,145 @@ skill) => ({
     },
 });
 /**
- * The dispatch transaction shared by new sub-agents and follow-ups: locks the parent conversation
- * row, then the parent run row (the order every terminal path uses),
- * runs `child` (writes the child conversation's first events and returns the task message, or
- * null to refuse), then inserts the child run and the dispatch row, appends `subagent_dispatched`
- * and the audit row. After commit: notifies both conversations and enqueues the child run.
- * Returns null when `child` refused.
- *
- * Under the parent run's row lock it first re-checks what the pipeline checked without it: a call
- * already dispatched (a second holder of the same step, e.g. after a stalled-job takeover) gets
- * the existing child run back and writes nothing, and a parent run that is no longer `running`
- * (stopped, orphaned) dispatches nothing. Then the run's limits (§8.2, {@link subagentLimits}),
- * read fresh: its children's token counter at or over the cap, its dispatches (follow-ups
- * included) at the cap, or as many active children as may run at once each refuse with the §4.5
- * text. The lock serializes the dispatches of one run, so the counts cannot race.
+ * {@link commit}'s transaction (run by `SubagentsService.commitDispatch`, `d.db` its handle).
+ * Null when `child` refused.
  */
-async function commit(d, a, plan, 
-/** Writes the child's events; `checked` is the org agent version the in-lock gates passed. */
-child) {
+export async function commitDispatchIn(d, a, plan, child) {
     const { ctx, callId, input } = a;
     const childRunId = randomUUID();
-    const out = await d.db.transaction().execute(async (t) => {
-        // the documented order, conversation row then run row (run-finish.ts, abortWaiting): the
-        // append to the parent below takes the conversation row, so it is taken first here, or a stop
-        // racing this commit could deadlock (final review m2); the child's row comes last
+    const t = d.db;
+    // the documented order, conversation row then run row (run-finish.ts, abortWaiting): the
+    // append to the parent below takes the conversation row, so it is taken first here, or a stop
+    // racing this commit could deadlock (final review m2); the child's row comes last
+    await t
+        .selectFrom("conversations")
+        .select("id")
+        .where("id", "=", ctx.conversationId)
+        .forUpdate()
+        .executeTakeFirst();
+    const parent = await t
+        .selectFrom("runs")
+        .select(["status", "subagent_tokens_used"])
+        .where("id", "=", ctx.runId)
+        .forUpdate()
+        .executeTakeFirst();
+    const existing = await t
+        .selectFrom("subagent_dispatches as sd")
+        .leftJoin("runs as cr", "cr.id", "sd.child_run_id")
+        .select(["sd.child_run_id", "sd.child_conversation_id", "cr.status", "cr.trigger_seq"])
+        .where("sd.parent_run_id", "=", ctx.runId)
+        .where("sd.parent_call_id", "=", callId)
+        .executeTakeFirst();
+    if (existing) {
+        return {
+            kind: "existing",
+            childRunId: existing.child_run_id,
+            // still queued: the first holder may have died before its enqueue (review M4)
+            requeue: existing.status === "queued" && existing.trigger_seq !== null
+                ? {
+                    conversationId: existing.child_conversation_id,
+                    seq: Number(existing.trigger_seq),
+                }
+                : null,
+        };
+    }
+    if (parent?.status !== "running")
+        return { kind: "stopped" };
+    const limit = await limitRefusal(t, d, ctx, parent.subagent_tokens_used);
+    if (limit !== null)
+        return { kind: "limit", content: limit };
+    let checked;
+    if (plan.source === "agent") {
+        // the org agent's gates again, under the parent run's lock, with both agents' rows held
+        // FOR SHARE (in id order) so a concurrent save of either serializes with this dispatch
         await t
-            .selectFrom("conversations")
+            .selectFrom("agents")
             .select("id")
-            .where("id", "=", ctx.conversationId)
-            .forUpdate()
-            .executeTakeFirst();
-        const parent = await t
-            .selectFrom("runs")
-            .select(["status", "subagent_tokens_used"])
-            .where("id", "=", ctx.runId)
-            .forUpdate()
-            .executeTakeFirst();
-        const existing = await t
-            .selectFrom("subagent_dispatches as sd")
-            .leftJoin("runs as cr", "cr.id", "sd.child_run_id")
-            .select(["sd.child_run_id", "sd.child_conversation_id", "cr.status", "cr.trigger_seq"])
-            .where("sd.parent_run_id", "=", ctx.runId)
-            .where("sd.parent_call_id", "=", callId)
-            .executeTakeFirst();
-        if (existing) {
-            return {
-                kind: "existing",
-                childRunId: existing.child_run_id,
-                // still queued: the first holder may have died before its enqueue (review M4)
-                requeue: existing.status === "queued" && existing.trigger_seq !== null
-                    ? {
-                        conversationId: existing.child_conversation_id,
-                        seq: Number(existing.trigger_seq),
-                    }
-                    : null,
-            };
-        }
-        if (parent?.status !== "running")
-            return { kind: "stopped" };
-        const limit = await limitRefusal(t, d, ctx, parent.subagent_tokens_used);
-        if (limit !== null)
-            return { kind: "limit", content: limit };
-        let checked;
-        if (plan.source === "agent") {
-            // the org agent's gates again, under the parent run's lock, with both agents' rows held
-            // FOR SHARE (in id order) so a concurrent save of either serializes with this dispatch
-            await t
-                .selectFrom("agents")
-                .select("id")
-                .where("id", "in", [ctx.agentId, plan.agentId])
-                .orderBy("id")
-                .forShare()
-                .execute();
-            const gates = await orgAgentGates(t, a, plan.agentId, plan.agentType, plan.resumed);
-            if ("refused" in gates)
-                return { kind: "gate", outcome: gates.refused };
-            checked = gates.checked;
-        }
-        const task = await child(t, checked);
-        if (task === null)
-            return null;
-        await t
-            .insertInto("runs")
-            .values({
-            id: childRunId,
-            conversation_id: plan.childConversationId,
-            status: "queued",
-            agent_version: plan.agentVersion,
-            trigger_account_id: ctx.accountId,
-            trigger_seq: task.seq,
-        })
+            .where("id", "in", [ctx.agentId, plan.agentId])
+            .orderBy("id")
+            .forShare()
             .execute();
-        await t
-            .insertInto("subagent_dispatches")
-            .values({
-            parent_run_id: ctx.runId,
-            parent_call_id: callId,
-            parent_conversation_id: ctx.conversationId,
-            step: ctx.step,
-            child_conversation_id: plan.childConversationId,
-            child_run_id: childRunId,
-            resumed: plan.resumed,
-        })
-            .execute();
-        const [dispatched] = await d.eventLog.append(ctx.conversationId, [
-            {
-                type: "subagent_dispatched",
-                runId: ctx.runId,
-                idemKey: dispatchedIdemKey(ctx.runId, callId),
-                payload: {
-                    step: ctx.step,
-                    callId,
-                    subagentId: plan.childConversationId,
-                    childRunId,
-                    agentType: plan.agentType,
-                    description: input.description,
-                    resumed: plan.resumed,
-                    model: { provider: plan.model.provider, model: plan.model.model },
-                    ...(plan.tierFallback && { tierFallback: true }),
-                    ...(a.forSkill !== undefined && { invokedSeq: a.forSkill.seq }),
-                },
-            },
-        ], t);
-        await audit(t, {
-            actorAccountId: ctx.accountId,
-            orgId: ctx.orgId,
-            action: "subagent.dispatched",
-            target: plan.childConversationId,
-            detail: {
-                parentConversationId: ctx.conversationId,
-                parentRunId: ctx.runId,
+        const gates = await orgAgentGates(t, a, plan.agentId, plan.agentType, plan.resumed);
+        if ("refused" in gates)
+            return { kind: "gate", outcome: gates.refused };
+        checked = gates.checked;
+    }
+    const task = await child(t, checked);
+    if (task === null)
+        return null;
+    await t
+        .insertInto("runs")
+        .values({
+        id: childRunId,
+        conversation_id: plan.childConversationId,
+        status: "queued",
+        agent_version: plan.agentVersion,
+        trigger_account_id: ctx.accountId,
+        trigger_seq: task.seq,
+    })
+        .execute();
+    await t
+        .insertInto("subagent_dispatches")
+        .values({
+        parent_run_id: ctx.runId,
+        parent_call_id: callId,
+        parent_conversation_id: ctx.conversationId,
+        step: ctx.step,
+        child_conversation_id: plan.childConversationId,
+        child_run_id: childRunId,
+        resumed: plan.resumed,
+    })
+        .execute();
+    const [dispatched] = await d.eventLog.appendIn(ctx.conversationId, [
+        {
+            type: "subagent_dispatched",
+            runId: ctx.runId,
+            idemKey: dispatchedIdemKey(ctx.runId, callId),
+            payload: {
+                step: ctx.step,
                 callId,
+                subagentId: plan.childConversationId,
+                childRunId,
                 agentType: plan.agentType,
-                source: plan.source,
-                ...(plan.source === "agent" && {
-                    agentId: plan.agentId,
-                    agentVersion: plan.agentVersion,
-                }),
+                description: input.description,
                 resumed: plan.resumed,
-                childRunId,
+                model: { provider: plan.model.provider, model: plan.model.model },
+                ...(plan.tierFallback && { tierFallback: true }),
+                ...(a.forSkill !== undefined && { invokedSeq: a.forSkill.seq }),
             },
-        });
-        return {
-            kind: "written",
-            childSeq: task.seq,
-            parentSeq: dispatched.seq,
-        };
+        },
+    ]);
+    await audit(t, {
+        actorAccountId: ctx.accountId,
+        orgId: ctx.orgId,
+        action: "subagent.dispatched",
+        target: plan.childConversationId,
+        detail: {
+            parentConversationId: ctx.conversationId,
+            parentRunId: ctx.runId,
+            callId,
+            agentType: plan.agentType,
+            source: plan.source,
+            ...(plan.source === "agent" && {
+                agentId: plan.agentId,
+                agentVersion: plan.agentVersion,
+            }),
+            resumed: plan.resumed,
+            childRunId,
+        },
     });
+    return {
+        kind: "written",
+        childRunId,
+        childSeq: task.seq,
+        parentSeq: dispatched.seq,
+    };
+}
+async function commit(d, a, plan, 
+/** Writes the child's events; `checked` is the org agent version the in-lock gates passed. */
+child) {
+    const { ctx } = a;
+    const out = await d.commitDispatch(a, plan, child);
     if (out === null)
         return null;
     if (out.kind === "existing") {
@@ -464,6 +458,7 @@ child) {
         return out.outcome;
     await d.eventLog.notify(plan.childConversationId, out.childSeq);
     await d.eventLog.notify(ctx.conversationId, out.parentSeq);
+    const childRunId = out.childRunId;
     const jobId = runJobId(plan.childConversationId, out.childSeq);
     try {
         await d.enqueue({ runId: childRunId, conversationId: plan.childConversationId }, jobId, "subagent");

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

@@ -1,6 +1,9 @@
-import type { Transaction } from "kysely";
 import { type KernelConfig } from "../../config/schema.js";
-import type { KernelDatabase, KernelDb } from "../../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
+/** The config the limits read (`KernelConfigService`, live: `subagents.*` is hot). */
+export interface SubagentsConfig {
+    get(): Pick<KernelConfig, "subagents">;
+}
 /** The sub-agent limits of one parent run (sub-agents spec §8.2). */
 export interface SubagentLimits {
     maxConcurrentPerRun: number;
@@ -14,10 +17,12 @@ export declare const SUBAGENT_LIMIT_DEFAULTS: SubagentLimits;
  * `subagentLimitOverrides`, value by value, over the hot config `subagents.*`. Read live (no cache),
  * in the caller's transaction when one is given, so every replica applies a change at once.
  */
-export declare function subagentLimits(db: KernelDb | Transaction<KernelDatabase>, config: () => Pick<KernelConfig, "subagents">, orgId: string): Promise<SubagentLimits>;
+export declare function subagentLimits(
+/** The pool, or the context's handle (a `@Transactional` caller's transaction). */
+db: KernelSchemaDb, config: SubagentsConfig, orgId: string): Promise<SubagentLimits>;
 /**
  * Whether the sub-agents of `parentRunId` have used their token budget (§8.3): its
  * `subagent_tokens_used`, read fresh, at or over `maxTokensPerRun`. A sub-agent's step checks it
  * before every model request and ends its run with `budget` when it is.
  */
-export declare function subagentBudgetUsedUp(db: KernelDb, config: () => Pick<KernelConfig, "subagents">, orgId: string, parentRunId: string): Promise<boolean>;
+export declare function subagentBudgetUsedUp(db: KernelSchemaDb, config: SubagentsConfig, orgId: string, parentRunId: string): Promise<boolean>;

package/dist/runtime/subagents/limits.js

@@ -7,8 +7,10 @@ export const SUBAGENT_LIMIT_DEFAULTS = KernelConfigSchema.shape.subagents.parse(
  * `subagentLimitOverrides`, value by value, over the hot config `subagents.*`. Read live (no cache),
  * in the caller's transaction when one is given, so every replica applies a change at once.
  */
-export async function subagentLimits(db, config, orgId) {
-    const base = config().subagents;
+export async function subagentLimits(
+/** The pool, or the context's handle (a `@Transactional` caller's transaction). */
+db, config, orgId) {
+    const base = config.get().subagents;
     const over = await readSubagentLimitOverride(db, orgId);
     return {
         maxConcurrentPerRun: over?.maxConcurrentPerRun ?? base.maxConcurrentPerRun,

package/dist/runtime/subagents/org-agents.d.ts

@@ -1,5 +1,5 @@
 import { type AgentDefinition } from "../../agents/definition.js";
-import type { KernelDb } from "../../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../../db/kernel-schema.js";
 /**
  * The gates an org agent sub-agent passes (spec §5.5), checked at every dispatch and every
  * follow-up: `deleted` (the agent is gone, or not of this org), `allowlist` (the parent agent's
@@ -22,7 +22,7 @@ export type OrgAgentCheck = {
  * dispatches at once). On success returns the agent's current version and definition, which the
  * caller freezes as is (never read again, so the frozen version is the one the gates saw).
  */
-export declare function checkOrgAgent(db: KernelDb, a: {
+export declare function checkOrgAgent(db: KernelSchemaDb, a: {
     orgId: string;
     parentDefinition: Pick<AgentDefinition, "subagents">;
     agentId: string;
@@ -32,12 +32,12 @@ export declare function checkOrgAgent(db: KernelDb, a: {
  * The parent agent's current definition (the allowlist gate reads it, not the run's version), or
  * null when the agent no longer exists or is deleted.
  */
-export declare function currentAgentDefinition(db: KernelDb, agentId: string): Promise<AgentDefinition | null>;
+export declare function currentAgentDefinition(db: KernelSchemaDb, agentId: string): Promise<AgentDefinition | null>;
 /**
  * Audits a refused org agent dispatch (`subagent.refused`, spec §5.5): actor the person who
  * started the parent run, target the refused agent, so its owner can see attempts to use it.
  */
-export declare function auditRefusal(db: KernelDb, a: {
+export declare function auditRefusal(db: KernelSchemaDb, a: {
     orgId: string;
     triggerAccountId: string;
     agentId: string;