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

package/dist/evals/budget.d.ts

@@ -1,5 +1,7 @@
 import type { ModelUsage } from "@capybara-hq/plugin-sdk";
-import type { KernelDb } from "../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
 /**
  * 评测运行的 token 预算（C7）：`eval_runs.tokens_used` 在 PG 里原子累加，达到 `token_cap` 的同一条语句把
  * 状态置为 `capped`；worker 每次请求前查 {@link runActive}，不活跃就不再发新请求。在途请求可以越过上限，
@@ -13,7 +15,7 @@ export declare const usageTokens: (u: ModelUsage) => number;
  * 累加用量：`UPDATE … RETURNING`，累加后 ≥ 上限且运行仍在执行 → 同一语句置 `capped`、记 `finished_at`。
  * 运行已不在（被删）时返回 `{ used: 0, capped: true }`，调用方同样停下。
  */
-export declare function consumeTokens(db: KernelDb, runId: string, tokens: number): Promise<{
+export declare function consumeTokens(db: KernelSchemaDb, runId: string, tokens: number): Promise<{
     used: number;
     capped: boolean;
 }>;
@@ -27,35 +29,54 @@ export declare const TOO_MANY_ERRORS: {
  * 同一语句置 `failed`、记原因与 `finished_at`；成功 → 清零。返回运行是否因此被熔断。
  * 多个任务并发时「连续」按写入顺序计（近似），足以挡住「每个请求都失败」的运行。
  */
-export declare function recordOutcome(db: KernelDb, runId: string, ok: boolean, maxConsecutive: number): Promise<{
+export declare function recordOutcome(db: KernelSchemaDb, runId: string, ok: boolean, maxConsecutive: number): Promise<{
     tripped: boolean;
 }>;
 /**
  * 运行停下（取消 / 越限 / 熔断 / 删除评测集）时：还在等评委的结果（`judge_status = 'pending'`）记 `skipped`，
  * 否则这些用例永远算不上做完。给了 `caseId` 只处理该用例。在途的评委请求做完后写不进来（条件是 pending），用量照样计入。
  */
-export declare function skipPendingJudges(db: KernelDb, runId: string, caseId?: string): Promise<void>;
-/**
- * 重算 `cases_done` = 结果全部结束、且没有等评委的结果的用例数（幂等：任务重做不会重复计数），达到 `cases_total` 且运行仍在执行 →
- * `completed`。先锁运行行再数（READ COMMITTED 下新语句看得到其他任务已提交的结果），并发完成的任务不会互相覆盖。
- * worker 每做完一个用例、取消、入队失败时都调用。在事务里调用时锁随事务释放。
- */
-export declare function recountCases(db: KernelDb, runId: string): Promise<void>;
+export declare function skipPendingJudges(db: KernelSchemaDb, runId: string, caseId?: string): Promise<void>;
 /**
  * 运行仍在执行（queued / running），且所属组织与评测集的 agent 都没有删除：取消、达到上限、已结束、运行行已删除、
  * 组织或 agent 已删除都为 false（删除组织 / agent 时会显式取消运行，这里再兜一次底，挡住删除与请求之间的竞争）。
  */
-export declare function runActive(db: KernelDb, runId: string): Promise<boolean>;
+export declare function runActive(db: KernelSchemaDb, runId: string): Promise<boolean>;
 /**
- * 删除组织或 agent 时（调用方的事务内）取消其在执行的评测运行：运行置 `cancelled`，未开始的结果 `skipped`、
- * 等评委的记 `skipped`，重算进度，每个运行写审计 `eval.run_cancelled`（detail 带原因）。在途请求做完后写不进新的请求
- * （worker 每次请求前查 {@link runActive}）。运行创建者离开组织不取消（Ruling S1-b：管理员的评测运行是组织的工作）。
+ * The eval run bookkeeping that needs a transaction: the progress recount (it locks the run row)
+ * and the cancellation of an org's or agent's runs when it is deleted. One provider, shared by the
+ * evals, the agents and the orgs.
  */
-export declare function cancelEvalRuns(trx: KernelDb, scope: {
-    orgId: string;
-    agentId?: string;
-}, actor: {
-    accountId: string;
-    tokenId?: string;
-}, reason: "org_deleted" | "agent_deleted"): Promise<string[]>;
+export declare class EvalBudget {
+    private readonly db;
+    readonly txHost: TransactionHost;
+    constructor(db: KernelDb, txHost: TransactionHost);
+    /**
+     * 重算 `cases_done` = 结果全部结束、且没有等评委的结果的用例数（幂等：任务重做不会重复计数），达到 `cases_total` 且运行仍在执行 →
+     * `completed`。先锁运行行再数（READ COMMITTED 下新语句看得到其他任务已提交的结果），并发完成的任务不会互相覆盖。
+     * worker 每做完一个用例、取消、入队失败时都调用。Joins the caller's transaction (the lock is released with it),
+     * else runs in its own.
+     */
+    recountCases(runId: string): Promise<void>;
+    /**
+     * 删除组织或 agent 时（调用方的事务内）取消其在执行的评测运行：运行置 `cancelled`，未开始的结果 `skipped`、
+     * 等评委的记 `skipped`，重算进度，每个运行写审计 `eval.run_cancelled`（detail 带原因）。在途请求做完后写不进新的请求
+     * （worker 每次请求前查 {@link runActive}）。运行创建者离开组织不取消（Ruling S1-b：管理员的评测运行是组织的工作）。
+     */
+    cancelRuns(scope: {
+        orgId: string;
+        agentId?: string;
+    }, actor: {
+        accountId: string;
+        tokenId?: string;
+    }, reason: "org_deleted" | "agent_deleted"): Promise<string[]>;
+    /**
+     * A run that stopped (cancelled, its set deleted): its results not started yet are `skipped`,
+     * the pending judges too, and the progress is recounted, in the caller's transaction.
+     */
+    skipRun(runId: string): Promise<void>;
+}
+/** {@link EvalBudget} on its own: the agents and the orgs import it without the evals. */
+export declare class EvalBudgetModule {
+}
 export declare const addUsage: (a: ModelUsage, b: ModelUsage) => ModelUsage;

package/dist/evals/budget.js

@@ -1,5 +1,18 @@
+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, Module } from "@nestjs/common";
 import { sql } from "kysely";
 import { audit } from "../identity/audit.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
 /**
  * 评测运行的 token 预算（C7）：`eval_runs.tokens_used` 在 PG 里原子累加，达到 `token_cap` 的同一条语句把
  * 状态置为 `capped`；worker 每次请求前查 {@link runActive}，不活跃就不再发新请求。在途请求可以越过上限，
@@ -83,13 +96,44 @@ export async function skipPendingJudges(db, runId, caseId) {
     await q.execute();
 }
 /**
- * 重算 `cases_done` = 结果全部结束、且没有等评委的结果的用例数（幂等：任务重做不会重复计数），达到 `cases_total` 且运行仍在执行 →
- * `completed`。先锁运行行再数（READ COMMITTED 下新语句看得到其他任务已提交的结果），并发完成的任务不会互相覆盖。
- * worker 每做完一个用例、取消、入队失败时都调用。在事务里调用时锁随事务释放。
+ * 运行仍在执行（queued / running），且所属组织与评测集的 agent 都没有删除：取消、达到上限、已结束、运行行已删除、
+ * 组织或 agent 已删除都为 false（删除组织 / agent 时会显式取消运行，这里再兜一次底，挡住删除与请求之间的竞争）。
  */
-export async function recountCases(db, runId) {
-    const run = async (trx) => {
-        const row = await trx
+export async function runActive(db, runId) {
+    const r = await db
+        .selectFrom("eval_runs as r")
+        .innerJoin("eval_sets as s", "s.id", "r.set_id")
+        .innerJoin("agents as a", "a.id", "s.agent_id")
+        .innerJoin("orgs as o", "o.id", "r.org_id")
+        .select("r.id")
+        .where("r.id", "=", runId)
+        .where("r.status", "in", [...ACTIVE_EVAL_STATUSES])
+        .where("a.deleted_at", "is", null)
+        .where("o.deleted_at", "is", null)
+        .executeTakeFirst();
+    return r !== undefined;
+}
+/**
+ * The eval run bookkeeping that needs a transaction: the progress recount (it locks the run row)
+ * and the cancellation of an org's or agent's runs when it is deleted. One provider, shared by the
+ * evals, the agents and the orgs.
+ */
+let EvalBudget = class EvalBudget {
+    db;
+    txHost;
+    constructor(db, txHost) {
+        this.db = db;
+        this.txHost = txHost;
+    }
+    /**
+     * 重算 `cases_done` = 结果全部结束、且没有等评委的结果的用例数（幂等：任务重做不会重复计数），达到 `cases_total` 且运行仍在执行 →
+     * `completed`。先锁运行行再数（READ COMMITTED 下新语句看得到其他任务已提交的结果），并发完成的任务不会互相覆盖。
+     * worker 每做完一个用例、取消、入队失败时都调用。Joins the caller's transaction (the lock is released with it),
+     * else runs in its own.
+     */
+    async recountCases(runId) {
+        const db = this.db.db;
+        const row = await db
             .selectFrom("eval_runs")
             .select(["cases_total", "status"])
             .where("id", "=", runId)
@@ -102,10 +146,10 @@ export async function recountCases(db, runId) {
         SELECT case_id FROM capybara.eval_results WHERE run_id = ${runId}
         GROUP BY case_id
         HAVING bool_and(status IN ('done', 'error', 'skipped') AND judge_status <> 'pending')
-      ) finished`.execute(trx);
+      ) finished`.execute(db);
         const done = Number(r.rows[0]?.n ?? 0);
         const complete = done >= row.cases_total && ACTIVE_EVAL_STATUSES.includes(row.status);
-        await trx
+        await db
             .updateTable("eval_runs")
             .set({
             cases_done: done,
@@ -113,66 +157,74 @@ export async function recountCases(db, runId) {
         })
             .where("id", "=", runId)
             .execute();
-    };
-    if (db.isTransaction)
-        await run(db);
-    else
-        await db.transaction().execute((trx) => run(trx));
-}
-/**
- * 运行仍在执行（queued / running），且所属组织与评测集的 agent 都没有删除：取消、达到上限、已结束、运行行已删除、
- * 组织或 agent 已删除都为 false（删除组织 / agent 时会显式取消运行，这里再兜一次底，挡住删除与请求之间的竞争）。
- */
-export async function runActive(db, runId) {
-    const r = await db
-        .selectFrom("eval_runs as r")
-        .innerJoin("eval_sets as s", "s.id", "r.set_id")
-        .innerJoin("agents as a", "a.id", "s.agent_id")
-        .innerJoin("orgs as o", "o.id", "r.org_id")
-        .select("r.id")
-        .where("r.id", "=", runId)
-        .where("r.status", "in", [...ACTIVE_EVAL_STATUSES])
-        .where("a.deleted_at", "is", null)
-        .where("o.deleted_at", "is", null)
-        .executeTakeFirst();
-    return r !== undefined;
-}
-/**
- * 删除组织或 agent 时（调用方的事务内）取消其在执行的评测运行：运行置 `cancelled`，未开始的结果 `skipped`、
- * 等评委的记 `skipped`，重算进度，每个运行写审计 `eval.run_cancelled`（detail 带原因）。在途请求做完后写不进新的请求
- * （worker 每次请求前查 {@link runActive}）。运行创建者离开组织不取消（Ruling S1-b：管理员的评测运行是组织的工作）。
- */
-export async function cancelEvalRuns(trx, scope, actor, reason) {
-    let q = trx
-        .updateTable("eval_runs")
-        .set({ status: "cancelled", finished_at: sql `now()` })
-        .where("org_id", "=", scope.orgId)
-        .where("status", "in", [...ACTIVE_EVAL_STATUSES]);
-    if (scope.agentId !== undefined) {
-        const agentId = scope.agentId;
-        q = q.where("set_id", "in", (eb) => eb.selectFrom("eval_sets").select("id").where("agent_id", "=", agentId));
     }
-    const runs = await q.returning("id").execute();
-    for (const r of runs) {
-        await trx
+    /**
+     * 删除组织或 agent 时（调用方的事务内）取消其在执行的评测运行：运行置 `cancelled`，未开始的结果 `skipped`、
+     * 等评委的记 `skipped`，重算进度，每个运行写审计 `eval.run_cancelled`（detail 带原因）。在途请求做完后写不进新的请求
+     * （worker 每次请求前查 {@link runActive}）。运行创建者离开组织不取消（Ruling S1-b：管理员的评测运行是组织的工作）。
+     */
+    async cancelRuns(scope, actor, reason) {
+        const db = this.db.db;
+        let q = db
+            .updateTable("eval_runs")
+            .set({ status: "cancelled", finished_at: sql `now()` })
+            .where("org_id", "=", scope.orgId)
+            .where("status", "in", [...ACTIVE_EVAL_STATUSES]);
+        if (scope.agentId !== undefined) {
+            const agentId = scope.agentId;
+            q = q.where("set_id", "in", (eb) => eb.selectFrom("eval_sets").select("id").where("agent_id", "=", agentId));
+        }
+        const runs = await q.returning("id").execute();
+        for (const r of runs) {
+            await this.skipRun(r.id);
+            await audit(db, {
+                actorAccountId: actor.accountId,
+                ...(actor.tokenId !== undefined && { actorTokenId: actor.tokenId }),
+                orgId: scope.orgId,
+                action: "eval.run_cancelled",
+                target: r.id,
+                detail: { reason },
+            });
+        }
+        return runs.map((r) => r.id);
+    }
+    /**
+     * A run that stopped (cancelled, its set deleted): its results not started yet are `skipped`,
+     * the pending judges too, and the progress is recounted, in the caller's transaction.
+     */
+    async skipRun(runId) {
+        await this.db
             .updateTable("eval_results")
             .set({ status: "skipped", updated_at: sql `now()` })
-            .where("run_id", "=", r.id)
+            .where("run_id", "=", runId)
             .where("status", "=", "pending")
             .execute();
-        await skipPendingJudges(trx, r.id);
-        await recountCases(trx, r.id);
-        await audit(trx, {
-            actorAccountId: actor.accountId,
-            ...(actor.tokenId !== undefined && { actorTokenId: actor.tokenId }),
-            orgId: scope.orgId,
-            action: "eval.run_cancelled",
-            target: r.id,
-            detail: { reason },
-        });
+        await skipPendingJudges(this.db.db, runId);
+        await this.recountCases(runId);
     }
-    return runs.map((r) => r.id);
-}
+};
+__decorate([
+    Transactional()
+], EvalBudget.prototype, "recountCases", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], EvalBudget.prototype, "cancelRuns", null);
+__decorate([
+    Transactional({ propagation: "mandatory" })
+], EvalBudget.prototype, "skipRun", null);
+EvalBudget = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(TransactionHost))
+], EvalBudget);
+export { EvalBudget };
+/** {@link EvalBudget} on its own: the agents and the orgs import it without the evals. */
+let EvalBudgetModule = class EvalBudgetModule {
+};
+EvalBudgetModule = __decorate([
+    Module({ providers: [EvalBudget], exports: [EvalBudget] })
+], EvalBudgetModule);
+export { EvalBudgetModule };
 export const addUsage = (a, b) => ({
     inputTokens: a.inputTokens + b.inputTokens,
     outputTokens: a.outputTokens + b.outputTokens,

package/dist/evals/evals.module.d.ts

@@ -0,0 +1,31 @@
+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 { type EvalJobData } from "./jobs.js";
+import { EvalWorker } from "./worker.js";
+/**
+ * Evals: the trajectory viewer, eval sets and cases, eval runs (the producer of
+ * `cap-kernel-evals`) and the run bookkeeping ({@link EvalBudgetModule}, re-exported).
+ */
+export declare class EvalsModule {
+}
+/** The consumer of `cap-kernel-evals` (one case per job): {@link EvalWorker}. */
+export declare class EvalsProcessor extends WorkerHost<Worker<EvalJobData>> {
+    private readonly evals;
+    constructor(evals: EvalWorker);
+    process(job: Job<EvalJobData>, token?: string): Promise<void>;
+    failed(job: Job<EvalJobData> | undefined, err: Error): void;
+    error(err: Error): void;
+}
+/**
+ * The eval worker (step and full-run replays, the judge) over the runtime's loop and model
+ * registry, and the consumer of `cap-kernel-evals`, its options from the startup config
+ * (concurrency `evals.workerConcurrency`, the run queues' job lock and stalled detection). Imported
+ * only by the worker role (`WorkerModule`), so other roles get no processor and no BullMQ worker.
+ * The worker never starts by itself: the worker role (`WorkerRole`) starts it after the extensions
+ * loaded, and drains it on stop.
+ */
+export declare class EvalWorkersModule {
+    static forRoot(config: KernelConfig): DynamicModule;
+}

package/dist/evals/evals.module.js

@@ -0,0 +1,114 @@
+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 EvalWorkersModule_1;
+import { hostname } from "node:os";
+import { OnWorkerEvent, WorkerHost } from "@nestjs/bullmq";
+import { Inject, Injectable, Module } from "@nestjs/common";
+import { EventLogModule } from "../conversations/event-log.js";
+import { IdentityModule } from "../identity/identity.module.js";
+import { configuredProcessor } from "../infra/queue/configured-processor.js";
+import { QueueModule } from "../infra/queue/queue.module.js";
+import { runJob } from "../infra/queue/run-job.js";
+import { ModelsModule } from "../models/models.module.js";
+import { OrgLockModule } from "../orgs/org-lock.js";
+import { ProvidersModule } from "../runtime/providers.js";
+import { RuntimeModule } from "../runtime/runtime.module.js";
+import { EvalBudgetModule } from "./budget.js";
+import { EVAL_QUEUE_NAME, EvalJobs } from "./jobs.js";
+import { EvalReplaySeeder } from "./run-replay.js";
+import { EvalRunsService } from "./runs.service.js";
+import { EvalSetsService } from "./sets.service.js";
+import { TrajectoryService } from "./trajectory.service.js";
+import { EVAL_MAX_STALLED_COUNT, EvalWorker } from "./worker.js";
+/**
+ * Evals: the trajectory viewer, eval sets and cases, eval runs (the producer of
+ * `cap-kernel-evals`) and the run bookkeeping ({@link EvalBudgetModule}, re-exported).
+ */
+let EvalsModule = class EvalsModule {
+};
+EvalsModule = __decorate([
+    Module({
+        imports: [
+            EventLogModule,
+            ModelsModule,
+            IdentityModule,
+            OrgLockModule,
+            ProvidersModule,
+            EvalBudgetModule,
+            QueueModule.registerQueue(EVAL_QUEUE_NAME),
+        ],
+        providers: [TrajectoryService, EvalSetsService, EvalRunsService, EvalJobs],
+        exports: [TrajectoryService, EvalSetsService, EvalRunsService, EvalJobs, EvalBudgetModule],
+    })
+], EvalsModule);
+export { EvalsModule };
+/** The consumer of `cap-kernel-evals` (one case per job): {@link EvalWorker}. */
+let EvalsProcessor = class EvalsProcessor extends WorkerHost {
+    evals;
+    constructor(evals) {
+        super();
+        this.evals = evals;
+    }
+    process(job, token) {
+        return runJob(EVAL_QUEUE_NAME, job, () => this.evals.process(job, token));
+    }
+    failed(job, err) {
+        this.evals.onFailed(job, err);
+    }
+    error(err) {
+        this.evals.onError(err);
+    }
+};
+__decorate([
+    OnWorkerEvent("failed")
+], EvalsProcessor.prototype, "failed", null);
+__decorate([
+    OnWorkerEvent("error")
+], EvalsProcessor.prototype, "error", null);
+EvalsProcessor = __decorate([
+    Injectable(),
+    __param(0, Inject(EvalWorker))
+], EvalsProcessor);
+export { EvalsProcessor };
+/**
+ * The eval worker (step and full-run replays, the judge) over the runtime's loop and model
+ * registry, and the consumer of `cap-kernel-evals`, its options from the startup config
+ * (concurrency `evals.workerConcurrency`, the run queues' job lock and stalled detection). Imported
+ * only by the worker role (`WorkerModule`), so other roles get no processor and no BullMQ worker.
+ * The worker never starts by itself: the worker role (`WorkerRole`) starts it after the extensions
+ * loaded, and drains it on stop.
+ */
+let EvalWorkersModule = EvalWorkersModule_1 = class EvalWorkersModule {
+    static forRoot(config) {
+        const { jobLockMs, stalledIntervalMs } = config.runtime;
+        return {
+            module: EvalWorkersModule_1,
+            imports: [EvalsModule, RuntimeModule, EventLogModule, ModelsModule],
+            providers: [
+                EvalReplaySeeder,
+                EvalWorker,
+                configuredProcessor(EvalsProcessor, EVAL_QUEUE_NAME, {
+                    // the worker name is recorded on the job (BullMQ processedBy): which replica ran it
+                    name: `${hostname()}-${process.pid}`,
+                    concurrency: config.evals.workerConcurrency,
+                    lockDuration: jobLockMs,
+                    stalledInterval: stalledIntervalMs,
+                    maxStalledCount: EVAL_MAX_STALLED_COUNT,
+                }),
+            ],
+            exports: [EvalWorker, EvalsProcessor],
+        };
+    }
+};
+EvalWorkersModule = EvalWorkersModule_1 = __decorate([
+    Module({})
+    // biome-ignore lint/complexity/noStaticOnlyClass: a Nest dynamic module
+], EvalWorkersModule);
+export { EvalWorkersModule };

package/dist/evals/jobs.d.ts

@@ -0,0 +1,20 @@
+import type { Queue } from "bullmq";
+/** 评测队列的 BullMQ 队列名（不含 `:`，C7）。 */
+export declare const EVAL_QUEUE_NAME = "cap-kernel-evals";
+/** 每个用例一个任务（C7；不含 `:`）。 */
+export declare const evalJobId: (runId: string, caseId: string) => string;
+/** 评测任务的数据。 */
+export interface EvalJobData {
+    runId: string;
+    caseId: string;
+    orgId: string;
+}
+/**
+ * The producer of `cap-kernel-evals` (one job per case, {@link evalJobId}); the eval worker
+ * consumes it on the worker role. A leaf module: the runs service and the worker import it.
+ */
+export declare class EvalJobs {
+    private readonly queue;
+    constructor(queue: Pick<Queue, "addBulk">);
+    enqueue(jobs: EvalJobData[]): Promise<void>;
+}

package/dist/evals/jobs.js

@@ -0,0 +1,45 @@
+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 } from "@nestjs/common";
+/** 评测队列的 BullMQ 队列名（不含 `:`，C7）。 */
+export const EVAL_QUEUE_NAME = "cap-kernel-evals";
+/** 每个用例一个任务（C7；不含 `:`）。 */
+export const evalJobId = (runId, caseId) => `eval-${runId}-${caseId}`;
+/**
+ * The producer of `cap-kernel-evals` (one job per case, {@link evalJobId}); the eval worker
+ * consumes it on the worker role. A leaf module: the runs service and the worker import it.
+ */
+let EvalJobs = class EvalJobs {
+    queue;
+    constructor(queue) {
+        this.queue = queue;
+    }
+    async enqueue(jobs) {
+        await this.queue.addBulk(jobs.map((data) => ({
+            name: "case",
+            data,
+            opts: {
+                jobId: evalJobId(data.runId, data.caseId),
+                // 处理函数外的暂时故障（PG / Redis）：指数退避重试，不让整个用例一次失败。
+                // 结果按认领号写入，重做不会重复写结果
+                attempts: 3,
+                backoff: { type: "exponential", delay: 1000 },
+                removeOnComplete: true,
+                removeOnFail: 1000,
+            },
+        })));
+    }
+};
+EvalJobs = __decorate([
+    Injectable(),
+    __param(0, Inject(getQueueToken(EVAL_QUEUE_NAME)))
+], EvalJobs);
+export { EvalJobs };

package/dist/evals/run-replay.d.ts

@@ -1,13 +1,17 @@
 import { type ContentBlock, type Logger, type ModelUsage, type StopReason } from "@capybara-hq/plugin-sdk";
-import type { KernelConfig } from "../config/schema.js";
-import type { EventLog } from "../conversations/event-log.js";
-import type { KernelDb } from "../db/kernel-schema.js";
+import { type ModelRef } from "../agents/definition.js";
+import { EventLog } from "../conversations/event-log.js";
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
+import type { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
 import type { KyselyCheckpointSaver } from "../runtime/checkpointer.js";
 import type { LoopDeps } from "../runtime/langgraph-loop.js";
 import type { AgentLoop, LoopOutcome } from "../runtime/loop.js";
 import { type MediaSourceDeps } from "../runtime/model-call.js";
 import type { ProviderRegistry } from "../runtime/providers.js";
-import type { CaseSnapshot } from "./snapshot.js";
+import type { RunFinish } from "../runtime/run-finish.js";
+import type { CaseSnapshot, SnapshotEvent } from "./snapshot.js";
 import type { ResolvedCandidate } from "./step-replay.js";
 /**
  * 整轮回放（D2 / C6）：在 `kind = 'eval'` 的隐藏对话里跑**同一个** `LangGraphLoop`，工具管线换成
@@ -50,9 +54,14 @@ export interface EvalReplayHooks {
     beforeJudge?(evalRunId: string): Promise<void>;
 }
 export interface RunReplayDeps {
-    db: KernelDb;
+    /** The context-aware handle (reads, the eval conversation's cleanup). */
+    readonly db: KernelSchemaDb;
     eventLog: EventLog;
-    config: () => KernelConfig;
+    /** Writes the seed (the eval conversation, its events, the run) in a transaction of its own. */
+    seeder: Pick<EvalReplaySeeder, "seed">;
+    /** Writes the replayed run's terminal state. */
+    runFinish: Pick<RunFinish, "finish">;
+    config: Pick<KernelConfigService, "get">;
     log: Logger;
     registry: Pick<ProviderRegistry, "resolve">;
     media?: MediaSourceDeps;
@@ -64,15 +73,54 @@ export interface RunReplayDeps {
     /** 本次执行是否仍持有结果的认领（失去认领 → 不再发请求）；不给 = 不检查。 */
     stillClaimed?: () => Promise<boolean>;
     /**
-     * 种子事务内调用：把评测对话记到结果上（以认领为条件）。返回 false = 已失去认领，种子回滚、抛 {@link ReplayClaimLost}。
+     * 种子事务内调用（its queries join the seed's transaction through the context-aware handle）：把评测对话记到结果上
+     * （以认领为条件）。返回 false = 已失去认领，种子回滚、抛 {@link ReplayClaimLost}。
      */
-    onSeeded?: (trx: KernelDb, conversationId: string) => Promise<boolean>;
+    onSeeded?: (conversationId: string) => Promise<boolean>;
     hooks?: EvalReplayHooks;
 }
 /** 写种子时发现已失去认领或运行已不在执行：本次执行停下，不留评测对话。 */
 export declare class ReplayClaimLost extends Error {
     constructor();
 }
+/** What {@link EvalReplaySeeder.seed} writes. */
+export interface ReplaySeed {
+    evalRunId: string;
+    orgId: string;
+    agentId: string;
+    accountId: string;
+    conversationId: string;
+    runId: string;
+    /** The original run's `run_started` seq: the seeds are the events before it. */
+    runStartedSeq: number;
+    /** The conversation's `consumed_seq` when the original run started. */
+    consumed: number;
+    seeds: SnapshotEvent[];
+    /** The run's trigger seq (the last user message before it). */
+    trigger: number;
+    agentVersion: number;
+    model: ModelRef;
+    /** The original run's `skills_catalog` event, its payload copied as is. */
+    catalog: {
+        payload: unknown;
+    } | undefined;
+}
+/**
+ * The seed of a full-run replay (C6): the `kind = 'eval'` conversation with the events before the
+ * original run at their original seqs, the run row and its `run_started` (and the original
+ * `skills_catalog`), in one transaction of its own.
+ */
+export declare class EvalReplaySeeder {
+    private readonly db;
+    private readonly eventLog;
+    readonly txHost: TransactionHost;
+    constructor(db: KernelDb, eventLog: Pick<EventLog, "appendIn">, txHost: TransactionHost);
+    /**
+     * Writes the seed; `onSeeded` runs inside the same transaction (false = the claim is lost: the
+     * seed rolls back and {@link ReplayClaimLost} is thrown).
+     */
+    seed(p: ReplaySeed, onSeeded?: (conversationId: string) => Promise<boolean>): Promise<void>;
+}
 /** 整轮回放被停下的原因（`run_aborted.detail`）。 */
 export type StopDetail = "cancelled" | "capped" | "too_many_errors" | "claim_lost" | "shutdown";
 /** 原运行（快照）的摘要，作为整轮回放的基线。 */