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

package/dist/runtime/run-queue.js

@@ -1,92 +1,82 @@
+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 { randomUUID } from "node:crypto";
-import { Queue } from "bullmq";
-import { Redis } from "ioredis";
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
-import { visibleTo } from "../agents/agents.service.js";
+import { visibleTo } from "../agents/agent-lookup.js";
+import { EventLog } from "../conversations/event-log.js";
 import { dispatchQueuedIn, pauseQueueWith } from "../conversations/queue.js";
-import { finishRunIn, notifyFinished } from "./run-finish.js";
-/** 内核运行队列的 BullMQ 队列名（不含 `:`；与插件队列 `cap.<插件>.<名>` 不会重名）。 */
-export const RUN_QUEUE_NAME = "cap-kernel-runs";
-/**
- * Queue of sub-agent (child) runs (sub-agents spec §7.4): a replica still on a version without
- * sub-agents never takes a child job, and child load shows apart from conversations.
- */
-export const SUBAGENT_RUN_QUEUE_NAME = "cap-kernel-subagent-runs";
-/** The run queue of a conversation kind: sub-agent conversations have their own. */
-export const runQueueNameFor = (kind) => kind === "subagent" ? SUBAGENT_RUN_QUEUE_NAME : RUN_QUEUE_NAME;
-/** 同一触发点（会话 + 最新用户消息 seq）只投递一次。 */
-export const runJobId = (conversationId, maxUserSeq) => `run-${conversationId}-${maxUserSeq}`;
-/** 未结束的运行状态（waiting：等人处理审批 / 输入请求，没有任务、不占会话锁与配额）。 */
-export const ACTIVE_RUN_STATUSES = ["queued", "running", "waiting"];
+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 { KERNEL_LOGGER } from "../infra/tokens.js";
+import { ToolPipeline } from "../tools/pipeline.js";
+import { KyselyCheckpointSaver } from "./checkpointer.js";
+import { ConversationLock } from "./conversation-lock.js";
+import { notifyFinished, RunFinish } from "./run-finish.js";
+import { ACTIVE_RUN_STATUSES, RunJobs, runJobId, runQueueNameFor, } from "./run-jobs.js";
+export { ACTIVE_RUN_STATUSES, RUN_QUEUE_NAME, runJobId, runQueueNameFor, SUBAGENT_RUN_QUEUE_NAME, } from "./run-jobs.js";
 /**
  * queued 运行的宽限期（秒）：`ensureRun` / 续跑先提交 runs 行、再投递任务，两步之间任务暂时不存在；
  * 只有进入 queued 超过这么久（`COALESCE(queued_at, created_at)`）仍没有任务的 queued 行才视为孤儿。
  */
 const ORPHAN_QUEUED_GRACE_SECONDS = 30;
-/** BullMQ 连接要求 maxRetriesPerRequest 为 null（Worker 的阻塞连接）；Queue 复用同样的配置。 */
-export function bullConnection(redisUrl, log) {
-    const c = new Redis(redisUrl, { maxRetriesPerRequest: null });
-    c.on("error", (err) => log.error("run queue redis connection error", { err }));
-    return c;
-}
 /**
  * 运行队列（生产方）：`ensureRun` 在会话有未消费的用户消息、且没有进行中的运行时插入 `runs` 行并投递任务。
  * 「是否已有运行」以 PG 为准（会话行锁内检查 `runs` 中的 queued / running），并参考会话锁的持有者；
  * 多副本并发调用对同一会话串行化，同一时刻至多一个未结束的运行。
  */
