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

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

@@ -0,0 +1,48 @@
+import type { Job, Queue } from "bullmq";
+import type { ConversationKind } from "../db/kernel-schema.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import type { KernelLogger } from "../log.js";
+/** 内核运行队列的 BullMQ 队列名（不含 `:`；与插件队列 `cap.<插件>.<名>` 不会重名）。 */
+export declare 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 declare const SUBAGENT_RUN_QUEUE_NAME = "cap-kernel-subagent-runs";
+/** The run queue of a conversation kind: sub-agent conversations have their own. */
+export declare const runQueueNameFor: (kind: ConversationKind) => string;
+/** 未结束的运行状态（waiting：等人处理审批 / 输入请求，没有任务、不占会话锁与配额）。 */
+export declare const ACTIVE_RUN_STATUSES: readonly ["queued", "running", "waiting"];
+/** 运行任务的数据。 */
+export interface RunJobData {
+    runId: string;
+    conversationId: string;
+}
+/** 同一触发点（会话 + 最新用户消息 seq）只投递一次。 */
+export declare const runJobId: (conversationId: string, maxUserSeq: number) => string;
+/**
+ * The producer side of the two run queues (`cap-kernel-runs`, `cap-kernel-subagent-runs`): adds
+ * run jobs under the caller's job id and looks them up. The run queue (`ensureRun`, orphan
+ * repairs), the waits (resumes) and the sub-agent dispatch enqueue through it; the run worker
+ * consumes both queues.
+ */
+export declare class RunJobs {
+    private readonly kdb;
+    private readonly queues;
+    constructor(kdb: KernelDb, runs: Queue<RunJobData>, subagentRuns: Queue<RunJobData>, log: KernelLogger);
+    /** The BullMQ queue `name` (default: conversation runs). */
+    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.
+     */
+    enqueue(data: RunJobData, jobId: string, kind?: ConversationKind): Promise<void>;
+}
+/** The run queues' producer (the sub-agent dispatch, the run queue and the waits use it). */
+export declare class RunJobsModule {
+}

package/dist/runtime/run-jobs.js

@@ -0,0 +1,95 @@
+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 { getQueueToken } from "@nestjs/bullmq";
+import { Inject, Injectable, Module } from "@nestjs/common";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { QueueModule } from "../infra/queue/queue.module.js";
+import { KERNEL_LOGGER } from "../infra/tokens.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;
+/** 未结束的运行状态（waiting：等人处理审批 / 输入请求，没有任务、不占会话锁与配额）。 */
+export const ACTIVE_RUN_STATUSES = ["queued", "running", "waiting"];
+/** 同一触发点（会话 + 最新用户消息 seq）只投递一次。 */
+export const runJobId = (conversationId, maxUserSeq) => `run-${conversationId}-${maxUserSeq}`;
+/** The options of every run job: one attempt (the run's own paths handle failures), not kept. */
+const RUN_JOB_OPTIONS = { attempts: 1, removeOnComplete: true, removeOnFail: true };
+/**
+ * The producer side of the two run queues (`cap-kernel-runs`, `cap-kernel-subagent-runs`): adds
+ * run jobs under the caller's job id and looks them up. The run queue (`ensureRun`, orphan
+ * repairs), the waits (resumes) and the sub-agent dispatch enqueue through it; the run worker
+ * consumes both queues.
+ */
+let RunJobs = class RunJobs {
+    kdb;
+    queues;
+    constructor(kdb, runs, subagentRuns, log) {
+        this.kdb = kdb;
+        this.queues = { [RUN_QUEUE_NAME]: runs, [SUBAGENT_RUN_QUEUE_NAME]: subagentRuns };
+        for (const [name, q] of Object.entries(this.queues)) {
+            q.on("error", (err) => log.error("run queue error", { err, queue: name }));
+        }
+    }
+    /** The BullMQ queue `name` (default: conversation runs). */
+    queue(name = RUN_QUEUE_NAME) {
+        const q = this.queues[name];
+        if (!q)
+            throw new Error(`unknown run queue ${name}`);
+        return q;
+    }
+    /** A run job by id on the queue `name`, or undefined. */
+    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.
+     */
+    async enqueue(data, jobId, kind) {
+        const k = kind ??
+            (await this.kdb.db
+                .selectFrom("conversations")
+                .select("kind")
+                .where("id", "=", data.conversationId)
+                .executeTakeFirst())?.kind ??
+            "chat";
+        await this.queue(runQueueNameFor(k)).add("run", data, { jobId, ...RUN_JOB_OPTIONS });
+    }
+};
+RunJobs = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(getQueueToken(RUN_QUEUE_NAME))),
+    __param(2, Inject(getQueueToken(SUBAGENT_RUN_QUEUE_NAME))),
+    __param(3, Inject(KERNEL_LOGGER))
+], RunJobs);
+export { RunJobs };
+/** The run queues' producer (the sub-agent dispatch, the run queue and the waits use it). */
+let RunJobsModule = class RunJobsModule {
+};
+RunJobsModule = __decorate([
+    Module({
+        imports: [QueueModule.registerQueue(RUN_QUEUE_NAME, SUBAGENT_RUN_QUEUE_NAME)],
+        providers: [RunJobs],
+        exports: [RunJobs],
+    })
+], RunJobsModule);
+export { RunJobsModule };

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

