@capybara-hq/kernel 0.1.0-rc.1 → 0.1.0-rc.3

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

@@ -1,7 +1,6 @@
-import { type Transaction } from "kysely";
-import type { AppendEvent, EventLog } from "../conversations/event-log.js";
-import type { KernelDatabase, KernelDb } from "../db/kernel-schema.js";
-type KernelTrx = Transaction<KernelDatabase>;
+import { type AppendEvent, EventLog } from "../conversations/event-log.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
 /** 运行的终态。 */
 export type TerminalStatus = "completed" | "failed" | "aborted";
 export declare const TERMINAL_STATUSES: ReadonlySet<string>;
@@ -20,26 +19,36 @@ export interface FinishRunArgs {
     floorToTrigger?: boolean;
     /**
      * Runs in the transaction once the run is known not to be terminal, before the terminal event:
-     * a parent's open `agent` calls get their results here (sub-agents spec §12, review m1).
+     * a parent's open `Agent` calls get their results here (sub-agents spec §12, review m1).
      */
-    beforeTerminal?: (t: KernelTrx) => Promise<void>;
+    beforeTerminal?: () => Promise<void>;
 }
 /**
- * 在事务 `t` 内写运行的终态：会话行锁 → 运行仍未结束才写终态事件、推进 `consumed_seq`、更新 `runs.status`。
- * 返回终态事件的 seq；运行已是终态（例如已被其他副本标记失败）→ 返回 null，什么都不写。
- *
- * `consumed_seq = GREATEST(consumed_seq, consumed, runs.trigger_seq)`：不回退，且失败 / 中止 / 完成都至少
- * 消费到触发该运行的消息——否则结束时的 ensureRun 会对同一条消息无限重试（失败）或卡住会话。
- * 超时（`floorToTrigger: false`）只取 `GREATEST(consumed_seq, consumed)`：没吸收的消息留给下一轮（R34）。
- * 加锁顺序与 `RunQueue.ensureRun` 一致（先会话行、后 runs 行），不会互相死锁。
- * 调用方在提交后对非 null 的返回值调用 `eventLog.notify`。
+ * Writes runs' terminal states (one instance; the run worker, the run queue's orphan repairs, the
+ * waits and the eval replays finish runs through it).
  */
-export declare function finishRunIn(t: KernelTrx, eventLog: EventLog, a: FinishRunArgs): Promise<number | null>;
+export declare class RunFinish {
+    private readonly kdb;
+    private readonly eventLog;
+    readonly txHost: TransactionHost;
+    constructor(kdb: KernelDb, eventLog: EventLog, txHost: TransactionHost);
+    /**
+     * 在调用方的事务内写运行的终态：会话行锁 → 运行仍未结束才写终态事件、推进 `consumed_seq`、更新 `runs.status`。
+     * 返回终态事件的 seq；运行已是终态（例如已被其他副本标记失败）→ 返回 null，什么都不写。
+     *
+     * `consumed_seq = GREATEST(consumed_seq, consumed, runs.trigger_seq)`：不回退，且失败 / 中止 / 完成都至少
+     * 消费到触发该运行的消息——否则结束时的 ensureRun 会对同一条消息无限重试（失败）或卡住会话。
+     * 超时（`floorToTrigger: false`）只取 `GREATEST(consumed_seq, consumed)`：没吸收的消息留给下一轮（R34）。
+     * 加锁顺序与 `RunQueue.ensureRun` 一致（先会话行、后 runs 行），不会互相死锁。
+     * 调用方在提交后对非 null 的返回值调用 {@link notifyFinished}。
+     */
+    finishIn(a: FinishRunArgs): Promise<number | null>;
+    /** 自开事务写终态并在提交后发布会话通知；返回值同 {@link finishIn}。 */
+    finish(a: FinishRunArgs): Promise<number | null>;
+    private finishOwn;
+}
 /**
  * After a terminal event committed: notify the log, and for a failed or stopped run also send
  * `changed: queue` (the queue may have paused).
  */
 export declare function notifyFinished(eventLog: Pick<EventLog, "notify" | "publishChanged">, conversationId: string, toSeq: number, status: TerminalStatus): Promise<void>;
-/** 自开事务写终态并在提交后发布会话通知；返回值同 {@link finishRunIn}。 */
-export declare function finishRun(db: KernelDb, eventLog: EventLog, a: FinishRunArgs): Promise<number | null>;
-export {};

package/dist/runtime/run-finish.js

@@ -1,56 +1,110 @@
+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 { sql } from "kysely";
+import { EventLog } from "../conversations/event-log.js";
 import { pauseQueueIn } from "../conversations/queue.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";
 export const TERMINAL_STATUSES = new Set([
     "completed",
     "failed",
     "aborted",
 ]);
 /**
- * 在事务 `t` 内写运行的终态：会话行锁 → 运行仍未结束才写终态事件、推进 `consumed_seq`、更新 `runs.status`。
- * 返回终态事件的 seq；运行已是终态（例如已被其他副本标记失败）→ 返回 null，什么都不写。
- *
- * `consumed_seq = GREATEST(consumed_seq, consumed, runs.trigger_seq)`：不回退，且失败 / 中止 / 完成都至少
- * 消费到触发该运行的消息——否则结束时的 ensureRun 会对同一条消息无限重试（失败）或卡住会话。
- * 超时（`floorToTrigger: false`）只取 `GREATEST(consumed_seq, consumed)`：没吸收的消息留给下一轮（R34）。
- * 加锁顺序与 `RunQueue.ensureRun` 一致（先会话行、后 runs 行），不会互相死锁。
- * 调用方在提交后对非 null 的返回值调用 `eventLog.notify`。
+ * Writes runs' terminal states (one instance; the run worker, the run queue's orphan repairs, the
+ * waits and the eval replays finish runs through it).
  */
