@capybara-hq/kernel 0.1.0-rc.5 → 0.1.0-rc.7

package/dist/evals/run-replay.js

@@ -20,6 +20,7 @@ import { TransactionHost } from "../infra/database/transaction-host.js";
 import { Transactional } from "../infra/database/transactional.decorator.js";
 import { estimateTokens } from "../runtime/context/tokens.js";
 import { RunError } from "../runtime/model-call.js";
+import { runContextIdemKey } from "../runtime/run-context.service.js";
 import { recordedSkillForks } from "../runtime/subagents/skill-fork.js";
 import { skillsCatalogIdemKey } from "../skills/catalog.js";
 import { ACTIVE_EVAL_STATUSES, addUsage, consumeTokens, TOO_MANY_ERRORS, usageTokens, } from "./budget.js";
@@ -121,6 +122,16 @@ let EvalReplaySeeder = class EvalReplaySeeder {
                     },
                 ]
                 : []),
+            ...(p.runContext
+                ? [
+                    {
+                        type: "run_context",
+                        runId,
+                        idemKey: runContextIdemKey(runId),
+                        payload: p.runContext.payload,
+                    },
+                ]
+                : []),
         ]);
         if (onSeeded && !(await onSeeded(conversationId)))
             throw new ReplayClaimLost();
@@ -320,6 +331,7 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
     }
     const trigger = replayTrigger(start.payload, seeds, consumed);
     const catalog = s.events.find((e) => e.runId === s.runId && e.type === "skills_catalog" && e.seq > R);
+    const runContext = s.events.find((e) => e.runId === s.runId && e.type === "run_context" && e.seq > R);
     // a sub-agent's case (spec §15.3) runs the effective definition frozen in its subagent_started
     // (the request renders that event's preamble and instructions; its tools come from it too), with
     // only the candidate's model and params, and the logged step limit
@@ -351,6 +363,7 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
         agentVersion: candidate.agentVersion,
         model: agent.model,
         catalog,
+        runContext,
     }, d.onSeeded);
     await d.hooks?.afterRunSeeded?.(evalRunId, conversationId);
     // 停止：取消 / 越限 / 熔断 / 失去认领 / 截止时间 → 中止 loop（进行中的请求立即停下，loop 以 aborted 返回）