-export class RunQueue {
-    db;
+let RunQueue = class RunQueue {
+    kdb;
     eventLog;
     lock;
-    redisUrl;
-    log;
+    jobs;
+    finisher;
     checkpoints;
-    subagents;
-    queues = new Map();
-    conn;
-    closed = false;
-    constructor(db, eventLog, lock, redisUrl, log, 
+    pipeline;
+    events;
+    log;
+    txHost;
+    constructor(kdb, eventLog, lock, jobs, finisher, 
     /** 运行以孤儿结束（标记失败 / 直接中止）后删除它的 checkpoint thread（thread_id = runId）。 */
     checkpoints, 
-    /** Sub-agent cleanup when an orphan repair ends a parent run (sub-agents spec §12). */
-    subagents) {
-        this.db = db;
+    /** The run's open `agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
+    pipeline, events, log, txHost) {
+        this.kdb = kdb;
         this.eventLog = eventLog;
         this.lock = lock;
-        this.redisUrl = redisUrl;
-        this.log = log;
+        this.jobs = jobs;
+        this.finisher = finisher;
         this.checkpoints = checkpoints;
-        this.subagents = subagents;
+        this.pipeline = pipeline;
+        this.events = events;
+        this.log = log;
+        this.txHost = txHost;
+    }
+    get db() {
+        return this.kdb.db;
     }
     /**
-     * The `beforeTerminal` of an orphan repair: writes the run's open `agent` call results in `t`;
-     * `fire()` runs their observe hooks after the commit (review m1).
+     * The `beforeTerminal` of an orphan repair: writes the run's open `agent` call results in the
+     * repair's transaction; `fire()` runs their observe hooks after the commit (review m1).
      */
     stopOpenCalls(runId) {
-        const sub = this.subagents;
-        if (!sub)
-            return { fire: () => { } };
         let fire = () => { };
         return {
-            beforeTerminal: async (t) => {
-                fire = (await sub.stopOpenCalls(t, runId)).fire;
+            beforeTerminal: async () => {
+                fire = (await this.pipeline.stopOpenAgentCalls(runId)).fire;
             },
             fire: () => fire(),
         };
     }
-    /** The BullMQ queue `name` (default: conversation runs); both share one connection. */
-    getQueue(name = RUN_QUEUE_NAME) {
-        if (this.closed)
-            throw new Error("run queue is closed");
-        let queue = this.queues.get(name);
-        if (!queue) {
-            this.conn ??= bullConnection(this.redisUrl, this.log);
-            queue = new Queue(name, { connection: this.conn });
-            queue.on("error", (err) => this.log.error("run queue error", { err, queue: name }));
-            this.queues.set(name, queue);
-        }
-        return queue;
-    }
     /**
      * 有未消费的用户消息（最新 user_message 的 seq > `consumed_seq`）、会话锁无人持有、
      * 且没有 queued / running / waiting 的运行时：插入 `runs`（queued）并投递任务，返回 runId；否则返回 null。
@@ -102,152 +92,16 @@ export class RunQueue {
     async ensureRun(conversationId) {
         if ((await this.lock.holder(conversationId)) !== null)
             return null;
-        let orphanSeq = null;
-        let orphanRunId = null;
-        let dispatchedSeq = null;
-        let dispatchedSwitch = false;
-        /** The queue paused in this transaction: the open pages hear it after the commit. */
-        let pausedNow = false;
-        let orphanStop;
-        const created = await this.db.transaction().execute(async (t) => {
-            const conv = await t
-                .selectFrom("conversations")
-                .select(["consumed_seq", "agent_id", "kind", "queue_paused", "account_id"])
-                .where("id", "=", conversationId)
-                .forUpdate()
-                .executeTakeFirst();
-            // 评测回放的隐藏对话：运行由评测 worker 在里面直接驱动（工具只回放记录），绝不为它起真实运行
-            if (conv?.kind !== "chat")
-                return null;
-            let last = await t
-                .selectFrom("conversation_events")
-                .select(["seq", "payload"])
-                .where("conversation_id", "=", conversationId)
-                .where("type", "=", "user_message")
-                .orderBy("seq", "desc")
-                .limit(1)
-                .executeTakeFirst();
-            if (!last || Number(last.seq) <= Number(conv.consumed_seq)) {
-                // Nothing unconsumed: the queue's head goes out when the conversation is idle (no active
-                // run, which includes runs waiting for approval or an answer) and the queue is not paused.
-                // Interjections are always unconsumed messages, so the queue never jumps ahead of them.
-                if (conv.queue_paused || (await this.activeRun(t, conversationId)))
-                    return null;
-                const owner = await t
-                    .selectFrom("agents")
-                    .select("deleted_at")
-                    .where("id", "=", conv.agent_id)
-                    .executeTakeFirstOrThrow();
-                if (owner.deleted_at !== null)
-                    return null;
-                const head = await t
-                    .selectFrom("conversation_queue")
-                    .select("id")
-                    .where("conversation_id", "=", conversationId)
-                    .limit(1)
-                    .executeTakeFirst();
-                if (!head)
-                    return null;
-                // A queued message may wait for hours: it goes out only while its author can still use
-                // the conversation (active, a member, the agent visible to them; the isAccessible rule).
-                // Otherwise the queue pauses instead of posting as someone who lost access.
-                if (!(await authorCanSend(t, conversationId, conv.account_id))) {
-                    await pauseQueueWith(t, conversationId, "author_cannot_send");
-                    pausedNow = true;
-                    this.log.warn("queued message not sent: its author can no longer use the conversation", {
-                        conversationId,
-                    });
-                    return null;
-                }
-                const sent = await dispatchQueuedIn(t, this.eventLog, conversationId);
-                if (!sent)
-                    return null;
-                if ("paused" in sent) {
-                    pausedNow = true;
-                    this.log.warn("queued skill invocation not sent: the skill can no longer be invoked", {
-                        conversationId,
-                    });
-                    return null;
-                }
-                dispatchedSeq = sent.event.seq;
-                dispatchedSwitch = sent.switched;
-                last = { seq: String(sent.event.seq), payload: sent.event.payload };
-            }
-            const active = await this.activeRun(t, conversationId);
-            if (active) {
-                if (!(await this.isOrphan(conversationId, active, conv.kind)))
-                    return null;
-                this.log.warn("marking orphaned run as failed", { conversationId, runId: active.id });
-                orphanRunId = active.id;
-                const stop = this.stopOpenCalls(active.id);
-                orphanStop = stop;
-                orphanSeq = await finishRunIn(t, this.eventLog, {
-                    conversationId,
-                    runId: active.id,
-                    status: "failed",
-                    consumed: null,
-                    ...(stop.beforeTerminal !== undefined && { beforeTerminal: stop.beforeTerminal }),
-                    event: {
-                        type: "run_failed",
-                        payload: {
-                            error: { code: "run.orphaned", message: "The run was lost and will not continue" },
-                        },
-                    },
-                });
-                // 孤儿运行的触发消息已被消费：之后没有更新的消息就不起新一轮。
-                if (Number(last.seq) <= Math.max(Number(conv.consumed_seq), Number(active.trigger_seq))) {
-                    return null;
-                }
-            }
-            // what is consumed now (an orphan's failure consumed up to its trigger)
-            const consumedNow = Math.max(Number(conv.consumed_seq), orphanRunId !== null && active ? Number(active.trigger_seq) : 0);
-            // phase D run boundary: the first unconsumed fork invocation is the trigger of the run that
-            // absorbs it (`forkBoundary`); later messages wait for the next run
-            const fork = await t
-                .selectFrom("conversation_events")
-                .select(["seq", "payload"])
-                .where("conversation_id", "=", conversationId)
-                .where("type", "=", "user_message")
-                .where("seq", ">", String(consumedNow))
-                .where(sql `payload -> 'skill' ->> 'mode' = 'fork'`)
-                .orderBy("seq")
-                .limit(1)
-                .executeTakeFirst();
-            const trigger = fork ?? last;
-            // BullMQ 对重复的 jobId 静默忽略（add 返回的 Job 由调用方数据构造，看不出是否真的入队）：
-            // 先显式查同一触发点的任务；仍存在（例如属于刚结束、尚未从队列移除的运行）就不插入 runs 行。
-            const jobId = runJobId(conversationId, Number(trigger.seq));
-            const existing = await this.getQueue().getJob(jobId);
-            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();
-            // agent 已软删除：会话对任何人都不可见，不再为它起运行。
-            if (agent.deleted_at !== null)
-                return null;
-            const runId = randomUUID();
-            await t
-                .insertInto("runs")
-                .values({
-                id: runId,
-                conversation_id: conversationId,
-                status: "queued",
-                agent_version: agent.current_version,
-                trigger_account_id: trigger.payload.authorAccountId,
-                trigger_seq: Number(trigger.seq),
-            })
-                .execute();
-            return { runId, jobId };
-        });
+        const st = {
+            orphanSeq: null,
+            orphanRunId: null,
+            dispatchedSeq: null,
+            dispatchedSwitch: false,
+            pausedNow: false,
+            orphanStop: undefined,
+        };
+        const created = await this.ensureRunIn(conversationId, st);
+        const { orphanSeq, orphanRunId, dispatchedSeq, dispatchedSwitch, pausedNow, orphanStop } = st;
         if (orphanSeq !== null) {
             await notifyFinished(this.eventLog, conversationId, orphanSeq, "failed");
             orphanStop?.fire();
@@ -265,18 +119,15 @@ export class RunQueue {
             await this.dropCheckpoints(orphanRunId);
             // a lost parent stops its children now, not at the next sweep (review m2)
             if (orphanSeq !== null) {
-                await this.subagents?.stopChildren(orphanRunId).catch((err) => this.log.error("cannot stop the sub-agents of an orphaned run", {
-                    runId: orphanRunId,
-                    err,
-                }));
+                await this.events.emit("run.orphaned", { runId: orphanRunId });
             }
         }
         if (!created)
             return null;
         const { runId, jobId } = created;
         try {
-            const queue = this.getQueue();
-            await queue.add("run", { runId, conversationId }, { jobId, attempts: 1, removeOnComplete: true, removeOnFail: true });
+            const queue = this.jobs.queue();
+            await this.jobs.add({ runId, conversationId }, jobId);
             // 从 Redis 读回核对：检查与 add 之间出现了同 jobId 的任务时 add 被静默忽略，撤销本次插入，
             // 不留下没有任务的 queued 行。读不到说明任务已被领取并移除（只可能是本次投递的），不撤销。
             const stored = await queue.getJob(jobId);
@@ -297,25 +148,153 @@ export class RunQueue {
         }
         return runId;
     }
+    /** {@link ensureRun}'s transaction: what it decided goes back through `st`. */
+    async ensureRunIn(conversationId, st) {
+        const t = this.db;
+        const conv = await t
+            .selectFrom("conversations")
+            .select(["consumed_seq", "agent_id", "kind", "queue_paused", "account_id"])
+            .where("id", "=", conversationId)
+            .forUpdate()
+            .executeTakeFirst();
+        // 评测回放的隐藏对话：运行由评测 worker 在里面直接驱动（工具只回放记录），绝不为它起真实运行
+        if (conv?.kind !== "chat")
+            return null;
+        let last = await t
+            .selectFrom("conversation_events")
+            .select(["seq", "payload"])
+            .where("conversation_id", "=", conversationId)
+            .where("type", "=", "user_message")
+            .orderBy("seq", "desc")
+            .limit(1)
+            .executeTakeFirst();
+        if (!last || Number(last.seq) <= Number(conv.consumed_seq)) {
+            // Nothing unconsumed: the queue's head goes out when the conversation is idle (no active
+            // run, which includes runs waiting for approval or an answer) and the queue is not paused.
+            // Interjections are always unconsumed messages, so the queue never jumps ahead of them.
+            if (conv.queue_paused || (await this.activeRun(t, conversationId)))
+                return null;
+            const owner = await t
+                .selectFrom("agents")
+                .select("deleted_at")
+                .where("id", "=", conv.agent_id)
+                .executeTakeFirstOrThrow();
+            if (owner.deleted_at !== null)
+                return null;
+            const head = await t
+                .selectFrom("conversation_queue")
+                .select("id")
+                .where("conversation_id", "=", conversationId)
+                .limit(1)
+                .executeTakeFirst();
+            if (!head)
+                return null;
+            // A queued message may wait for hours: it goes out only while its author can still use
+            // the conversation (active, a member, the agent visible to them; the isAccessible rule).
+            // Otherwise the queue pauses instead of posting as someone who lost access.
+            if (!(await authorCanSend(t, conversationId, conv.account_id))) {
+                await pauseQueueWith(t, conversationId, "author_cannot_send");
+                st.pausedNow = true;
+                this.log.warn("queued message not sent: its author can no longer use the conversation", {
+                    conversationId,
+                });
+                return null;
+            }
+            const sent = await dispatchQueuedIn(t, this.eventLog, conversationId);
+            if (!sent)
+                return null;
+            if ("paused" in sent) {
+                st.pausedNow = true;
+                this.log.warn("queued skill invocation not sent: the skill can no longer be invoked", {
+                    conversationId,
+                });
+                return null;
+            }
+            st.dispatchedSeq = sent.event.seq;
+            st.dispatchedSwitch = sent.switched;
+            last = { seq: String(sent.event.seq), payload: sent.event.payload };
+        }
+        const active = await this.activeRun(t, conversationId);
+        if (active) {
+            if (!(await this.isOrphan(conversationId, active, conv.kind)))
+                return null;
+            this.log.warn("marking orphaned run as failed", { conversationId, runId: active.id });
+            st.orphanRunId = active.id;
+            const stop = this.stopOpenCalls(active.id);
+            st.orphanStop = stop;
+            st.orphanSeq = await this.finisher.finishIn({
+                conversationId,
+                runId: active.id,
+                status: "failed",
+                consumed: null,
+                ...(stop.beforeTerminal !== undefined && { beforeTerminal: stop.beforeTerminal }),
+                event: {
+                    type: "run_failed",
+                    payload: {
+                        error: { code: "run.orphaned", message: "The run was lost and will not continue" },
+                    },
+                },
+            });
+            // 孤儿运行的触发消息已被消费：之后没有更新的消息就不起新一轮。
+            if (Number(last.seq) <= Math.max(Number(conv.consumed_seq), Number(active.trigger_seq))) {
+                return null;
+            }
+        }
+        // what is consumed now (an orphan's failure consumed up to its trigger)
+        const consumedNow = Math.max(Number(conv.consumed_seq), st.orphanRunId !== null && active ? Number(active.trigger_seq) : 0);
+        // phase D run boundary: the first unconsumed fork invocation is the trigger of the run that
+        // absorbs it (`forkBoundary`); later messages wait for the next run
+        const fork = await t
+            .selectFrom("conversation_events")
+            .select(["seq", "payload"])
+            .where("conversation_id", "=", conversationId)
+            .where("type", "=", "user_message")
+            .where("seq", ">", String(consumedNow))
+            .where(sql `payload -> 'skill' ->> 'mode' = 'fork'`)
+            .orderBy("seq")
+            .limit(1)
+            .executeTakeFirst();
+        const trigger = fork ?? last;
+        // BullMQ 对重复的 jobId 静默忽略（add 返回的 Job 由调用方数据构造，看不出是否真的入队）：
+        // 先显式查同一触发点的任务；仍存在（例如属于刚结束、尚未从队列移除的运行）就不插入 runs 行。
+        const jobId = runJobId(conversationId, Number(trigger.seq));
+        const existing = await this.jobs.getJob(jobId);
+        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();
+        // agent 已软删除：会话对任何人都不可见，不再为它起运行。
+        if (agent.deleted_at !== null)
+            return null;
+        const runId = randomUUID();
+        await t
+            .insertInto("runs")
+            .values({
+            id: runId,
+            conversation_id: conversationId,
+            status: "queued",
+            agent_version: agent.current_version,
+            trigger_account_id: trigger.payload.authorAccountId,
+            trigger_seq: Number(trigger.seq),
+        })
+            .execute();
+        return { runId, jobId };
+    }
     /**
      * Enqueues a run job under the caller's job id (resumes, dispatches, repairs), with the same
-     * options as {@link ensureRun}. 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.
+     * options as {@link ensureRun} (see {@link RunJobs.enqueue}).
      */
-    async enqueue(data, jobId, kind) {
-        const k = kind ??
-            (await this.db
-                .selectFrom("conversations")
-                .select("kind")
-                .where("id", "=", data.conversationId)
-                .executeTakeFirst())?.kind ??
-            "chat";
-        await this.getQueue(runQueueNameFor(k)).add("run", data, {
-            jobId,
-            attempts: 1,
-            removeOnComplete: true,
-            removeOnFail: true,
-        });
+    enqueue(data, jobId, kind) {
+        return this.jobs.enqueue(data, jobId, kind);
     }
     /**
      * 中止一个孤儿运行（`POST .../abort` 用）：运行仍是 queued / running、会话锁无人持有、BullMQ 任务已不存在
@@ -327,31 +306,7 @@ export class RunQueue {
         if ((await this.lock.holder(conversationId)) !== null)
             return false;
         const stop = this.stopOpenCalls(runId);
-        const toSeq = await this.db.transaction().execute(async (t) => {
-            const conv = await t
-                .selectFrom("conversations")
-                .select("kind")
-                .where("id", "=", conversationId)
-                .forUpdate()
-                .executeTakeFirst();
-            const active = await this.activeRun(t, conversationId);
-            if (!conv || !active || active.id !== runId)
-                return null;
-            if (!(await this.isOrphan(conversationId, active, conv.kind)))
-                return null;
-            this.log.warn("aborting orphaned run directly", { conversationId, runId });
-            return finishRunIn(t, this.eventLog, {
-                conversationId,
-                runId,
-                status: "aborted",
-                consumed: null,
-                ...(stop.beforeTerminal !== undefined && { beforeTerminal: stop.beforeTerminal }),
-                event: {
-                    type: "run_aborted",
-                    payload: { byAccountId, reason: "user", ...(detail !== undefined && { detail }) },
-                },
-            });
-        });
+        const toSeq = await this.abortOrphanIn(conversationId, runId, byAccountId, detail, stop);
         if (toSeq === null)
             return false;
         await notifyFinished(this.eventLog, conversationId, toSeq, "aborted");
@@ -359,6 +314,32 @@ export class RunQueue {
         await this.dropCheckpoints(runId);
         return true;
     }
+    async abortOrphanIn(conversationId, runId, byAccountId, detail, stop) {
+        const t = this.db;
+        const conv = await t
+            .selectFrom("conversations")
+            .select("kind")
+            .where("id", "=", conversationId)
+            .forUpdate()
+            .executeTakeFirst();
+        const active = await this.activeRun(t, conversationId);
+        if (!conv || !active || active.id !== runId)
+            return null;
+        if (!(await this.isOrphan(conversationId, active, conv.kind)))
+            return null;
+        this.log.warn("aborting orphaned run directly", { conversationId, runId });
+        return this.finisher.finishIn({
+            conversationId,
+            runId,
+            status: "aborted",
+            consumed: null,
+            beforeTerminal: stop.beforeTerminal,
+            event: {
+                type: "run_aborted",
+                payload: { byAccountId, reason: "user", ...(detail !== undefined && { detail }) },
+            },
+        });
+    }
     /**
      * Repairs an orphaned run of a conversation nobody else repairs on demand (a sub-agent's: no
      * `ensureRun` ever runs for it; sub-agents spec §7.5), with the same orphan test as
@@ -374,37 +355,7 @@ export class RunQueue {
     async repairOrphan(conversationId, runId) {
         if ((await this.lock.holder(conversationId)) !== null)
             return null;
-        const r = await this.db.transaction().execute(async (t) => {
-            const conv = await t
-                .selectFrom("conversations")
-                .select("kind")
-                .where("id", "=", conversationId)
-                .forUpdate()
-                .executeTakeFirst();
-            const active = await this.activeRun(t, conversationId);
-            if (!conv || !active || active.id !== runId)
-                return null;
-            if (!(await this.isOrphan(conversationId, active, conv.kind)))
-                return null;
-            if (active.status === "queued") {
-                const jobId = active.job_id ?? runJobId(conversationId, Number(active.trigger_seq));
-                return { kind: "requeued", jobId, convKind: conv.kind };
-            }
-            this.log.warn("marking orphaned run as failed", { conversationId, runId });
-            const seq = await finishRunIn(t, this.eventLog, {
-                conversationId,
-                runId,
-                status: "failed",
-                consumed: null,
-                event: {
-                    type: "run_failed",
-                    payload: {
-                        error: { code: "run.orphaned", message: "The run was lost and will not continue" },
-                    },
-                },
-            });
-            return { kind: "failed", seq };
-        });
+        const r = await this.repairOrphanIn(conversationId, runId);
         if (!r)
             return null;
         if (r.kind === "requeued") {
@@ -416,6 +367,38 @@ export class RunQueue {
         await this.dropCheckpoints(runId);
         return "failed";
     }
+    async repairOrphanIn(conversationId, runId) {
+        const t = this.db;
+        const conv = await t
+            .selectFrom("conversations")
+            .select("kind")
+            .where("id", "=", conversationId)
+            .forUpdate()
+            .executeTakeFirst();
+        const active = await this.activeRun(t, conversationId);
+        if (!conv || !active || active.id !== runId)
+            return null;
+        if (!(await this.isOrphan(conversationId, active, conv.kind)))
+            return null;
+        if (active.status === "queued") {
+            const jobId = active.job_id ?? runJobId(conversationId, Number(active.trigger_seq));
+            return { kind: "requeued", jobId, convKind: conv.kind };
+        }
+        this.log.warn("marking orphaned run as failed", { conversationId, runId });
+        const seq = await this.finisher.finishIn({
+            conversationId,
+            runId,
+            status: "failed",
+            consumed: null,
+            event: {
+                type: "run_failed",
+                payload: {
+                    error: { code: "run.orphaned", message: "The run was lost and will not continue" },
+                },
+            },
+        });
+        return { kind: "failed", seq };
+    }
     /** 会话当前未结束的运行（调用方已持有会话行锁）。 */
     activeRun(t, conversationId) {
         return t
@@ -442,13 +425,13 @@ export class RunQueue {
         if (active.status === "queued" && !active.past_grace)
             return false;
         const jobId = active.job_id ?? runJobId(conversationId, Number(active.trigger_seq));
-        const job = await this.getQueue(runQueueNameFor(kind)).getJob(jobId);
+        const job = await this.jobs.getJob(jobId, runQueueNameFor(kind));
         return !job;
     }
     /** 删除已结束运行的 checkpoint thread（失败只记日志）。 */
     async dropCheckpoints(runId) {
         await this.checkpoints
-            ?.deleteThread(runId)
+            .deleteThread(runId)
             .catch((err) => this.log.warn("checkpoint delete failed", { runId, err }));
     }
     async deleteQueued(runId) {
@@ -458,17 +441,30 @@ export class RunQueue {
             .where("status", "=", "queued")
             .execute();
     }
-    async close() {
-        this.closed = true;
-        const qs = [...this.queues.values()];
-        const c = this.conn;
-        this.queues.clear();
-        this.conn = undefined;
-        await Promise.all(qs.map((q) => q.close().catch(() => { })));
-        if (c)
-            await c.quit().catch(() => c.disconnect());
-    }
-}
+};
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], RunQueue.prototype, "ensureRunIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], RunQueue.prototype, "abortOrphanIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], RunQueue.prototype, "repairOrphanIn", null);
+RunQueue = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(EventLog)),
+    __param(2, Inject(ConversationLock)),
+    __param(3, Inject(RunJobs)),
+    __param(4, Inject(RunFinish)),
+    __param(5, Inject(KyselyCheckpointSaver)),
+    __param(6, Inject(ToolPipeline)),
+    __param(7, Inject(KernelEvents)),
+    __param(8, Inject(KERNEL_LOGGER)),
+    __param(9, Inject(TransactionHost))
+], RunQueue);
+export { RunQueue };
 /** The conversation's owner is active and can still see its agent (`isAccessible`'s rule). */
 async function authorCanSend(t, conversationId, accountId) {
     const row = await t