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

package/dist/evals/runs.service.js

@@ -1,63 +1,34 @@
-import { Queue } from "bullmq";
+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 EvalRunsService_1;
+import { Inject, Injectable } from "@nestjs/common";
 import { sql } from "kysely";
-import { paramIssues } from "../agents/agents.service.js";
-import { normalizeStoredDefinition, } from "../agents/definition.js";
+import { normalizeStoredDefinition, paramIssues, } from "../agents/definition.js";
 import { effectiveDefinition, NO_SELECTION, selectionAt, } from "../conversations/selection.js";
 import { ApiError } from "../errors.js";
 import { audit } from "../identity/audit.js";
-import { costOf, priceKey } from "../models/prices.js";
-import { lockOrgAndAuthorize } from "../orgs/org-lock.js";
-import { ProviderListError } from "../runtime/providers.js";
-import { bullConnection } from "../runtime/run-queue.js";
-import { ACTIVE_EVAL_STATUSES, recountCases, skipPendingJudges, usageTokens } 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 { LockService } from "../infra/lock/lock.service.js";
+import { costOf, PricesService, priceKey } from "../models/prices.js";
+import { ModelPurposesService } from "../models/purposes.js";
+import { OrgLock } from "../orgs/org-lock.js";
+import { ProviderListError, ProviderRegistry } from "../runtime/providers.js";
+import { ACTIVE_EVAL_STATUSES, EvalBudget, usageTokens } from "./budget.js";
+import { EvalJobs } from "./jobs.js";
 import { judgeOverheadTokens } from "./judge.js";
 import { candidateModel } from "./step-replay.js";
-/** 评测队列的 BullMQ 队列名（不含 `:`，C7）。 */
-export const EVAL_QUEUE_NAME = "cap-kernel-evals";
-/** 每个用例一个任务（C7；不含 `:`）。 */
-export const evalJobId = (runId, caseId) => `eval-${runId}-${caseId}`;
-/** 评测队列（生产方）：懒建连接；`close()` 关闭。 */
-export class EvalQueue {
-    redisUrl;
-    log;
-    queue;
-    conn;
-    closed = false;
-    constructor(redisUrl, log) {
-        this.redisUrl = redisUrl;
-        this.log = log;
-    }
-    get() {
-        if (this.closed)
-            throw new Error("eval queue is closed");
-        if (!this.queue) {
-            this.conn = bullConnection(this.redisUrl, this.log);
-            this.queue = new Queue(EVAL_QUEUE_NAME, { connection: this.conn });
-            this.queue.on("error", (err) => this.log.error("eval queue error", { err }));
-        }
-        return this.queue;
-    }
-    async enqueue(jobs) {
-        await this.get().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,
-            },
-        })));
-    }
-    async close() {
-        this.closed = true;
-        await this.queue?.close().catch(() => { });
-        this.conn?.disconnect();
-    }
-}
+export { EVAL_QUEUE_NAME, evalJobId } from "./jobs.js";
 const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 const setNotFound = () => new ApiError("eval.set_not_found", "Eval set not found");
 const runNotFound = () => new ApiError("eval.run_not_found", "Eval run not found");
