@capybara-hq/kernel 0.1.0-rc.4 → 0.1.0-rc.5

package/dist/runtime/run-drafts.js

@@ -0,0 +1,230 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+import { Inject, Injectable } from "@nestjs/common";
+import { conversationTopic, EventLog, } from "../conversations/event-log.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { KERNEL_LOGGER, REDIS } from "../infra/tokens.js";
+import { assistantIdemKey } from "./model-call.js";
+/** How long a draft lives without a write (a step that keeps streaming keeps refreshing it). */
+export const DRAFT_TTL_SECONDS = 600;
+/** At most one write per step per window, plus the one at the end of the model stream. */
+export const DRAFT_FLUSH_MS = 200;
+/** One step's draft: `{ text, thinking }` as JSON (spec 2026-11-07 §3.2). */
+export const draftKey = (runId, step) => `capk:run-draft:${runId}:${step}`;
+/** The steps of a run that have a draft (a set, so a reader finds them without a key scan). */
+const stepsKey = (runId) => `capk:run-draft-steps:${runId}`;
+const parse = (step, v) => {
+    if (v === null)
+        return null;
+    try {
+        const d = JSON.parse(v);
+        return {
+            step,
+            text: typeof d.text === "string" ? d.text : "",
+            thinking: typeof d.thinking === "string" ? d.thinking : "",
+        };
+    }
+    catch {
+        return null;
+    }
+};
+/**
+ * Live drafts (spec 2026-11-07-run-input-and-live-drafts §3.2): what each step of a running run
+ * has streamed so far, kept in Redis so a viewer that (re)connects on any replica gets the text
+ * already shown, then the deltas from there on.
+ *
+ * The writer is the process executing the run: it holds the step's draft in memory (only for the
+ * runs it executes; {@link release} drops them when the execution ends) and writes it at most once
+ * per {@link DRAFT_FLUSH_MS}: on the first delta past the window, or, when deltas stop inside it,
+ * by one trailing one-shot timer per held step (process-local, unref'd, cancelled by a write,
+ * {@link clear} and {@link release}), plus once when the model stream ends ({@link flush}). Writes are issued before the delta is published, on the same
+ * connection as the bus publish, so a viewer that sees a delta past its snapshot and asks again
+ * gets a draft at least that far whenever that delta was written. Every write refreshes the
+ * {@link DRAFT_TTL_SECONDS} TTL; {@link clear} deletes the step's draft once its
+ * `assistant_message` is logged or the step is reset. Redis failures are logged, never thrown to
+ * the run: a draft is a convenience, the log stays the truth.
+ */
+let RunDrafts = class RunDrafts {
+    redis;
+    kdb;
+    eventLog;
+    log;
+    held = new Map();
+    constructor(redis, kdb, eventLog, log) {
+        this.redis = redis;
+        this.kdb = kdb;
+        this.eventLog = eventLog;
+        this.log = log;
+    }
+    get db() {
+        return this.kdb.db;
+    }
+    /** Adds a delta to the step's draft; writes it when the last write is a window old. */
+    append(runId, step, channel, text) {
+        let h = this.held.get(runId);
+        if (h?.step !== step) {
+            if (h)
+                this.drop(runId, h);
+            h = {
+                step,
+                text: "",
+                thinking: "",
+                writtenAt: Number.NEGATIVE_INFINITY,
+                dirty: false,
+                timer: undefined,
+            };
+            this.held.set(runId, h);
+        }
+        h[channel] += text;
+        h.dirty = true;
+        const elapsed = Date.now() - h.writtenAt;
+        if (elapsed >= DRAFT_FLUSH_MS)
+            this.write(runId, h);
+        else if (h.timer === undefined) {
+            // held: written when the window ends even if no delta follows (a tool input, a pause)
+            h.timer = setTimeout(() => {
+                h.timer = undefined;
+                this.flush(runId, step);
+            }, DRAFT_FLUSH_MS - elapsed).unref();
+        }
+    }
+    /** The end of the step's model stream: writes what the window still holds. */
+    flush(runId, step) {
+        const h = this.held.get(runId);
+        if (h?.step === step && h.dirty)
+            this.write(runId, h);
+    }
+    /** Deletes the step's draft (its `assistant_message` is logged, or the step starts over). */
+    clear(runId, step) {
+        const h = this.held.get(runId);
+        if (h?.step === step)
+            this.drop(runId, h);
+        this.redis
+            .multi()
+            .del(draftKey(runId, step))
+            .srem(stepsKey(runId), String(step))
+            .exec()
+            .catch((err) => this.log.warn("run draft clear failed", { runId, step, err }));
+    }
+    /**
+     * Drops what this process holds for the run (its execution here ended: finished, suspended,
+     * handed over). Redis keeps what was written: another worker may continue the run, and a step
+     * that never ended is not shown once the run is no longer running (TTL removes it).
+     */
+    release(runId) {
+        const h = this.held.get(runId);
+        if (h)
+            this.drop(runId, h);
+    }
+    /** The run's steps with a draft, by step. */
+    async read(runId) {
+        const steps = (await this.redis.smembers(stepsKey(runId)))
+            .map(Number)
+            .filter((n) => Number.isSafeInteger(n))
+            .sort((a, b) => a - b);
+        if (steps.length === 0)
+            return [];
+        const values = await this.redis.mget(steps.map((s) => draftKey(runId, s)));
+        return steps.flatMap((s, i) => parse(s, values[i] ?? null) ?? []);
+    }
+    /**
+     * The drafts a viewer of the conversation is shown: steps of its running run (or only `runId`)
+     * whose `assistant_message` is not logged. Redis is read before the log, so a step finalized
+     * meanwhile is either skipped here or its `assistant_message` reaches the viewer after the draft.
+     */
+    async live(conversationId, runId) {
+        let q = this.db
+            .selectFrom("runs")
+            .select("id")
+            .where("conversation_id", "=", conversationId)
+            .where("status", "=", "running");
+        if (runId !== undefined)
+            q = q.where("id", "=", runId);
+        const out = [];
+        for (const run of await q.execute()) {
+            for (const d of await this.read(run.id)) {
+                const final = await this.eventLog.findByIdem(conversationId, assistantIdemKey(run.id, d.step));
+                if (final === undefined)
+                    out.push({ runId: run.id, ...d });
+            }
+        }
+        return out;
+    }
+    /** Whether the run belongs to the conversation (the draft route's 404). */
+    async runOf(conversationId, runId) {
+        const row = await this.db
+            .selectFrom("runs")
+            .select("id")
+            .where("id", "=", runId)
+            .where("conversation_id", "=", conversationId)
+            .executeTakeFirst();
+        return row !== undefined;
+    }
+    drop(runId, h) {
+        clearTimeout(h.timer);
+        h.timer = undefined;
+        this.held.delete(runId);
+    }
+    write(runId, h) {
+        clearTimeout(h.timer);
+        h.timer = undefined;
+        h.writtenAt = Date.now();
+        h.dirty = false;
+        const { step } = h;
+        this.redis
+            .multi()
+            .set(draftKey(runId, step), JSON.stringify({ text: h.text, thinking: h.thinking }), "EX", DRAFT_TTL_SECONDS)
+            .sadd(stepsKey(runId), String(step))
+            .expire(stepsKey(runId), DRAFT_TTL_SECONDS)
+            .exec()
+            .catch((err) => this.log.warn("run draft write failed", { runId, step, err }));
+    }
+};
+RunDrafts = __decorate([
+    Injectable(),
+    __param(0, Inject(REDIS)),
+    __param(1, Inject(KernelDb)),
+    __param(2, Inject(EventLog)),
+    __param(3, Inject(KERNEL_LOGGER))
+], RunDrafts);
+export { RunDrafts };
+/**
+ * The run's stream sink (one per execution of a run): publishes deltas on the conversation's topic
+ * (`conv.<id>`, shared with `{ kind: "events" }`, so a subscriber on any replica gets them) with
+ * `offset`, the characters of that channel (text or thinking) this attempt of the step streamed
+ * before the delta, and keeps the step's live draft. `step_reset` clears the draft and both
+ * offsets; `stream_end` / `step_end` only flush / clear the draft and are not published. A failed
+ * publish is only logged: deltas are drafts, the `assistant_message` in the log is the truth.
+ */
+export function streamSink(conversationId, deps) {
+    let at = { runId: "", step: -1, text: 0, thinking: 0 };
+    const publish = (msg) => deps.bus
+        .publish(conversationTopic(conversationId), msg)
+        .catch((err) => deps.log.warn("stream delta publish failed", { conversationId, err }));
+    return (d) => {
+        if (d.kind === "stream_end")
+            return deps.drafts.flush(d.runId, d.step);
+        if (d.kind === "step_end")
+            return deps.drafts.clear(d.runId, d.step);
+        if (at.runId !== d.runId || at.step !== d.step || d.kind === "step_reset") {
+            at = { runId: d.runId, step: d.step, text: 0, thinking: 0 };
+        }
+        if (d.kind === "step_reset") {
+            deps.drafts.clear(d.runId, d.step);
+            void publish({ kind: "delta", runId: d.runId, step: d.step, delta: "step_reset" });
+            return;
+        }
+        const text = d.text ?? "";
+        const offset = at[d.kind];
+        at[d.kind] += text.length;
+        deps.drafts.append(d.runId, d.step, d.kind, text);
+        void publish({ kind: "delta", runId: d.runId, step: d.step, delta: d.kind, text, offset });
+    };
+}

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