@@ -0,0 +1,60 @@
+import { WorkerHost } from "@nestjs/bullmq";
+import { type DynamicModule } from "@nestjs/common";
+import type { Job, Worker } from "bullmq";
+import type { KernelConfig } from "../config/schema.js";
+import { TitleQueue } from "../conversations/titles.js";
+import { type RunJobData } from "./run-jobs.js";
+import { RunWorker } from "./run-worker.js";
+import { UsageReporter, type UsageReportJob } from "./usage-report.js";
+type RunResult = Awaited<ReturnType<RunWorker["process"]>>;
+/** The consumer of `cap-kernel-runs` (conversation runs): {@link RunWorker}. */
+export declare class RunsProcessor extends WorkerHost<Worker<RunJobData, RunResult>> {
+    private readonly runs;
+    constructor(runs: RunWorker);
+    process(job: Job<RunJobData>, token?: string): Promise<RunResult>;
+    completed(job: Job<RunJobData>, result: RunResult): void;
+    failed(job: Job<RunJobData> | undefined, err: Error): void;
+    error(err: Error): void;
+}
+/** The consumer of `cap-kernel-subagent-runs` (sub-agent runs, spec §7.4): {@link RunWorker}. */
+export declare class SubagentRunsProcessor extends WorkerHost<Worker<RunJobData, RunResult>> {
+    private readonly runs;
+    constructor(runs: RunWorker);
+    process(job: Job<RunJobData>, token?: string): Promise<RunResult>;
+    completed(job: Job<RunJobData>, result: RunResult): void;
+    failed(job: Job<RunJobData> | undefined, err: Error): void;
+    error(err: Error): void;
+}
+/** The consumer of `cap-kernel-usage-report`: {@link UsageReporter}. */
+export declare class UsageReportProcessor extends WorkerHost<Worker<UsageReportJob>> {
+    private readonly reporter;
+    constructor(reporter: UsageReporter);
+    process(job: Job<UsageReportJob>, token?: string): Promise<void>;
+    failed(job: Job<UsageReportJob> | undefined, err: Error): void;
+    error(err: Error): void;
+}
+/** The consumer of `cap-kernel-titles`: {@link TitleQueue}. */
+export declare class TitleProcessor extends WorkerHost<Worker<{
+    conversationId: string;
+    attempt: number;
+}>> {
+    private readonly titles;
+    constructor(titles: TitleQueue);
+    process(job: Job<{
+        conversationId: string;
+        attempt: number;
+    }>): Promise<void>;
+    error(err: Error): void;
+}
+/**
+ * The runtime's queue consumers: the run worker on both run queues, `usage.report` deliveries and
+ * conversation titles. Imported only by the worker role (`WorkerModule`), so other roles get no
+ * processor and no BullMQ worker. Their worker options come from the startup config (concurrency
+ * per queue, the run queues' job lock and stalled detection, which the usage and title workers
+ * follow). The workers never start by themselves: the worker role (`WorkerRole`) starts them after
+ * the extensions loaded, and pauses them on stop.
+ */
+export declare class RuntimeWorkersModule {
+    static forRoot(config: KernelConfig): DynamicModule;
+}
+export {};

package/dist/runtime/run-processors.js

