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

package/dist/evals/sets.service.js

@@ -1,9 +1,26 @@
+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 EvalSetsService_1;
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
 import { typedInvocation } from "../conversations/events.js";
 import { ApiError } from "../errors.js";
 import { audit } from "../identity/audit.js";
-import { lockOrgAndAuthorize } from "../orgs/org-lock.js";
-import { recountCases, skipPendingJudges } from "./budget.js";
+import { SettingsService } from "../identity/settings.js";
+import { KernelConfigService } from "../infra/config/kernel-config.service.js";
+import { KernelDb } from "../infra/database/kernel-db.js";
+import { TransactionHost } from "../infra/database/transaction-host.js";
+import { Transactional } from "../infra/database/transactional.decorator.js";
+import { PricesService } from "../models/prices.js";
+import { OrgLock } from "../orgs/org-lock.js";
+import { EvalBudget } from "./budget.js";
 import { casePlans } from "./plan.js";
 import { caseBase } from "./runs.service.js";
 import { readSnapshot, replayableCalls, takeSnapshot, toEvents, } from "./snapshot.js";
@@ -74,16 +91,28 @@ function toCaseView(r) {
  * （`takeSnapshot`，≤ `evals.maxCaseBytes`），之后与原对话无关。写操作在事务里锁组织行并复核角色
  * （`evals.manage`），再锁集合行，串行化同一集合的容量判定。查看用例内容写审计 `trajectory.viewed`。
  */
-export class EvalSetsService {
-    db;
+let EvalSetsService = EvalSetsService_1 = class EvalSetsService {
+    kdb;
     config;
     prices;
     settings;
-    constructor(db, config, prices, settings) {
-        this.db = db;
+    orgLock;
+    budget;
+    txHost;
+    constructor(kdb, config, prices, settings, 
+    /** The org row lock (orgs/org-lock.ts): joins the caller's transaction. */
+    orgLock, budget, txHost) {
+        this.kdb = kdb;
         this.config = config;
         this.prices = prices;
         this.settings = settings;
+        this.orgLock = orgLock;
+        this.budget = budget;
+        this.txHost = txHost;
+    }
+    /** The context-aware handle (the `@Transactional` method's transaction, else the pool). */
+    get db() {
+        return this.kdb.db;
     }
     views(orgId) {
         return this.db
@@ -121,42 +150,10 @@ export class EvalSetsService {
         const r = await this.views(orgId).where("s.id", "=", setId).executeTakeFirst();
         if (!r)
             throw setNotFound();
-        return EvalSetsService.toView(r);
+        return EvalSetsService_1.toView(r);
     }
-    async create(orgId, actor, input, actorTokenId) {
-        const id = await this.db.transaction().execute(async (trx) => {
-            await lockOrgAndAuthorize(trx, orgId, actor, "evals.manage");
-            const agent = await trx
-                .selectFrom("agents")
-                .select("id")
-                .where("id", "=", input.agentId)
-                .where("org_id", "=", orgId)
-                .where("deleted_at", "is", null)
-                .executeTakeFirst();
-            if (!agent)
-                throw new ApiError("agent.not_found", "Agent not found");
-            const row = await trx
-                .insertInto("eval_sets")
-                .values({
-                org_id: orgId,
-                agent_id: input.agentId,
-                name: input.name,
-                description: input.description ?? "",
-                rubric: input.rubric ?? null,
-                created_by: actor,
-            })
-                .returning("id")
-                .executeTakeFirstOrThrow();
-            await audit(trx, {
-                actorAccountId: actor,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "eval.set_created",
-                target: row.id,
-                detail: { agentId: input.agentId, name: input.name },
-            });
-            return row.id;
-        });
+    async create(orgId, actor, input, actorTokenId, auditDetail) {
+        const id = await this.createIn(orgId, actor, input, actorTokenId, auditDetail);
         return this.view(orgId, id);
     }
     async list(orgId) {
@@ -164,7 +161,7 @@ export class EvalSetsService {
             .orderBy("s.created_at", "desc")
             .orderBy("s.id", "desc")
             .execute();
-        return rows.map((r) => EvalSetsService.toView(r));
+        return rows.map((r) => EvalSetsService_1.toView(r));
     }
     async get(orgId, setId) {
         const set = await this.view(orgId, setId);
@@ -178,65 +175,190 @@ export class EvalSetsService {
             .execute();
         return { ...set, cases: cases.map(toCaseView) };
     }
-    async update(orgId, actor, setId, patch, actorTokenId) {
+    async update(orgId, actor, setId, patch, actorTokenId, auditDetail) {
         if (!UUID.test(setId))
             throw setNotFound();
-        await this.db.transaction().execute(async (trx) => {
-            await lockOrgAndAuthorize(trx, orgId, actor, "evals.manage");
-            const r = await trx
-                .updateTable("eval_sets")
-                .set({
-                ...(patch.name !== undefined && { name: patch.name }),
-                ...(patch.description !== undefined && { description: patch.description }),
-                ...(patch.rubric !== undefined && { rubric: patch.rubric }),
-                updated_at: sql `now()`,
-            })
-                .where("id", "=", setId)
-                .where("org_id", "=", orgId)
-                .where("deleted_at", "is", null)
-                .executeTakeFirst();
-            if (Number(r.numUpdatedRows) === 0)
-                throw setNotFound();
-            await audit(trx, {
-                actorAccountId: actor,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "eval.set_updated",
-                target: setId,
-                // 只记改了哪些字段（评分标准可能很长，不进审计）
-                detail: {
-                    fields: ["name", "description", "rubric"].filter((f) => patch[f] !== undefined),
-                },
-            });
-        });
+        await this.updateIn(orgId, actor, setId, patch, actorTokenId, auditDetail);
         return this.view(orgId, setId);
     }
     /**
      * 删除评测集（Ruling S1-a）：集合行软删除，留作审计存根；用例（含快照）硬删，结果随之级联删除，不留复制来的对话内容；
      * 在执行的运行取消，运行行保留（无入口）。
      */
-    async remove(orgId, actor, setId, actorTokenId) {
+    async remove(orgId, actor, setId, actorTokenId, auditDetail) {
         if (!UUID.test(setId))
             throw setNotFound();
-        await this.db.transaction().execute(async (trx) => {
-            await lockOrgAndAuthorize(trx, orgId, actor, "evals.manage");
-            const r = await trx
-                .updateTable("eval_sets")
-                .set({ deleted_at: sql `now()`, updated_at: sql `now()` })
-                .where("id", "=", setId)
-                .where("org_id", "=", orgId)
-                .where("deleted_at", "is", null)
-                .executeTakeFirst();
-            if (Number(r.numUpdatedRows) === 0)
-                throw setNotFound();
-            await stopAndPurgeRuns(trx, setId);
-            await audit(trx, {
-                actorAccountId: actor,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "eval.set_deleted",
-                target: setId,
-            });
+        await this.removeIn(orgId, actor, setId, actorTokenId, auditDetail);
+    }
+    async createIn(orgId, actor, input, actorTokenId, auditDetail) {
+        await this.orgLock.lockAndAuthorize(orgId, actor, "evals.manage");
+        const agent = await this.db
+            .selectFrom("agents")
+            .select("id")
+            .where("id", "=", input.agentId)
+            .where("org_id", "=", orgId)
+            .where("deleted_at", "is", null)
+            .executeTakeFirst();
+        if (!agent)
+            throw new ApiError("agent.not_found", "Agent not found");
+        const row = await this.db
+            .insertInto("eval_sets")
+            .values({
+            org_id: orgId,
+            agent_id: input.agentId,
+            name: input.name,
+            description: input.description ?? "",
+            rubric: input.rubric ?? null,
+            created_by: actor,
+        })
+            .returning("id")
+            .executeTakeFirstOrThrow();
+        await audit(this.db, {
+            actorAccountId: actor,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "eval.set_created",
+            target: row.id,
+            detail: { agentId: input.agentId, name: input.name, ...auditDetail },
+        });
+        return row.id;
+    }
+    async updateIn(orgId, actor, setId, patch, actorTokenId, auditDetail) {
+        await this.orgLock.lockAndAuthorize(orgId, actor, "evals.manage");
+        const r = await this.db
+            .updateTable("eval_sets")
+            .set({
+            ...(patch.name !== undefined && { name: patch.name }),
+            ...(patch.description !== undefined && { description: patch.description }),
+            ...(patch.rubric !== undefined && { rubric: patch.rubric }),
+            updated_at: sql `now()`,
+        })
+            .where("id", "=", setId)
+            .where("org_id", "=", orgId)
+            .where("deleted_at", "is", null)
+            .executeTakeFirst();
+        if (Number(r.numUpdatedRows) === 0)
+            throw setNotFound();
+        await audit(this.db, {
+            actorAccountId: actor,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "eval.set_updated",
+            target: setId,
+            // 只记改了哪些字段（评分标准可能很长，不进审计）
+            detail: {
+                fields: ["name", "description", "rubric"].filter((f) => patch[f] !== undefined),
+                ...auditDetail,
+            },
+        });
+    }
+    async removeIn(orgId, actor, setId, actorTokenId, auditDetail) {
+        await this.orgLock.lockAndAuthorize(orgId, actor, "evals.manage");
+        const r = await this.db
+            .updateTable("eval_sets")
+            .set({ deleted_at: sql `now()`, updated_at: sql `now()` })
+            .where("id", "=", setId)
+            .where("org_id", "=", orgId)
+            .where("deleted_at", "is", null)
+            .executeTakeFirst();
+        if (Number(r.numUpdatedRows) === 0)
+            throw setNotFound();
+        await stopAndPurgeRuns(this.db, this.budget, setId);
+        await audit(this.db, {
+            actorAccountId: actor,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "eval.set_deleted",
+            target: setId,
+            ...(auditDetail !== undefined && { detail: auditDetail }),
+        });
+    }
+    async insertCaseIn(orgId, actor, setId, snapshot, extra, prepared) {
+        const { max, json, plans, base } = prepared;
+        await this.orgLock.lockAndAuthorize(orgId, actor, "evals.manage");
+        const set = await this.db
+            .selectFrom("eval_sets")
+            .select("id")
+            .where("id", "=", setId)
+            .where("org_id", "=", orgId)
+            .where("deleted_at", "is", null)
+            .forUpdate()
+            .executeTakeFirst();
+        if (!set)
+            throw setNotFound();
+        if ((await this.caseCount(this.db, setId)) >= max)
+            return "full";
+        const row = await this.db
+            .insertInto("eval_cases")
+            .values({
+            set_id: setId,
+            org_id: orgId,
+            source_conversation_id: snapshot.conversationId,
+            source_run_id: snapshot.runId,
+            agent_version: snapshot.agentVersion,
+            title: caseTitle(snapshot),
+            snapshot: json,
+            snapshot_bytes: Buffer.byteLength(json),
+            replayable_steps: replayableCalls(snapshot).length,
+            plan_step: JSON.stringify(plans.step),
+            plan_run: JSON.stringify(plans.run),
+            base_model: base ? JSON.stringify(base.definition.model) : null,
+            added_by: actor,
+        })
+            .onConflict((oc) => oc.columns(["set_id", "source_run_id"]).doNothing())
+            .returning(CASE_COLUMNS)
+            .executeTakeFirst();
+        if (!row)
+            return "exists";
+        await audit(this.db, {
+            actorAccountId: actor,
+            ...(extra.actorTokenId !== undefined && { actorTokenId: extra.actorTokenId }),
+            orgId,
+            action: "eval.case_added",
+            target: setId,
+            detail: {
+                caseId: row.id,
+                conversationId: snapshot.conversationId,
+                runId: snapshot.runId,
+                ...(extra.sampled && { sampled: true }),
+                ...extra.auditDetail,
+            },
+        });
+        return toCaseView(row);
+    }
+    async removeCaseIn(orgId, actor, setId, caseId, actorTokenId, auditDetail) {
+        await this.orgLock.lockAndAuthorize(orgId, actor, "evals.manage");
+        const set = await this.db
+            .selectFrom("eval_sets")
+            .select("id")
+            .where("id", "=", setId)
+            .where("org_id", "=", orgId)
+            .where("deleted_at", "is", null)
+            .forUpdate()
+            .executeTakeFirst();
+        if (!set)
+            throw setNotFound();
+        const r = await this.db
+            .deleteFrom("eval_cases")
+            .where("id", "=", caseId)
+            .where("set_id", "=", setId)
+            .where("org_id", "=", orgId)
+            .returning(["source_conversation_id", "source_run_id"])
+            .executeTakeFirst();
+        if (!r)
+            throw caseNotFound();
+        await audit(this.db, {
+            actorAccountId: actor,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "eval.case_removed",
+            target: setId,
+            detail: {
+                caseId,
+                conversationId: r.source_conversation_id,
+                runId: r.source_run_id,
+                ...auditDetail,
+            },
         });
     }
     /** 未删除的评测集；不存在 → `eval.set_not_found`。 */
@@ -267,7 +389,7 @@ export class EvalSetsService {
      * `(set_id, source_run_id)` 已存在时返回 null（不写）。成功时写审计 `eval.case_added`。
      */
     async insertCase(orgId, actor, setId, snapshot, extra) {
-        const max = this.config().evals.maxCasesPerSet;
+        const max = this.config.get().evals.maxCasesPerSet;
         const json = JSON.stringify(snapshot);
         // 估算与启动只读这些列（不读快照）：两种模式的计划与用例原版本的模型
         const plans = casePlans(snapshot);
@@ -277,64 +399,14 @@ export class EvalSetsService {
             plans.step.switchedModel = switched;
             plans.run.switchedModel = switched;
         }
-        return this.db.transaction().execute(async (trx) => {
-            await lockOrgAndAuthorize(trx, orgId, actor, "evals.manage");
-            const set = await trx
-                .selectFrom("eval_sets")
-                .select("id")
-                .where("id", "=", setId)
-                .where("org_id", "=", orgId)
-                .where("deleted_at", "is", null)
-                .forUpdate()
-                .executeTakeFirst();
-            if (!set)
-                throw setNotFound();
-            if ((await this.caseCount(trx, setId)) >= max)
-                return "full";
-            const row = await trx
-                .insertInto("eval_cases")
-                .values({
-                set_id: setId,
-                org_id: orgId,
-                source_conversation_id: snapshot.conversationId,
-                source_run_id: snapshot.runId,
-                agent_version: snapshot.agentVersion,
-                title: caseTitle(snapshot),
-                snapshot: json,
-                snapshot_bytes: Buffer.byteLength(json),
-                replayable_steps: replayableCalls(snapshot).length,
-                plan_step: JSON.stringify(plans.step),
-                plan_run: JSON.stringify(plans.run),
-                base_model: base ? JSON.stringify(base.definition.model) : null,
-                added_by: actor,
-            })
-                .onConflict((oc) => oc.columns(["set_id", "source_run_id"]).doNothing())
-                .returning(CASE_COLUMNS)
-                .executeTakeFirst();
-            if (!row)
-                return "exists";
-            await audit(trx, {
-                actorAccountId: actor,
-                ...(extra.actorTokenId !== undefined && { actorTokenId: extra.actorTokenId }),
-                orgId,
-                action: "eval.case_added",
-                target: setId,
-                detail: {
-                    caseId: row.id,
-                    conversationId: snapshot.conversationId,
-                    runId: snapshot.runId,
-                    ...(extra.sampled && { sampled: true }),
-                },
-            });
-            return toCaseView(row);
-        });
+        return this.insertCaseIn(orgId, actor, setId, snapshot, extra, { max, json, plans, base });
     }
     /**
      * 把某次运行加为用例。对话不在本组织（或是 eval 对话）→ `conversation.not_found`；对话的 agent 不是集合的 agent →
      * `eval.agent_mismatch`；已在集合里 → `eval.case_exists`；集合满了 → `eval.too_many_cases`；
      * 运行未终态 / 快照超大 → `eval.run_not_finished` / `eval.case_too_large`（`takeSnapshot`）。
      */
-    async addCase(orgId, actor, setId, input, actorTokenId) {
+    async addCase(orgId, actor, setId, input, actorTokenId, auditDetail) {
         const set = await this.liveSet(orgId, setId);
         const conv = await this.db
             .selectFrom("conversations")
@@ -358,7 +430,7 @@ export class EvalSetsService {
             .executeTakeFirst();
         if (exists)
             throw caseExists();
-        const { maxCasesPerSet, maxCaseBytes } = this.config().evals;
+        const { maxCasesPerSet, maxCaseBytes } = this.config.get().evals;
         // 先判容量再取快照（快照可能很大）；写入时在锁内再判一次
         if ((await this.caseCount(this.db, setId)) >= maxCasesPerSet)
             throw tooMany(maxCasesPerSet);
@@ -366,6 +438,7 @@ export class EvalSetsService {
         const r = await this.insertCase(orgId, actor, setId, snapshot, {
             sampled: false,
             ...(actorTokenId !== undefined && { actorTokenId }),
+            ...(auditDetail !== undefined && { auditDetail }),
         });
         if (r === "exists")
             throw caseExists();
@@ -378,9 +451,9 @@ export class EvalSetsService {
      * `min(count, 剩余容量)` 个，逐个取快照写入。快照超大（或其间被删除 / 写入时已满 / 并发加入）的计入 `skipped`。
      * 集合已满 → `eval.too_many_cases`。逐个写入，内存里一次只有一份快照。
      */
-    async sample(orgId, actor, setId, input, actorTokenId) {
+    async sample(orgId, actor, setId, input, actorTokenId, auditDetail) {
         const set = await this.liveSet(orgId, setId);
-        const { maxCasesPerSet, maxCaseBytes } = this.config().evals;
+        const { maxCasesPerSet, maxCaseBytes } = this.config.get().evals;
         const room = maxCasesPerSet - (await this.caseCount(this.db, setId));
         if (room <= 0)
             throw tooMany(maxCasesPerSet);
@@ -429,6 +502,7 @@ export class EvalSetsService {
             const r = await this.insertCase(orgId, actor, setId, snapshot, {
                 sampled: true,
                 ...(actorTokenId !== undefined && { actorTokenId }),
+                ...(auditDetail !== undefined && { auditDetail }),
             });
             if (typeof r === "string")
                 skipped++;
@@ -437,51 +511,18 @@ export class EvalSetsService {
         }
         return { added, skipped };
     }
-    async removeCase(orgId, actor, setId, caseId, actorTokenId) {
+    async removeCase(orgId, actor, setId, caseId, actorTokenId, auditDetail) {
         if (!UUID.test(setId))
             throw setNotFound();
         if (!UUID.test(caseId))
             throw caseNotFound();
-        await this.db.transaction().execute(async (trx) => {
-            await lockOrgAndAuthorize(trx, orgId, actor, "evals.manage");
-            const set = await trx
-                .selectFrom("eval_sets")
-                .select("id")
-                .where("id", "=", setId)
-                .where("org_id", "=", orgId)
-                .where("deleted_at", "is", null)
-                .forUpdate()
-                .executeTakeFirst();
-            if (!set)
-                throw setNotFound();
-            const r = await trx
-                .deleteFrom("eval_cases")
-                .where("id", "=", caseId)
-                .where("set_id", "=", setId)
-                .where("org_id", "=", orgId)
-                .returning(["source_conversation_id", "source_run_id"])
-                .executeTakeFirst();
-            if (!r)
-                throw caseNotFound();
-            await audit(trx, {
-                actorAccountId: actor,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "eval.case_removed",
-                target: setId,
-                detail: {
-                    caseId,
-                    conversationId: r.source_conversation_id,
-                    runId: r.source_run_id,
-                },
-            });
-        });
+        await this.removeCaseIn(orgId, actor, setId, caseId, actorTokenId, auditDetail);
     }
     /**
      * 用例详情：由快照还原轨迹（原对话删除后照常可读）。快照即对话内容，每次查看写审计 `trajectory.viewed`
      * （target = 原对话 id，detail 带 `caseId` / `setId`）。
      */
-    async getCase(orgId, actor, setId, caseId, actorTokenId) {
+    async getCase(orgId, actor, setId, caseId, actorTokenId, auditDetail) {
         await this.liveSet(orgId, setId);
         if (!UUID.test(caseId))
             throw caseNotFound();
@@ -502,7 +543,7 @@ export class EvalSetsService {
             orgId,
             action: "trajectory.viewed",
             target: row.source_conversation_id,
-            detail: { agentId: snapshot.agentId, caseId, setId },
+            detail: { agentId: snapshot.agentId, caseId, setId, ...auditDetail },
         });
         return {
             case: toCaseView(row),
@@ -514,15 +555,41 @@ export class EvalSetsService {
             }),
         };
     }
-}
+};
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EvalSetsService.prototype, "createIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EvalSetsService.prototype, "updateIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EvalSetsService.prototype, "removeIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EvalSetsService.prototype, "insertCaseIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EvalSetsService.prototype, "removeCaseIn", null);
+EvalSetsService = EvalSetsService_1 = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(KernelConfigService)),
+    __param(2, Inject(PricesService)),
+    __param(3, Inject(SettingsService)),
+    __param(4, Inject(OrgLock)),
+    __param(5, Inject(EvalBudget)),
+    __param(6, Inject(TransactionHost))
+], EvalSetsService);
+export { EvalSetsService };
 /**
  * 删除评测集时（同一事务内）：在执行的评测运行置 `cancelled`、未开始的结果 `skipped`（在途的用例在下一次请求前停下），
  * 删掉这些运行的整轮回放隐藏对话（及其 checkpoint）与集合的全部用例（结果级联删除）——集合软删后它们没有入口，也不该留着。
  * 与回放写种子互斥：种子事务对运行行加共享锁并复核仍在执行（见 `replayRun`），这里的 UPDATE 持行锁，
  * 先提交的一方胜出，不会在删除之后再长出新的评测对话。
  */
-async function stopAndPurgeRuns(trx, setId) {
-    const runs = await trx
+async function stopAndPurgeRuns(db, budget, setId) {
+    const runs = await db
         .updateTable("eval_runs")
         .set({ status: "cancelled", finished_at: sql `now()` })
         .where("set_id", "=", setId)
@@ -530,29 +597,22 @@ async function stopAndPurgeRuns(trx, setId) {
         .returning("id")
         .execute();
     for (const r of runs) {
-        await trx
-            .updateTable("eval_results")
-            .set({ status: "skipped", updated_at: sql `now()` })
-            .where("run_id", "=", r.id)
-            .where("status", "=", "pending")
-            .execute();
-        await skipPendingJudges(trx, r.id);
-        await recountCases(trx, r.id);
+        await budget.skipRun(r.id);
     }
-    const all = trx.selectFrom("eval_runs").select("id").where("set_id", "=", setId);
-    const convs = trx
+    const all = db.selectFrom("eval_runs").select("id").where("set_id", "=", setId);
+    const convs = db
         .selectFrom("conversations")
         .select("id")
         .where("kind", "=", "eval")
         .where("eval_run_id", "in", all);
-    const threads = trx.selectFrom("runs").select("id").where("conversation_id", "in", convs);
-    await trx.deleteFrom("lg_checkpoint_writes").where("thread_id", "in", threads).execute();
-    await trx.deleteFrom("lg_checkpoints").where("thread_id", "in", threads).execute();
-    await trx
+    const threads = db.selectFrom("runs").select("id").where("conversation_id", "in", convs);
+    await db.deleteFrom("lg_checkpoint_writes").where("thread_id", "in", threads).execute();
+    await db.deleteFrom("lg_checkpoints").where("thread_id", "in", threads).execute();
+    await db
         .deleteFrom("conversations")
         .where("kind", "=", "eval")
         .where("eval_run_id", "in", all)
         .execute();
     // 用例快照是复制来的对话内容：硬删（结果随之级联删除），与单个移除用例一致
-    await trx.deleteFrom("eval_cases").where("set_id", "=", setId).execute();
+    await db.deleteFrom("eval_cases").where("set_id", "=", setId).execute();
 }

package/dist/evals/snapshot.d.ts

@@ -1,7 +1,7 @@
 import type { ToolSpec } from "@capybara-hq/plugin-sdk";
 import { type AgentDefinition } from "../agents/definition.js";
 import type { ConversationEvent, ConversationEventType } from "../conversations/events.js";
-import type { KernelDb } from "../db/kernel-schema.js";
+import type { KernelSchemaDb } from "../db/kernel-schema.js";
 /**
  * 评测用例快照（C3）：复制截至某次运行终态的会话事件、这些事件引用的 agent 版本定义、请求用到的工具定义
  * （按 specHash）。回放只读快照，不改原对话的日志；媒体不复制字节，回放时按引用取原附件。
@@ -57,10 +57,11 @@ export interface CaseSnapshot {
  * 运行还没有终态事件 → `eval.run_not_finished`（409）；序列化后超过 `maxBytes` 字节 → `eval.case_too_large`（413）。
  * `maxBytes` 由调用方传入（`evals.maxCaseBytes`）。
  */
-export declare function takeSnapshot(db: KernelDb, orgId: string, conversationId: string, runId: string, maxBytes: number): Promise<CaseSnapshot>;
+export declare function takeSnapshot(db: KernelSchemaDb, orgId: string, conversationId: string, runId: string, maxBytes: number): Promise<CaseSnapshot>;
 /**
- * 读出库里存的快照（`eval_cases.snapshot`）：把各版本定义里改名前（D17）的 `{ kind: "app" }` 工具引用规范化为
- * connector 形（C27）。整轮回放会把定义交给实时注册表，不规范化的话连接器工具全部失效。其余字段原样。
+ * Reads a stored snapshot (`eval_cases.snapshot`): each version's definition goes through
+ * `normalizeStoredDefinition` (rc tool keys, and an enabled tool list read as nothing turned off).
+ * Other fields as they are.
  */
 export declare function readSnapshot(raw: unknown): CaseSnapshot;
 /** 快照事件还原为日志事件（`createdAt` 转回 Date）。 */