@@ -34,12 +34,10 @@ export declare class RunJobs {
     queue(name?: string): Queue<RunJobData>;
     /** A run job by id on the queue `name`, or undefined. */
     getJob(jobId: string, name?: string): Promise<Job<RunJobData> | undefined>;
-    /** Adds a conversation run job (`ensureRun`'s own enqueue). */
-    add(data: RunJobData, jobId: string): Promise<void>;
     /**
-     * Enqueues a run job under the caller's job id (resumes, dispatches, repairs). The queue follows
-     * the conversation's kind (a sub-agent's runs go to {@link SUBAGENT_RUN_QUEUE_NAME}); pass
-     * `kind` when the caller knows it, else it is read.
+     * Enqueues a run job under the caller's job id (`ensureRun`, resumes, dispatches, repairs). The
+     * queue follows the conversation's kind (a sub-agent's runs go to
+     * {@link SUBAGENT_RUN_QUEUE_NAME}); pass `kind` when the caller knows it, else it is read.
      */
     enqueue(data: RunJobData, jobId: string, kind?: ConversationKind): Promise<void>;
 }

package/dist/runtime/run-jobs.js

@@ -54,14 +54,10 @@ let RunJobs = class RunJobs {
     getJob(jobId, name = RUN_QUEUE_NAME) {
         return this.queue(name).getJob(jobId);
     }
-    /** Adds a conversation run job (`ensureRun`'s own enqueue). */
-    async add(data, jobId) {
-        await this.queue().add("run", data, { jobId, ...RUN_JOB_OPTIONS });
-    }
     /**
-     * Enqueues a run job under the caller's job id (resumes, dispatches, repairs). The queue follows
-     * the conversation's kind (a sub-agent's runs go to {@link SUBAGENT_RUN_QUEUE_NAME}); pass
-     * `kind` when the caller knows it, else it is read.
+     * Enqueues a run job under the caller's job id (`ensureRun`, resumes, dispatches, repairs). The
+     * queue follows the conversation's kind (a sub-agent's runs go to
+     * {@link SUBAGENT_RUN_QUEUE_NAME}); pass `kind` when the caller knows it, else it is read.
      */
     async enqueue(data, jobId, kind) {
         const k = kind ??

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

@@ -52,9 +52,11 @@ export declare class RunQueue {
      * 且没有 queued / running / waiting 的运行时：插入 `runs`（queued）并投递任务，返回 runId；否则返回 null。
      *
      * The boundary (`trigger_seq`) is that newest message; with none unconsumed, the queue's head
-     * once it is sent; with no head either, a wake-eligible finished background task (background
-     * Bash spec §3, {@link wakeDecisionIn}): the run is then attributed to the task's trigger
-     * account, and a finish inside the wake window schedules the delayed `bg-wake` job instead.
+     * once it is sent; with no head either, a wake-eligible finished background task or sub-agent
+     * delivery (background Bash spec §3, agent map spec §5.3, {@link wakeDecisionIn}): the run is
+     * then attributed to the event's trigger account and joins the tree's budget window, and an
+     * event inside the wake window schedules the delayed `bg-wake` job instead. A sub-agent's
+     * conversation is only woken this way ({@link childWakeIn}).
      *
      * 孤儿清理（R29，按需进行，没有定时器）：已有的 queued / running 运行若 BullMQ 任务已不存在、
      * 会话锁也无人持有（queued 的还要超过宽限期），说明没有任何 worker 会再执行它——写
@@ -71,6 +73,38 @@ export declare class RunQueue {
     }): Promise<string | null>;
     /** {@link ensureRun}'s transaction: what it decided goes back through `st`. */
     private ensureRunIn;
+    /**
+     * {@link ensureRunIn} for a sub-agent's conversation (agent map spec §5.3), under its row lock.
+     * Its runs from a task, or from a message to an idle sub-agent, are started by the dispatch
+     * (`Agent`, `SendMessage`), which also records the dispatch. Here it is started from a parent's
+     * message that reached its run after that run's last model call (agent map spec §10: a message
+     * racing the run's end starts a new run, never lost); and it is woken by its own background
+     * task's finish or a delivery from its own sub-agent, under the same rules as a chat
+     * conversation. Neither happens once its last run was stopped (`aborted`): a stopped sub-agent is
+     * started again only by its parent. Both read the queue and the trigger account's access on the root
+     * of its tree; a message needs no wake setting and has no wake window. The run counts against
+     * the root's budget window and runs on the sub-agent queue under `runJobId(child, boundary
+     * seq)`. An active run is left to the orphan repair after the commit (`repairRunId`), never
+     * started past.
+     */
+    private childWakeIn;
+    /**
+     * The newest unconsumed message of an idle sub-agent (a `SendMessage` its last run did not absorb)
+     * as a run boundary, or null: none; the root's queue is paused or the root deleted (the
+     * message waits for the unpause, {@link wakeHeldTree}); or its author can no longer send to the
+     * root (it waits for a later run). The caller already refused a stopped sub-agent (last run
+     * `aborted`): a message that reached it while running and then stopped is parked, and the next
+     * run its parent starts absorbs it. Called under the sub-agent's row lock.
+     */
+    private pendingMessageIn;
+    /**
+     * Re-derives the wakes a paused root held for its tree (agent map spec §5.3: a paused root queue
+     * holds the wakes of the whole tree): after the root's queue is unpaused, {@link ensureRun} on
+     * every sub-agent conversation below it that has an unconsumed wake event or message and no
+     * active run (the root itself is the caller's own `ensureRun`). Errors are logged; the next
+     * event, run end or page opening of that conversation re-derives its wake.
+     */
+    wakeHeldTree(rootId: string): Promise<void>;
     /**
      * Schedules the delayed `bg-wake` job at the end of the conversation's wake window (after the
      * commit): one job per conversation and window end, so finishes inside one window share it. It

package/dist/runtime/run-queue.js

@@ -15,6 +15,7 @@ import { visibleTo } from "../agents/agent-lookup.js";
 import { BG_WAKE_JOB, bgWakeJobId, wakeDecisionIn, } from "../background/wake-rules.js";
 import { EventLog } from "../conversations/event-log.js";
 import { dispatchQueuedIn, pauseQueueWith } from "../conversations/queue.js";
+import { conversationTree } from "../conversations/tree.js";
 import { KernelConfigService } from "../infra/config/kernel-config.service.js";
 import { KernelDb } from "../infra/database/kernel-db.js";
 import { TransactionHost } from "../infra/database/transaction-host.js";
@@ -27,6 +28,8 @@ import { ConversationLock } from "./conversation-lock.js";
 import { MAINTENANCE_QUEUE_NAME } from "./maintenance-queue.js";
 import { notifyFinished, RunFinish } from "./run-finish.js";
 import { ACTIVE_RUN_STATUSES, RunJobs, runJobId, runQueueNameFor, } from "./run-jobs.js";
+import { rootConversationOf } from "./subagents/child.js";
+import { budgetWindowOf } from "./subagents/limits.js";
 export { ACTIVE_RUN_STATUSES, RUN_QUEUE_NAME, runJobId, runQueueNameFor, SUBAGENT_RUN_QUEUE_NAME, } from "./run-jobs.js";
 /**
  * queued 运行的宽限期（秒）：`ensureRun` / 续跑先提交 runs 行、再投递任务，两步之间任务暂时不存在；
@@ -98,9 +101,11 @@ let RunQueue = class RunQueue {
      * 且没有 queued / running / waiting 的运行时：插入 `runs`（queued）并投递任务，返回 runId；否则返回 null。
      *
      * The boundary (`trigger_seq`) is that newest message; with none unconsumed, the queue's head
-     * once it is sent; with no head either, a wake-eligible finished background task (background
-     * Bash spec §3, {@link wakeDecisionIn}): the run is then attributed to the task's trigger
-     * account, and a finish inside the wake window schedules the delayed `bg-wake` job instead.
+     * once it is sent; with no head either, a wake-eligible finished background task or sub-agent
+     * delivery (background Bash spec §3, agent map spec §5.3, {@link wakeDecisionIn}): the run is
+     * then attributed to the event's trigger account and joins the tree's budget window, and an
+     * event inside the wake window schedules the delayed `bg-wake` job instead. A sub-agent's
+     * conversation is only woken this way ({@link childWakeIn}).
      *
      * 孤儿清理（R29，按需进行，没有定时器）：已有的 queued / running 运行若 BullMQ 任务已不存在、
      * 会话锁也无人持有（queued 的还要超过宽限期），说明没有任何 worker 会再执行它——写
@@ -124,8 +129,14 @@ let RunQueue = class RunQueue {
             pausedNow: false,
             orphanStop: undefined,
             wakeLater: null,
+            repairRunId: null,
         };
         const created = await this.ensureRunIn(conversationId, st);
+        if (st.repairRunId !== null) {
+            // a sub-agent's run nobody runs any more: requeued when queued, failed when running (its
+            // finish then reaches the parent through the wait sweep's undelivered repair)
+            await this.repairOrphan(conversationId, st.repairRunId);
+        }
         if (st.wakeLater !== null) {
             await this.scheduleWake(conversationId, st.wakeLater, opts.wakeRetry ?? 0);
         }
@@ -155,10 +166,10 @@ let RunQueue = class RunQueue {
         }
         if (!created)
             return null;
-        const { runId, jobId } = created;
+        const { runId, jobId, kind } = created;
         try {
-            const queue = this.jobs.queue();
-            await this.jobs.add({ runId, conversationId }, jobId);
+            const queue = this.jobs.queue(runQueueNameFor(kind));
+            await this.jobs.enqueue({ runId, conversationId }, jobId, kind);
             // 从 Redis 读回核对：检查与 add 之间出现了同 jobId 的任务时 add 被静默忽略，撤销本次插入，
             // 不留下没有任务的 queued 行。读不到说明任务已被领取并移除（只可能是本次投递的），不撤销。
             const stored = await queue.getJob(jobId);
@@ -197,11 +208,13 @@ let RunQueue = class RunQueue {
             .forUpdate()
             .executeTakeFirst();
         // 评测回放的隐藏对话：运行由评测 worker 在里面直接驱动（工具只回放记录），绝不为它起真实运行
-        if (conv?.kind !== "chat")
+        if (conv?.kind !== "chat" && conv?.kind !== "subagent")
             return null;
         // A deleted conversation starts no run, whatever is still unconsumed or queued
         if (conv.deleted_at !== null)
             return null;
+        if (conv.kind === "subagent")
+            return this.childWakeIn(conversationId, conv, st);
         const newest = await t
             .selectFrom("conversation_events")
             .select(["seq", "payload"])
@@ -210,6 +223,8 @@ let RunQueue = class RunQueue {
             .orderBy("seq", "desc")
             .limit(1)
             .executeTakeFirst();
+        /** The boundary is a wake event: the run joins the tree's budget window (agent map §6). */
+        let isWake = false;
         /** The run's boundary: its `trigger_seq` and the account it runs as. */
         let last = newest && {
             seq: newest.seq,
@@ -220,8 +235,8 @@ let RunQueue = class RunQueue {
             : undefined;
         if (idleActive && Number(idleActive.trigger_seq) > Number(conv.consumed_seq)) {
             // No unconsumed message, but a run whose boundary is not consumed yet (a wake run, whose
-            // boundary is a finished background task): it goes through the orphan check below with
-            // that boundary, as a message's run does
+            // boundary is a finished background task or a sub-agent's delivery): it goes through the
+            // orphan check below with that boundary, as a message's run does
             last = { seq: idleActive.trigger_seq, accountId: idleActive.trigger_account_id };
         }
         else if (!last || Number(last.seq) <= Number(conv.consumed_seq)) {
@@ -276,12 +291,13 @@ let RunQueue = class RunQueue {
             else {
                 // Nothing queued either: a finished background task may wake the idle conversation
                 // (background Bash spec §3; a person's message or the queue always goes first)
-                const wake = await wakeDecisionIn(t, { id: conversationId, orgId: conv.org_id }, Number(conv.consumed_seq), this.config.get().runtime.wakeOnBackgroundTask, (accountId) => authorCanSend(t, conversationId, accountId));
+                const wake = await wakeDecisionIn(t, { id: conversationId, orgId: conv.org_id, rootId: conversationId }, Number(conv.consumed_seq), this.config.get().runtime.wakeOnBackgroundTask, (accountId) => authorCanSend(t, conversationId, accountId));
                 if (wake?.kind === "later")
                     st.wakeLater = wake;
                 if (wake?.kind !== "wake")
                     return null;
                 last = { seq: String(wake.seq), accountId: wake.triggerAccountId };
+                isWake = true;
             }
         }
         const active = await this.activeRun(t, conversationId);
@@ -357,9 +373,170 @@ let RunQueue = class RunQueue {
             agent_version: agent.current_version,
             trigger_account_id: trigger.accountId,
             trigger_seq: Number(trigger.seq),
+            // a chat conversation always has its person-triggered run before any wake (a wake event
+            // comes from a run of it or of its tree); null would only make the wake run its own window
+            budget_run_id: isWake ? await budgetWindowOf(t, conversationId) : null,
         })
             .execute();
-        return { runId, jobId };
+        return { runId, jobId, kind: "chat" };
+    }
+    /**
+     * {@link ensureRunIn} for a sub-agent's conversation (agent map spec §5.3), under its row lock.
+     * Its runs from a task, or from a message to an idle sub-agent, are started by the dispatch
+     * (`Agent`, `SendMessage`), which also records the dispatch. Here it is started from a parent's
+     * message that reached its run after that run's last model call (agent map spec §10: a message
+     * racing the run's end starts a new run, never lost); and it is woken by its own background
+     * task's finish or a delivery from its own sub-agent, under the same rules as a chat
+     * conversation. Neither happens once its last run was stopped (`aborted`): a stopped sub-agent is
+     * started again only by its parent. Both read the queue and the trigger account's access on the root
+     * of its tree; a message needs no wake setting and has no wake window. The run counts against
+     * the root's budget window and runs on the sub-agent queue under `runJobId(child, boundary
+     * seq)`. An active run is left to the orphan repair after the commit (`repairRunId`), never
+     * started past.
+     */
+    async childWakeIn(conversationId, conv, st) {
+        const t = this.db;
+        const active = await this.activeRun(t, conversationId);
+        if (active) {
+            if (active.status !== "waiting")
+                st.repairRunId = active.id;
+            return null;
+        }
+        // a stopped sub-agent (its last run `aborted`: a person's or a tree stop) stays stopped: no
+        // message, task finish or delivery that reached it before or during the stop wakes it (a
+        // descendant's report that landed just before the stop would otherwise restart the stopped
+        // branch); they are parked for its next run, which only its parent starts (`Agent`,
+        // `SendMessage`)
+        const last = await t
+            .selectFrom("runs")
+            .select("status")
+            .where("conversation_id", "=", conversationId)
+            .orderBy("created_at", "desc")
+            .orderBy("id", "desc")
+            .limit(1)
+            .executeTakeFirst();
+        if (last?.status === "aborted")
+            return null;
+        const rootId = await rootConversationOf(t, conversationId);
+        const wake = (await this.pendingMessageIn(conversationId, Number(conv.consumed_seq), rootId)) ??
+            (await wakeDecisionIn(t, { id: conversationId, orgId: conv.org_id, rootId }, Number(conv.consumed_seq), this.config.get().runtime.wakeOnBackgroundTask, (accountId) => authorCanSend(t, rootId, accountId)));
+        if (wake?.kind === "later")
+            st.wakeLater = wake;
+        if (wake?.kind !== "wake")
+            return null;
+        const jobId = runJobId(conversationId, wake.seq);
+        const existing = await this.jobs.getJob(jobId, runQueueNameFor("subagent"));
+        if (existing) {
+            this.log.warn("run job for this trigger already exists; not enqueuing", {
+                conversationId,
+                jobId,
+                existingRunId: existing.data?.runId,
+            });
+            return null;
+        }
+        const agent = await t
+            .selectFrom("agents")
+            .select(["current_version", "deleted_at"])
+            .where("id", "=", conv.agent_id)
+            .executeTakeFirstOrThrow();
+        if (agent.deleted_at !== null)
+            return null;
+        // a sub-agent runs its definition frozen at dispatch: its runs keep the version recorded then
+        const previous = await t
+            .selectFrom("runs")
+            .select("agent_version")
+            .where("conversation_id", "=", conversationId)
+            .orderBy("created_at", "desc")
+            .limit(1)
+            .executeTakeFirst();
+        const runId = randomUUID();
+        await t
+            .insertInto("runs")
+            .values({
+            id: runId,
+            conversation_id: conversationId,
+            status: "queued",
+            agent_version: previous?.agent_version ?? agent.current_version,
+            trigger_account_id: wake.triggerAccountId,
+            trigger_seq: wake.seq,
+            budget_run_id: await budgetWindowOf(t, rootId),
+        })
+            .execute();
+        return { runId, jobId, kind: "subagent" };
+    }
+    /**
+     * The newest unconsumed message of an idle sub-agent (a `SendMessage` its last run did not absorb)
+     * as a run boundary, or null: none; the root's queue is paused or the root deleted (the
+     * message waits for the unpause, {@link wakeHeldTree}); or its author can no longer send to the
+     * root (it waits for a later run). The caller already refused a stopped sub-agent (last run
+     * `aborted`): a message that reached it while running and then stopped is parked, and the next
+     * run its parent starts absorbs it. Called under the sub-agent's row lock.
+     */
+    async pendingMessageIn(conversationId, consumed, rootId) {
+        const t = this.db;
+        const message = await t
+            .selectFrom("conversation_events")
+            .select(["seq", "payload"])
+            .where("conversation_id", "=", conversationId)
+            .where("type", "=", "user_message")
+            .where("seq", ">", String(consumed))
+            .orderBy("seq", "desc")
+            .limit(1)
+            .executeTakeFirst();
+        if (!message)
+            return null;
+        const root = await t
+            .selectFrom("conversations")
+            .select(["queue_paused", "deleted_at"])
+            .where("id", "=", rootId)
+            .executeTakeFirst();
+        if (!root || root.queue_paused || root.deleted_at !== null)
+            return null;
+        const accountId = message.payload.authorAccountId;
+        if (!(await authorCanSend(t, rootId, accountId)))
+            return null;
+        return { kind: "wake", seq: Number(message.seq), triggerAccountId: accountId };
+    }
+    /**
+     * Re-derives the wakes a paused root held for its tree (agent map spec §5.3: a paused root queue
+     * holds the wakes of the whole tree): after the root's queue is unpaused, {@link ensureRun} on
+     * every sub-agent conversation below it that has an unconsumed wake event or message and no
+     * active run (the root itself is the caller's own `ensureRun`). Errors are logged; the next
+     * event, run end or page opening of that conversation re-derives its wake.
+     */
+    async wakeHeldTree(rootId) {
+        const ids = (await conversationTree(this.db, rootId))
+            .filter((c) => c.level > 0)
+            .map((c) => c.id);
+        if (ids.length === 0)
+            return;
+        const held = await this.db
+            .selectFrom("conversations as c")
+            .select("c.id")
+            .where("c.id", "in", ids)
+            .where("c.deleted_at", "is", null)
+            .where(({ exists, selectFrom }) => exists(selectFrom("conversation_events as e")
+            .select(sql `1`.as("one"))
+            .whereRef("e.conversation_id", "=", "c.id")
+            .where("e.type", "in", [
+            "background_task_finished",
+            "subagent_delivery",
+            "user_message",
+        ])
+            .whereRef("e.seq", ">", "c.consumed_seq")))
+            .where(({ not, exists, selectFrom }) => not(exists(selectFrom("runs as r")
+            .select(sql `1`.as("one"))
+            .whereRef("r.conversation_id", "=", "c.id")
+            .where("r.status", "in", ACTIVE_RUN_STATUSES))))
+            .execute();
+        for (const c of held) {
+            try {
+                await this.ensureRun(c.id);
+            }
+            catch (err) {
+                this.log.warn("cannot wake a held sub-agent", { conversationId: c.id, err });
+            }
+        }
     }
     /**
      * Schedules the delayed `bg-wake` job at the end of the conversation's wake window (after the

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

@@ -14,6 +14,7 @@ import { KyselyCheckpointSaver } from "./checkpointer.js";
 import { ConversationLock } from "./conversation-lock.js";
 import { ProviderRegistry } from "./providers.js";
 import { type OrgQuota } from "./quota.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";
@@ -70,6 +71,8 @@ export declare class RunWorker {
     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 +87,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. */
@@ -98,7 +101,9 @@ export declare class RunWorker {
      * (`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 +124,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;
     /**