@@ -0,0 +1,185 @@
+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); }
+};
+var RuntimeWorkersModule_1;
+import { hostname } from "node:os";
+import { OnWorkerEvent, WorkerHost } from "@nestjs/bullmq";
+import { Inject, Injectable, Module } from "@nestjs/common";
+import { TITLE_QUEUE, TitleQueue, TitlesModule } from "../conversations/titles.js";
+import { configuredProcessor } from "../infra/queue/configured-processor.js";
+import { runJob } from "../infra/queue/run-job.js";
+import { RUN_QUEUE_NAME, SUBAGENT_RUN_QUEUE_NAME } from "./run-jobs.js";
+import { MAX_STALLED_COUNT, RunWorker } from "./run-worker.js";
+import { RuntimeModule } from "./runtime.module.js";
+import { USAGE_REPORT_QUEUE, UsageReporter, UsageReportModule, } from "./usage-report.js";
+/** The consumer of `cap-kernel-runs` (conversation runs): {@link RunWorker}. */
+let RunsProcessor = class RunsProcessor extends WorkerHost {
+    runs;
+    constructor(runs) {
+        super();
+        this.runs = runs;
+    }
+    process(job, token) {
+        return runJob(RUN_QUEUE_NAME, job, () => this.runs.process(job, token));
+    }
+    completed(job, result) {
+        this.runs.onCompleted(job, result);
+    }
+    failed(job, err) {
+        this.runs.onFailed(job, err);
+    }
+    error(err) {
+        this.runs.onError(err, RUN_QUEUE_NAME);
+    }
+};
+__decorate([
+    OnWorkerEvent("completed")
+], RunsProcessor.prototype, "completed", null);
+__decorate([
+    OnWorkerEvent("failed")
+], RunsProcessor.prototype, "failed", null);
+__decorate([
+    OnWorkerEvent("error")
+], RunsProcessor.prototype, "error", null);
+RunsProcessor = __decorate([
+    Injectable(),
+    __param(0, Inject(RunWorker))
+], RunsProcessor);
+export { RunsProcessor };
+/** The consumer of `cap-kernel-subagent-runs` (sub-agent runs, spec §7.4): {@link RunWorker}. */
+let SubagentRunsProcessor = class SubagentRunsProcessor extends WorkerHost {
+    runs;
+    constructor(runs) {
+        super();
+        this.runs = runs;
+    }
+    process(job, token) {
+        return runJob(SUBAGENT_RUN_QUEUE_NAME, job, () => this.runs.process(job, token));
+    }
+    completed(job, result) {
+        this.runs.onCompleted(job, result);
+    }
+    failed(job, err) {
+        this.runs.onFailed(job, err);
+    }
+    error(err) {
+        this.runs.onError(err, SUBAGENT_RUN_QUEUE_NAME);
+    }
+};
+__decorate([
+    OnWorkerEvent("completed")
+], SubagentRunsProcessor.prototype, "completed", null);
+__decorate([
+    OnWorkerEvent("failed")
+], SubagentRunsProcessor.prototype, "failed", null);
+__decorate([
+    OnWorkerEvent("error")
+], SubagentRunsProcessor.prototype, "error", null);
+SubagentRunsProcessor = __decorate([
+    Injectable(),
+    __param(0, Inject(RunWorker))
+], SubagentRunsProcessor);
+export { SubagentRunsProcessor };
+/** The consumer of `cap-kernel-usage-report`: {@link UsageReporter}. */
+let UsageReportProcessor = class UsageReportProcessor extends WorkerHost {
+    reporter;
+    constructor(reporter) {
+        super();
+        this.reporter = reporter;
+    }
+    process(job, token) {
+        return runJob(USAGE_REPORT_QUEUE, job, () => this.reporter.process(job, token));
+    }
+    failed(job, err) {
+        this.reporter.onFailed(job, err);
+    }
+    error(err) {
+        this.reporter.onError(err);
+    }
+};
+__decorate([
+    OnWorkerEvent("failed")
+], UsageReportProcessor.prototype, "failed", null);
+__decorate([
+    OnWorkerEvent("error")
+], UsageReportProcessor.prototype, "error", null);
+UsageReportProcessor = __decorate([
+    Injectable(),
+    __param(0, Inject(UsageReporter))
+], UsageReportProcessor);
+export { UsageReportProcessor };
+/** The consumer of `cap-kernel-titles`: {@link TitleQueue}. */
+let TitleProcessor = class TitleProcessor extends WorkerHost {
+    titles;
+    constructor(titles) {
+        super();
+        this.titles = titles;
+    }
+    process(job) {
+        return runJob(TITLE_QUEUE, job, () => this.titles.process(job));
+    }
+    error(err) {
+        this.titles.onError(err);
+    }
+};
+__decorate([
+    OnWorkerEvent("error")
+], TitleProcessor.prototype, "error", null);
+TitleProcessor = __decorate([
+    Injectable(),
+    __param(0, Inject(TitleQueue))
+], TitleProcessor);
+export { TitleProcessor };
+/**
+ * The runtime's queue consumers: the run worker on both run queues, `usage.report` deliveries and
+ * conversation titles. Imported only by the worker role (`WorkerModule`), so other roles get no
+ * processor and no BullMQ worker. Their worker options come from the startup config (concurrency
+ * per queue, the run queues' job lock and stalled detection, which the usage and title workers
+ * follow). The workers never start by themselves: the worker role (`WorkerRole`) starts them after
+ * the extensions loaded, and pauses them on stop.
+ */
+let RuntimeWorkersModule = RuntimeWorkersModule_1 = class RuntimeWorkersModule {
+    static forRoot(config) {
+        const { workerConcurrency, jobLockMs, stalledIntervalMs } = config.runtime;
+        const runs = {
+            // the worker name is recorded on the job (BullMQ processedBy): which replica ran it
+            name: `${hostname()}-${process.pid}`,
+            concurrency: workerConcurrency,
+            lockDuration: jobLockMs,
+            stalledInterval: stalledIntervalMs,
+            maxStalledCount: MAX_STALLED_COUNT,
+        };
+        return {
+            module: RuntimeWorkersModule_1,
+            imports: [RuntimeModule, TitlesModule, UsageReportModule],
+            providers: [
+                configuredProcessor(RunsProcessor, RUN_QUEUE_NAME, runs),
+                configuredProcessor(SubagentRunsProcessor, SUBAGENT_RUN_QUEUE_NAME, runs),
+                configuredProcessor(UsageReportProcessor, USAGE_REPORT_QUEUE, {
+                    concurrency: config.hooks.usageReportConcurrency,
+                    lockDuration: jobLockMs,
+                    stalledInterval: stalledIntervalMs,
+                    maxStalledCount: 3,
+                }),
+                configuredProcessor(TitleProcessor, TITLE_QUEUE, {
+                    concurrency: 4,
+                    lockDuration: jobLockMs,
+                    stalledInterval: stalledIntervalMs,
+                    maxStalledCount: 1,
+                }),
+            ],
+            exports: [RunsProcessor, SubagentRunsProcessor, UsageReportProcessor, TitleProcessor],
+        };
+    }
+};
+RuntimeWorkersModule = RuntimeWorkersModule_1 = __decorate([
+    Module({})
+    // biome-ignore lint/complexity/noStaticOnlyClass: a Nest dynamic module
+], RuntimeWorkersModule);
+export { RuntimeWorkersModule };

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