@@ -435,8 +448,10 @@ export async function replayRun(d, s, candidate, evalRunId, signal) {
         return metered;
     };
     const registry = {
-        resolve: async (ref) => {
-            const r = await d.registry.resolve(ref);
+        // the case's org (its effective provider config), whatever the replayed step passes
+        // (and its disabled lists: a candidate disabled there is refused, spec B §5.3)
+        resolve: async (_orgId, ref, opts) => {
+            const r = await d.registry.resolve(s.orgId, ref, opts);
             return { ...r, provider: meter(r.provider) };
         },
     };

package/dist/evals/runs.controller.d.ts

@@ -1,62 +1,8 @@
-import { z } from "zod";
+import type { z } from "zod";
 import { type Principal } from "../identity/principal.js";
 import { type OrgContext } from "../orgs/org.guard.js";
+import { EvalRunEstimateBody as EstimateBody, EvalLabelBody as LabelBody, EvalRunResultsQuery as ResultsQuery, EvalRunStartBody as StartBody } from "./evals.schemas.js";
 import { type EvalEstimate, type EvalResultLight, type EvalResultView, EvalRunsService, type EvalRunView, type EvalTokenCaps } from "./runs.service.js";
-/** `tokenCap` 只校验类型，范围由服务判定（`eval.token_cap_invalid`）。 */
-declare const EstimateBody: z.ZodObject<{
-    mode: z.ZodEnum<{
-        run: "run";
-        step: "step";
-    }>;
-    candidate: z.ZodObject<{
-        agentVersion: z.ZodOptional<z.ZodNumber>;
-        model: z.ZodOptional<z.ZodObject<{
-            provider: z.ZodString;
-            model: z.ZodString;
-        }, z.core.$strict>>;
-        modelParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
-        instructions: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    judge: z.ZodDefault<z.ZodBoolean>;
-    tokenCap: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-declare const StartBody: z.ZodObject<{
-    mode: z.ZodEnum<{
-        run: "run";
-        step: "step";
-    }>;
-    candidate: z.ZodObject<{
-        agentVersion: z.ZodOptional<z.ZodNumber>;
-        model: z.ZodOptional<z.ZodObject<{
-            provider: z.ZodString;
-            model: z.ZodString;
-        }, z.core.$strict>>;
-        modelParams: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
-        instructions: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>;
-    judge: z.ZodDefault<z.ZodBoolean>;
-    tokenCap: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
-/**
- * `view=light`：不含内容块（结果表与轮询用，响应带 `asOf`）；缺省 `full`。`updatedSince`（ISO 时间）只取之后有变化的，
- * 轮询时传上一次的 `asOf`。
- */
-declare const ResultsQuery: z.ZodObject<{
-    after: z.ZodOptional<z.ZodString>;
-    limit: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
-    view: z.ZodDefault<z.ZodEnum<{
-        full: "full";
-        light: "light";
-    }>>;
-    updatedSince: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-declare const LabelBody: z.ZodObject<{
-    label: z.ZodNullable<z.ZodEnum<{
-        fail: "fail";
-        pass: "pass";
-    }>>;
-    note: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
 /**
  * 评测运行（`/api/v1/orgs/:orgId/eval-sets/:setId/runs`、`/api/v1/orgs/:orgId/eval-runs/:runId[/results[/:resultId]]`）与
  * 结果的人工标注（`/api/v1/orgs/:orgId/eval-results/:resultId/label`）：
@@ -97,4 +43,3 @@ export declare class EvalRunsController {
         result: EvalResultView;
     }>;
 }
-export {};

package/dist/evals/runs.controller.js

@@ -8,53 +8,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Controller, Get, HttpCode, Inject, Param, Post, Put } from "@nestjs/common";
-import { z } from "zod";
-import { ModelRef } from "../agents/definition.js";
 import { CurrentPrincipal, patTokenId, requireUser, } from "../identity/principal.js";
 import { createZodDto } from "../infra/validation/create-zod-dto.js";
 import { ZBody, ZQuery } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
+import { EvalRunEstimateBody as EstimateBody, EvalLabelBody as LabelBody, EvalRunResultsQuery as ResultsQuery, EvalRunStartBody as StartBody, } from "./evals.schemas.js";
 import { EvalRunsService, } from "./runs.service.js";
-const Candidate = z
-    .object({
-    agentVersion: z.number().int().min(1).optional(),
-    model: ModelRef.strict().optional(),
-    modelParams: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).optional(),
-    instructions: z.string().max(100_000).optional(),
-})
-    .strict();
-/** `tokenCap` 只校验类型，范围由服务判定（`eval.token_cap_invalid`）。 */
-const EstimateBody = z
-    .object({
-    mode: z.enum(["step", "run"]),
-    candidate: Candidate,
-    judge: z.boolean().default(false),
-    tokenCap: z.number().int().optional(),
-})
-    .strict();
-const StartBody = EstimateBody;
-/**
- * `view=light`：不含内容块（结果表与轮询用，响应带 `asOf`）；缺省 `full`。`updatedSince`（ISO 时间）只取之后有变化的，
- * 轮询时传上一次的 `asOf`。
- */
-const ResultsQuery = z
-    .object({
-    after: z.string().max(100).optional(),
-    limit: z.coerce.number().int().min(1).max(200).default(50),
-    view: z.enum(["full", "light"]).default("full"),
-    updatedSince: z
-        .string()
-        .max(64)
-        .refine((v) => !Number.isNaN(Date.parse(v)), { message: "must be an ISO timestamp" })
-        .optional(),
-})
-    .strict();
-const LabelBody = z
-    .object({
-    label: z.enum(["pass", "fail"]).nullable(),
-    note: z.string().max(2000).optional(),
-})
-    .strict();
 /** 去掉 zod 输出里值为 undefined 的键（exactOptionalPropertyTypes）。 */
 function candidateOf(c) {
     return {

package/dist/evals/runs.service.d.ts

@@ -149,7 +149,8 @@ export declare class EvalRunsService {
     private liveSet;
     /**
      * 解析模型；不存在 / 不可用 → `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.
      */
     private resolveModel;
     /**
@@ -194,7 +195,7 @@ export declare class EvalRunsService {
         candidate: EvalCandidate;
         judge: boolean;
         tokenCap?: number;
-    }, actorTokenId?: string): Promise<EvalRunView>;
+    }, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<EvalRunView>;
     /** The run row and its pending results, in a transaction of their own (enqueued after the commit). */
     private startIn;
     /** The enqueue failed: the run is `failed`, its pending results `skipped`. */
@@ -216,7 +217,7 @@ export declare class EvalRunsService {
         after?: string;
         limit: number;
         updatedSince?: string;
-    }, actorTokenId?: string): Promise<{
+    }, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<{
         results: EvalResultView[];
         next: string | null;
     }>;
@@ -228,18 +229,18 @@ export declare class EvalRunsService {
         after?: string;
         limit: number;
         updatedSince?: string;
-    }, actorTokenId?: string): Promise<{
+    }, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<{
         results: EvalResultLight[];
         next: string | null;
         asOf: string;
     }>;
     /** 一条结果的完整行（查看器按需读取）；不在该运行 / 本组织 → `eval.result_not_found`。写查看审计（去重）。 */
-    result(orgId: string, actor: string, runId: string, resultId: string, actorTokenId?: string): Promise<EvalResultView>;
+    result(orgId: string, actor: string, runId: string, resultId: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<EvalResultView>;
     /**
      * 取消：queued / running → cancelled，尚未开始的结果立即 skipped；在途请求做完照常写入（C7 在途可超出），
      * 之后的请求不再发。已结束 → `eval.run_finished`。
      */
-    cancel(orgId: string, actor: string, runId: string, actorTokenId?: string): Promise<EvalRunView>;
+    cancel(orgId: string, actor: string, runId: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<EvalRunView>;
     /**
      * 人工标注（D3）：标通过 / 不通过（附可选备注），`label: null` 清除标注与备注。评测集已删除、结果不属于本组织 →
      * `eval.result_not_found`。事务内锁组织并复核 `evals.manage`，写审计 `eval.result_labeled`（不含备注全文）。
@@ -247,7 +248,7 @@ export declare class EvalRunsService {
     label(orgId: string, actor: string, resultId: string, input: {
         label: "pass" | "fail" | null;
         note?: string;
-    }, actorTokenId?: string): Promise<EvalResultView>;
+    }, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<EvalResultView>;
     private cancelIn;
     private labelIn;
 }

package/dist/evals/runs.service.js

@@ -187,11 +187,12 @@ let EvalRunsService = EvalRunsService_1 = 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)
@@ -208,7 +209,7 @@ let EvalRunsService = EvalRunsService_1 = 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`, [
@@ -227,7 +228,7 @@ let EvalRunsService = EvalRunsService_1 = 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)
@@ -239,7 +240,7 @@ let EvalRunsService = EvalRunsService_1 = 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
@@ -277,7 +278,7 @@ let EvalRunsService = EvalRunsService_1 = 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)
@@ -329,7 +330,7 @@ let EvalRunsService = EvalRunsService_1 = 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) {
@@ -396,8 +397,8 @@ let EvalRunsService = EvalRunsService_1 = class EvalRunsService {
         const set = await this.liveSet(orgId, setId);
         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 };
     }
@@ -417,15 +418,15 @@ let EvalRunsService = EvalRunsService_1 = 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(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");
         }
@@ -434,7 +435,7 @@ let EvalRunsService = EvalRunsService_1 = class EvalRunsService {
         if (firstProblem) {
             throw candidateInvalid(firstProblem.message, firstProblem.details ?? []);
         }
-        const { runId, plans } = await this.startIn(orgId, actor, setId, set.agent_id, input, tokenCap, planned, judge, actorTokenId);
+        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 })));
         }
@@ -445,7 +446,7 @@ let EvalRunsService = EvalRunsService_1 = class EvalRunsService {
         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) {
+    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）互斥：之后读到的用例在提交前不会被删
@@ -510,7 +511,14 @@ let EvalRunsService = EvalRunsService_1 = class EvalRunsService {
             orgId,
             action: "eval.run_started",
             target: run.id,
-            detail: { setId, mode: input.mode, judge: input.judge, tokenCap, cases: plans.length },
+            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) };
@@ -631,7 +639,7 @@ let EvalRunsService = EvalRunsService_1 = class EvalRunsService {
      * 查看结果的审计 `eval.results_viewed`（结果里有回放出来的对话内容）：每位查看者每次运行每小时一条——Redis
      * `SET NX EX` 去重（多副本共享），轻量轮询因此不会刷审计。Redis 不可用时照写（宁多不漏）。
      */
-    async viewed(orgId, runId, actor, actorTokenId) {
+    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);
@@ -647,6 +655,7 @@ let EvalRunsService = EvalRunsService_1 = class EvalRunsService {
             orgId,
             action: "eval.results_viewed",
             target: runId,
+            ...(auditDetail !== undefined && { detail: auditDetail }),
         });
     }
     /** 结果分页的公共部分：按 id 升序，`after` 为上一页最后一条的 id；`updatedSince` 只取之后有变化的。 */
@@ -672,11 +681,11 @@ let EvalRunsService = EvalRunsService_1 = 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,
@@ -686,13 +695,13 @@ let EvalRunsService = EvalRunsService_1 = 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,
@@ -714,7 +723,7 @@ let EvalRunsService = EvalRunsService_1 = 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();
@@ -727,31 +736,31 @@ let EvalRunsService = EvalRunsService_1 = 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.cancelIn(orgId, actor, runId, actorTokenId);
+        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.labelIn(orgId, actor, resultId, input, actorTokenId);
+        const row = await this.labelIn(orgId, actor, resultId, input, actorTokenId, auditDetail);
         return resultView(row);
     }
-    async cancelIn(orgId, actor, runId, actorTokenId) {
+    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")
@@ -771,9 +780,10 @@ let EvalRunsService = EvalRunsService_1 = class EvalRunsService {
             orgId,
             action: "eval.run_cancelled",
             target: runId,
+            ...(auditDetail !== undefined && { detail: auditDetail }),
         });
     }
-    async labelIn(orgId, actor, resultId, input, actorTokenId) {
+    async labelIn(orgId, actor, resultId, input, actorTokenId, auditDetail) {
         await this.d.orgLock.lockAndAuthorize(orgId, actor, "evals.manage");
         // 先锁住这条结果、读出原标注（写进审计）
         const before = await this.d.db
@@ -813,7 +823,12 @@ let EvalRunsService = EvalRunsService_1 = class EvalRunsService {
             orgId,
             action: "eval.result_labeled",
             target: resultId,
-            detail: { runId: r.run_id, label: input.label, previousLabel: before.label },
+            detail: {
+                runId: r.run_id,
+                label: input.label,
+                previousLabel: before.label,
+                ...auditDetail,
+            },
         });
         return r;
     }

package/dist/evals/sets.controller.d.ts

@@ -1,33 +1,8 @@
-import { z } from "zod";
+import type { z } from "zod";
 import { type Principal } from "../identity/principal.js";
 import { type OrgContext } from "../orgs/org.guard.js";
+import { EvalAddCaseBody as AddCaseBody, EvalSetCreateBody as CreateBody, EvalSetPatchBody as PatchBody, EvalSampleBody as SampleBody } from "./evals.schemas.js";
 import { type EvalCaseDetail, type EvalCaseView, type EvalSetDetail, EvalSetsService, type EvalSetView } from "./sets.service.js";
-declare const CreateBody: z.ZodObject<{
-    agentId: z.ZodString;
-    name: z.ZodString;
-    description: z.ZodOptional<z.ZodString>;
-    rubric: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-declare const PatchBody: z.ZodObject<{
-    name: z.ZodOptional<z.ZodString>;
-    description: z.ZodOptional<z.ZodString>;
-    rubric: z.ZodOptional<z.ZodNullable<z.ZodString>>;
-}, z.core.$strict>;
-declare const AddCaseBody: z.ZodObject<{
-    conversationId: z.ZodString;
-    runId: z.ZodString;
-}, z.core.$strict>;
-declare const SampleBody: z.ZodObject<{
-    from: z.ZodOptional<z.ZodISODateTime>;
-    to: z.ZodOptional<z.ZodISODateTime>;
-    count: z.ZodNumber;
-    status: z.ZodOptional<z.ZodEnum<{
-        any: "any";
-        completed: "completed";
-        failed: "failed";
-    }>>;
-    minToolCalls: z.ZodOptional<z.ZodNumber>;
-}, z.core.$strict>;
 /**
  * 评测集与用例（`/api/v1/orgs/:orgId/eval-sets`）：全部 `evals.manage`（admin 起、只给人）。
  * 用例详情返回快照还原的轨迹，每次写审计 `trajectory.viewed`。
@@ -58,4 +33,3 @@ export declare class EvalSetsController {
     getCase(principal: Principal, org: OrgContext, setId: string, caseId: string): Promise<EvalCaseDetail>;
     removeCase(principal: Principal, org: OrgContext, setId: string, caseId: string): Promise<void>;
 }
-export {};

package/dist/evals/sets.controller.js

@@ -8,42 +8,12 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 import { Controller, Delete, Get, HttpCode, Inject, Param, Patch, Post } from "@nestjs/common";
-import { z } from "zod";
 import { CurrentPrincipal, patTokenId, requireUser, } from "../identity/principal.js";
 import { createZodDto } from "../infra/validation/create-zod-dto.js";
 import { ZBody } from "../infra/validation/zod-params.js";
 import { CurrentOrg, OrgAction } from "../orgs/org.guard.js";
+import { EvalAddCaseBody as AddCaseBody, EvalSetCreateBody as CreateBody, EvalSetPatchBody as PatchBody, EvalSampleBody as SampleBody, } from "./evals.schemas.js";
 import { EvalSetsService, } from "./sets.service.js";
-const NAME = z.string().trim().min(1).max(200);
-const DESCRIPTION = z.string().max(2000);
-const RUBRIC = z.string().min(1).max(20_000);
-const CreateBody = z
-    .object({
-    agentId: z.string().min(1).max(100),
-    name: NAME,
-    description: DESCRIPTION.optional(),
-    rubric: RUBRIC.optional(),
-})
-    .strict();
-const PatchBody = z
-    .object({
-    name: NAME.optional(),
-    description: DESCRIPTION.optional(),
-    rubric: RUBRIC.nullable().optional(),
-})
-    .strict();
-const AddCaseBody = z
-    .object({ conversationId: z.string().min(1).max(100), runId: z.string().min(1).max(100) })
-    .strict();
-const SampleBody = z
-    .object({
-    from: z.iso.datetime({ offset: true }).optional(),
-    to: z.iso.datetime({ offset: true }).optional(),
-    count: z.number().int().min(1).max(50),
-    status: z.enum(["completed", "failed", "any"]).optional(),
-    minToolCalls: z.number().int().min(0).max(1000).optional(),
-})
-    .strict();
 class CreateBodyDto extends createZodDto(CreateBody, "EvalSetCreateBody") {
 }
 class PatchBodyDto extends createZodDto(PatchBody, "EvalSetPatchBody") {

package/dist/evals/sets.service.d.ts

@@ -91,19 +91,19 @@ export declare class EvalSetsService {
         name: string;
         description?: string;
         rubric?: string;
-    }, actorTokenId?: string): Promise<EvalSetView>;
+    }, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<EvalSetView>;
     list(orgId: string): Promise<EvalSetView[]>;
     get(orgId: string, setId: string): Promise<EvalSetDetail>;
     update(orgId: string, actor: string, setId: string, patch: {
         name?: string;
         description?: string;
         rubric?: string | null;
-    }, actorTokenId?: string): Promise<EvalSetView>;
+    }, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<EvalSetView>;
     /**
      * 删除评测集（Ruling S1-a）：集合行软删除，留作审计存根；用例（含快照）硬删，结果随之级联删除，不留复制来的对话内容；
      * 在执行的运行取消，运行行保留（无入口）。
      */
-    remove(orgId: string, actor: string, setId: string, actorTokenId?: string): Promise<void>;
+    remove(orgId: string, actor: string, setId: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<void>;
     private createIn;
     private updateIn;
     private removeIn;
@@ -125,20 +125,20 @@ export declare class EvalSetsService {
     addCase(orgId: string, actor: string, setId: string, input: {
         conversationId: string;
         runId: string;
-    }, actorTokenId?: string): Promise<EvalCaseView>;
+    }, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<EvalCaseView>;
     /**
      * 抽样：从该 agent 的 chat 对话里随机取（`ORDER BY random()`）已终态、尚不在集合里的运行，至多
      * `min(count, 剩余容量)` 个，逐个取快照写入。快照超大（或其间被删除 / 写入时已满 / 并发加入）的计入 `skipped`。
      * 集合已满 → `eval.too_many_cases`。逐个写入，内存里一次只有一份快照。
      */
-    sample(orgId: string, actor: string, setId: string, input: SampleInput, actorTokenId?: string): Promise<{
+    sample(orgId: string, actor: string, setId: string, input: SampleInput, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<{
         added: number;
         skipped: number;
     }>;
-    removeCase(orgId: string, actor: string, setId: string, caseId: string, actorTokenId?: string): Promise<void>;
+    removeCase(orgId: string, actor: string, setId: string, caseId: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<void>;
     /**
      * 用例详情：由快照还原轨迹（原对话删除后照常可读）。快照即对话内容，每次查看写审计 `trajectory.viewed`
      * （target = 原对话 id，detail 带 `caseId` / `setId`）。
      */
-    getCase(orgId: string, actor: string, setId: string, caseId: string, actorTokenId?: string): Promise<EvalCaseDetail>;
+    getCase(orgId: string, actor: string, setId: string, caseId: string, actorTokenId?: string, auditDetail?: Record<string, unknown>): Promise<EvalCaseDetail>;
 }