-export async function finishRunIn(t, eventLog, a) {
-    await t
-        .selectFrom("conversations")
-        .select("id")
-        .where("id", "=", a.conversationId)
-        .forUpdate()
-        .executeTakeFirst();
-    const run = await t
-        .selectFrom("runs")
-        .select("status")
-        .where("id", "=", a.runId)
-        .forUpdate()
-        .executeTakeFirst();
-    if (!run || TERMINAL_STATUSES.has(run.status))
-        return null;
-    await a.beforeTerminal?.(t);
-    const [ev] = await eventLog.append(a.conversationId, [{ ...a.event, runId: a.runId, idemKey: `${a.event.type}:${a.runId}` }], t);
-    await t
-        .updateTable("conversations")
-        .set({
-        consumed_seq: a.floorToTrigger === false
-            ? sql `GREATEST(consumed_seq, ${a.consumed ?? 0}::bigint)`
-            : sql `GREATEST(consumed_seq, ${a.consumed ?? 0}::bigint, (SELECT r.trigger_seq FROM capybara.runs r WHERE r.id = ${a.runId}))`,
-    })
-        .where("id", "=", a.conversationId)
-        .execute();
-    await t
-        .updateTable("runs")
-        .set({ status: a.status, finished_at: sql `now()` })
-        .where("id", "=", a.runId)
-        .execute();
-    // a failed or stopped run pauses the queued messages until the person resumes (spec §5.7)
-    if (a.status !== "completed")
-        await pauseQueueIn(t, a.conversationId);
-    return ev.seq;
-}
+let RunFinish = class RunFinish {
+    kdb;
+    eventLog;
+    txHost;
+    constructor(kdb, eventLog, txHost) {
+        this.kdb = kdb;
+        this.eventLog = eventLog;
+        this.txHost = txHost;
+    }
+    /**
+     * 在调用方的事务内写运行的终态：会话行锁 → 运行仍未结束才写终态事件、推进 `consumed_seq`、更新 `runs.status`。
+     * 返回终态事件的 seq；运行已是终态（例如已被其他副本标记失败）→ 返回 null，什么都不写。
+     *
+     * `consumed_seq = GREATEST(consumed_seq, consumed, runs.trigger_seq)`：不回退，且失败 / 中止 / 完成都至少
+     * 消费到触发该运行的消息——否则结束时的 ensureRun 会对同一条消息无限重试（失败）或卡住会话。
+     * 超时（`floorToTrigger: false`）只取 `GREATEST(consumed_seq, consumed)`：没吸收的消息留给下一轮（R34）。
+     * 加锁顺序与 `RunQueue.ensureRun` 一致（先会话行、后 runs 行），不会互相死锁。
+     * 调用方在提交后对非 null 的返回值调用 {@link notifyFinished}。
+     */
+    async finishIn(a) {
+        const t = this.kdb.db;
+        await t
+            .selectFrom("conversations")
+            .select("id")
+            .where("id", "=", a.conversationId)
+            .forUpdate()
+            .executeTakeFirst();
+        const run = await t
+            .selectFrom("runs")
+            .select("status")
+            .where("id", "=", a.runId)
+            .forUpdate()
+            .executeTakeFirst();
+        if (!run || TERMINAL_STATUSES.has(run.status))
+            return null;
+        await a.beforeTerminal?.();
+        const [ev] = await this.eventLog.appendIn(a.conversationId, [
+            { ...a.event, runId: a.runId, idemKey: `${a.event.type}:${a.runId}` },
+        ]);
+        await t
+            .updateTable("conversations")
+            .set({
+            consumed_seq: a.floorToTrigger === false
+                ? sql `GREATEST(consumed_seq, ${a.consumed ?? 0}::bigint)`
+                : sql `GREATEST(consumed_seq, ${a.consumed ?? 0}::bigint, (SELECT r.trigger_seq FROM capybara.runs r WHERE r.id = ${a.runId}))`,
+        })
+            .where("id", "=", a.conversationId)
+            .execute();
+        await t
+            .updateTable("runs")
+            .set({ status: a.status, finished_at: sql `now()` })
+            .where("id", "=", a.runId)
+            .execute();
+        // a failed or stopped run pauses the queued messages until the person resumes (spec §5.7)
+        if (a.status !== "completed")
+            await pauseQueueIn(t, a.conversationId);
+        return ev.seq;
+    }
+    /** 自开事务写终态并在提交后发布会话通知；返回值同 {@link finishIn}。 */
+    async finish(a) {
+        const toSeq = await this.finishOwn(a);
+        if (toSeq !== null)
+            await notifyFinished(this.eventLog, a.conversationId, toSeq, a.status);
+        return toSeq;
+    }
+    finishOwn(a) {
+        return this.finishIn(a);
+    }
+};
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], RunFinish.prototype, "finishIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], RunFinish.prototype, "finishOwn", null);
+RunFinish = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(EventLog)),
+    __param(2, Inject(TransactionHost))
+], RunFinish);
+export { RunFinish };
 /**
  * After a terminal event committed: notify the log, and for a failed or stopped run also send
  * `changed: queue` (the queue may have paused).
@@ -60,10 +114,3 @@ export async function notifyFinished(eventLog, conversationId, toSeq, status) {
     if (status !== "completed")
         await eventLog.publishChanged(conversationId, "queue");
 }
-/** 自开事务写终态并在提交后发布会话通知；返回值同 {@link finishRunIn}。 */
-export async function finishRun(db, eventLog, a) {
-    const toSeq = await db.transaction().execute((t) => finishRunIn(t, eventLog, a));
-    if (toSeq !== null)
-        await notifyFinished(eventLog, a.conversationId, toSeq, a.status);
-    return toSeq;
-}

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 };