@@ -1,71 +1,45 @@
 import type { Logger } from "@capybara-hq/plugin-sdk";
-import { Redis } from "ioredis";
-import { type Transaction } from "kysely";
-import type { EventLog } from "../conversations/event-log.js";
-import type { ConversationKind, KernelDatabase, KernelDb } from "../db/kernel-schema.js";
+import { EventLog } from "../conversations/event-log.js";
+import type { ConversationKind } from "../db/kernel-schema.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { KernelEvents } from "../infra/events/kernel-events.js";
+import { ToolPipeline } from "../tools/pipeline.js";
 import type { RunAbortDetail } from "./abort.js";
-import type { KyselyCheckpointSaver } from "./checkpointer.js";
-import type { ConversationLock } from "./conversation-lock.js";
-/** 内核运行队列的 BullMQ 队列名（不含 `:`；与插件队列 `cap.<插件>.<名>` 不会重名）。 */
-export declare 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 declare const SUBAGENT_RUN_QUEUE_NAME = "cap-kernel-subagent-runs";
-/** The run queue of a conversation kind: sub-agent conversations have their own. */
-export declare const runQueueNameFor: (kind: ConversationKind) => string;
-/** 运行任务的数据。 */
-export interface RunJobData {
-    runId: string;
-    conversationId: string;
-}
-/** 同一触发点（会话 + 最新用户消息 seq）只投递一次。 */
-export declare const runJobId: (conversationId: string, maxUserSeq: number) => string;
-/** 未结束的运行状态（waiting：等人处理审批 / 输入请求，没有任务、不占会话锁与配额）。 */
-export declare const ACTIVE_RUN_STATUSES: readonly ["queued", "running", "waiting"];
-type KernelTrx = Transaction<KernelDatabase>;
-/** What an orphan repair does for a parent's sub-agents (wired by the kernel). */
-export interface OrphanSubagents {
-    /** `ToolPipeline.stopOpenAgentCalls`: the run's open `agent` call results, in `t`. */
-    stopOpenCalls(t: KernelTrx, runId: string): Promise<{
-        fire: () => void;
-    }>;
-    /** `stopChildren(runId, null)`: after the commit, its active children stop. */
-    stopChildren(runId: string): Promise<unknown>;
-}
-/** BullMQ 连接要求 maxRetriesPerRequest 为 null（Worker 的阻塞连接）；Queue 复用同样的配置。 */
-export declare function bullConnection(redisUrl: string, log: Pick<Logger, "error">): Redis;
+import { KyselyCheckpointSaver } from "./checkpointer.js";
+import { ConversationLock } from "./conversation-lock.js";
+import { RunFinish } from "./run-finish.js";
+import { type RunJobData, RunJobs } from "./run-jobs.js";
+export { ACTIVE_RUN_STATUSES, RUN_QUEUE_NAME, type RunJobData, runJobId, runQueueNameFor, SUBAGENT_RUN_QUEUE_NAME, } from "./run-jobs.js";
 /**
  * 运行队列（生产方）：`ensureRun` 在会话有未消费的用户消息、且没有进行中的运行时插入 `runs` 行并投递任务。
  * 「是否已有运行」以 PG 为准（会话行锁内检查 `runs` 中的 queued / running），并参考会话锁的持有者；
  * 多副本并发调用对同一会话串行化，同一时刻至多一个未结束的运行。
  */
 export declare class RunQueue {
-    private readonly db;
+    private readonly kdb;
     private readonly eventLog;
     private readonly lock;
-    private readonly redisUrl;
-    private readonly log;
+    private readonly jobs;
+    private readonly finisher;
     /** 运行以孤儿结束（标记失败 / 直接中止）后删除它的 checkpoint thread（thread_id = runId）。 */
-    private readonly checkpoints?;
-    /** Sub-agent cleanup when an orphan repair ends a parent run (sub-agents spec §12). */
-    private readonly subagents?;
-    private readonly queues;
-    private conn;
-    private closed;
-    constructor(db: KernelDb, eventLog: EventLog, lock: Pick<ConversationLock, "holder">, redisUrl: string, log: Pick<Logger, "error" | "warn">, 
+    private readonly checkpoints;
+    /** The run's open `agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
+    private readonly pipeline;
+    private readonly events;
+    private readonly log;
+    readonly txHost: TransactionHost;
+    constructor(kdb: KernelDb, eventLog: EventLog, lock: Pick<ConversationLock, "holder">, jobs: RunJobs, finisher: Pick<RunFinish, "finishIn">, 
     /** 运行以孤儿结束（标记失败 / 直接中止）后删除它的 checkpoint thread（thread_id = runId）。 */
-    checkpoints?: Pick<KyselyCheckpointSaver, "deleteThread"> | undefined, 
-    /** Sub-agent cleanup when an orphan repair ends a parent run (sub-agents spec §12). */
-    subagents?: OrphanSubagents | undefined);
+    checkpoints: Pick<KyselyCheckpointSaver, "deleteThread">, 
+    /** The run's open `agent` call results, in the orphan repair's transaction (sub-agents spec §12). */
+    pipeline: Pick<ToolPipeline, "stopOpenAgentCalls">, events: KernelEvents, log: Pick<Logger, "error" | "warn">, txHost: TransactionHost);
+    private get 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).
      */
     private stopOpenCalls;
