@capybara-hq/kernel 0.1.0-rc.6 → 0.1.0-rc.8

package/dist/evals/evals.schemas.js

@@ -0,0 +1,107 @@
+import { z } from "zod";
+import { ModelRef } from "../agents/definition.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);
+export const EvalSetCreateBody = z
+    .object({
+    agentId: z.string().min(1).max(100),
+    name: NAME,
+    description: DESCRIPTION.optional(),
+    rubric: RUBRIC.optional(),
+})
+    .strict();
+export const EvalSetPatchBody = z
+    .object({
+    name: NAME.optional(),
+    description: DESCRIPTION.optional(),
+    rubric: RUBRIC.nullable().optional(),
+})
+    .strict();
+export const EvalAddCaseBody = z
+    .object({ conversationId: z.string().min(1).max(100), runId: z.string().min(1).max(100) })
+    .strict();
+export const EvalSampleBody = 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();
+export const EvalCandidateSchema = 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` is only type-checked here; the service judges the range (`eval.token_cap_invalid`). */
+export const EvalRunEstimateBody = z
+    .object({
+    mode: z.enum(["step", "run"]),
+    candidate: EvalCandidateSchema,
+    judge: z.boolean().default(false),
+    tokenCap: z.number().int().optional(),
+})
+    .strict();
+export const EvalRunStartBody = EvalRunEstimateBody;
+/**
+ * `view=light`: no content blocks (result tables and polling; the response carries `asOf`);
+ * default `full`. `updatedSince` (ISO time) takes only what changed after it.
+ */
+export const EvalRunResultsQuery = 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();
+export const EvalLabelBody = z
+    .object({
+    label: z.enum(["pass", "fail"]).nullable(),
+    note: z.string().max(2000).optional(),
+})
+    .strict();
+/** The path params the eval routes read (`@Param`), bounded as the operations take them. */
+const Id = z.string().min(1).max(100);
+export const EvalSetParams = z.object({ setId: Id });
+export const EvalCaseParams = z.object({ setId: Id, caseId: Id });
+export const EvalRunParams = z.object({ runId: Id });
+export const EvalResultParams = z.object({ runId: Id, resultId: Id });
+export const EvalLabelParams = z.object({ resultId: Id });
+const O = "/api/v1/orgs/:orgId";
+export const EVAL_ROUTES = [
+    { route: `POST ${O}/eval-sets`, body: EvalSetCreateBody },
+    { route: `GET ${O}/eval-sets` },
+    { route: `GET ${O}/eval-sets/:setId`, params: EvalSetParams },
+    { route: `PATCH ${O}/eval-sets/:setId`, params: EvalSetParams, body: EvalSetPatchBody },
+    { route: `DELETE ${O}/eval-sets/:setId`, params: EvalSetParams },
+    { route: `POST ${O}/eval-sets/:setId/cases`, params: EvalSetParams, body: EvalAddCaseBody },
+    {
+        route: `POST ${O}/eval-sets/:setId/cases/sample`,
+        params: EvalSetParams,
+        body: EvalSampleBody,
+    },
+    { route: `GET ${O}/eval-sets/:setId/cases/:caseId`, params: EvalCaseParams },
+    { route: `DELETE ${O}/eval-sets/:setId/cases/:caseId`, params: EvalCaseParams },
+    {
+        route: `POST ${O}/eval-sets/:setId/runs/estimate`,
+        params: EvalSetParams,
+        body: EvalRunEstimateBody,
+    },
+    { route: `POST ${O}/eval-sets/:setId/runs`, params: EvalSetParams, body: EvalRunStartBody },
+    { route: `GET ${O}/eval-sets/:setId/runs`, params: EvalSetParams },
+    { route: `GET ${O}/eval-runs/:runId`, params: EvalRunParams },
+    { route: `GET ${O}/eval-runs/:runId/results`, params: EvalRunParams, query: EvalRunResultsQuery },
+    { route: `GET ${O}/eval-runs/:runId/results/:resultId`, params: EvalResultParams },
+    { route: `POST ${O}/eval-runs/:runId/cancel`, params: EvalRunParams },
+    { route: `PUT ${O}/eval-results/:resultId/label`, params: EvalLabelParams, body: EvalLabelBody },
+];

package/dist/evals/reconstruct.js

@@ -1,5 +1,5 @@
 import { sanitizeParams, } from "@capybara-hq/plugin-sdk";
-import { AgentDefinitionSchema, normalizeStoredDefinition, } from "../agents/definition.js";
+import { AgentDefinitionSchema, builtinDisabled, canonicalDisabledTools, normalizeStoredDefinition, } from "../agents/definition.js";
 import { sameModel, selectionAt } from "../conversations/selection.js";
 import { ApiError } from "../errors.js";
 import { mediaRefs, planMedia, } from "../runtime/context/build.js";
@@ -217,18 +217,25 @@ const sameTemplate = (logged, t) => logged.source !== "plugin" ||
         (logged.platformTemplateId ?? null) === (t.platformTemplateId ?? null));
 const pinsOf = (d) => [...new Set(d.skills?.pinned ?? [])].slice(0, PINNED_SKILLS_LIMITS.count);
 /**
- * Tool refs as a sub-agent gets them without template narrowing (general and org agents).
- * `Agent` depends on the child's depth, not on the definition (agent map spec §4.1): it is kept
- * only when the logged child had it, so a child logged without it (at the depth limit, or before
- * nesting) compares equal to a candidate that offers it.
+ * A sub-agent's tools without template narrowing (general and org agents), as compared: its
+ * turned-off tools (tools default-on spec §4) and its key filter's allowlist and `deny` keys,
+ * {@link CHILD_REMOVED_TOOLS} left out. `Agent` depends on the child's depth, not on the
+ * definition (agent map spec §4.1): a `deny` of it never counts, and a turned-off `Agent` counts
+ * only when the logged child had it (`keepAgent`), so a child logged without it (at the depth
+ * limit, or before nesting) compares equal to a candidate that offers it.
  */
-const childToolsOf = (d, keepAgent) => canonicalJson(d.tools.filter((t) => t.kind !== "builtin" ||
-    (!CHILD_REMOVED_TOOLS.includes(t.name) &&
-        (keepAgent || t.name !== AGENT_TOOL))));
-const hasAgent = (d) => d.tools.some((t) => t.kind === "builtin" && t.name === AGENT_TOOL);
+const childToolsOf = (d, keepAgent) => canonicalJson({
+    disabled: canonicalDisabledTools((d.disabledTools ?? []).filter((r) => keepAgent || r.kind !== "builtin" || r.name !== AGENT_TOOL)),
+    allow: d.subagentTools?.allow ?? null,
+    deny: (d.subagentTools?.deny ?? []).filter((k) => !CHILD_REMOVED_TOOLS.includes(k) && k !== AGENT_TOOL),
+});
+/** Does the child have `Agent` by its definition (not turned off, not removed by its filter)? */
+const hasAgent = (d) => !builtinDisabled(d.disabledTools, AGENT_TOOL) &&
+    !(d.subagentTools?.deny ?? []).includes(AGENT_TOOL) &&
+    (d.subagentTools?.allow === undefined || d.subagentTools.allow.includes(AGENT_TOOL));
 /** The parent's selection a template child depends on: its tools, org skills and roster entry. */
 const parentSide = (d, started) => canonicalJson({
-    tools: d.tools,
+    disabledTools: canonicalDisabledTools(d.disabledTools ?? []),
     orgSkills: d.skills?.orgSkills ?? [],
     listed: started.template.source === "general"
         ? d.subagents?.general !== false
@@ -264,7 +271,7 @@ original) {
         (pinned !== null && canonicalJson(pinned) !== canonicalJson(pinsOf(logged))) ||
         (tools !== null && tools !== childTools(logged));
     if (sameVersion) {
-        return differs(candidate.instructions, pinsOf(candidate), canonicalJson(candidate.tools));
+        return differs(candidate.instructions, pinsOf(candidate), childTools(candidate));
     }
     switch (started.template.source) {
         case "agent":

package/dist/evals/recorded-tools.d.ts

@@ -31,7 +31,8 @@ export interface RecordedCall {
  * - a connector: the tool definition the key was recorded with (`toolSpecs`, found by the specHash of
  *   its `tool_call_started` or its `model_call` tools / catalog entry) has `connectorData`;
  * - an extension: that definition exists without `connectorData` and its name is the key's tool
- *   part, or an agent definition names exactly that tool as a `{ kind: "plugin", plugin: x, name }` ref.
+ *   part, or an rc-era agent definition names exactly that tool as a `{ kind: "plugin", plugin: x, name }`
+ *   ref.
  */
 export declare function legacyScopeOf(s: CaseSnapshot): LegacyScope;
 /**

package/dist/evals/recorded-tools.js

@@ -16,7 +16,8 @@ export const REPLAY_NO_RECORDING = "[replay] No recorded result matches this too
  * - a connector: the tool definition the key was recorded with (`toolSpecs`, found by the specHash of
  *   its `tool_call_started` or its `model_call` tools / catalog entry) has `connectorData`;
  * - an extension: that definition exists without `connectorData` and its name is the key's tool
- *   part, or an agent definition names exactly that tool as a `{ kind: "plugin", plugin: x, name }` ref.
+ *   part, or an rc-era agent definition names exactly that tool as a `{ kind: "plugin", plugin: x, name }`
+ *   ref.
  */
 export function legacyScopeOf(s) {
     const hashes = new Map();
@@ -42,10 +43,17 @@ export function legacyScopeOf(s) {
     const extensionNames = new Set();
     const connectorSlugs = new Set();
     const planted = new Set();
+    // rc-era snapshots hold definitions from before tools were on by default: an enabled `tools`
+    // list of refs (tools default-on spec §2)
     for (const def of Object.values(s.definitions)) {
-        for (const t of def.tools)
-            if (t.kind === "plugin")
+        const refs = def.tools;
+        if (!Array.isArray(refs))
+            continue;
+        for (const t of refs) {
+            if (t?.kind === "plugin" && typeof t.plugin === "string" && typeof t.name === "string") {
                 planted.add(`${t.plugin}__${t.name}`);
+            }
+        }
     }
     for (const [key, set] of hashes) {
         const i = key.indexOf("__");

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

@@ -18,7 +18,7 @@ import type { ResolvedCandidate } from "./step-replay.js";
  * {@link RecordedToolPipeline}（只回放记录的结果，不执行任何工具、沙箱、连接器或审批）。
  *
  * - 种子：原运行 `run_started` 之前的事件按原 seq 插入（`last_seq` 停在其前一位，新的 `run_started` 因此与原来同 seq），
- *   原运行开始时的 `skills_catalog` 照抄；然后写 `runs` 行与 `run_started`，`agent` 用候选定义。
+ *   原运行开始时的 `skills_catalog` 与 `run_context` 照抄；然后写 `runs` 行与 `run_started`，`agent` 用候选定义。
  * - 插话：原运行中途吸收的可吸收事件（user_message, and finished background tasks: background Bash
  *   spec §4.4），在「原吸收步骤 ≤ 当前步骤」时追加进评测对话并交给 loop（a recorded finish is
  *   appended as recorded: no task starts, polls or stops; likewise a sub-agent's delivery, agent map
@@ -114,6 +114,13 @@ export interface ReplaySeed {
     catalog: {
         payload: unknown;
     } | undefined;
+    /**
+     * The original run's `run_context` event (run context spec §8), copied as is: a candidate sees
+     * the original date, names and org, never the eval day's.
+     */
+    runContext: {
+        payload: unknown;
+    } | undefined;
 }
 /**
  * The seed of a full-run replay (C6): the `kind = 'eval'` conversation with the events before the

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 返回）

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

@@ -195,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`. */
@@ -217,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;
     }>;
@@ -229,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`（不含备注全文）。
@@ -248,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

@@ -418,7 +418,7 @@ 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;
@@ -435,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 })));
         }
@@ -446,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）互斥：之后读到的用例在提交前不会被删
@@ -511,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) };
@@ -632,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);
@@ -648,6 +655,7 @@ let EvalRunsService = EvalRunsService_1 = class EvalRunsService {
             orgId,
             action: "eval.results_viewed",
             target: runId,
+            ...(auditDetail !== undefined && { detail: auditDetail }),
         });
     }
     /** 结果分页的公共部分：按 id 升序，`after` 为上一页最后一条的 id；`updatedSince` 只取之后有变化的。 */
@@ -673,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,
@@ -687,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,
@@ -715,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();
@@ -728,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")
@@ -772,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
@@ -814,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 {};