@@ -180,10 +151,25 @@ const resultsViewedKey = (runId, accountId) => `capk:eval-results-viewed:${runId
  * 评测运行（D5、C7）：估算、启动（校验候选、预建结果、每个用例入队一个任务）、查看、结果分页、取消。
  * 执行在 `evals/worker.ts`。写操作在事务里锁组织行并复核角色（`evals.manage`）。
  */
-export class EvalRunsService {
+let EvalRunsService = EvalRunsService_1 = class EvalRunsService {
+    txHost;
     d;
-    constructor(d) {
-        this.d = d;
+    constructor(kdb, orgLock, locks, config, registry, prices, settings, queue, budget, purposes, txHost) {
+        this.txHost = txHost;
+        this.d = {
+            orgLock,
+            get db() {
+                return kdb.db;
+            },
+            locks,
+            config,
+            registry,
+            prices,
+            settings,
+            queue,
+            budget,
+            purposes,
+        };
     }
     async liveSet(orgId, setId) {
         if (!UUID.test(setId))
@@ -201,11 +187,12 @@ export class EvalRunsService {
     }
     /**
      * 解析模型；不存在 / 不可用 → `eval.candidate_invalid`（供应商列表暂时失败照常抛出）。
-     * 按部署范围解析，与运行时一致；组织级模型准入若在第二段落地，须同样覆盖评测候选。
+     * Resolved for the org (its effective provider config), as the runtime does; per-org model
+     * admission must cover eval candidates the same way.
      */
-    async resolveModel(ref) {
+    async resolveModel(orgId, ref) {
         try {
-            return await this.d.registry.resolve(ref);
+            return await this.d.registry.resolve(orgId, ref);
         }
         catch (e) {
             if (e instanceof ProviderListError)
@@ -222,7 +209,7 @@ export class EvalRunsService {
      * 校验候选：版本存在（该集合的 agent）、模型可解析、参数按所用模型的声明严格通过（`paramIssues`）。
      * 所用模型 = 候选模型，否则候选版本的模型，否则 agent 当前版本的模型。返回候选版本的定义。
      */
-    async checkCandidate(agentId, c) {
+    async checkCandidate(orgId, agentId, c) {
         const versionDef = await versionDefinition(this.d.db, agentId, c.agentVersion);
         if (c.agentVersion !== undefined && versionDef === undefined) {
             throw candidateInvalid(`Agent version ${c.agentVersion} does not exist`, [
@@ -241,7 +228,7 @@ export class EvalRunsService {
         }
         if (model === undefined)
             return versionDef;
-        const { info } = await this.resolveModel(model);
+        const { info } = await this.resolveModel(orgId, model);
         if (c.modelParams !== undefined) {
             const issues = paramIssues("candidate.modelParams", info.parameters, c.modelParams);
             if (issues.length > 0)
@@ -253,7 +240,7 @@ export class EvalRunsService {
      * 各用例的回放计划与成本：只读写入时存好的列（`plan_step` / `plan_run`、`base_model`），不读快照。
      * 给了候选参数时按每个用例实际所用的模型严格校验（同一模型在一次调用里只解析一次）。
      */
-    async plan(setId, mode, c, versionDef) {
+    async plan(orgId, setId, mode, c, versionDef) {
         const table = await this.d.prices.table();
         const versionOnly = c.agentVersion !== undefined && c.model === undefined;
         const rows = await this.d.db
@@ -291,7 +278,7 @@ export class EvalRunsService {
                 const key = priceKey(model.provider, model.model);
                 if (!infos.has(key)) {
                     try {
-                        infos.set(key, (await this.d.registry.resolve(model)).info);
+                        infos.set(key, (await this.d.registry.resolve(orgId, model)).info);
                     }
                     catch (e) {
                         if (e instanceof ProviderListError)
@@ -330,7 +317,7 @@ export class EvalRunsService {
     async judgePricing(orgId, rubric, judge) {
         if (!judge)
             return null;
-        const configured = this.d.config().evals.judgeMaxOutputTokens;
+        const configured = this.d.config.get().evals.judgeMaxOutputTokens;
         let target;
         try {
             target = await this.d.purposes.resolve(orgId, "eval");
@@ -343,7 +330,7 @@ export class EvalRunsService {
         }
         let maxOutputTokens = configured;
         try {
-            const { info } = await this.d.registry.resolve(target.model);
+            const { info } = await this.d.registry.resolve(orgId, target.model);
             maxOutputTokens = Math.min(configured, info.maxOutputTokens);
         }
         catch (e) {
@@ -394,13 +381,13 @@ export class EvalRunsService {
      * 集合的 agent 已删除 → `agent.not_found`（删除 agent 会取消它的运行；之后再估算 / 启动只会建出全部跳过的运行）。
      * 在事务里调用时 FOR SHARE，与删除 agent 互斥。
      */
-    async assertAgentLive(db, agentId) {
-        let q = db
+    async assertAgentLive(agentId, forShare = false) {
+        let q = this.d.db
             .selectFrom("agents")
             .select("id")
             .where("id", "=", agentId)
             .where("deleted_at", "is", null);
-        if (db !== this.d.db)
+        if (forShare)
             q = q.forShare();
         if (!(await q.executeTakeFirst())) {
             throw new ApiError("agent.not_found", "The agent of this eval set was deleted");
@@ -408,16 +395,16 @@ export class EvalRunsService {
     }
     async estimate(orgId, setId, input) {
         const set = await this.liveSet(orgId, setId);
-        await this.assertAgentLive(this.d.db, set.agent_id);
+        await this.assertAgentLive(set.agent_id);
         const caps = this.tokenCaps(input.tokenCap);
-        const versionDef = await this.checkCandidate(set.agent_id, input.candidate);
-        const plans = await this.plan(setId, input.mode, input.candidate, versionDef);
+        const versionDef = await this.checkCandidate(orgId, set.agent_id, input.candidate);
+        const plans = await this.plan(orgId, setId, input.mode, input.candidate, versionDef);
         const judge = await this.judgePricing(orgId, set.rubric, input.judge);
         return { estimate: await this.summarize(plans, judge), ...caps };
     }
     /** token 上限：给了就校验 [1, `evals.maxTokenCap`]，缺省 `evals.defaultTokenCap`（D5）。 */
     tokenCaps(tokenCap) {
-        const { defaultTokenCap, maxTokenCap } = this.d.config().evals;
+        const { defaultTokenCap, maxTokenCap } = this.d.config.get().evals;
         const effectiveTokenCap = tokenCap ?? defaultTokenCap;
         if (!Number.isInteger(effectiveTokenCap) ||
             effectiveTokenCap < 1 ||
@@ -431,15 +418,15 @@ export class EvalRunsService {
      * 没有可回放的 → `eval.nothing_to_replay`。事务内建运行行、预建 pending 结果，提交后每个用例入队一个任务；
      * 入队失败 → 运行标 failed、结果 skipped，错误照常抛出。
      */
-    async start(orgId, actor, setId, input, actorTokenId) {
+    async start(orgId, actor, setId, input, actorTokenId, auditDetail) {
         const set = await this.liveSet(orgId, setId);
-        await this.assertAgentLive(this.d.db, set.agent_id);
+        await this.assertAgentLive(set.agent_id);
         const tokenCap = this.tokenCaps(input.tokenCap).effectiveTokenCap;
-        const versionDef = await this.checkCandidate(set.agent_id, input.candidate);
+        const versionDef = await this.checkCandidate(orgId, set.agent_id, input.candidate);
         if (input.judge)
             await this.d.purposes.resolve(orgId, "eval");
         const judge = await this.judgePricing(orgId, set.rubric, input.judge);
-        const planned = await this.plan(setId, input.mode, input.candidate, versionDef);
+        const planned = await this.plan(orgId, setId, input.mode, input.candidate, versionDef);
         if (planned.length === 0) {
             throw new ApiError("eval.nothing_to_replay", "The eval set has nothing to replay");
         }
@@ -448,97 +435,110 @@ export class EvalRunsService {
         if (firstProblem) {
             throw candidateInvalid(firstProblem.message, firstProblem.details ?? []);
         }
-        const { runId, plans } = await this.d.db.transaction().execute(async (trx) => {
-            await lockOrgAndAuthorize(trx, orgId, actor, "evals.manage");
-            // 与删除用例（锁集合行 FOR UPDATE）互斥：之后读到的用例在提交前不会被删
-            const locked = await trx
-                .selectFrom("eval_sets")
-                .select("id")
-                .where("id", "=", setId)
-                .where("org_id", "=", orgId)
-                .where("deleted_at", "is", null)
-                .forShare()
-                .executeTakeFirst();
-            if (!locked)
-                throw setNotFound();
-            await this.assertAgentLive(trx, set.agent_id);
-            const alive = new Set((await trx
-                .selectFrom("eval_cases")
-                .select("id")
-                .where("set_id", "=", setId)
-                .where("id", "in", planned.map((p) => p.caseId))
-                .execute()).map((r) => r.id));
-            const plans = planned.filter((p) => alive.has(p.caseId));
-            if (plans.length === 0) {
-                throw new ApiError("eval.nothing_to_replay", "The eval set has nothing to replay");
-            }
-            const estimate = await this.summarize(plans, judge);
-            const run = await trx
-                .insertInto("eval_runs")
-                .values({
-                org_id: orgId,
-                set_id: setId,
-                mode: input.mode,
-                candidate: JSON.stringify(input.candidate),
-                judge: input.judge,
-                token_cap: String(tokenCap),
-                cases_total: plans.length,
-                estimate: JSON.stringify(estimate),
-                created_by: actor,
-            })
-                .returning("id")
-                .executeTakeFirstOrThrow();
-            // 候选不合法的用例：结果直接记错误（计入进度，不入队）
-            const rows = plans.flatMap((p) => p.results.map((r) => ({
-                run_id: run.id,
-                case_id: p.caseId,
-                org_id: orgId,
-                step: r.step,
-                model_call_seq: r.modelCallSeq,
-                ...(p.problem !== null && {
-                    status: "error",
-                    error: JSON.stringify(p.problem),
-                }),
-            })));
-            for (let i = 0; i < rows.length; i += INSERT_CHUNK) {
-                await trx
-                    .insertInto("eval_results")
-                    .values(rows.slice(i, i + INSERT_CHUNK))
-                    .execute();
-            }
-            await audit(trx, {
-                actorAccountId: actor,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "eval.run_started",
-                target: run.id,
-                detail: { setId, mode: input.mode, judge: input.judge, tokenCap, cases: plans.length },
-            });
-            await recountCases(trx, run.id);
-            return { runId: run.id, plans: plans.filter((p) => p.problem === null) };
-        });
+        const { runId, plans } = await this.startIn(orgId, actor, setId, set.agent_id, input, tokenCap, planned, judge, actorTokenId, auditDetail);
         try {
             await this.d.queue.enqueue(plans.map((p) => ({ runId, caseId: p.caseId, orgId })));
         }
         catch (e) {
-            await this.d.db.transaction().execute(async (trx) => {
-                await trx
-                    .updateTable("eval_runs")
-                    .set({ status: "failed", finished_at: sql `now()` })
-                    .where("id", "=", runId)
-                    .execute();
-                await trx
-                    .updateTable("eval_results")
-                    .set({ status: "skipped", updated_at: sql `now()` })
-                    .where("run_id", "=", runId)
-                    .where("status", "=", "pending")
-                    .execute();
-                await recountCases(trx, runId);
-            });
+            await this.failStartIn(runId);
             throw e;
         }
         return this.get(orgId, runId);
     }
+    /** The run row and its pending results, in a transaction of their own (enqueued after the commit). */
+    async startIn(orgId, actor, setId, agentId, input, tokenCap, planned, judge, actorTokenId, auditDetail) {
+        const db = this.d.db;
+        await this.d.orgLock.lockAndAuthorize(orgId, actor, "evals.manage");
+        // 与删除用例（锁集合行 FOR UPDATE）互斥：之后读到的用例在提交前不会被删
+        const locked = await db
+            .selectFrom("eval_sets")
+            .select("id")
+            .where("id", "=", setId)
+            .where("org_id", "=", orgId)
+            .where("deleted_at", "is", null)
+            .forShare()
+            .executeTakeFirst();
+        if (!locked)
+            throw setNotFound();
+        await this.assertAgentLive(agentId, true);
+        const alive = new Set((await db
+            .selectFrom("eval_cases")
+            .select("id")
+            .where("set_id", "=", setId)
+            .where("id", "in", planned.map((p) => p.caseId))
+            .execute()).map((r) => r.id));
+        const plans = planned.filter((p) => alive.has(p.caseId));
+        if (plans.length === 0) {
+            throw new ApiError("eval.nothing_to_replay", "The eval set has nothing to replay");
+        }
+        const estimate = await this.summarize(plans, judge);
+        const run = await db
+            .insertInto("eval_runs")
+            .values({
+            org_id: orgId,
+            set_id: setId,
+            mode: input.mode,
+            candidate: JSON.stringify(input.candidate),
+            judge: input.judge,
+            token_cap: String(tokenCap),
+            cases_total: plans.length,
+            estimate: JSON.stringify(estimate),
+            created_by: actor,
+        })
+            .returning("id")
+            .executeTakeFirstOrThrow();
+        // 候选不合法的用例：结果直接记错误（计入进度，不入队）
+        const rows = plans.flatMap((p) => p.results.map((r) => ({
+            run_id: run.id,
+            case_id: p.caseId,
+            org_id: orgId,
+            step: r.step,
+            model_call_seq: r.modelCallSeq,
+            ...(p.problem !== null && {
+                status: "error",
+                error: JSON.stringify(p.problem),
+            }),
+        })));
+        for (let i = 0; i < rows.length; i += INSERT_CHUNK) {
+            await db
+                .insertInto("eval_results")
+                .values(rows.slice(i, i + INSERT_CHUNK))
+                .execute();
+        }
+        await audit(db, {
+            actorAccountId: actor,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "eval.run_started",
+            target: run.id,
+            detail: {
+                setId,
+                mode: input.mode,
+                judge: input.judge,
+                tokenCap,
+                cases: plans.length,
+                ...auditDetail,
+            },
+        });
+        await this.d.budget.recountCases(run.id);
+        return { runId: run.id, plans: plans.filter((p) => p.problem === null) };
+    }
+    /** The enqueue failed: the run is `failed`, its pending results `skipped`. */
+    async failStartIn(runId) {
+        const db = this.d.db;
+        await db
+            .updateTable("eval_runs")
+            .set({ status: "failed", finished_at: sql `now()` })
+            .where("id", "=", runId)
+            .execute();
+        await db
+            .updateTable("eval_results")
+            .set({ status: "skipped", updated_at: sql `now()` })
+            .where("run_id", "=", runId)
+            .where("status", "=", "pending")
+            .execute();
+        await this.d.budget.recountCases(runId);
+    }
     /** 各运行的汇总（只算已结束的）。 */
     async summaries(rows) {
         const finished = rows
@@ -620,7 +620,7 @@ export class EvalRunsService {
         if (!r)
             throw runNotFound();
         const sums = await this.summaries([r]);
-        return EvalRunsService.toView(r, sums.get(r.id) ?? null);
+        return EvalRunsService_1.toView(r, sums.get(r.id) ?? null);
     }
     async listForSet(orgId, setId) {
         await this.liveSet(orgId, setId);
@@ -633,31 +633,29 @@ export class EvalRunsService {
             .orderBy("id", "desc")
             .execute();
         const sums = await this.summaries(rows);
-        return rows.map((r) => EvalRunsService.toView(r, sums.get(r.id) ?? null));
+        return rows.map((r) => EvalRunsService_1.toView(r, sums.get(r.id) ?? null));
     }
     /**
      * 查看结果的审计 `eval.results_viewed`（结果里有回放出来的对话内容）：每位查看者每次运行每小时一条——Redis
      * `SET NX EX` 去重（多副本共享），轻量轮询因此不会刷审计。Redis 不可用时照写（宁多不漏）。
      */
-    async viewed(orgId, runId, actor, actorTokenId) {
-        if (this.d.redis) {
-            let first = true;
-            try {
-                const r = await this.d.redis.set(resultsViewedKey(runId, actor), "1", "EX", RESULTS_VIEWED_TTL_SECONDS, "NX");
-                first = r === "OK";
-            }
-            catch {
-                first = true;
-            }
-            if (!first)
-                return;
+    async viewed(orgId, runId, actor, actorTokenId, auditDetail) {
+        let first = true;
+        try {
+            first = await this.d.locks.lease(resultsViewedKey(runId, actor), "1", RESULTS_VIEWED_TTL_SECONDS * 1000);
+        }
+        catch {
+            first = true;
         }
+        if (!first)
+            return;
         await audit(this.d.db, {
             actorAccountId: actor,
             ...(actorTokenId !== undefined && { actorTokenId }),
             orgId,
             action: "eval.results_viewed",
             target: runId,
+            ...(auditDetail !== undefined && { detail: auditDetail }),
         });
     }
     /** 结果分页的公共部分：按 id 升序，`after` 为上一页最后一条的 id；`updatedSince` 只取之后有变化的。 */
@@ -683,11 +681,11 @@ export class EvalRunsService {
         return query;
     }
     /** 结果分页（完整行）：按 id 升序，`after` 为上一页最后一条的 id。写查看审计（去重见 {@link viewed}）。 */
-    async results(orgId, actor, runId, q, actorTokenId) {
+    async results(orgId, actor, runId, q, actorTokenId, auditDetail) {
         await this.get(orgId, runId);
         const rows = await this.resultsQuery(orgId, runId, q).selectAll().execute();
         const page = rows.slice(0, q.limit);
-        await this.viewed(orgId, runId, actor, actorTokenId);
+        await this.viewed(orgId, runId, actor, actorTokenId, auditDetail);
         return {
             results: page.map(resultView),
             next: rows.length > q.limit ? (page.at(-1)?.id ?? null) : null,
@@ -697,13 +695,13 @@ export class EvalRunsService {
      * 结果分页（轻量，结果表与轮询用）：不含内容块。`asOf` 作为下一次轮询的 `updatedSince`（已留余量，
      * 见 {@link RESULTS_ASOF_OVERLAP_MS}；重复的行由调用方按 id 合并）。
      */
-    async resultsLight(orgId, actor, runId, q, actorTokenId) {
+    async resultsLight(orgId, actor, runId, q, actorTokenId, auditDetail) {
         await this.get(orgId, runId);
         const now = await sql `SELECT now() AS now`.execute(this.d.db);
         const asOf = new Date(new Date(now.rows[0]?.now ?? Date.now()).getTime() - RESULTS_ASOF_OVERLAP_MS);
         const rows = await this.resultsQuery(orgId, runId, q).select(LIGHT_COLUMNS).execute();
         const page = rows.slice(0, q.limit);
-        await this.viewed(orgId, runId, actor, actorTokenId);
+        await this.viewed(orgId, runId, actor, actorTokenId, auditDetail);
         return {
             results: page.map((r) => ({
                 id: r.id,
@@ -725,7 +723,7 @@ export class EvalRunsService {
         };
     }
     /** 一条结果的完整行（查看器按需读取）；不在该运行 / 本组织 → `eval.result_not_found`。写查看审计（去重）。 */
-    async result(orgId, actor, runId, resultId, actorTokenId) {
+    async result(orgId, actor, runId, resultId, actorTokenId, auditDetail) {
         await this.get(orgId, runId);
         if (!UUID.test(resultId))
             throw resultNotFound();
@@ -738,99 +736,127 @@ export class EvalRunsService {
             .executeTakeFirst();
         if (!row)
             throw resultNotFound();
-        await this.viewed(orgId, runId, actor, actorTokenId);
+        await this.viewed(orgId, runId, actor, actorTokenId, auditDetail);
         return resultView(row);
     }
     /**
      * 取消：queued / running → cancelled，尚未开始的结果立即 skipped；在途请求做完照常写入（C7 在途可超出），
      * 之后的请求不再发。已结束 → `eval.run_finished`。
      */
-    async cancel(orgId, actor, runId, actorTokenId) {
+    async cancel(orgId, actor, runId, actorTokenId, auditDetail) {
         if (!UUID.test(runId))
             throw runNotFound();
         await this.get(orgId, runId);
-        await this.d.db.transaction().execute(async (trx) => {
-            await lockOrgAndAuthorize(trx, orgId, actor, "evals.manage");
-            const r = await trx
-                .updateTable("eval_runs")
-                .set({ status: "cancelled", finished_at: sql `now()` })
-                .where("id", "=", runId)
-                .where("org_id", "=", orgId)
-                .where("status", "in", [...ACTIVE_EVAL_STATUSES])
-                .executeTakeFirst();
-            if (Number(r.numUpdatedRows) === 0) {
-                throw new ApiError("eval.run_finished", "The eval run has already finished");
-            }
-            await trx
-                .updateTable("eval_results")
-                .set({ status: "skipped", updated_at: sql `now()` })
-                .where("run_id", "=", runId)
-                .where("status", "=", "pending")
-                .execute();
-            await skipPendingJudges(trx, runId);
-            // 尚未开始的用例此刻已全部结束：进度立即反映（在途的用例做完后由 worker 再重算）
-            await recountCases(trx, runId);
-            await audit(trx, {
-                actorAccountId: actor,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "eval.run_cancelled",
-                target: runId,
-            });
-        });
+        await this.cancelIn(orgId, actor, runId, actorTokenId, auditDetail);
         return this.get(orgId, runId);
     }
     /**
      * 人工标注（D3）：标通过 / 不通过（附可选备注），`label: null` 清除标注与备注。评测集已删除、结果不属于本组织 →
      * `eval.result_not_found`。事务内锁组织并复核 `evals.manage`，写审计 `eval.result_labeled`（不含备注全文）。
      */
-    async label(orgId, actor, resultId, input, actorTokenId) {
+    async label(orgId, actor, resultId, input, actorTokenId, auditDetail) {
         if (!UUID.test(resultId))
             throw resultNotFound();
-        const row = await this.d.db.transaction().execute(async (trx) => {
-            await lockOrgAndAuthorize(trx, orgId, actor, "evals.manage");
-            // 先锁住这条结果、读出原标注（写进审计）
-            const before = await trx
-                .selectFrom("eval_results")
-                .select("label")
-                .where("id", "=", resultId)
-                .where("org_id", "=", orgId)
-                .forUpdate()
-                .executeTakeFirst();
-            if (!before)
-                throw resultNotFound();
-            const cleared = input.label === null;
-            const r = await trx
-                .updateTable("eval_results")
-                .set({
+        const row = await this.labelIn(orgId, actor, resultId, input, actorTokenId, auditDetail);
+        return resultView(row);
+    }
+    async cancelIn(orgId, actor, runId, actorTokenId, auditDetail) {
+        await this.d.orgLock.lockAndAuthorize(orgId, actor, "evals.manage");
+        const r = await this.d.db
+            .updateTable("eval_runs")
+            .set({ status: "cancelled", finished_at: sql `now()` })
+            .where("id", "=", runId)
+            .where("org_id", "=", orgId)
+            .where("status", "in", [...ACTIVE_EVAL_STATUSES])
+            .executeTakeFirst();
+        if (Number(r.numUpdatedRows) === 0) {
+            throw new ApiError("eval.run_finished", "The eval run has already finished");
+        }
+        // 尚未开始的用例此刻已全部结束：进度立即反映（在途的用例做完后由 worker 再重算）
+        await this.d.budget.skipRun(runId);
+        await audit(this.d.db, {
+            actorAccountId: actor,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "eval.run_cancelled",
+            target: runId,
+            ...(auditDetail !== undefined && { detail: auditDetail }),
+        });
+    }
+    async labelIn(orgId, actor, resultId, input, actorTokenId, auditDetail) {
+        await this.d.orgLock.lockAndAuthorize(orgId, actor, "evals.manage");
+        // 先锁住这条结果、读出原标注（写进审计）
+        const before = await this.d.db
+            .selectFrom("eval_results")
+            .select("label")
+            .where("id", "=", resultId)
+            .where("org_id", "=", orgId)
+            .forUpdate()
+            .executeTakeFirst();
+        if (!before)
+            throw resultNotFound();
+        const cleared = input.label === null;
+        const r = await this.d.db
+            .updateTable("eval_results")
+            .set({
+            label: input.label,
+            label_note: cleared ? null : (input.note ?? null),
+            labeled_by: cleared ? null : actor,
+            labeled_at: cleared ? null : sql `now()`,
+            updated_at: sql `now()`,
+        })
+            .where("id", "=", resultId)
+            .where("org_id", "=", orgId)
+            .where((eb) => eb.exists(eb
+            .selectFrom("eval_runs as er")
+            .innerJoin("eval_sets as es", "es.id", "er.set_id")
+            .select("er.id")
+            .whereRef("er.id", "=", "eval_results.run_id")
+            .where("es.deleted_at", "is", null)))
+            .returningAll()
+            .executeTakeFirst();
+        if (!r)
+            throw resultNotFound();
+        await audit(this.d.db, {
+            actorAccountId: actor,
+            ...(actorTokenId !== undefined && { actorTokenId }),
+            orgId,
+            action: "eval.result_labeled",
+            target: resultId,
+            detail: {
+                runId: r.run_id,
                 label: input.label,
-                label_note: cleared ? null : (input.note ?? null),
-                labeled_by: cleared ? null : actor,
-                labeled_at: cleared ? null : sql `now()`,
-                updated_at: sql `now()`,
-            })
-                .where("id", "=", resultId)
-                .where("org_id", "=", orgId)
-                .where((eb) => eb.exists(eb
-                .selectFrom("eval_runs as er")
-                .innerJoin("eval_sets as es", "es.id", "er.set_id")
-                .select("er.id")
-                .whereRef("er.id", "=", "eval_results.run_id")
-                .where("es.deleted_at", "is", null)))
-                .returningAll()
-                .executeTakeFirst();
-            if (!r)
-                throw resultNotFound();
-            await audit(trx, {
-                actorAccountId: actor,
-                ...(actorTokenId !== undefined && { actorTokenId }),
-                orgId,
-                action: "eval.result_labeled",
-                target: resultId,
-                detail: { runId: r.run_id, label: input.label, previousLabel: before.label },
-            });
-            return r;
+                previousLabel: before.label,
+                ...auditDetail,
+            },
         });
-        return resultView(row);
+        return r;
     }
-}
+};
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EvalRunsService.prototype, "startIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EvalRunsService.prototype, "failStartIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EvalRunsService.prototype, "cancelIn", null);
+__decorate([
+    Transactional({ propagation: "requires_new" })
+], EvalRunsService.prototype, "labelIn", null);
+EvalRunsService = EvalRunsService_1 = __decorate([
+    Injectable(),
+    __param(0, Inject(KernelDb)),
+    __param(1, Inject(OrgLock)),
+    __param(2, Inject(LockService)),
+    __param(3, Inject(KernelConfigService)),
+    __param(4, Inject(ProviderRegistry)),
+    __param(5, Inject(PricesService)),
+    __param(6, Inject(SettingsService)),
+    __param(7, Inject(EvalJobs)),
+    __param(8, Inject(EvalBudget)),
+    __param(9, Inject(ModelPurposesService)),
+    __param(10, Inject(TransactionHost))
+], EvalRunsService);
+export { EvalRunsService };