-    /** The BullMQ queue `name` (default: conversation runs); both share one connection. */
-    private getQueue;
     /**
      * 有未消费的用户消息（最新 user_message 的 seq > `consumed_seq`）、会话锁无人持有、
      * 且没有 queued / running / waiting 的运行时：插入 `runs`（queued）并投递任务，返回 runId；否则返回 null。
@@ -79,10 +53,11 @@ export declare class RunQueue {
      * agent 已软删除的会话不起新运行（孤儿清理照常进行）。
      */
     ensureRun(conversationId: string): Promise<string | null>;
+    /** {@link ensureRun}'s transaction: what it decided goes back through `st`. */
+    private ensureRunIn;
     /**
      * 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}).
      */
     enqueue(data: RunJobData, jobId: string, kind?: ConversationKind): Promise<void>;
     /**
@@ -92,6 +67,7 @@ export declare class RunQueue {
      * 不是孤儿（有人在执行或即将执行）或运行已结束 → 返回 false，由调用方走广播中止。
      */
     abortIfOrphaned(conversationId: string, runId: string, byAccountId: string | null, detail?: RunAbortDetail): Promise<boolean>;
+    private abortOrphanIn;
     /**
      * 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
@@ -105,6 +81,7 @@ export declare class RunQueue {
      * Not an orphan, or already finished → null.
      */
     repairOrphan(conversationId: string, runId: string): Promise<"requeued" | "failed" | null>;
+    private repairOrphanIn;
     /** 会话当前未结束的运行（调用方已持有会话行锁）。 */
     private activeRun;
     /**
@@ -116,6 +93,4 @@ export declare class RunQueue {
     /** 删除已结束运行的 checkpoint thread（失败只记日志）。 */
     private dropCheckpoints;
     private deleteQueued;
-    close(): Promise<void>;
 }
-export {};