niceeval 0.8.0 → 0.9.0

package/src/report/types.ts

@@ -299,6 +299,57 @@ export interface ScopeSummaryData {
   totalCostUSD: MetricCell;
 }
 
+// ───────────────────────── 站点组件(Hero / CopyFixPrompt / TraceWaterfall)─────────────────────────
+
+/**
+ * `HeroCard` 的数据(docs/feature/reports/library/site-components.md):站点标题区的
+ * 运行 meta——最后运行时间与快照合成来源。标题不在 data 里,它是站点声明与 Scope 的合成物,
+ * 经 `HeroCardProps.title` 传入。
+ */
+export interface HeroData {
+  /** Scope 中最新快照的开始时间;空 Scope 为 null,不编造当前时间。 */
+  latestStartedAt: string | null;
+  /** 贡献当前水位的快照数;大于 1 时 web 面标注「由 N 次运行合成」。 */
+  snapshots: number;
+}
+
+/**
+ * `CopyFixPrompt` 的数据:resolve 期算好的修复 prompt 全文与参与的失败数
+ * (docs/feature/reports/library/site-components.md)。
+ */
+export interface CopyFixPromptData {
+  /** 修复 prompt 全文;失败逐条含 eval id、主失败摘要与 attempt 下钻命令。 */
+  prompt: string;
+  /** 参与 prompt 的失败 attempt 数(verdict 为 failed / errored)。 */
+  failures: number;
+}
+
+/** `TraceWaterfall` 一行里的一个顶层 span 摘要(canonical OTel 字段归一后的形态)。 */
+export interface TraceSpanSummary {
+  name: string;
+  /** 归一后的语义角色;turn 归入 agent,未识别落 other。 */
+  kind: "agent" | "model" | "tool" | "other";
+  /** 相对该 attempt trace 起点的偏移(毫秒)。 */
+  startOffsetMs: number;
+  durationMs: number;
+  /** span status 为 error 时 true(web 面失败标记的来源)。 */
+  failed: boolean;
+}
+
+/**
+ * `TraceWaterfall` 一行 = 一次 attempt 的执行时间瀑布摘要。只画被测 agent 的原始 span
+ * (trace.json);runner 生命周期节点(`result.phases`)不进瀑布,组合视图归 attempt 详情。
+ */
+export interface TraceWaterfallRow {
+  experimentId: string;
+  evalId: string;
+  locator: AttemptLocator;
+  /** trace.json 缺失或为空时 null;行照常出现,证据位置如实显示缺失,不猜值。 */
+  durationMs: number | null;
+  /** 顶层 span 摘要,按 startOffsetMs 升序。 */
+  spans: readonly TraceSpanSummary[];
+}
+
 /** 一个可比组的数据;三个子块都只消费本组快照,不能含其它父目录的引用。 */
 export interface ExperimentComparisonGroupData {
   /** experiment id 的完整父路径;根目录 experiment 使用完整 id。 */
@@ -394,14 +445,3 @@ export interface ExperimentListItem {
   lastRunAt: string;
   evalRows: ExperimentListEvalRow[];
 }
-
-/** 三个实体列表共用的计算选项。 */
-export interface EntityListDataOptions {
-  /**
-   * 展示层遮蔽:只改写这次组件数据中的自由文本——条目本身与任何嵌套 attempt 条目的
-   * `failureSummary`;身份与分类字段(experimentId、evalId、locator、数值指标)不经它。
-   * 只作用于这次计算产出的组件数据,不改盘上或任何导出目录里的 artifact;
-   * 发布 artifact 的脱敏用 copySnapshots({ redact })。
-   */
-  redact?: (text: string) => string;
-}

package/src/report/web.ts

@@ -2,7 +2,6 @@
 // HTML 烘进查看器的报告槽。只有这一侧真正 import react-dom(import 边界即运行时边界),
 // 所以本文件不从 niceeval/report 的入口 re-export —— 宿主与测试按源路径 import。
 
-import * as React from "react";
 import type { ReactNode } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
 import type { AttemptLocator } from "../results/locator.ts";
@@ -26,39 +25,11 @@ export interface StaticHtmlOptions {
   locale?: ReportLocale;
 }
 
-/**
- * 挑选警告的 HTML 形态:宿主级前置块(`.nre nre-report-warnings` 外壳内一个
- * `ul.nre-warnings` + `li.nre-warning[data-kind]`,复用 styles.css 已有样式)。
- * 带 `command` 的警告把命令渲染为可复制块(`.nre-warning-command`);无 command 的
- * 只显示 message,不硬造动作。经 renderToStaticMarkup 走 React,文本自动转义。
- */
-function renderScopeWarningsHtml(scope: Scope): string {
-  return renderToStaticMarkup(
-    React.createElement(
-      "div",
-      { className: "nre nre-report-warnings" },
-      React.createElement(
-        "ul",
-        { className: "nre-warnings" },
-        scope.warnings.map((w, i) =>
-          React.createElement(
-            "li",
-            { key: i, className: "nre-warning", "data-kind": w.kind },
-            w.message,
-            "command" in w && w.command
-              ? React.createElement("code", { className: "nre-warning-command", "data-nre-copy": w.command }, w.command)
-              : null,
-          ),
-        ),
-      ),
-    ),
-  );
-}
-
 /**
  * web 宿主的装载语义:选页 → resolve(组合展开 + spec 取数,唯一的 await 边界)→
- * 树校验(与 text 宿主同一遍)→ 静态渲染 web 面;Scope 有挑选警告时在报告顶部前置
- * 一块警告 HTML(宿主是 warning 的唯一呈现者,组件数据不复制 warning)。
+ * 树校验(与 text 宿主同一遍)→ 静态渲染 web 面。宿主不在报告树外另设警告通道——
+ * 挑选警告的呈现件是 `ScopeWarnings` 组件,内建报告每页都放它,自定义报告放不放是
+ * 作者义务(docs/feature/reports/architecture.md「Scope 是计算入口」)。
  */
 export async function renderReportToStaticHtml(
   definition: ReportDefinition,
@@ -78,15 +49,13 @@ export async function renderReportToStaticHtml(
     attemptHref: options?.attemptHref ?? ((locator) => `#/attempt/${locator}`),
     locale: options?.locale ?? DEFAULT_REPORT_LOCALE,
   };
-  const body = runWithWebContext(webCtx, () => renderToStaticMarkup(resolved as ReactNode));
-  const warnings = ctx.scope.warnings.length > 0 ? renderScopeWarningsHtml(ctx.scope) : "";
-  return warnings + body;
+  return runWithWebContext(webCtx, () => renderToStaticMarkup(resolved as ReactNode));
 }
 
 /**
  * 渲染一页报告树的 web 面(宿主逐页调用;页选择归宿主):resolve → validate → 静态渲染。
- * Scope 有挑选警告时在页顶前置警告块(带 command 的警告渲染为可复制命令)——宿主是
- * warning 的唯一呈现者,组件数据不复制 warning。ctx.report 是宿主规范化后的声明。
+ * 挑选警告由页内的 `ScopeWarnings` 组件呈现,宿主不前置任何树外块。
+ * ctx.report 是宿主规范化后的声明。
  */
 export async function renderReportTreeToStaticHtml(
   tree: import("./tree.ts").ReportNode,
@@ -104,7 +73,5 @@ export async function renderReportTreeToStaticHtml(
     attemptHref: options?.attemptHref ?? ((locator) => `#/attempt/${locator}`),
     locale: options?.locale ?? DEFAULT_REPORT_LOCALE,
   };
-  const body = runWithWebContext(webCtx, () => renderToStaticMarkup(resolved as ReactNode));
-  const warnings = ctx.scope.warnings.length > 0 ? renderScopeWarningsHtml(ctx.scope) : "";
-  return warnings + body;
+  return runWithWebContext(webCtx, () => renderToStaticMarkup(resolved as ReactNode));
 }

package/src/results/copy.ts

@@ -1,7 +1,7 @@
 // copySnapshots:把选中快照按格式感知地复制到另一个目录(定稿见 docs/feature/results/library.md「复制与瘦身」)。
 //
 // 发布场景的原语:只带指定 artifact、只带选中快照的全部 attempt,布局知识不外泄。
-// artifact 复制忠实于源(copyFile 原字节,不重新序列化、不消毒);snapshot.json / result.json
+// artifact 复制忠实于源(原字节,不重新序列化、不改写);snapshot.json / result.json
 // 按选中条目重建,版本元数据保留。产物是一个标准结果根目录(同布局),openResults /
 // `niceeval view` 直接能读。唯一随行补记的是挑选时的覆盖事实:每个复制出的快照带上
 // knownEvalIds(复制时刻该实验已知的 eval 并集),发布目录上重新 openResults().latest(),
@@ -9,21 +9,13 @@
 
 import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
-import type { EvalResult, StreamEvent, TraceSpan } from "../types.ts";
+import type { EvalResult } from "../types.ts";
 import { RESULTS_FORMAT } from "../types.ts";
 import { RESULT_FILE, SNAPSHOT_FILE, artifactFileOf, experimentDirOf } from "./format.ts";
 import { experimentOfSnapshot } from "./open.ts";
 import { isNewerSnapshot } from "./select.ts";
 import { hashEvalSource, normalizeEvalSource } from "./source-hash.ts";
-import {
-  PUBLISH_FILE_MAX_BYTES,
-  redactEvents,
-  redactExperimentInfo,
-  redactJsonValue,
-  redactResultRecord,
-  redactSpans,
-  type Redactor,
-} from "./publish.ts";
+import { PUBLISH_FILE_MAX_BYTES } from "./publish.ts";
 import type { ArtifactKind, AttemptHandle, Scope, Snapshot, SnapshotMeta } from "./types.ts";
 
 /** 缺省携带的 artifact:events / trace / o11y / agentSetup / sources;diff 不截断、可达百 MB,缺省不带。 */
@@ -33,12 +25,6 @@ const VALID_ARTIFACTS: ArtifactKind[] = ["events", "trace", "o11y", "agentSetup"
 export interface CopySnapshotsOptions {
   /** 要带上的 artifact 种类;缺省带 events / trace / o11y / agentSetup / sources,不带 diff。 */
   artifacts?: ArtifactKind[];
-  /**
-   * 发布消毒(必填,没有隐式默认):传函数逐值消毒自由文本字段,或显式传 `false` 声明
-   * 「这批数据可以原文发布」——「不消毒」必须是写在代码里的选择,不是忘了传参数的副作用。
-   * 结构字段(格式、判定、身份、路径、哈希)永不经过 redactor。
-   */
-  redact: Redactor | false;
 }
 
 export interface CopySnapshotsResult {
@@ -56,7 +42,7 @@ export interface CopySnapshotsResult {
 export async function copySnapshots(
   scope: Scope | readonly Snapshot[],
   destDir: string,
-  opts: CopySnapshotsOptions,
+  opts: CopySnapshotsOptions = {},
 ): Promise<CopySnapshotsResult> {
   const selected = Array.isArray(scope) ? (scope as readonly Snapshot[]) : (scope as Scope).snapshots;
   if (selected.length === 0) {
@@ -64,12 +50,6 @@ export async function copySnapshots(
       "copySnapshots got no snapshots to copy. Check the experiments filter, or pass snapshots from openResults().latest().",
     );
   }
-  if (opts?.redact === undefined) {
-    throw new Error(
-      'copySnapshots requires an explicit "redact" option: pass a (text) => string sanitizer, or the literal false to declare this data safe to publish verbatim.',
-    );
-  }
-  const redactor: Redactor | undefined = opts.redact === false ? undefined : opts.redact;
   const kinds = opts.artifacts ?? [...DEFAULT_PUBLISH_ARTIFACTS];
   for (const kind of kinds) {
     if (!VALID_ARTIFACTS.includes(kind)) {
@@ -97,11 +77,11 @@ export async function copySnapshots(
     if (isNewerSnapshot(snapshot, existing)) byExperiment.set(snapshot.experimentId, snapshot);
   }
 
-  // 发布前整文件预检:先规划并序列化全部目标文件(消毒发生在序列化后、写盘前),任一文件
-  // 超过 PUBLISH_FILE_MAX_BYTES 就整体失败,不留半成品目标目录。
+  // 发布前整文件预检:先规划并序列化全部目标文件,任一文件超过 PUBLISH_FILE_MAX_BYTES
+  // 就整体失败,不留半成品目标目录。
   const planned: PlannedFile[] = [];
   for (const snapshot of byExperiment.values()) {
-    planned.push(...(await planOneSnapshot(snapshot, [...selected], dest, kinds, redactor)));
+    planned.push(...(await planOneSnapshot(snapshot, [...selected], dest, kinds)));
   }
   const oversized = planned.filter((f) => f.bytes.byteLength > PUBLISH_FILE_MAX_BYTES);
   if (oversized.length > 0) {
@@ -135,7 +115,6 @@ async function planOneSnapshot(
   selected: Snapshot[],
   destRoot: string,
   kinds: ArtifactKind[],
-  redactor: Redactor | undefined,
 ): Promise<PlannedFile[]> {
   const destSnapDir = join(destRoot, experimentDirOf(snapshot.experimentId), basename(snapshot.dir));
   const planned: PlannedFile[] = [];
@@ -144,31 +123,22 @@ async function planOneSnapshot(
   // 复制到目的地也只应该有一份——这个 Set 记录本快照已经规划过的 hash,整快照的 attempt 共享。
   const plannedSourceHashes = new Set<string>();
   for (const attempt of snapshot.attempts) {
-    planned.push(...(await planOneAttempt(attempt, destSnapDir, kinds, plannedSourceHashes, redactor)));
+    planned.push(...(await planOneAttempt(attempt, destSnapDir, kinds, plannedSourceHashes)));
   }
 
   const knownEvalIds = experimentOfSnapshot(snapshot)?.evalIds ?? fallbackUnion(selected, snapshot.experimentId);
-  const experiment =
-    snapshot.experiment !== undefined && redactor
-      ? (redactExperimentInfo(snapshot.experiment as unknown as Record<string, unknown>, redactor) as unknown as SnapshotMeta["experiment"])
-      : snapshot.experiment;
   const meta: SnapshotMeta = {
     format: RESULTS_FORMAT,
     schemaVersion: snapshot.schemaVersion,
     producer: snapshot.producer,
     experimentId: snapshot.experimentId,
-    ...(experiment !== undefined ? { experiment } : {}),
+    ...(snapshot.experiment !== undefined ? { experiment: snapshot.experiment } : {}),
     agent: snapshot.agent,
     ...(snapshot.model !== undefined ? { model: snapshot.model } : {}),
     startedAt: snapshot.startedAt,
     ...(snapshot.completedAt !== undefined ? { completedAt: snapshot.completedAt } : {}),
     ...(knownEvalIds.length ? { knownEvalIds } : {}),
-    ...(snapshot.name !== undefined
-      ? { name: redactor && typeof snapshot.name === "string" ? redactor(snapshot.name) : snapshot.name }
-      : {}),
-    // 发布根标记只声明流程,不证明结果:applied = 消毒函数对全部自由文本字段跑过;
-    // none = 作者显式的原文发布声明。view --out 的防呆据此分级。
-    publish: { redaction: redactor ? "applied" : "none" },
+    ...(snapshot.name !== undefined ? { name: snapshot.name } : {}),
   };
   planned.push({ path: join(destSnapDir, SNAPSHOT_FILE), bytes: Buffer.from(JSON.stringify(meta, null, 2), "utf-8") });
   return planned;
@@ -179,21 +149,18 @@ async function planOneAttempt(
   destSnapDir: string,
   kinds: ArtifactKind[],
   plannedSourceHashes: Set<string>,
-  redactor: Redactor | undefined,
 ): Promise<PlannedFile[]> {
   const destAttemptDir = join(destSnapDir, attempt.ref.attempt);
   const planned: PlannedFile[] = [];
 
   // sources 是唯一「两层」的 artifact(attempt 级引用 + 快照级去重仓库),不能像其它四类那样
   // 单文件原字节完事——原字节只是引用,不带内容。走读取面已经会解引用+回退的 attempt.sources()
-  // 拿到完整内容,消毒后按(消毒后)内容哈希重新去重落盘——发布根里引用与内容永远一致。
+  // 拿到完整内容,按内容哈希重新去重落盘——发布根里引用与内容永远一致,携带条目也被归拢进本快照。
   const genericKinds = kinds.filter((k) => k !== "sources");
   const files = await findArtifactFiles(attempt, genericKinds);
   const copied = new Set(files.map((f) => f.kind));
   for (const { kind, source } of files) {
-    const raw = await readFile(source);
-    const bytes = redactor ? redactArtifactBytes(kind, raw, redactor) : raw;
-    planned.push({ path: join(destAttemptDir, artifactFileOf(kind)), bytes, source });
+    planned.push({ path: join(destAttemptDir, artifactFileOf(kind)), bytes: await readFile(source), source });
   }
 
   if (kinds.includes("sources")) {
@@ -203,13 +170,12 @@ async function planOneAttempt(
       const destStoreDir = join(destSnapDir, "sources");
       const refs: { path: string; sha256: string }[] = [];
       for (const src of sources) {
-        const content = redactor ? redactor(src.content) : src.content;
-        const sha256 = hashEvalSource(normalizeEvalSource(content));
+        const sha256 = hashEvalSource(normalizeEvalSource(src.content));
         refs.push({ path: src.path, sha256 });
         if (!plannedSourceHashes.has(sha256)) {
           planned.push({
             path: join(destStoreDir, `${sha256}.json`),
-            bytes: Buffer.from(JSON.stringify({ content }), "utf-8"),
+            bytes: Buffer.from(JSON.stringify({ content: src.content }), "utf-8"),
           });
           plannedSourceHashes.add(sha256);
         }
@@ -221,40 +187,11 @@ async function planOneAttempt(
     }
   }
 
-  let record = slimForCopy(attempt.result, copied);
-  if (redactor) record = redactResultRecord(record, redactor);
+  const record = slimForCopy(attempt.result, copied);
   planned.push({ path: join(destAttemptDir, RESULT_FILE), bytes: Buffer.from(JSON.stringify(record, null, 2), "utf-8") });
   return planned;
 }
 
-/** 单个 artifact 文件的消毒:按种类解析 JSON、走各自的自由文本标注,重新序列化。 */
-function redactArtifactBytes(kind: ArtifactKind, raw: Buffer, redactor: Redactor): Buffer {
-  try {
-    const parsed = JSON.parse(raw.toString("utf-8")) as unknown;
-    let next: unknown;
-    switch (kind) {
-      case "events":
-        next = redactEvents(parsed as StreamEvent[], redactor);
-        break;
-      case "trace":
-        next = redactSpans(parsed as TraceSpan[], redactor);
-        break;
-      // diff 的 before/after/内容与 o11y 的命令 / 错误 / URL 都是自由文本;路径键为结构字段。
-      case "diff":
-      case "o11y":
-      case "agentSetup":
-        next = redactJsonValue(parsed, redactor);
-        break;
-      default:
-        next = parsed;
-    }
-    return Buffer.from(JSON.stringify(next), "utf-8");
-  } catch {
-    // 解析不了的按原字节透传(malformed 数据不该在发布路径上被静默改写)。
-    return raw;
-  }
-}
-
 /** 目标目录非空即报错:盘上不该出现「我没写的东西被动过」的惊讶;发布脚本要幂等就自己先清目录。 */
 async function assertEmptyDestination(dest: string): Promise<void> {
   let entries: string[];

package/src/results/host-equivalence.test.ts

@@ -126,7 +126,8 @@ interface NormExperiment {
 type NormWarning =
   | { kind: "partial-coverage"; experimentId: string; covered: number; total: number }
   | { kind: "stale-snapshot"; experimentId: string; startedAt: string; latestStartedAt: string }
-  | { kind: "unfinished-snapshot"; experimentId: string; startedAt: string };
+  | { kind: "unfinished-snapshot"; experimentId: string; startedAt: string }
+  | { kind: "unreadable-snapshot"; reason: string };
 interface NormSelection {
   warnings: NormWarning[];
   experiments: NormExperiment[];
@@ -141,6 +142,9 @@ function normalizeWarning(w: ScopeWarning): NormWarning {
     case "unfinished-snapshot":
       // dir 是宿主机绝对路径,归一化掉;身份靠 experimentId + startedAt。
       return { kind: w.kind, experimentId: w.experimentId, startedAt: w.startedAt };
+    case "unreadable-snapshot":
+      // dir 是宿主机绝对路径,归一化掉;这个 kind 本就非实验作用域,没有 experimentId 可比。
+      return { kind: w.kind, reason: w.reason };
   }
 }
 

package/src/results/open.ts

@@ -150,7 +150,7 @@ export async function openResults(dir: string): Promise<Results> {
   try {
     targetStat = await stat(target);
   } catch {
-    return makeResults([], []);
+    return makeResults([], [], target);
   }
 
   if (targetStat.isFile()) {
@@ -165,17 +165,18 @@ export async function openResults(dir: string): Promise<Results> {
   // 建 locator 索引:必须在全部快照扫完、Experiment 归组完成之后,返回 Results 之前——
   // 撞车(LocatorCollisionError)在这里抛,不静默吞、不拖到消费方第一次 resolveLocator() 才发现。
   const locatorIndex = buildAttemptLocatorIndex(experiments);
-  const results = makeResults(experiments, state.skipped);
+  const results = makeResults(experiments, state.skipped, target);
   locatorIndexByResults.set(results, locatorIndex);
   return results;
 }
 
-function makeResults(experiments: Experiment[], skipped: SkippedDir[]): Results {
+function makeResults(experiments: Experiment[], skipped: SkippedDir[], root: string): Results {
   const results: Results = {
+    root,
     experiments,
     skipped,
     latest(opts?: { experiments?: string | string[] }): Scope {
-      return selectLatest(experiments, opts);
+      return selectLatest(results, opts);
     },
     current(opts?: { experiments?: string | string[] }): Scope {
       return selectCurrentResults(results, { experiment: opts?.experiments });

package/src/results/publish.ts

@@ -1,149 +1,7 @@
-// 发布消毒与发布预算(见 docs/feature/results/library.md「复制与瘦身:copySnapshots」)。
-// 结果数据分两个等级:.niceeval/ 是本地事实根(未消毒);任何要离开本机的拷贝是发布拷贝,
-// 只能经 copySnapshots 这一条管线产出,消毒在这里做且没有隐式默认(redact 必填)。
-//
-// redact 逐值消毒,范围由 schema 的自由文本标注决定:redactor 只对自由文本字段调用——
-// 格式、判定、身份、路径、哈希这类结构字段永不经过它,发布根不会因 redact 变得不可读或
-// 引用断裂。自由文本清单在下面的 FREE_TEXT 标注单点维护(与 AttemptList.redact 同一口径)。
-
-import type { EvalResult, StreamEvent, TraceSpan } from "../types.ts";
+// 发布预算(见 docs/feature/results/library.md「复制与瘦身:copySnapshots」)。
+// 结果数据分两类:.niceeval/ 是本地事实根,不是默认可提交目录;任何要离开本机的拷贝是
+// 发布拷贝,经 copySnapshots 这一条管线产出。管线只做选择、归拢与整文件大小预检,
+// 不改写内容——保密边界由格式在采集侧划定(env 值与命令 stdout/stderr 不进结果文件)。
 
 /** 发布前整文件预检的单文件上限(50 MiB,为 GitHub 100 MB 硬限保留余量);不是可调旋钮。 */
 export const PUBLISH_FILE_MAX_BYTES = 50 * 1024 * 1024;
-
-export type Redactor = (text: string) => string;
-
-/**
- * 结构字段键名(取值是格式、判定、身份、路径、哈希——redactor 永不触碰):
- * 事件的 type/callId/status/role/tool/skill/requestId/optionId、span 的 ids/kind、
- * 断言的 name/severity/outcome、错误的 code/phase、locator/artifactBase/fingerprint、
- * 源码路径与 sha256、provider 名、时间戳等。新增字符串字段先判断体裁再决定进不进这张表。
- */
-const STRUCTURAL_KEYS = new Set([
-  "type",
-  "callId",
-  "status",
-  "role",
-  "tool",
-  "requestId",
-  "optionId",
-  "id",
-  "traceId",
-  "spanId",
-  "parentSpanId",
-  "kind",
-  "format",
-  "verdict",
-  "severity",
-  "outcome",
-  "artifactBase",
-  "locator",
-  "fingerprint",
-  "sha256",
-  "path",
-  "file",
-  "provider",
-  "sandboxId",
-  "code",
-  "phase",
-  "level",
-  "agent",
-  "model",
-  "experimentId",
-  "startedAt",
-  "completedAt",
-  "schemaVersion",
-  "evalFilterFingerprint",
-  "reasoningEffort",
-  "skill",
-  "window",
-  "net",
-  "loc",
-  "dedupeKey",
-]);
-
-/** 深度遍历 JSON 值:字符串按「键名是否结构字段」决定过不过 redactor;结构键下整棵子树跳过。 */
-export function redactJsonValue(value: unknown, redact: Redactor, key?: string): unknown {
-  if (typeof value === "string") {
-    if (key !== undefined && STRUCTURAL_KEYS.has(key)) return value;
-    return redact(value);
-  }
-  if (Array.isArray(value)) return value.map((v) => redactJsonValue(v, redact, key));
-  if (value !== null && typeof value === "object") {
-    const out: Record<string, unknown> = {};
-    for (const [k, v] of Object.entries(value)) {
-      if (STRUCTURAL_KEYS.has(k) && typeof v === "string") {
-        out[k] = v;
-        continue;
-      }
-      out[k] = redactJsonValue(v, redact, k);
-    }
-    return out;
-  }
-  return value;
-}
-
-/** events.json 的发布消毒:消息与工具入出参是自由文本,type/callId/status 等结构字段不动。 */
-export function redactEvents(events: StreamEvent[], redact: Redactor): StreamEvent[] {
-  return redactJsonValue(events, redact) as StreamEvent[];
-}
-
-/** trace.json 的发布消毒:属性值与可携带动态内容的 span name 过 redactor,ids/kind 不动。 */
-export function redactSpans(spans: TraceSpan[], redact: Redactor): TraceSpan[] {
-  return spans.map((span) => ({
-    ...span,
-    name: redact(span.name),
-    ...(span.attributes !== undefined
-      ? { attributes: redactJsonValue(span.attributes, redact) as TraceSpan["attributes"] }
-      : {}),
-  }));
-}
-
-/** result.json 的发布消毒:断言 detail/evidence/expected/received、error/diagnostic 的
- *  message/cause/stack、skipReason、description 是自由文本;判定与身份字段不动。 */
-export function redactResultRecord(record: Record<string, unknown>, redact: Redactor): Record<string, unknown> {
-  const r = record as Partial<EvalResult> & Record<string, unknown>;
-  const out: Record<string, unknown> = { ...record };
-  if (typeof r.description === "string") out.description = redact(r.description);
-  if (typeof r.skipReason === "string") out.skipReason = redact(r.skipReason);
-  if (Array.isArray(r.assertions)) {
-    out.assertions = r.assertions.map((a) => ({
-      ...a,
-      ...(a.detail !== undefined ? { detail: redact(a.detail) } : {}),
-      ...(a.outcome !== "unavailable" && a.evidence !== undefined ? { evidence: redact(a.evidence) } : {}),
-      ...(a.outcome !== "unavailable" && a.expected !== undefined ? { expected: redact(a.expected) } : {}),
-      ...(a.outcome !== "unavailable" && a.received !== undefined ? { received: redact(a.received) } : {}),
-    }));
-  }
-  if (r.error !== undefined) {
-    out.error = {
-      ...r.error,
-      message: redact(r.error.message),
-      ...(r.error.stack !== undefined ? { stack: redact(r.error.stack) } : {}),
-      ...(r.error.cause !== undefined ? { cause: { ...r.error.cause, message: redact(r.error.cause.message) } } : {}),
-    };
-  }
-  if (Array.isArray(r.diagnostics)) {
-    out.diagnostics = r.diagnostics.map((d) => ({
-      ...d,
-      message: redact(d.message),
-      ...(d.data !== undefined ? { data: redactJsonValue(d.data, redact) as typeof d.data } : {}),
-    }));
-  }
-  if (r.experiment !== undefined) {
-    out.experiment = redactExperimentInfo(r.experiment as unknown as Record<string, unknown>, redact);
-  }
-  return out;
-}
-
-/** ExperimentRunInfo 的发布消毒:description、flags 与 sandbox params 的字符串值。 */
-export function redactExperimentInfo(info: Record<string, unknown>, redact: Redactor): Record<string, unknown> {
-  const out: Record<string, unknown> = { ...info };
-  if (typeof info.description === "string") out.description = redact(info.description);
-  if (info.flags !== undefined) out.flags = redactJsonValue(info.flags, redact);
-  const sandbox = info.sandbox as { provider: string; params?: Record<string, unknown> } | undefined;
-  if (sandbox?.params !== undefined) {
-    out.sandbox = { ...sandbox, params: redactJsonValue(sandbox.params, redact) };
-  }
-  return out;
-}