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

package/dist/runtime/run-worker.d.ts

@@ -14,6 +14,8 @@ import { KyselyCheckpointSaver } from "./checkpointer.js";
 import { ConversationLock } from "./conversation-lock.js";
 import { ProviderRegistry } from "./providers.js";
 import { type OrgQuota } from "./quota.js";
+import { RunContextService } from "./run-context.service.js";
+import { RunDrafts } from "./run-drafts.js";
 import { RunFinish } from "./run-finish.js";
 import type { RunJobData } from "./run-jobs.js";
 import { RunQueue } from "./run-queue.js";
@@ -62,14 +64,18 @@ export declare class RunWorker {
     private readonly models;
     /** Run start's skills catalog snapshot (reads the pinned skills' bodies, phase B). */
     private readonly skillsCatalog;
+    /** Run start's run context (run context spec §5): who the agent is, the day, the person. */
+    private readonly runContext;
     /**
-     * In the terminal transaction of every run: writes its open `agent` call results
+     * In the terminal transaction of every run: writes its open `Agent` call results
      * (`stopOpenAgentCalls`; a no-op without dispatches); `fire` runs their observe hooks after the
      * commit (sub-agents spec §12, review m1: a failed or stalled parent too).
      */
     private readonly pipeline;
     private readonly finisher;
     readonly txHost: TransactionHost;
+    /** The steps' live drafts this process writes for the runs it executes. */
+    private readonly drafts;
     private readonly hooks?;
     /** The two run queues' BullMQ workers (spec §7.4), once {@link start}ed on the worker role. */
     private workers;
@@ -84,7 +90,7 @@ export declare class RunWorker {
     /** 运行到达终态后删除该运行（thread_id = runId）的 checkpoint thread（只用于续跑，结束后无用）。 */
     checkpoints: Pick<KyselyCheckpointSaver, "deleteThread">, 
     /** loop 返回 `suspended` 后把运行置为 waiting（释放会话锁与配额之后）; the child lifecycle. */
-    waits: Pick<Waits, "suspend" | "childFinished" | "stopChildren">, 
+    waits: Pick<Waits, "suspend" | "childFinished" | "stopChildren" | "stopDescendantsOfStopped">, 
     /** `run.started` (the channel outbound enqueues the conversation's IM delivery). */
     events: KernelEvents, 
     /** A completed run enqueues the conversation's title job. */
@@ -93,12 +99,16 @@ export declare class RunWorker {
     models: Pick<ProviderRegistry, "resolve">, 
     /** Run start's skills catalog snapshot (reads the pinned skills' bodies, phase B). */
     skillsCatalog: Pick<SkillsCatalogService, "record">, 
+    /** Run start's run context (run context spec §5): who the agent is, the day, the person. */
+    runContext: Pick<RunContextService, "record">, 
     /**
-     * In the terminal transaction of every run: writes its open `agent` call results
+     * In the terminal transaction of every run: writes its open `Agent` call results
      * (`stopOpenAgentCalls`; a no-op without dispatches); `fire` runs their observe hooks after the
      * commit (sub-agents spec §12, review m1: a failed or stalled parent too).
      */
-    pipeline: Pick<ToolPipeline, "stopOpenAgentCalls">, finisher: Pick<RunFinish, "finish">, txHost: TransactionHost, hooks?: RunHooks | undefined);
+    pipeline: Pick<ToolPipeline, "stopOpenAgentCalls">, finisher: Pick<RunFinish, "finish">, txHost: TransactionHost, 
+    /** The steps' live drafts this process writes for the runs it executes. */
+    drafts: RunDrafts, hooks?: RunHooks | undefined);
     private get db();
     /**
      * Starts consuming (worker role only): `workers` are the `@Processor` workers of both run queues
@@ -119,13 +129,14 @@ export declare class RunWorker {
     /** A job failed (the worker's `failed` event). */
     onFailed(job: Job<RunJobData> | undefined, err: Error): void;
     /**
-     * 流式增量发布到会话频道（与 `{ kind: "events" }` 共用 `conv.<id>`），任意副本上的订阅方都能收到。
-     * 发布失败只记日志：增量只是草稿，最终内容以日志中的 assistant_message 为准。
+     * The run's stream sink: deltas on the conversation's topic (any replica's subscribers get them)
+     * and the steps' live drafts in Redis ({@link streamSink}, spec 2026-11-07 §3.2).
      */
     private sinkFor;
     /**
      * After any terminal commit of a run that is not a sub-agent's (sub-agents spec §12): stops its
-     * active children on its behalf (no account). The wait sweep is the backstop.
+     * active fork invocation child on its behalf (no account); background `Agent` children keep
+     * running (agent map spec §5.4). The wait sweep is the backstop.
      */
     private stopChildren;
     /**
@@ -164,7 +175,7 @@ export declare class RunWorker {
      * model removed), writes `model_switched { model: null, effort: null, reason: "unavailable" }`
      * for this run (idempotent) and clears the cached selection: the run and the next ones use the
      * agent's model. A provider that only failed to list its models is not "gone" (the run's ladder
-     * handles it).
+     * handles it). Resolved for the conversation's org (its effective provider config).
      */
     private fallBackIfUnavailable;
     /**

package/dist/runtime/run-worker.js

@@ -10,8 +10,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 import { Inject, Injectable, Optional } from "@nestjs/common";
 import { DelayedError } from "bullmq";
 import { sql } from "kysely";
-import { normalizeStoredDefinition } from "../agents/definition.js";
-import { conversationTopic, EventLog, } from "../conversations/event-log.js";
+import { EventLog } from "../conversations/event-log.js";
+import { isAbsorbable, } from "../conversations/events.js";
 import { effectiveDefinition, NO_SELECTION, readSelection, sameModel, sameSelection, } from "../conversations/selection.js";
 import { TitleQueue } from "../conversations/titles.js";
 import { ApiError } from "../errors.js";
@@ -24,6 +24,7 @@ import { Transactional } from "../infra/database/transactional.decorator.js";
 import { KernelEvents } from "../infra/events/kernel-events.js";
 import { KERNEL_BUS, KERNEL_LOGGER } from "../infra/tokens.js";
 import { pinnedFailureText, SkillsCatalogService } from "../skills/catalog.js";
+import { normalizeStoredDefinitionIn } from "../tools/legacy-data.js";
 import { ToolPipeline } from "../tools/pipeline.js";
 import { RunAbort } from "./abort.js";
 import { KyselyCheckpointSaver } from "./checkpointer.js";
@@ -31,10 +32,12 @@ import { ConversationLock } from "./conversation-lock.js";
 import { RunError } from "./model-call.js";
 import { ProviderListError, ProviderRegistry } from "./providers.js";
 import { ORG_QUOTA_LEASE_MS, orgRunLimit, RUN_QUOTA } from "./quota.js";
+import { RunContextService } from "./run-context.service.js";
+import { RunDrafts, streamSink } from "./run-drafts.js";
 import { RunFinish, TERMINAL_STATUSES } from "./run-finish.js";
 import { RunQueue } from "./run-queue.js";
 import { AgentLoops, RunSteps } from "./run-steps.js";
-import { dispatchOfChildRun } from "./subagents/child.js";
+import { dispatchOfChildRun, rootConversationOf } from "./subagents/child.js";
 import { childRunDefinition } from "./subagents/definition.js";
 import { forkBoundary } from "./subagents/skill-fork.js";
 import { Waits } from "./waits.js";
@@ -82,9 +85,11 @@ let RunWorker = class RunWorker {
     titles;
     models;
     skillsCatalog;
+    runContext;
     pipeline;
     finisher;
     txHost;
+    drafts;
     hooks;
     /** The two run queues' BullMQ workers (spec §7.4), once {@link start}ed on the worker role. */
     workers = [];
@@ -108,12 +113,16 @@ let RunWorker = class RunWorker {
     models, 
     /** Run start's skills catalog snapshot (reads the pinned skills' bodies, phase B). */
     skillsCatalog, 
+    /** Run start's run context (run context spec §5): who the agent is, the day, the person. */
+    runContext, 
     /**
-     * In the terminal transaction of every run: writes its open `agent` call results
+     * In the terminal transaction of every run: writes its open `Agent` call results
      * (`stopOpenAgentCalls`; a no-op without dispatches); `fire` runs their observe hooks after the
      * commit (sub-agents spec §12, review m1: a failed or stalled parent too).
      */
-    pipeline, finisher, txHost, hooks) {
+    pipeline, finisher, txHost, 
+    /** The steps' live drafts this process writes for the runs it executes. */
+    drafts, hooks) {
         this.kdb = kdb;
         this.eventLog = eventLog;
         this.lock = lock;
@@ -130,9 +139,11 @@ let RunWorker = class RunWorker {
         this.titles = titles;
         this.models = models;
         this.skillsCatalog = skillsCatalog;
+        this.runContext = runContext;
         this.pipeline = pipeline;
         this.finisher = finisher;
         this.txHost = txHost;
+        this.drafts = drafts;
         this.hooks = hooks;
         this.loop = loops.create(steps.deps);
     }
@@ -177,35 +188,16 @@ let RunWorker = class RunWorker {
         }
     }
     /**
-     * 流式增量发布到会话频道（与 `{ kind: "events" }` 共用 `conv.<id>`），任意副本上的订阅方都能收到。
-     * 发布失败只记日志：增量只是草稿，最终内容以日志中的 assistant_message 为准。
+     * The run's stream sink: deltas on the conversation's topic (any replica's subscribers get them)
+     * and the steps' live drafts in Redis ({@link streamSink}, spec 2026-11-07 §3.2).
      */
     sinkFor(conversationId) {
-        // 本次运行执行中推出的文本字符数（按步，step_reset 清零）：本进程正在执行的这次运行自己的计数
-        let at = { runId: "", step: -1, chars: 0 };
-        return (d) => {
-            if (at.runId !== d.runId || at.step !== d.step || d.kind === "step_reset") {
-                at = { runId: d.runId, step: d.step, chars: 0 };
-            }
-            const offset = at.chars;
-            if (d.kind === "text")
-                at.chars += d.text?.length ?? 0;
-            const msg = {
-                kind: "delta",
-                runId: d.runId,
-                step: d.step,
-                delta: d.kind,
-                ...(d.text !== undefined && { text: d.text }),
-                ...(d.kind === "text" && { offset }),
-            };
-            this.bus
-                .publish(conversationTopic(conversationId), msg)
-                .catch((err) => this.log.warn("stream delta publish failed", { conversationId, err }));
-        };
+        return streamSink(conversationId, { bus: this.bus, drafts: this.drafts, log: this.log });
     }
     /**
      * After any terminal commit of a run that is not a sub-agent's (sub-agents spec §12): stops its
-     * active children on its behalf (no account). The wait sweep is the backstop.
+     * active fork invocation child on its behalf (no account); background `Agent` children keep
+     * running (agent map spec §5.4). The wait sweep is the backstop.
      */
     async stopChildren(runId) {
         try {
@@ -227,6 +219,14 @@ let RunWorker = class RunWorker {
         catch (err) {
             this.log.error("cannot report finished sub-agent run to its parent", { runId, err });
         }
+        // a sub-agent a person stopped stops its descendants too, also one it dispatched after the
+        // tree stop read the tree (agent map spec §6); any other end leaves them running
+        try {
+            await this.waits.stopDescendantsOfStopped(runId);
+        }
+        catch (err) {
+            this.log.error("cannot stop the descendants of a stopped sub-agent", { runId, err });
+        }
     }
     /**
      * 任务结束后的 ensureRun，失败按 {@link ENSURE_RETRY_DELAYS_MS} 退避重试；停机开始后不再等待间隔
@@ -368,6 +368,7 @@ let RunWorker = class RunWorker {
             "trigger_seq",
             "started_at",
             "waited_ms",
+            "budget_run_id",
         ])
             .where("id", "=", runId)
             .executeTakeFirst();
@@ -385,7 +386,7 @@ let RunWorker = class RunWorker {
             return;
         const conv = await this.db
             .selectFrom("conversations")
-            .select(["org_id", "agent_id", "kind"])
+            .select(["org_id", "agent_id", "kind", "subagent_depth"])
             .where("id", "=", conversationId)
             .executeTakeFirst();
         if (!conv)
@@ -515,6 +516,8 @@ let RunWorker = class RunWorker {
         let saved;
         let maxSteps = runtime.maxSteps;
         let parent;
+        /** A sub-agent's name in its run context: the roster name, or the forked skill's. */
+        let childName;
         if (conv.kind === "subagent") {
             // a sub-agent runs its effective definition frozen at dispatch, never agent_versions
             // (spec §6.3), and works for the parent call that dispatched this run
@@ -525,24 +528,43 @@ let RunWorker = class RunWorker {
             // a follow-up runs with its task message's narrowing (final review I1): the frozen tools
             // and org skills the current version still allows, recorded at its dispatch
             const trigger = (await this.eventLog.readAfter(conversationId, Number(run.trigger_seq) - 1, 1))[0];
-            agent = childRunDefinition(normalizeStoredDefinition(started.payload.definition), trigger?.type === "user_message" && trigger.seq === Number(run.trigger_seq)
+            agent = childRunDefinition(await normalizeStoredDefinitionIn(this.db, conv.org_id, started.payload.definition), trigger?.type === "user_message" && trigger.seq === Number(run.trigger_seq)
                 ? trigger.payload.dispatch?.narrowed
                 : undefined);
             maxSteps = Math.min(started.payload.maxSteps, runtime.maxSteps);
+            childName = started.payload.template.invokedSkill?.name ?? started.payload.agentType;
             const row = await dispatchOfChildRun(this.db, runId);
             const otherAgent = started.payload.template.source === "agent";
+            const parentConversationId = row?.parentConversationId ?? started.payload.parent.conversationId;
+            // a sub-agent conversation is at depth 1 at least: one written before depths were recorded
+            // (default 0) was a child of a root
+            const depth = Math.max(conv.subagent_depth, 1) - 1;
+            const rootConversationId = depth === 0
+                ? parentConversationId
+                : await rootConversationOf(this.db, parentConversationId);
+            // the tree's budget window of THIS run (agent map spec §6): its own `budget_run_id`, set when
+            // it was created (a dispatch, or a wake run from the root's current window), else its
+            // dispatch's; never derived from the parent run, which for a wake run is the first dispatch's
+            const budgetRunId = run.budget_run_id ?? row?.budgetRunId;
             parent = row
                 ? {
                     conversationId: row.parentConversationId,
                     runId: row.parentRunId,
                     callId: row.parentCallId,
+                    depth,
+                    rootConversationId,
                     otherAgent,
+                    ...(budgetRunId !== undefined && { budgetRunId }),
+                    ...(row.forSkill === true && { forSkill: true }),
                 }
                 : {
                     conversationId: started.payload.parent.conversationId,
                     runId: started.payload.parent.runId,
                     callId: started.payload.parent.callId,
+                    depth,
+                    rootConversationId,
                     otherAgent,
+                    ...(budgetRunId !== undefined && { budgetRunId }),
                 };
         }
         else {
@@ -552,7 +574,7 @@ let RunWorker = class RunWorker {
                 .where("agent_id", "=", conv.agent_id)
                 .where("version", "=", run.agent_version)
                 .executeTakeFirstOrThrow();
-            saved = normalizeStoredDefinition(version.definition);
+            saved = await normalizeStoredDefinitionIn(this.db, conv.org_id, version.definition);
             agent = saved;
         }
         let startedAt = run.started_at;
@@ -567,7 +589,7 @@ let RunWorker = class RunWorker {
         if (run.status === "queued" || startedAt === null) {
             if (!existingStart) {
                 if (saved !== undefined)
-                    await this.fallBackIfUnavailable(conversationId, runId, saved);
+                    await this.fallBackIfUnavailable(conv.org_id, conversationId, runId, saved);
                 const started = await this.appendRunStarted(conversationId, run, agent, saved);
                 agent = started.agent;
                 const toSeq = started.toSeq;
@@ -606,6 +628,22 @@ let RunWorker = class RunWorker {
                 });
                 return "finished";
             }
+            // run context (spec §5): after the catalog, before the run is running, so before any
+            // compaction and model call; a retried run start finds its event or no change
+            await this.runContext.record({
+                orgId: conv.org_id,
+                conversationId,
+                runId,
+                triggerSeq: Number(run.trigger_seq),
+                agent,
+                ...(parent !== undefined && {
+                    subagent: {
+                        parentConversationId: parent.conversationId,
+                        parentRunId: parent.runId,
+                        name: childName ?? agent.name,
+                    },
+                }),
+            });
             const updated = await this.db
                 .updateTable("runs")
                 .set({ status: "running", started_at: sql `COALESCE(started_at, now())` })
@@ -642,15 +680,16 @@ let RunWorker = class RunWorker {
                 .executeTakeFirstOrThrow();
             const startConsumed = Number(consumed_seq);
             let absorbed = startConsumed;
-            const pendingUserMessages = async (afterSeq) => {
+            const pendingAbsorbable = async (afterSeq) => {
                 // loop 声明已吸收到 afterSeq（续跑时来自 checkpoint，可能包含之前进程吸收的消息）。
                 absorbed = Math.max(absorbed, afterSeq);
                 const out = [];
                 let after = Math.max(afterSeq, startConsumed);
                 for (;;) {
                     const page = await this.eventLog.readAfter(conversationId, after, READ_PAGE);
+                    // messages and finished background tasks (spec 2026-11-05-background-bash-design §2.4)
                     for (const e of page)
-                        if (e.type === "user_message")
+                        if (isAbsorbable(e))
                             out.push(e);
                     const last = page.at(-1);
                     if (page.length < READ_PAGE || !last)
@@ -677,7 +716,7 @@ let RunWorker = class RunWorker {
                     signal: ac.signal,
                     shutdown: state.shutdown.signal,
                     sink: this.sinkFor(conversationId),
-                    pendingUserMessages,
+                    pendingAbsorbable,
                     limits: { maxSteps, deadline },
                     // a sub-agent's conversation fires hooks like a chat, with `parent` set (spec §11)
                     conversationKind: conv.kind === "eval" ? "eval" : conv.kind === "subagent" ? "subagent" : "chat",
@@ -701,6 +740,10 @@ let RunWorker = class RunWorker {
                 });
                 return "finished";
             }
+            finally {
+                // the execution here ended: what this process held of the run's drafts goes
+                this.drafts.release(runId);
+            }
             if (state.abandoned)
                 return "abandoned";
             // 锁在运行中丢失：无论 loop 返回什么都不写终态，任务回到队列由持锁者续跑。
@@ -770,14 +813,14 @@ let RunWorker = class RunWorker {
      * model removed), writes `model_switched { model: null, effort: null, reason: "unavailable" }`
      * for this run (idempotent) and clears the cached selection: the run and the next ones use the
      * agent's model. A provider that only failed to list its models is not "gone" (the run's ladder
-     * handles it).
+     * handles it). Resolved for the conversation's org (its effective provider config).
      */
-    async fallBackIfUnavailable(conversationId, runId, agent) {
+    async fallBackIfUnavailable(orgId, conversationId, runId, agent) {
         const sel = await readSelection(this.db, conversationId);
         if (sel.model === null || sameModel(sel.model, agent.model))
             return;
         try {
-            await this.models.resolve(sel.model);
+            await this.models.resolve(orgId, sel.model);
             return;
         }
         catch (e) {
@@ -814,6 +857,14 @@ let RunWorker = class RunWorker {
         const agent = saved !== undefined
             ? effectiveDefinition(saved, await readSelection(t, conversationId))
             : current;
+        // a wake run's boundary is a finished background task (background Bash §3) or a sub-agent's
+        // delivery (agent map spec §5.3), not a message
+        const boundary = await t
+            .selectFrom("conversation_events")
+            .select("type")
+            .where("conversation_id", "=", conversationId)
+            .where("seq", "=", run.trigger_seq)
+            .executeTakeFirst();
         const [ev] = await this.eventLog.appendIn(conversationId, [
             {
                 type: "run_started",
@@ -823,6 +874,14 @@ let RunWorker = class RunWorker {
                     agentVersion: run.agent_version,
                     model: agent.model,
                     triggerAccountId: run.trigger_account_id,
+                    ...(boundary?.type === "background_task_finished" && {
+                        trigger: "background_task",
+                        triggerSeq: Number(run.trigger_seq),
+                    }),
+                    ...(boundary?.type === "subagent_delivery" && {
+                        trigger: "subagent",
+                        triggerSeq: Number(run.trigger_seq),
+                    }),
                 },
             },
         ]);
@@ -911,10 +970,12 @@ RunWorker = __decorate([
     __param(15, Inject(TitleQueue)),
     __param(16, Inject(ProviderRegistry)),
     __param(17, Inject(SkillsCatalogService)),
-    __param(18, Inject(ToolPipeline)),
-    __param(19, Inject(RunFinish)),
-    __param(20, Inject(TransactionHost)),
-    __param(21, Optional()),
-    __param(21, Inject(RUN_HOOKS))
+    __param(18, Inject(RunContextService)),
+    __param(19, Inject(ToolPipeline)),
+    __param(20, Inject(RunFinish)),
+    __param(21, Inject(TransactionHost)),
+    __param(22, Inject(RunDrafts)),
+    __param(23, Optional()),
+    __param(23, Inject(RUN_HOOKS))
 ], RunWorker);
 export { RunWorker };

package/dist/runtime/runtime.module.js

@@ -5,6 +5,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 import { Module } from "@nestjs/common";
+import { BackgroundModule } from "../background/background.module.js";
+import { BackgroundWake } from "../background/wake.js";
 import { ConversationAccessModule } from "../conversations/access.js";
 import { AttachmentsModule } from "../conversations/attachments.module.js";
 import { EventLogModule } from "../conversations/event-log.js";
@@ -22,13 +24,15 @@ import { ConversationLock } from "./conversation-lock.js";
 import { MAINTENANCE_QUEUE_NAME } from "./maintenance-queue.js";
 import { ProvidersModule } from "./providers.js";
 import { EVAL_QUOTA, EVAL_QUOTA_PREFIX, OrgQuota, RUN_QUOTA, RUN_QUOTA_PREFIX } from "./quota.js";
+import { RunContextService } from "./run-context.service.js";
 import { RunControl } from "./run-control.js";
+import { RunDrafts } from "./run-drafts.js";
 import { RunFinish } from "./run-finish.js";
 import { RunJobsModule } from "./run-jobs.js";
 import { RunQueue } from "./run-queue.js";
 import { AgentLoops, RunSteps } from "./run-steps.js";
 import { RunWorker } from "./run-worker.js";
-import { StepLog } from "./step-log.js";
+import { StepLogModule } from "./step-log.js";
 import { ConversationStreams } from "./stream.js";
 import { SubagentsModule } from "./subagents/subagents.service.js";
 import { UsageReportModule } from "./usage-report.js";
@@ -58,6 +62,8 @@ RuntimeModule = __decorate([
             SubagentsModule,
             UsageReportModule,
             TitlesModule,
+            StepLogModule,
+            BackgroundModule,
             // the producer side of `wait-timeout` jobs (`MaintenanceProcessor` consumes them)
             QueueModule.registerQueue(MAINTENANCE_QUEUE_NAME),
         ],
@@ -67,14 +73,17 @@ RuntimeModule = __decorate([
             RunAbort,
             KyselyCheckpointSaver,
             RunFinish,
-            StepLog,
             RunQueue,
             Waits,
             DecisionResumer,
             RunControl,
+            RunDrafts,
             AgentLoops,
             RunSteps,
+            RunContextService,
             RunWorker,
+            // a finished background task wakes an idle conversation (background Bash spec §3)
+            BackgroundWake,
             // one quota per key prefix (the org run quota, the org eval quota)
             {
                 provide: RUN_QUOTA,
@@ -93,10 +102,11 @@ RuntimeModule = __decorate([
             RunAbort,
             KyselyCheckpointSaver,
             RunFinish,
-            StepLog,
+            StepLogModule,
             RunQueue,
             Waits,
             RunControl,
+            RunDrafts,
             AgentLoops,
             RunSteps,
             RunWorker,

package/dist/runtime/step-log.d.ts

@@ -19,11 +19,16 @@ export declare class StepLog {
     constructor(kdb: KernelDb, eventLog: EventLog, txHost: TransactionHost);
     /**
      * Appends events of a sub-agent's run and adds the tokens of the usage events it newly wrote to
-     * the parent run's `subagent_tokens_used` (sub-agents spec §8.3): 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).
+     * 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).
      */
-    appendCounted(conversationId: string, parentRunId: string, events: AppendEvent[]): Promise<{
+    appendCounted(conversationId: string, counter: {
+        parentRunId: string;
+        budgetRunId?: string | undefined;
+    }, events: AppendEvent[]): Promise<{
         written: ConversationEvent[];
         toSeq: number | null;
     }>;
@@ -38,3 +43,9 @@ export declare class StepLog {
         spec: ToolSpec;
     }[], events: AppendEvent[]): Promise<ConversationEvent[]>;
 }
+/**
+ * The step writes ({@link StepLog}): a module of its own, so the tools domain (the `WebFetch`
+ * extraction's usage and denials) uses them without importing the runtime.
+ */
+export declare class StepLogModule {
+}

package/dist/runtime/step-log.js

@@ -7,15 +7,16 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
-import { Inject, Injectable } from "@nestjs/common";
+import { Inject, Injectable, Module } from "@nestjs/common";
 import { sql } from "kysely";
-import { EventLog } from "../conversations/event-log.js";
+import { EventLog, EventLogModule } from "../conversations/event-log.js";
 import { usageTokens } from "../evals/budget.js";
 import { audit } from "../identity/audit.js";
 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 { recordToolSpecs } from "../tools/specs.js";
+import { budgetRunOf } from "./subagents/limits.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
@@ -33,11 +34,13 @@ let StepLog = class StepLog {
     }
     /**
      * Appends events of a sub-agent's run and adds the tokens of the usage events it newly wrote to
-     * the parent run's `subagent_tokens_used` (sub-agents spec §8.3): 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).
+     * 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).
      */
-    async appendCounted(conversationId, parentRunId, events) {
+    async appendCounted(conversationId, counter, events) {
         const t = this.kdb.db;
         // the conversation row lock the append takes anyway, taken first to read the seq before it
         const before = await t
@@ -56,7 +59,7 @@ let StepLog = class StepLog {
             await t
                 .updateTable("runs")
                 .set({ subagent_tokens_used: sql `subagent_tokens_used + ${tokens}` })
-                .where("id", "=", parentRunId)
+                .where("id", "=", counter.budgetRunId ?? (await budgetRunOf(t, counter.parentRunId)))
                 .execute();
         }
         return { written, toSeq: fresh.length > 0 ? Math.max(...fresh.map((e) => e.seq)) : null };
@@ -92,3 +95,17 @@ StepLog = __decorate([
     __param(2, Inject(TransactionHost))
 ], StepLog);
 export { StepLog };
+/**
+ * The step writes ({@link StepLog}): a module of its own, so the tools domain (the `WebFetch`
+ * extraction's usage and denials) uses them without importing the runtime.
+ */
+let StepLogModule = class StepLogModule {
+};
+StepLogModule = __decorate([
+    Module({
+        imports: [EventLogModule],
+        providers: [StepLog],
+        exports: [StepLog],
+    })
+], StepLogModule);
+export { StepLogModule };

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

@@ -1,18 +1,27 @@
+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";
 import { type OrgContext } from "../orgs/org.guard.js";
+import { type RunDraft, RunDrafts } from "./run-drafts.js";
 import { ConversationStreams } from "./stream.js";
 declare const StreamQuery: z.ZodObject<{
     after: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strip>;
+declare const DraftParams: z.ZodObject<{
+    id: z.ZodString;
+    runId: z.ZodString;
+}, z.core.$strip>;
 /**
  * 会话事件流（SSE）：`GET /api/v1/orgs/:orgId/conversations/:id/stream?after=<seq>`，`agents.use`，只有会话所有者可用。
  * - 打开时不阻塞地调用一次 ensureRun（`ConversationsService.kickRun`），停在「运行中」的孤儿运行由此被清理；
  * - 先订阅会话频道、再回放 `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);
  *   之后收到 `events` 通知就补读新事件（按 seq 去重），收到增量就发 `event: delta`，收到界面刷新
  *   （插件 `ctx.ui.invalidate`）就发 `event: ui`（`data: {"plugin","contribution"}`）；
  * - 每 `runtime.sseHeartbeatMs` 发 `: ping` 注释；每 `runtime.sseRecheckMs` 复核凭据（会话未吊销 / 令牌仍有效，
@@ -25,7 +34,20 @@ export declare class ConversationStreamController {
     private readonly sessions;
     private readonly tokens;
     private readonly conversations;
-    constructor(streams: ConversationStreams, sessions: SessionService, tokens: ApiTokenService, conversations: ConversationsService);
+    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">);
+    /**
+     * 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
+     * longer running). What a stream client asks for when a delta's `offset` is past its draft.
+     * The stream's access rule (the conversation is visible to the viewer, else 404
+     * `conversation.not_found`); a run not of this conversation → 404 `run.not_found`.
+     */
+    draft(principal: Principal, org: OrgContext, params: z.infer<typeof DraftParams>): Promise<{
+        drafts: RunDraft[];
+    }>;
     stream(principal: Principal, org: OrgContext, id: string, q: z.infer<typeof StreamQuery>, lastEventId: string | undefined, req: FastifyRequest, reply: FastifyReply): Promise<void>;
 }
 export {};