@capybara-hq/kernel 0.1.0-rc.23 → 0.1.0-rc.25

package/dist/runtime/step-log.js

@@ -17,28 +17,43 @@ import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { recordToolSpecs } from "../tools/specs.js";
 import { budgetRunOf } from "./subagents/limits.js";
+import { UsageReportJobs, UsageReportJobsModule } from "./usage-report-jobs.js";
 /**
  * The writes of a run step that go to the event log together with another row, each in a
  * transaction of its own (the caller notifies the log after the commit): a model call with the
- * tool definitions it sent, a denial with its audit row, and a sub-agent's usage counted on its
- * parent run. The step functions (`model-call.ts`, `hook-calls.ts`) reach it through their deps.
+ * tool definitions it sent, a denial with its audit row, usage events with their owed
+ * `usage.report` deliveries (transactional outbox spec §8.1), and a sub-agent's usage counted on
+ * its parent run. The step functions (`model-call.ts`, `hook-calls.ts`) reach it through their deps.
  */
 let StepLog = class StepLog {
     kdb;
     eventLog;
+    usage;
     txHost;
-    constructor(kdb, eventLog, txHost) {
+    constructor(kdb, eventLog, usage, txHost) {
         this.kdb = kdb;
         this.eventLog = eventLog;
+        this.usage = usage;
         this.txHost = txHost;
     }
+    /**
+     * Appends events and owes the `usage.report` delivery of the `usage` events it newly wrote, in
+     * one transaction. Returns what was written (hits included) and the highest new seq (null:
+     * nothing new).
+     */
+    async appendReported(conversationId, events) {
+        const { events: written, fresh } = await this.eventLog.appendInReport(conversationId, events);
+        const added = written.filter((_, i) => fresh[i]);
+        await this.usage.oweEvents(conversationId, added);
+        return { written, toSeq: added.length > 0 ? Math.max(...added.map((e) => e.seq)) : null };
+    }
     /**
      * Appends events of a sub-agent's run and adds the tokens of the usage events it newly wrote to
      * the `subagent_tokens_used` of the tree's budget run (sub-agents spec §8.3, agent map spec §6:
      * the whole tree counts on one run): `counter.budgetRunId`, the run's own window
      * (`SubagentParent.budgetRunId`), else the parent run's ({@link budgetRunOf}). A usage event
      * already in the log (an idempotent hit after a crash) adds nothing, so each call counts exactly
-     * once. Returns what was written (hits included) and the highest new seq (null: nothing new).
+     * once; the new usage events' `usage.report` deliveries are owed in the same transaction. Returns what was written (hits included) and the highest new seq (null: nothing new).
      */
     async appendCounted(conversationId, counter, events) {
         const t = this.kdb.db;
@@ -51,6 +66,7 @@ let StepLog = class StepLog {
             .executeTakeFirstOrThrow();
         const written = await this.eventLog.appendIn(conversationId, events);
         const fresh = written.filter((e) => e.seq > Number(before.last_seq));
+        await this.usage.oweEvents(conversationId, fresh);
         let tokens = 0;
         for (const e of fresh)
             if (e.type === "usage")
@@ -79,6 +95,9 @@ let StepLog = class StepLog {
         return this.eventLog.appendIn(conversationId, events);
     }
 };
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], StepLog.prototype, "appendReported", null);
 __decorate([
     Transactional({ propagation: "requires_new" })
 ], StepLog.prototype, "appendCounted", null);
@@ -92,7 +111,8 @@ StepLog = __decorate([
     Injectable(),
     __param(0, Inject(KernelDb)),
     __param(1, Inject(EventLog)),
-    __param(2, Inject(TransactionHost))
+    __param(2, Inject(UsageReportJobs)),
+    __param(3, Inject(TransactionHost))
 ], StepLog);
 export { StepLog };
 /**
@@ -103,7 +123,7 @@ let StepLogModule = class StepLogModule {
 };
 StepLogModule = __decorate([
     Module({
-        imports: [EventLogModule],
+        imports: [EventLogModule, UsageReportJobsModule],
         providers: [StepLog],
         exports: [StepLog],
     })

package/dist/runtime/stream.controller.d.ts

@@ -2,7 +2,6 @@ import type { Logger } from "@capybara-hq/plugin-sdk";
 import type { FastifyReply, FastifyRequest } from "fastify";
 import { z } from "zod";
 import { ConversationAccess } from "../conversations/access.js";
-import { ConversationsService } from "../conversations/conversations.service.js";
 import { ApiTokenService } from "../identity/api-tokens.js";
 import { type Principal } from "../identity/principal.js";
 import { SessionService } from "../identity/sessions.js";
@@ -18,7 +17,7 @@ declare const DraftParams: z.ZodObject<{
 }, z.core.$strip>;
 /**
  * 会话事件流（SSE）：`GET /api/v1/orgs/:orgId/conversations/:id/stream?after=<seq>`，`agents.use`，只有会话所有者可用。
- * - 打开时不阻塞地调用一次 ensureRun（`ConversationsService.kickRun`），停在「运行中」的孤儿运行由此被清理；
+ * - opening it never changes run state (a read; transactional outbox spec §6);
  * - 先订阅会话频道、再回放 `after`（或优先的 `Last-Event-ID`）之后的事件：`id: <seq>` / `event: event`；
  * - after that catch-up, one `event: draft` (`data: {"runId","step","text","thinking"}`) per step of
  *   the running run whose `assistant_message` is not logged (live drafts, spec 2026-11-07 §3.2);
@@ -33,11 +32,10 @@ export declare class ConversationStreamController {
     private readonly streams;
     private readonly sessions;
     private readonly tokens;
-    private readonly conversations;
     private readonly access;
     private readonly drafts;
     private readonly log;
-    constructor(streams: ConversationStreams, sessions: SessionService, tokens: ApiTokenService, conversations: ConversationsService, access: ConversationAccess, drafts: RunDrafts, log: Pick<Logger, "warn">);
+    constructor(streams: ConversationStreams, sessions: SessionService, tokens: ApiTokenService, access: ConversationAccess, drafts: RunDrafts, log: Pick<Logger, "warn">);
     /**
      * The live drafts of one run (spec 2026-11-07 §3.2): `{ drafts: { step, text, thinking }[] }`,
      * the steps still streaming whose `assistant_message` is not logged (none once the run is no

package/dist/runtime/stream.controller.js

@@ -10,7 +10,6 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Controller, Get, Headers, Inject, Param, Req, Res } from "@nestjs/common";
 import { z } from "zod";
 import { ConversationAccess } from "../conversations/access.js";
-import { ConversationsService } from "../conversations/conversations.service.js";
 import { ApiError } from "../errors.js";
 import { ApiTokenService } from "../identity/api-tokens.js";
 import { credentialCheck } from "../identity/credential-check.js";
@@ -45,7 +44,7 @@ class RunDraftParamsDto extends createZodDto(DraftParams, "RunDraftParams") {
 }
 /**
  * 会话事件流（SSE）：`GET /api/v1/orgs/:orgId/conversations/:id/stream?after=<seq>`，`agents.use`，只有会话所有者可用。
- * - 打开时不阻塞地调用一次 ensureRun（`ConversationsService.kickRun`），停在「运行中」的孤儿运行由此被清理；
+ * - opening it never changes run state (a read; transactional outbox spec §6);
  * - 先订阅会话频道、再回放 `after`（或优先的 `Last-Event-ID`）之后的事件：`id: <seq>` / `event: event`；
  * - after that catch-up, one `event: draft` (`data: {"runId","step","text","thinking"}`) per step of
  *   the running run whose `assistant_message` is not logged (live drafts, spec 2026-11-07 §3.2);
@@ -60,15 +59,13 @@ let ConversationStreamController = class ConversationStreamController {
     streams;
     sessions;
     tokens;
-    conversations;
     access;
     drafts;
     log;
-    constructor(streams, sessions, tokens, conversations, access, drafts, log) {
+    constructor(streams, sessions, tokens, access, drafts, log) {
         this.streams = streams;
         this.sessions = sessions;
         this.tokens = tokens;
-        this.conversations = conversations;
         this.access = access;
         this.drafts = drafts;
         this.log = log;
@@ -131,8 +128,6 @@ let ConversationStreamController = class ConversationStreamController {
             },
         });
         reply.hijack();
-        // 可见性已通过：不阻塞地 ensureRun（清理孤儿运行、投递等待中的消息），见 ConversationsService.kickRun。
-        this.conversations.kickRun(id);
         res.on("close", () => handle.close());
         // 订阅期间客户端已断开：close 事件可能已经错过
         if (res.destroyed || !res.socket || res.socket.destroyed) {
@@ -173,9 +168,8 @@ ConversationStreamController = __decorate([
     __param(0, Inject(ConversationStreams)),
     __param(1, Inject(SessionService)),
     __param(2, Inject(ApiTokenService)),
-    __param(3, Inject(ConversationsService)),
-    __param(4, Inject(ConversationAccess)),
-    __param(5, Inject(RunDrafts)),
-    __param(6, Inject(KERNEL_LOGGER))
+    __param(3, Inject(ConversationAccess)),
+    __param(4, Inject(RunDrafts)),
+    __param(5, Inject(KERNEL_LOGGER))
 ], ConversationStreamController);
 export { ConversationStreamController };

package/dist/runtime/subagents/child.js

@@ -179,7 +179,7 @@ export async function childResult(eventLog, row, opts = {}) {
     else {
         status = "aborted";
         // §4.4: a person's stop names its account; a stop by nobody (null) is the kernel stopping the
-        // child on its parent's behalf (stopChildren with no account: the parent's end, the sweep)
+        // child on its parent's behalf (stopChildren with no account: the parent's end, its `stop-tree` job)
         abortedBy =
             terminal.payload.reason === "user" && terminal.payload.byAccountId === null
                 ? "parent"

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

@@ -20,6 +20,7 @@ export declare class SubagentTypeGoneError extends Error {
 export interface EffectiveDefinition {
     definition: AgentDefinition;
     template: EventPayload<"subagent_started">["template"];
+    /** The child's step limit; 0 = no limit. */
     maxSteps: number;
     /**
      * The child's preamble, frozen into `subagent_started.preamble` (model-visible):
@@ -72,7 +73,7 @@ export interface ChildDepth {
  * - `general` / `inline` / `plugin`: the parent's definition narrowed by the template (tools by
  *   resolved key, `disallowedTools`, {@link CHILD_REMOVED_TOOLS}; policies stricter-wins; skills
  *   by its `disallowedSkills`), the template's instructions, its `skills` the child has named in
- *   the preamble to load first (general gets no line), `maxSteps = min(template ?? runtime.maxSteps, runtime.maxSteps)`, and the model tier
+ *   the preamble to load first (general gets no line), `maxSteps` = the tighter of the template's and `runtime.maxSteps` (0 = no limit), and the model tier
  *   `tier` (the call's) → the template's → `inherit`; an unmapped tier runs on the parent's model
  *   (`tierFallback`); a template `effort` is set when the resolved model declares it;
  * - `agent`: the org agent's version that passed the gates (`orgAgent`, from {@link checkOrgAgent}),

package/dist/runtime/subagents/definition.js

@@ -6,6 +6,7 @@ import { ApiError } from "../../errors.js";
 import { invocationOf, resolveSkills } from "../../skills/catalog.js";
 import { agentSkills, usableSkills } from "../../skills/usable.js";
 import { AGENT_TOOL, CHILD_REMOVED_TOOLS } from "../../tools/builtin-names.js";
+import { tightestLimit } from "../limits.js";
 import { SUBAGENT_PREAMBLE } from "./preamble.js";
 export { CHILD_REMOVED_TOOLS } from "../../tools/builtin-names.js";
 /**
@@ -222,7 +223,7 @@ function orgAgentDefinition(d, a) {
  * - `general` / `inline` / `plugin`: the parent's definition narrowed by the template (tools by
  *   resolved key, `disallowedTools`, {@link CHILD_REMOVED_TOOLS}; policies stricter-wins; skills
  *   by its `disallowedSkills`), the template's instructions, its `skills` the child has named in
- *   the preamble to load first (general gets no line), `maxSteps = min(template ?? runtime.maxSteps, runtime.maxSteps)`, and the model tier
+ *   the preamble to load first (general gets no line), `maxSteps` = the tighter of the template's and `runtime.maxSteps` (0 = no limit), and the model tier
  *   `tier` (the call's) → the template's → `inherit`; an unmapped tier runs on the parent's model
  *   (`tierFallback`); a template `effort` is set when the resolved model declares it;
  * - `agent`: the org agent's version that passed the gates (`orgAgent`, from {@link checkOrgAgent}),
@@ -293,7 +294,8 @@ export async function effectiveDefinition(d, a) {
     return {
         definition,
         template: ref,
-        maxSteps: Math.min(template?.maxSteps ?? runtimeMax, runtimeMax),
+        // the tighter of the template's and the deployment's, 0 = no limit (`runtime.maxSteps` 0)
+        maxSteps: tightestLimit(template?.maxSteps, runtimeMax) ?? 0,
         preamble: names.length === 0
             ? SUBAGENT_PREAMBLE
             : `${SUBAGENT_PREAMBLE}\n\n${loadSkillsFirstText(names)}`,

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

@@ -3,6 +3,7 @@ import type { EventPayload } from "../../conversations/events.js";
 import { KernelDb } from "../../infra/database/kernel-db.js";
 import { TransactionHost } from "../../infra/database/transaction-host.js";
 import { KernelEvents } from "../../infra/events/kernel-events.js";
+import { OutboxService } from "../../infra/outbox/outbox.service.js";
 import type { KernelLogger } from "../../log.js";
 import { type DispatchRow } from "./child.js";
 /** What a caller of {@link SubagentDeliveries.deliverIn} gives; the rest comes from the dispatch. */
@@ -17,7 +18,7 @@ export declare const finishedDeliveryIdemKey: (childRunId: string) => string;
  *
  * A background child's run reaching a terminal state ({@link childFinished}) writes the
  * display-only `subagent_finished` and a `finished` delivery in one transaction, both idempotent by
- * the child run, so of two finishers (the worker and a stop, the orphan sweep) exactly one writes
+ * the child run, so of two finishers (the worker, a stop, the `deliver-to-parent` job, the `run-orphan-check`) exactly one writes
  * them. A run that handed back a report and then completed writes no delivery (acceptance
  * 2026-11-07): the report already told the parent everything, and a content-free "completed" line
  * only woke an idle parent for nothing and pushed the report away from the end of its request. Fork invocations (phase D, `for_skill`) do not deliver: their parent run waits on the child
@@ -29,7 +30,8 @@ export declare class SubagentDeliveries {
     private readonly events;
     private readonly log;
     readonly txHost: TransactionHost;
-    constructor(kdb: KernelDb, eventLog: EventLog, events: KernelEvents, log: Pick<KernelLogger, "warn">, txHost: TransactionHost);
+    private readonly outbox;
+    constructor(kdb: KernelDb, eventLog: EventLog, events: KernelEvents, log: Pick<KernelLogger, "warn">, txHost: TransactionHost, outbox: Pick<OutboxService, "add">);
     /** The context's handle (the transaction of a `@Transactional` method, else the pool). */
     private get db();
     /**
@@ -38,7 +40,8 @@ export declare class SubagentDeliveries {
      * the child run's (a wake runs as that person, §7). Idempotent by `opts.idemKey` (a finish's
      * default is {@link finishedDeliveryIdemKey}; a report or a note must name its own): under the
      * parent conversation's row lock, an existing delivery returns null and writes nothing. After
-     * the commit: the log's notify and `subagent.delivered`. Returns the new event's seq.
+     * the commit: the log's notify and `subagent.delivered`; the parent's ensure-run backstop is
+     * owed in the transaction. Returns the new event's seq.
      */
     deliverIn(row: DispatchRow, d: DeliveryInput, opts?: {
         idemKey?: string;

package/dist/runtime/subagents/deliveries.js

@@ -15,8 +15,9 @@ import { KernelDb } from "../../infra/database/kernel-db.js";
 import { TransactionHost } from "../../infra/database/transaction-host.js";
 import { Transactional } from "../../infra/database/transactional.decorator.js";
 import { KernelEvents } from "../../infra/events/kernel-events.js";
+import { OutboxService } from "../../infra/outbox/outbox.service.js";
 import { KERNEL_LOGGER } from "../../infra/tokens.js";
-import { TERMINAL_STATUSES } from "../run-finish.js";
+import { oweEnsureRun, TERMINAL_STATUSES } from "../run-jobs.js";
 import { childResult, deliveryRowOfChildRun, finishedEvent } from "./child.js";
 import { dispatchedIdemKey } from "./dispatch.js";
 /** Idempotency key of a child run's finished delivery (one per child run). */
@@ -31,7 +32,7 @@ const DELIVERY_TEXT_MAX = 200_000;
  *
  * A background child's run reaching a terminal state ({@link childFinished}) writes the
  * display-only `subagent_finished` and a `finished` delivery in one transaction, both idempotent by
- * the child run, so of two finishers (the worker and a stop, the orphan sweep) exactly one writes
+ * the child run, so of two finishers (the worker, a stop, the `deliver-to-parent` job, the `run-orphan-check`) exactly one writes
  * them. A run that handed back a report and then completed writes no delivery (acceptance
  * 2026-11-07): the report already told the parent everything, and a content-free "completed" line
  * only woke an idle parent for nothing and pushed the report away from the end of its request. Fork invocations (phase D, `for_skill`) do not deliver: their parent run waits on the child
@@ -43,12 +44,14 @@ let SubagentDeliveries = class SubagentDeliveries {
     events;
     log;
     txHost;
-    constructor(kdb, eventLog, events, log, txHost) {
+    outbox;
+    constructor(kdb, eventLog, events, log, txHost, outbox) {
         this.kdb = kdb;
         this.eventLog = eventLog;
         this.events = events;
         this.log = log;
         this.txHost = txHost;
+        this.outbox = outbox;
     }
     /** The context's handle (the transaction of a `@Transactional` method, else the pool). */
     get db() {
@@ -60,7 +63,8 @@ let SubagentDeliveries = class SubagentDeliveries {
      * the child run's (a wake runs as that person, §7). Idempotent by `opts.idemKey` (a finish's
      * default is {@link finishedDeliveryIdemKey}; a report or a note must name its own): under the
      * parent conversation's row lock, an existing delivery returns null and writes nothing. After
-     * the commit: the log's notify and `subagent.delivered`. Returns the new event's seq.
+     * the commit: the log's notify and `subagent.delivered`; the parent's ensure-run backstop is
+     * owed in the transaction. Returns the new event's seq.
      */
     async deliverIn(row, d, opts = {}) {
         const idemKey = opts.idemKey ?? (d.kind === "finished" ? finishedDeliveryIdemKey(row.childRunId) : undefined);
@@ -68,9 +72,9 @@ let SubagentDeliveries = class SubagentDeliveries {
             throw new Error(`a ${d.kind} delivery needs its idempotency key`);
         const t = this.db;
         const parent = row.parentConversationId;
-        await t
+        const conv = await t
             .selectFrom("conversations")
-            .select("id")
+            .select("org_id")
             .where("id", "=", parent)
             .forUpdate()
             .executeTakeFirst();
@@ -103,6 +107,10 @@ let SubagentDeliveries = class SubagentDeliveries {
         ]);
         if (!event)
             return null;
+        // the parent's wake is owed with the delivery: the wake after the commit (`BackgroundWake`)
+        // may never happen (transactional outbox spec §6)
+        if (conv)
+            await oweEnsureRun(this.outbox, parent, event.seq, conv.org_id);
         afterCommit(async () => {
             await this.eventLog.notify(parent, event.seq);
             await this.events.emit("subagent.delivered", { conversationId: parent });
@@ -223,6 +231,7 @@ SubagentDeliveries = __decorate([
     __param(1, Inject(EventLog)),
     __param(2, Inject(KernelEvents)),
     __param(3, Inject(KERNEL_LOGGER)),
-    __param(4, Inject(TransactionHost))
+    __param(4, Inject(TransactionHost)),
+    __param(5, Inject(OutboxService))
 ], SubagentDeliveries);
 export { SubagentDeliveries };

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

@@ -18,8 +18,11 @@ export interface DispatchDeps {
     purposes: Pick<ModelPurposesService, "resolve">;
     registry: Pick<ProviderRegistry, "resolve">;
     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>;
+    /**
+     * Owes a child run's job in the dispatch's transaction (`RunJobs.owe`: on the sub-agent run
+     * queue, `kind` is always `subagent`); false when the job id is already owed.
+     */
+    owe: (data: RunJobData, jobId: string, kind: ConversationKind, orgId: string) => Promise<boolean>;
     log: Pick<Logger, "error" | "warn">;
     /**
      * Runs {@link commitDispatchIn} in a transaction of its own (`SubagentsService.commitDispatch`,
@@ -121,9 +124,9 @@ export interface DispatchPlan {
  * dispatches of one run serialize) inserts the child conversation, appends `subagent_started` and
  * the task message, inserts the child run (`queued`) and the `subagent_dispatches` row, appends
  * `subagent_dispatched` and the call's `tool_result` ({@link agentStartedText}: the sub-agent runs
- * in the background) to the parent and audits `subagent.dispatched` and `tool.called`. After
- * commit the child run is enqueued; a failed enqueue only logs (the dispatch is durable, the wait
- * sweep re-enqueues it). A fork invocation (`forSkill`) writes no `tool_result`: its run waits on
+ * in the background) to the parent and audits `subagent.dispatched` and `tool.called`. The child
+ * run's job is owed in the same transaction (transactional outbox spec §6), so the committed
+ * dispatch always starts its child. A fork invocation (`forSkill`) writes no `tool_result`: its run waits on
  * the child (`advanceSkillForks`).
  *
  * Refusals (§4.5) start nothing: a call from a run at `subagents.maxDepth` (agent map spec §4.1:
@@ -188,7 +191,8 @@ export declare const sentMessageIdemKey: (runId: string, callId: string) => stri
  * 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.
+ * and the audit row, and owes the child run's job (transactional outbox spec §6). After commit:
+ * notifies both conversations.
  * Returns null when `child` refused.
  *
  * Under the parent run's row lock it first re-checks what the pipeline checked without it: a call
@@ -205,10 +209,6 @@ export type DispatchCommit = {
     kind: "existing";
     childRunId: string;
     childConversationId: string;
-    requeue: {
-        conversationId: string;
-        seq: number;
-    } | null;
     /** The call's logged result (null for a fork dispatch) and its seq, to notify. */
     result: {
         content: string;
@@ -233,7 +233,7 @@ export type DispatchCommit = {
  * {@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>;
-export declare function commit(d: Pick<DispatchDeps, "commitDispatch" | "enqueue" | "log" | "eventLog">, a: DispatchArgs, plan: DispatchPlan, 
+export declare function commitDispatchIn(d: Pick<DispatchDeps, "db" | "eventLog" | "config" | "owe">, a: DispatchArgs, plan: DispatchPlan, child: ChildWriter): Promise<DispatchCommit | null>;
+export declare function commit(d: Pick<DispatchDeps, "commitDispatch" | "eventLog">, a: DispatchArgs, plan: DispatchPlan, 
 /** Writes the child's events; `checked` is the org agent version the in-lock gates passed. */
 child: ChildWriter): Promise<DispatchOutcome | null>;

package/dist/runtime/subagents/dispatch.js

@@ -31,9 +31,9 @@ export const dispatchedIdemKey = (runId, callId) => `subagent_dispatched:${runId
  * dispatches of one run serialize) inserts the child conversation, appends `subagent_started` and
  * the task message, inserts the child run (`queued`) and the `subagent_dispatches` row, appends
  * `subagent_dispatched` and the call's `tool_result` ({@link agentStartedText}: the sub-agent runs
- * in the background) to the parent and audits `subagent.dispatched` and `tool.called`. After
- * commit the child run is enqueued; a failed enqueue only logs (the dispatch is durable, the wait
- * sweep re-enqueues it). A fork invocation (`forSkill`) writes no `tool_result`: its run waits on
+ * in the background) to the parent and audits `subagent.dispatched` and `tool.called`. The child
+ * run's job is owed in the same transaction (transactional outbox spec §6), so the committed
+ * dispatch always starts its child. A fork invocation (`forSkill`) writes no `tool_result`: its run waits on
  * the child (`advanceSkillForks`).
  *
  * Refusals (§4.5) start nothing: a call from a run at `subagents.maxDepth` (agent map spec §4.1:
@@ -121,6 +121,7 @@ export async function dispatchSubagent(d, a) {
             parent_conversation_id: ctx.conversationId,
             subagent_type: entry.type,
             subagent_depth: childDepth,
+            source: "subagent",
         })
             .execute();
         const [, task] = await d.eventLog.appendIn(childId, [
@@ -226,7 +227,7 @@ const isActiveStatus = (status) => ACTIVE_RUN_STATUSES.includes(status);
  * delivered (agent map spec, rc upgrade: a foreground-era dispatch whose rc finisher wrote
  * `subagent_finished` and resumed the parent): the child's report (`childResult`), with the
  * parent's `subagent_finished` appended in this transaction when it is missing (idempotent by its
- * key), so the undelivered sweep never delivers it a second time. Null when the parent already
+ * key), so the `deliver-to-parent` job never delivers it a second time. Null when the parent already
  * has a delivery for the run (it carries the result) or the run has no terminal event yet.
  */
 async function rcFinishedResult(d, row) {
@@ -272,7 +273,7 @@ export async function commitDispatchIn(d, a, plan, child) {
     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"])
+        .select(["sd.child_run_id", "sd.child_conversation_id", "cr.status"])
         .where("sd.parent_run_id", "=", ctx.runId)
         .where("sd.parent_call_id", "=", callId)
         .executeTakeFirst();
@@ -284,10 +285,10 @@ export async function commitDispatchIn(d, a, plan, child) {
         let result = null;
         if (a.forSkill === undefined) {
             // an rc child that already ended under the foreground wait, whose rc finisher wrote
-            // `subagent_finished` and resumed this run (no delivery; the sweep never delivers a run with
-            // `subagent_finished`): its report is this call's result, as the rc gave it, or it is lost.
+            // `subagent_finished` and resumed this run (no delivery; a run with `subagent_finished` is
+            // never delivered): its report is this call's result, as the rc gave it, or it is lost.
             // Only while the call has no result: a call that has one (a background dispatch's second
-            // holder) keeps it, and its child's finish stays to its delivery or the undelivered sweep.
+            // holder) keeps it, and its child's finish stays to its delivery (or its `deliver-to-parent` job).
             const resultKey = resultEvent(ctx, callId, AGENT_TOOL, "").idemKey;
             const finished = a.sent === undefined &&
                 existing.status !== null &&
@@ -312,13 +313,6 @@ export async function commitDispatchIn(d, a, plan, child) {
             childRunId: existing.child_run_id,
             childConversationId: existing.child_conversation_id,
             result,
-            // 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")
@@ -384,6 +378,9 @@ export async function commitDispatchIn(d, a, plan, child) {
         for_skill: a.forSkill !== undefined,
     })
         .execute();
+    // the child run's job is owed with its row (transactional outbox spec §6): a queued child
+    // always has its job, whatever happens after the commit
+    await d.owe({ runId: childRunId, conversationId: plan.childConversationId }, runJobId(plan.childConversationId, task.seq), "subagent", ctx.orgId);
     // an org agent runs on its own model (§5.4): a `model` on the call was ignored
     const ownModel = plan.source === "agent" && input.model !== undefined;
     const content = a.sent?.content ?? agentStartedText(plan.childConversationId, { ownModel });
@@ -475,19 +472,7 @@ child) {
     if (out === null)
         return null;
     if (out.kind === "existing") {
-        // a child still queued is enqueued again under the first dispatch's job id (BullMQ dedupes
-        // it while that job exists), so a holder that died before its enqueue does not leave the
-        // child to the wait sweep
-        if (out.requeue !== null) {
-            const jobId = runJobId(out.requeue.conversationId, out.requeue.seq);
-            await d
-                .enqueue({ runId: out.childRunId, conversationId: out.requeue.conversationId }, jobId, "subagent")
-                .catch((err) => d.log.error("cannot enqueue sub-agent run; the sweep retries", {
-                childRunId: out.childRunId,
-                jobId,
-                err,
-            }));
-        }
+        // the child's job was owed with the first dispatch (a still queued child has it)
         if (out.result !== null)
             await d.eventLog.notify(ctx.conversationId, out.result.seq);
         return {
@@ -507,18 +492,9 @@ 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");
-    }
-    catch (err) {
-        // the dispatch is committed: the wait sweep re-enqueues the queued child run
-        d.log.error("cannot enqueue sub-agent run; the sweep retries", { childRunId, jobId, err });
-    }
     return {
         kind: "dispatched",
-        childRunId,
+        childRunId: out.childRunId,
         childConversationId: plan.childConversationId,
         content: out.content,
     };

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

@@ -50,12 +50,16 @@ export declare class SubagentMessages {
     private readonly kdb;
     private readonly eventLog;
     private readonly config;
+    /** Owes a restarted sub-agent's run job in the dispatch's transaction. */
+    private readonly jobs;
     private readonly deliveries;
     readonly txHost: TransactionHost;
     private readonly hooks?;
     /** What the dispatch transaction of a restart needs (`commit`). */
     private readonly deps;
-    constructor(kdb: KernelDb, eventLog: EventLog, config: KernelConfigService, jobs: RunJobs, log: KernelLogger, deliveries: SubagentDeliveries, txHost: TransactionHost, hooks?: SubagentMessagesHooks | undefined);
+    constructor(kdb: KernelDb, eventLog: EventLog, config: KernelConfigService, 
+    /** Owes a restarted sub-agent's run job in the dispatch's transaction. */
+    jobs: Pick<RunJobs, "owe">, log: KernelLogger, deliveries: SubagentDeliveries, txHost: TransactionHost, hooks?: SubagentMessagesHooks | undefined);
     /** The restart's dispatch writes in a transaction of their own (see `commitDispatchIn`). */
     private commitDispatch;
     /** The context's handle (the transaction of a `@Transactional` method, else the pool). */

package/dist/runtime/subagents/messages.js

@@ -56,28 +56,36 @@ let SubagentMessages = class SubagentMessages {
     kdb;
     eventLog;
     config;
+    jobs;
     deliveries;
     txHost;
     hooks;
     /** What the dispatch transaction of a restart needs (`commit`). */
     deps;
-    constructor(kdb, eventLog, config, jobs, log, deliveries, txHost, hooks) {
+    constructor(kdb, eventLog, config, 
+    /** Owes a restarted sub-agent's run job in the dispatch's transaction. */
+    jobs, log, deliveries, txHost, hooks) {
         this.kdb = kdb;
         this.eventLog = eventLog;
         this.config = config;
+        this.jobs = jobs;
         this.deliveries = deliveries;
         this.txHost = txHost;
         this.hooks = hooks;
         this.deps = {
             eventLog,
-            enqueue: (data, jobId, kind) => jobs.enqueue(data, jobId, kind),
             log,
             commitDispatch: (a, plan, child) => this.commitDispatch(a, plan, child),
         };
     }
     /** The restart's dispatch writes in a transaction of their own (see `commitDispatchIn`). */
     commitDispatch(a, plan, child) {
-        return commitDispatchIn({ db: this.db, eventLog: this.eventLog, config: this.config }, a, plan, child);
+        return commitDispatchIn({
+            db: this.db,
+            eventLog: this.eventLog,
+            config: this.config,
+            owe: (data, jobId, kind, orgId) => this.jobs.owe(data, jobId, kind, orgId),
+        }, a, plan, child);
     }
     /** The context's handle (the transaction of a `@Transactional` method, else the pool). */
     get db() {

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

@@ -11,8 +11,8 @@ import { type DispatchDeps } from "./dispatch.js";
  * 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
+ * `skill_fork_result` and the parent's model answers. Every terminal path of the run
+ * (`RunFinish.finishIn`) 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). */
@@ -108,7 +108,7 @@ export declare const recordedSkillForks: (eventLog: Pick<EventLog, "append" | "f
     payload: unknown;
 }[]) => SkillForks;
 /**
- * In the transaction of a run's terminal path (or the wait sweep): the run's fork invocation
+ * In the transaction of a run's terminal path (`RunFinish.finishIn`): 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