niceeval 0.8.0 → 0.8.1

package/dist/report/components.d.ts

@@ -1,7 +1,7 @@
 import { type ReportComponent } from "./tree.ts";
 import type { ReportLocale } from "./locale.ts";
 import type { AttemptLocator } from "../results/locator.ts";
-import type { AttemptListItem, DeltaData, EntityListDataOptions, EvalListItem, ExperimentComparisonData, ExperimentListItem, LineData, MatrixData, ReportInput, ScatterData, ScopeSummaryData, ScoreboardData, TableData } from "./types.ts";
+import type { AttemptListItem, DeltaData, EvalListItem, ExperimentComparisonData, ExperimentListItem, LineData, MatrixData, ReportInput, ScatterData, ScopeSummaryData, ScoreboardData, TableData } from "./types.ts";
 import { type DeltaTableOptions, type MetricLineOptions, type MetricMatrixOptions, type MetricScatterOptions, type MetricTableOptions, type ScoreboardOptions } from "./compute.ts";
 type Never<T> = {
     [K in keyof T]?: never;
@@ -38,7 +38,7 @@ export declare const ExperimentComparison: ReportComponent<ExperimentComparisonP
 interface EntityListChrome extends ChromeProps {
     attemptHref?: (locator: AttemptLocator) => string;
 }
-export type ExperimentListProps = DataProps<readonly ExperimentListItem[], EntityListDataOptions, EntityListChrome & {
+export type ExperimentListProps = DataProps<readonly ExperimentListItem[], Record<never, never>, EntityListChrome & {
     /** web 面在比较表前显示实验过滤框;text 面忽略。 */
     filter?: boolean;
     /**
@@ -49,10 +49,10 @@ export type ExperimentListProps = DataProps<readonly ExperimentListItem[], Entit
 }>;
 /** 实验列表:每项一个 experiment,固定八列比较表 + 展开到 Eval / Attempt。 */
 export declare const ExperimentList: ReportComponent<ExperimentListProps>;
-export type EvalListProps = DataProps<readonly EvalListItem[], EntityListDataOptions, EntityListChrome>;
+export type EvalListProps = DataProps<readonly EvalListItem[], Record<never, never>, EntityListChrome>;
 /** Eval 列表:每项一个 experimentId + evalId,展开到这道题的 Attempt。 */
 export declare const EvalList: ReportComponent<EvalListProps>;
-export type AttemptListProps = DataProps<readonly AttemptListItem[], EntityListDataOptions, EntityListChrome & {
+export type AttemptListProps = DataProps<readonly AttemptListItem[], Record<never, never>, EntityListChrome & {
     /** 过滤 / 截断前的总数;省略时等于 data 长度。 */
     total?: number;
 }>;
@@ -63,7 +63,6 @@ export interface FailureListProps {
     limit?: number;
     /** 默认宿主注入的 Scope。 */
     input?: ReportInput;
-    redact?: (text: string) => string;
     attemptHref?: (locator: AttemptLocator) => string;
     locale?: ReportLocale;
     className?: string;

package/dist/report/components.js

@@ -261,8 +261,8 @@ export const ExperimentList = makeDataComponent({
     name: "ExperimentList",
     dataFnName: "experimentListData",
     shapeName: "ExperimentListItem[]",
-    dataFn: (input, options) => experimentListData(input, options),
-    specKeys: ["redact"],
+    dataFn: (input) => experimentListData(input),
+    specKeys: [],
     validate: validateExperimentListData,
     web: (props, ctx) => (_jsx(ExperimentListWeb, { data: props.data, filter: props.filter, relativeTo: props.relativeTo, locale: props.locale ?? ctx.locale, attemptHref: hrefOf(props, ctx) ?? ctx.attemptHref, className: props.className })),
     text: (props, ctx) => experimentListText(props.data, ctx, props.relativeTo),
@@ -272,8 +272,8 @@ export const EvalList = makeDataComponent({
     name: "EvalList",
     dataFnName: "evalListData",
     shapeName: "EvalListItem[]",
-    dataFn: (input, options) => evalListData(input, options),
-    specKeys: ["redact"],
+    dataFn: (input) => evalListData(input),
+    specKeys: [],
     validate: validateEvalListData,
     web: (props, ctx) => (_jsx(EvalListWeb, { data: props.data, locale: props.locale ?? ctx.locale, attemptHref: hrefOf(props, ctx) ?? ctx.attemptHref, className: props.className })),
     text: (props, ctx) => evalListText(props.data, ctx),
@@ -283,8 +283,8 @@ export const AttemptList = makeDataComponent({
     name: "AttemptList",
     dataFnName: "attemptListData",
     shapeName: "AttemptListItem[]",
-    dataFn: (input, options) => attemptListData(input, options),
-    specKeys: ["redact"],
+    dataFn: (input) => attemptListData(input),
+    specKeys: [],
     validate: validateAttemptListData,
     web: (props, ctx) => (_jsx(AttemptListWeb, { data: props.data, total: props.total, locale: props.locale ?? ctx.locale, attemptHref: hrefOf(props, ctx) ?? ctx.attemptHref, className: props.className })),
     text: (props, ctx) => attemptListText(props.data, props.total, ctx),
@@ -297,7 +297,7 @@ export const AttemptList = makeDataComponent({
  */
 export const FailureList = defineComponent(async (props, ctx) => {
     const input = props.input ?? ctx.scope;
-    const all = await attemptListData(input, props.redact !== undefined ? { redact: props.redact } : undefined);
+    const all = await attemptListData(input);
     // attempt 开始时间不在列表条目里(它不是列表展示字段);从同一 input 的读取面按 locator 对回。
     const startedAtByLocator = new Map();
     for (const item of collectItems(resolveInput(input).snapshots)) {

package/dist/report/compute.d.ts

@@ -1,4 +1,4 @@
-import type { AttemptListItem, DeltaData, DeltaPair, DimensionInput, EntityListDataOptions, EvalListItem, ExperimentComparisonData, ExperimentListItem, FlagPairs, LineData, MatrixData, Metric, NumericAxis, ReportInput, ScatterData, ScopeSummaryData, ScoreboardData, TableData } from "./types.ts";
+import type { AttemptListItem, DeltaData, DeltaPair, DimensionInput, EvalListItem, ExperimentComparisonData, ExperimentListItem, FlagPairs, LineData, MatrixData, Metric, NumericAxis, ReportInput, ScatterData, ScopeSummaryData, ScoreboardData, TableData } from "./types.ts";
 import type { JsonValue } from "../types.ts";
 export interface MetricTableOptions {
     /** 行维度(内置 / 自定义 / flag() / runConfig())。 */
@@ -23,9 +23,9 @@ export interface MetricMatrixOptions {
 }
 export declare function metricMatrixData(input: ReportInput, options: MetricMatrixOptions): Promise<MatrixData>;
 /** `attemptListData(input)`:每个 Attempt 一项,顺序取自 Scope 展平顺序(不重排)。 */
-export declare function attemptListData(input: ReportInput, options?: EntityListDataOptions): Promise<AttemptListItem[]>;
+export declare function attemptListData(input: ReportInput): Promise<AttemptListItem[]>;
 /** `evalListData(input)`:每个 `experimentId + evalId` 一项,按 evalId 再按 experimentId 升序。 */
-export declare function evalListData(input: ReportInput, options?: EntityListDataOptions): Promise<EvalListItem[]>;
+export declare function evalListData(input: ReportInput): Promise<EvalListItem[]>;
 /**
  * `experimentListData(input)`:每个 experiment 一项,展开到每道 Eval;初始按端到端成功率
  * 从高到低(缺数据沉底,同分按 id)。一行只有一套 agent / model / flags 是输入约束:
@@ -33,7 +33,7 @@ export declare function evalListData(input: ReportInput, options?: EntityListDat
  * Snapshot[] 时若同一 experiment 混入不一致的可比性配置,按完整用户反馈失败并指引——
  * 看跨配置演化用 snapshot 维度或 MetricLine,不把两套配置拼成一行冒充单一配置。
  */
-export declare function experimentListData(input: ReportInput, options?: EntityListDataOptions): Promise<ExperimentListItem[]>;
+export declare function experimentListData(input: ReportInput): Promise<ExperimentListItem[]>;
 /**
  * `scopeSummaryData(input)`:范围摘要——快照时间窗、experiment / eval / attempt 数、
  * 两级判定计票、端到端成功率与总成本(docs/feature/reports/library/summaries.md)。

package/dist/report/compute.js

@@ -117,9 +117,8 @@ function failureSummaryOf(result) {
     }
     return { summary: null, more: 0 };
 }
-const identityRedact = (text) => text;
 /** AttemptList / ExperimentList / EvalList 共用的叶子构造:一个 Item → 一个 AttemptListItem。 */
-async function attemptListItemOf(item, redact) {
+async function attemptListItemOf(item) {
     const result = item.attempt.result;
     const { summary, more } = failureSummaryOf(result);
     return {
@@ -128,7 +127,7 @@ async function attemptListItemOf(item, redact) {
         attempt: result.attempt,
         agent: result.agent,
         verdict: result.verdict,
-        failureSummary: summary === null ? null : redact(summary),
+        failureSummary: summary,
         moreFailures: more,
         examScore: await computeCell(examScore, [item]),
         durationMs: result.durationMs,
@@ -137,16 +136,14 @@ async function attemptListItemOf(item, redact) {
     };
 }
 /** `attemptListData(input)`:每个 Attempt 一项,顺序取自 Scope 展平顺序(不重排)。 */
-export async function attemptListData(input, options) {
+export async function attemptListData(input) {
     const { snapshots } = resolveInput(input);
-    const redact = options?.redact ?? identityRedact;
     const items = collectItems(snapshots);
-    return Promise.all(items.map((item) => attemptListItemOf(item, redact)));
+    return Promise.all(items.map((item) => attemptListItemOf(item)));
 }
 /** `evalListData(input)`:每个 `experimentId + evalId` 一项,按 evalId 再按 experimentId 升序。 */
-export async function evalListData(input, options) {
+export async function evalListData(input) {
     const { snapshots } = resolveInput(input);
-    const redact = options?.redact ?? identityRedact;
     const items = collectItems(snapshots);
     const groups = new Map();
     for (const item of items) {
@@ -161,7 +158,7 @@ export async function evalListData(input, options) {
     for (const group of groups.values()) {
         const sorted = [...group].sort((a, b) => a.attempt.result.attempt - b.attempt.result.attempt);
         const verdict = foldEvalVerdict(sorted.map((item) => item.attempt.result));
-        const attempts = await Promise.all(sorted.map((item) => attemptListItemOf(item, redact)));
+        const attempts = await Promise.all(sorted.map((item) => attemptListItemOf(item)));
         out.push({
             experimentId: experimentIdOf(sorted[0]),
             evalId: evalIdOf(sorted[0]),
@@ -182,9 +179,8 @@ export async function evalListData(input, options) {
  * Snapshot[] 时若同一 experiment 混入不一致的可比性配置,按完整用户反馈失败并指引——
  * 看跨配置演化用 snapshot 维度或 MetricLine,不把两套配置拼成一行冒充单一配置。
  */
-export async function experimentListData(input, options) {
+export async function experimentListData(input) {
     const { snapshots } = resolveInput(input);
-    const redact = options?.redact ?? identityRedact;
     // 可比性配置单义检查:同一 experiment 的输入快照必须共享一套可比性配置。
     const configByExperiment = new Map();
     for (const snapshot of snapshots) {
@@ -211,7 +207,7 @@ export async function experimentListData(input, options) {
         for (const [evalId, evalItems] of evalGroups) {
             const sorted = [...evalItems].sort((a, b) => a.attempt.result.attempt - b.attempt.result.attempt);
             const verdict = foldEvalVerdict(sorted.map((item) => item.attempt.result));
-            const attempts = await Promise.all(sorted.map((item) => attemptListItemOf(item, redact)));
+            const attempts = await Promise.all(sorted.map((item) => attemptListItemOf(item)));
             evalRows.push({
                 evalId,
                 verdict,

package/dist/report/index.d.ts

@@ -14,6 +14,6 @@ export { AttemptList, DeltaTable, EvalList, ExperimentComparison, ExperimentList
 export type { AttemptListProps, DataProps, DeltaTableProps, EvalListProps, ExperimentComparisonProps, ExperimentListProps, FailureListProps, MetricBarsProps, MetricLineProps, MetricMatrixProps, MetricScatterProps, MetricTableProps, ScoreboardProps, ScopeSummaryProps, } from "./components.tsx";
 export { attemptListData, deltaTableData, evalListData, experimentComparisonData, experimentListData, metricLineData, metricMatrixData, metricScatterData, metricTableData, pairsByFlag, scopeSummaryData, scoreboardData, } from "./compute.ts";
 export type { DeltaTableOptions, MetricLineOptions, MetricMatrixOptions, MetricScatterOptions, MetricTableOptions, ScoreboardOptions, } from "./compute.ts";
-export type { Aggregator, AttemptListItem, AttemptLocator, BuiltInDimension, CustomDimension, DeltaData, DeltaPair, DimensionInput, DimensionOptions, DimensionRef, EntityListDataOptions, EvalListItem, ExperimentComparisonData, ExperimentComparisonGroupData, ExperimentListEvalRow, ExperimentListItem, FlagPairs, LineData, MatrixData, Metric, MetricAggregate, MetricCell, MetricColumn, NumericAxis, NumericAxisOptions, NumericRunConfigAxisOptions, ReportInput, RunConfigKey, ScatterData, ScopeSummaryData, ScopeWarning, ScoreboardData, TableData, VerdictTally, } from "./types.ts";
+export type { Aggregator, AttemptListItem, AttemptLocator, BuiltInDimension, CustomDimension, DeltaData, DeltaPair, DimensionInput, DimensionOptions, DimensionRef, EvalListItem, ExperimentComparisonData, ExperimentComparisonGroupData, ExperimentListEvalRow, ExperimentListItem, FlagPairs, LineData, MatrixData, Metric, MetricAggregate, MetricCell, MetricColumn, NumericAxis, NumericAxisOptions, NumericRunConfigAxisOptions, ReportInput, RunConfigKey, ScatterData, ScopeSummaryData, ScopeWarning, ScoreboardData, TableData, VerdictTally, } from "./types.ts";
 export type { AttemptHandle, Results, Scope, Snapshot } from "../results/types.ts";
 export { experimentGroupOf } from "../shared/aggregate.ts";

package/dist/report/types.d.ts

@@ -359,13 +359,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/dist/results/types.d.ts

@@ -33,13 +33,6 @@ export interface SnapshotMeta {
     completedAt?: string;
     /** 写入时刻该实验已知的 eval 并集 —— 残缺检测的分母随数据走(copySnapshots 自动补记,writer 可声明)。 */
     knownEvalIds?: string[];
-    /**
-     * 发布拷贝的自描述标记:copySnapshots 补记,消毒函数 → "applied"、redact: false → "none";
-     * 本地事实根没有此字段。只声明流程,不证明无秘密;view --out 据此分级防呆。
-     */
-    publish?: {
-        redaction: "applied" | "none";
-    };
     /** 项目名(来自 config.name),透传给 `niceeval view` 顶部 hero 显示。 */
     name?: LocalizedText;
 }
@@ -117,10 +110,6 @@ export interface Snapshot {
     dir: string;
     /** 写入时刻该实验已知的 eval 并集(可选);copySnapshots 自动补记,writer.snapshot() 也可声明。 */
     knownEvalIds?: string[];
-    /** 发布拷贝的自描述标记(见 SnapshotMeta.publish);本地事实根没有此字段。 */
-    publish?: {
-        redaction: "applied" | "none";
-    };
 }
 /** 一个实验的全部历史:同一 experiment id 的历次快照归在一起。 */
 export interface Experiment {

package/docs-site/zh/how-to/publish-report.mdx

@@ -20,12 +20,9 @@ const results = await openResults(".niceeval");
 await rm(output, { recursive: true, force: true });
 await copySnapshots(results.latest(), output, {
   artifacts: ["sources", "events", "trace", "o11y", "agentSetup"],
-  redact: (text) => text.replaceAll(/sk-[A-Za-z0-9]+/g, "[redacted]"),
 });
 ```
 
-`redact` 是必填项：给一个函数改写待发布文件里的自由文本，或者确认这批数据可以原文公开、显式传 `redact: false`。要发布的站点谁都能翻到 prompt 和工具输出，这个选择必须写在脚本里。
-
 运行 `npx tsx scripts/publish-results.ts`，然后提交 `report-data/`。`copySnapshots` 在创建目录前检查所有待发布文件；任何文件超过 50 MiB 时整体失败并列出路径、大小和处理建议，不会留下半份目录。`diff` 缺省不发布；需要 diff 时显式加进 `artifacts`，它也受同一个预算约束。历史版本留下的超大 events / trace 不会被悄悄改写，预检会要求你排除这类证据或用当前版本重跑。
 
 ## 构建命令就是导出命令
@@ -139,4 +136,4 @@ jobs:
 
 ## 发布的是选中的证据
 
-整站导出会带上发布结果根里选中的 transcript、源码快照和 trace。新写入的超大 events / trace 字符串可能带结构化截断标记。`copySnapshots` 只在你给了消毒函数时改写自由文本（`redact` 是必填项，见上），其余只做选择和整文件大小预检；传 `redact: false` 的目录再导出时还要加 `--allow-sensitive-artifacts` 确认一次。发布到公网前确认结果里没有密钥或敏感数据。
+整站导出会带上发布结果根里选中的 transcript、源码快照和 trace。新写入的超大 events / trace 字符串可能带结构化截断标记。`copySnapshots` 只做选择和整文件大小预检，不改写任何内容。发布的站点谁都能翻到 prompt 和工具输出，发布到公网前确认结果内容适合公开——NiceEval 在记录时就不把环境变量值和命令输出写进结果文件，transcript 里是 Agent 自己的输入输出和你的 eval 任务本身。

package/docs-site/zh/reference/cli.mdx

@@ -88,7 +88,6 @@ npx niceeval exp compare-models weather
 | `--json` | string | 额外写一份 JSON 结果(`RunSummary` 原样序列化)到指定路径,供 CI 或下游脚本消费。 |
 | `--out` | string | `view` 命令专用:把结果查看器静态导出到指定目录。 |
 | `--port` | number | `view` 命令专用:指定本地服务器监听端口。 |
-| `--allow-sensitive-artifacts` | boolean | `view --out` 专用:对非发布根(快照没有 publish:{redaction:"applied"} 标记)导出时的显式确认——静态站会原样携带未消毒的证据文件。 |
 | `--source` | boolean | `show` 命令专用:该 attempt 运行时保存的 Eval 源码,gate/soft 断言标回源码行(证据切面)。 |
 | `--execution` | boolean | `show` 命令专用:该 attempt 的标准执行事件流(消息、thinking、Skill load、工具调用/结果);有 OTel 时同一节点补时间(证据切面)。 |
 | `--timing` | boolean | `show` 命令专用:整个 Attempt 的统一时间树;裸 `--timing` 给有界诊断投影,`--timing=full` 逐节点展开全部 runner/已关联 OTel 节点。 |

package/docs-site/zh/reference/report-components.mdx

@@ -211,7 +211,7 @@ inspect: niceeval show @<id> [--eval|--execution|--diff]
 每项固定代表一个 Attempt，显示 experiment、Eval、Attempt 序号、判定、耗时、成本、失败断言、结构化 error 的一层摘要、Judge 评语和证据链接。diagnostics、cause 和 stack 留给 locator 下钻详情，避免比较列表被基础设施日志撑开。它既能列失败证据，也能列通过样本，不把 verdict 过滤写死在组件名里。
 
 ```tsx
-const attempts = await AttemptList.data(selection, { redact });
+const attempts = await AttemptList.data(selection);
 
 <AttemptList
   items={attempts.filter((item) => item.verdict === "failed" || item.verdict === "errored")}
@@ -234,7 +234,7 @@ inspect: niceeval show @<id> [--eval|--execution|--diff]
 (3 more not shown · showing 20 of 23)
 ```
 
-要在页面显示前遮蔽 error message/cause/stack、diagnostic message/data、断言 detail 或 Judge 评语，把 `redact` 交给 `.data()`；稳定 code、lifecycle operation、experiment、Eval 和 locator 不改。它只影响这份组件数据，管不到发布目录里的 artifact 文件——发布数据集的消毒用 [`copySnapshots` 的 `redact` 选项](/zh/reference/results-data)。要展示哪些 Attempt，过滤返回的 `AttemptListItem[]`。`limit` 也由报告作者在数组上用 `.slice(0, 20)` 表达，截断时把原始数量交给组件的 `total`，组件据此显示“还有 n 项未展示”，不静默截断。
+要展示哪些 Attempt，过滤返回的 `AttemptListItem[]`。`limit` 也由报告作者在数组上用 `.slice(0, 20)` 表达，截断时把原始数量交给组件的 `total`，组件据此显示“还有 n 项未展示”，不静默截断。
 
 ## 指标表（`MetricTable`）
 

package/docs-site/zh/reference/results-data.mdx

@@ -235,9 +235,7 @@ import { openResults, copySnapshots } from "niceeval/results";
 const results = await openResults(".niceeval");
 await copySnapshots(results.latest(), "site-data/run", {
   artifacts: ["sources", "events", "trace", "o11y"],   // diff 不截断,缺省也不带;
-  redact: (text) => text.replaceAll(/sk-[A-Za-z0-9]+/g, "[redacted]"),
-});                                                     // redact 必填:函数消毒,或 false 显式声明原文发布;
-                                                        // 每个待发布文件还会经过 50 MiB 预检;
+});                                                     // 每个待发布文件还会经过 50 MiB 预检;
                                                         // o11y 只有几 KB,报告用到 turns 这类
                                                         // 读 o11y 的指标就把它带上,不然渲染成「—」
 ```
@@ -246,7 +244,7 @@ await copySnapshots(results.latest(), "site-data/run", {
 
 复制开始前，NiceEval 会规划全部目标文件并检查序列化后的大小。任一文件超过固定的 50 MiB，整次复制在创建目标目录前失败，错误会列出路径、实际大小和处理建议。你可以从 `artifacts` 排除那类证据；如果是旧版本留下的超大 events / trace，用当前版本重跑后再发布。这个检查既覆盖没有逐值截断的源码 / diff，也覆盖单值都正常但累计过大的 JSON，避免直到 `git push` 才撞上 Git host 的单文件限制。
 
-大小预检只决定整次复制成功或失败，不会从一个超大文件中间删内容。消毒不是可选项——`copySnapshots` 要求显式传 `redact`：给一个函数就改写复制出来的所有文件里的自由文本（events、trace、源码、diff、运行摘要都在内；id、事件类型这类标识字段不动），确定这批数据可以原文公开就传 `redact: false`，两个都不传会直接报错。注意报告积木 `AttemptList.data` 的 `redact` 只影响页面上显示的数据，管不到发布目录里的 artifact 文件；发布场景一律在 `copySnapshots` 这一步消毒。唯一随行补记的是挑选时的**覆盖事实**：`partial-coverage` 警告的分母是实验的历史并集，而发布目录没有历史——所以每个复制出的快照带上 `knownEvalIds`（复制时刻该实验已知的 eval 并集），reader 端把它并进 `exp.evalIds` 的计算（取本地历史与快照携带值的并集）。发布目录上重新 `openResults().latest()`，残缺警告被同一套机制重新算出来，不靠发布者转述。复制出的目录就是标准结果目录，`niceeval view --results <目录>` 直接能看；要让报告站随 push 自动更新，workflow 见[通过 CI 发布报告](/zh/how-to/publish-report)。
+大小预检只决定整次复制成功或失败，不会从一个超大文件中间删内容。复制忠实于源：artifact 按原字节复制，不重新序列化、不改写。唯一随行补记的是挑选时的**覆盖事实**：`partial-coverage` 警告的分母是实验的历史并集，而发布目录没有历史——所以每个复制出的快照带上 `knownEvalIds`（复制时刻该实验已知的 eval 并集），reader 端把它并进 `exp.evalIds` 的计算（取本地历史与快照携带值的并集）。发布目录上重新 `openResults().latest()`，残缺警告被同一套机制重新算出来，不靠发布者转述。复制出的目录就是标准结果目录，`niceeval view --results <目录>` 直接能看；要让报告站随 push 自动更新，workflow 见[通过 CI 发布报告](/zh/how-to/publish-report)。
 
 ## 分层速览
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niceeval",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Agent-native eval tool — eval agents, services, functions, and coding-agent fixtures",
   "type": "module",
   "license": "MIT",

package/src/cli.ts

@@ -105,7 +105,6 @@ interface Flags {
   timing?: "summary" | "full";
   keepSandbox?: "failed" | "all";
   all: boolean;
-  allowSensitiveArtifacts: boolean;
   window?: string;
   sandboxPath?: string;
   leaveRunning: boolean;
@@ -156,8 +155,6 @@ const FLAG_OPTIONS = {
   out: { type: "string" },
   /** `view` 命令专用:指定本地服务器监听端口。 */
   port: { type: "string" },
-  /** `view --out` 专用:对非发布根(快照没有 publish:{redaction:"applied"} 标记)导出时的显式确认——静态站会原样携带未消毒的证据文件。 */
-  "allow-sensitive-artifacts": { type: "boolean" },
   // show 的证据切面 / 时间轴 / 报告装载(docs-site/zh/how-to/viewing-results.mdx)。
   // 证据切面只认 `@<locator>`(或收窄到单个 eval 的前缀)选出的那一个 attempt——不再有
   // 数字 `--attempt`,选哪个 attempt 由 locator 精确指名,不是「先选 eval 再挑第几次」。
@@ -307,7 +304,6 @@ function parseArgs(argv: string[]): { command: string; positionals: string[]; fl
     timing: values.timing === true ? (timingMode ?? "summary") : undefined,
     keepSandbox: values["keep-sandbox"] === true ? (keepSandboxTier ?? "failed") : undefined,
     all: values.all === true,
-    allowSensitiveArtifacts: values["allow-sensitive-artifacts"] === true,
     window: values.window as string | undefined,
     sandboxPath: values.path as string | undefined,
     leaveRunning: values["leave-running"] === true,
@@ -591,7 +587,7 @@ async function main(): Promise<void> {
       ...(flags.page !== undefined ? { page: flags.page } : {}),
     };
     if (flags.out) {
-      const out = await buildView({ input: viewInput.input, out: flags.out, allowSensitiveArtifacts: flags.allowSensitiveArtifacts, scan }).catch(exitOnViewUserError);
+      const out = await buildView({ input: viewInput.input, out: flags.out, scan }).catch(exitOnViewUserError);
       process.stdout.write(t("cli.view.exportedDir", { out }));
       process.exit(0);
     }

package/src/context/context.ts

@@ -165,7 +165,7 @@ export function createEvalContext(deps: ContextDeps): { context: TestContext; st
     return brief(value, 4000);
   }
 
-  /** 失败断言的 evidence:被检查值自带命令摘要(CommandResult.command)时就是「命令行本身」。 */
+  /** evidence 不区分 pass/fail(与 judge 同口径):被检查值自带命令摘要(CommandResult.command)时就是「命令行本身」。 */
   function checkedValueEvidence(value: unknown): string | undefined {
     const command = asCommandResult(value)?.command;
     return typeof command === "string" && command.length > 0 ? command : undefined;
@@ -378,12 +378,15 @@ export function createEvalContext(deps: ContextDeps): { context: TestContext; st
         evaluate: async (sc) => {
           const resolved = await resolveValue(value, sc);
           const score = await assertion.score(resolved);
-          if (computePassed(spec.severity, spec.threshold, score)) return score;
+          const evidence = checkedValueEvidence(resolved);
+          if (computePassed(spec.severity, spec.threshold, score)) {
+            return evidence !== undefined ? { score, evidence } : score;
+          }
           return {
             score,
             expected: assertion.expected,
             received: previewCheckedValue(resolved),
-            ...(checkedValueEvidence(resolved) !== undefined ? { evidence: checkedValueEvidence(resolved) } : {}),
+            ...(evidence !== undefined ? { evidence } : {}),
           };
         },
       };
@@ -395,18 +398,21 @@ export function createEvalContext(deps: ContextDeps): { context: TestContext; st
       const score = await assertion.score(v);
       // require 恒为硬门槛(不过即中止 eval),判定口径与 finalize 同一份 computePassed。
       const passed = computePassed("gate", assertion.threshold, score);
+      const evidence = checkedValueEvidence(v);
       collector.record({
         name: assertion.name,
         severity: "gate",
         threshold: assertion.threshold,
         evaluate: () =>
           passed
-            ? score
+            ? evidence !== undefined
+              ? { score, evidence }
+              : score
             : {
                 score,
                 expected: assertion.expected,
                 received: previewCheckedValue(v),
-                ...(checkedValueEvidence(v) !== undefined ? { evidence: checkedValueEvidence(v) } : {}),
+                ...(evidence !== undefined ? { evidence } : {}),
               },
       });
       if (!passed) throw new EvalRequirementFailed(assertion.name);

package/src/report/components.tsx

@@ -26,7 +26,6 @@ import type { AttemptLocator } from "../results/locator.ts";
 import type {
   AttemptListItem,
   DeltaData,
-  EntityListDataOptions,
   EvalListItem,
   ExperimentComparisonData,
   ExperimentListItem,
@@ -400,7 +399,7 @@ interface EntityListChrome extends ChromeProps {
 
 export type ExperimentListProps = DataProps<
   readonly ExperimentListItem[],
-  EntityListDataOptions,
+  Record<never, never>,
   EntityListChrome & {
     /** web 面在比较表前显示实验过滤框;text 面忽略。 */
     filter?: boolean;
@@ -415,14 +414,14 @@ export type ExperimentListProps = DataProps<
 /** 实验列表:每项一个 experiment,固定八列比较表 + 展开到 Eval / Attempt。 */
 export const ExperimentList = makeDataComponent<
   readonly ExperimentListItem[],
-  EntityListDataOptions,
+  Record<never, never>,
   EntityListChrome & { filter?: boolean; relativeTo?: string }
 >({
   name: "ExperimentList",
   dataFnName: "experimentListData",
   shapeName: "ExperimentListItem[]",
-  dataFn: (input, options) => experimentListData(input, options),
-  specKeys: ["redact"],
+  dataFn: (input) => experimentListData(input),
+  specKeys: [],
   validate: validateExperimentListData,
   web: (props, ctx) => (
     <ExperimentListWeb
@@ -437,15 +436,15 @@ export const ExperimentList = makeDataComponent<
   text: (props, ctx) => experimentListText(props.data, ctx, props.relativeTo),
 }) as unknown as ReportComponent<ExperimentListProps>;
 
-export type EvalListProps = DataProps<readonly EvalListItem[], EntityListDataOptions, EntityListChrome>;
+export type EvalListProps = DataProps<readonly EvalListItem[], Record<never, never>, EntityListChrome>;
 
 /** Eval 列表:每项一个 experimentId + evalId,展开到这道题的 Attempt。 */
-export const EvalList = makeDataComponent<readonly EvalListItem[], EntityListDataOptions, EntityListChrome>({
+export const EvalList = makeDataComponent<readonly EvalListItem[], Record<never, never>, EntityListChrome>({
   name: "EvalList",
   dataFnName: "evalListData",
   shapeName: "EvalListItem[]",
-  dataFn: (input, options) => evalListData(input, options),
-  specKeys: ["redact"],
+  dataFn: (input) => evalListData(input),
+  specKeys: [],
   validate: validateEvalListData,
   web: (props, ctx) => (
     <EvalListWeb
@@ -460,7 +459,7 @@ export const EvalList = makeDataComponent<readonly EvalListItem[], EntityListDat
 
 export type AttemptListProps = DataProps<
   readonly AttemptListItem[],
-  EntityListDataOptions,
+  Record<never, never>,
   EntityListChrome & {
     /** 过滤 / 截断前的总数;省略时等于 data 长度。 */
     total?: number;
@@ -470,14 +469,14 @@ export type AttemptListProps = DataProps<
 /** Attempt 列表:实体列表的叶子层,每项一次 attempt 的判定、单行摘要与 locator。 */
 export const AttemptList = makeDataComponent<
   readonly AttemptListItem[],
-  EntityListDataOptions,
+  Record<never, never>,
   EntityListChrome & { total?: number }
 >({
   name: "AttemptList",
   dataFnName: "attemptListData",
   shapeName: "AttemptListItem[]",
-  dataFn: (input, options) => attemptListData(input, options),
-  specKeys: ["redact"],
+  dataFn: (input) => attemptListData(input),
+  specKeys: [],
   validate: validateAttemptListData,
   web: (props, ctx) => (
     <AttemptListWeb
@@ -498,7 +497,6 @@ export interface FailureListProps {
   limit?: number;
   /** 默认宿主注入的 Scope。 */
   input?: ReportInput;
-  redact?: (text: string) => string;
   attemptHref?: (locator: AttemptLocator) => string;
   locale?: ReportLocale;
   className?: string;
@@ -512,7 +510,7 @@ export interface FailureListProps {
  */
 export const FailureList = defineComponent<FailureListProps>(async (props, ctx) => {
   const input = props.input ?? ctx.scope;
-  const all = await attemptListData(input, props.redact !== undefined ? { redact: props.redact } : undefined);
+  const all = await attemptListData(input);
   // attempt 开始时间不在列表条目里(它不是列表展示字段);从同一 input 的读取面按 locator 对回。
   const startedAtByLocator = new Map<string, string>();
   for (const item of collectItems(resolveInput(input).snapshots)) {

package/src/report/compute.ts

@@ -17,7 +17,6 @@ import type {
   DeltaData,
   DeltaPair,
   DimensionInput,
-  EntityListDataOptions,
   EvalListItem,
   ExperimentComparisonData,
   ExperimentComparisonGroupData,
@@ -199,10 +198,8 @@ function failureSummaryOf(result: EvalResult): { summary: string | null; more: n
   return { summary: null, more: 0 };
 }
 
-const identityRedact = (text: string): string => text;
-
 /** AttemptList / ExperimentList / EvalList 共用的叶子构造:一个 Item → 一个 AttemptListItem。 */
-async function attemptListItemOf(item: Item, redact: (text: string) => string): Promise<AttemptListItem> {
+async function attemptListItemOf(item: Item): Promise<AttemptListItem> {
   const result = item.attempt.result;
   const { summary, more } = failureSummaryOf(result);
   return {
@@ -211,7 +208,7 @@ async function attemptListItemOf(item: Item, redact: (text: string) => string):
     attempt: result.attempt,
     agent: result.agent,
     verdict: result.verdict,
-    failureSummary: summary === null ? null : redact(summary),
+    failureSummary: summary,
     moreFailures: more,
     examScore: await computeCell(examScore, [item]),
     durationMs: result.durationMs,
@@ -221,20 +218,15 @@ async function attemptListItemOf(item: Item, redact: (text: string) => string):
 }
 
 /** `attemptListData(input)`:每个 Attempt 一项,顺序取自 Scope 展平顺序(不重排)。 */
-export async function attemptListData(
-  input: ReportInput,
-  options?: EntityListDataOptions,
-): Promise<AttemptListItem[]> {
+export async function attemptListData(input: ReportInput): Promise<AttemptListItem[]> {
   const { snapshots } = resolveInput(input);
-  const redact = options?.redact ?? identityRedact;
   const items = collectItems(snapshots);
-  return Promise.all(items.map((item) => attemptListItemOf(item, redact)));
+  return Promise.all(items.map((item) => attemptListItemOf(item)));
 }
 
 /** `evalListData(input)`:每个 `experimentId + evalId` 一项,按 evalId 再按 experimentId 升序。 */
-export async function evalListData(input: ReportInput, options?: EntityListDataOptions): Promise<EvalListItem[]> {
+export async function evalListData(input: ReportInput): Promise<EvalListItem[]> {
   const { snapshots } = resolveInput(input);
-  const redact = options?.redact ?? identityRedact;
   const items = collectItems(snapshots);
   const groups = new Map<string, Item[]>();
   for (const item of items) {
@@ -247,7 +239,7 @@ export async function evalListData(input: ReportInput, options?: EntityListDataO
   for (const group of groups.values()) {
     const sorted = [...group].sort((a, b) => a.attempt.result.attempt - b.attempt.result.attempt);
     const verdict = foldEvalVerdict(sorted.map((item) => item.attempt.result));
-    const attempts = await Promise.all(sorted.map((item) => attemptListItemOf(item, redact)));
+    const attempts = await Promise.all(sorted.map((item) => attemptListItemOf(item)));
     out.push({
       experimentId: experimentIdOf(sorted[0]!),
       evalId: evalIdOf(sorted[0]!),
@@ -269,12 +261,8 @@ export async function evalListData(input: ReportInput, options?: EntityListDataO
  * Snapshot[] 时若同一 experiment 混入不一致的可比性配置,按完整用户反馈失败并指引——
  * 看跨配置演化用 snapshot 维度或 MetricLine,不把两套配置拼成一行冒充单一配置。
  */
-export async function experimentListData(
-  input: ReportInput,
-  options?: EntityListDataOptions,
-): Promise<ExperimentListItem[]> {
+export async function experimentListData(input: ReportInput): Promise<ExperimentListItem[]> {
   const { snapshots } = resolveInput(input);
-  const redact = options?.redact ?? identityRedact;
 
   // 可比性配置单义检查:同一 experiment 的输入快照必须共享一套可比性配置。
   const configByExperiment = new Map<string, { snapshot: Snapshot; config: unknown }>();
@@ -304,7 +292,7 @@ export async function experimentListData(
     for (const [evalId, evalItems] of evalGroups) {
       const sorted = [...evalItems].sort((a, b) => a.attempt.result.attempt - b.attempt.result.attempt);
       const verdict = foldEvalVerdict(sorted.map((item) => item.attempt.result));
-      const attempts = await Promise.all(sorted.map((item) => attemptListItemOf(item, redact)));
+      const attempts = await Promise.all(sorted.map((item) => attemptListItemOf(item)));
       evalRows.push({
         evalId,
         verdict,

package/src/report/index.ts

@@ -168,7 +168,6 @@ export type {
   DimensionInput,
   DimensionOptions,
   DimensionRef,
-  EntityListDataOptions,
   EvalListItem,
   ExperimentComparisonData,
   ExperimentComparisonGroupData,

package/src/report/report.test.ts

@@ -3,8 +3,8 @@
 // niceeval/results 的读取契约手工构造)。覆盖登记行:两级聚合 vs 平铺、errored=0 口径、
 // skipped=null、null≠0、Scoreboard 固定分母(notRun/unscorable 分开)、权重最长前缀、
 // 身份键去重、现刻水位、自定义指标 where/aggregate、evalGroup 完整父路径、verdict 权威、
-// MetricCell 诚实、缺 artifact 指标、repeatedFailedCommands、实体列表 failureSummary /
-// redact、scopeSummaryData 两级计票、experimentComparisonData 分区、pairsByFlag、
+// MetricCell 诚实、缺 artifact 指标、repeatedFailedCommands、实体列表 failureSummary、
+// scopeSummaryData 两级计票、experimentComparisonData 分区、pairsByFlag、
 // MetricLine 点身份、空数组反馈、metricTableData sort。
 
 import { describe, expect, it } from "vitest";
@@ -595,24 +595,6 @@ describe("实体列表 data", () => {
     expect(byEval.get("list/errored")!.costUSD).toBeNull();
   });
 
-  it("redact 只改写 failureSummary(含嵌套 attempt 条目);身份字段、locator 与数值指标原样", async () => {
-    const redact = (text: string) => text.replaceAll("41", "[redacted]");
-    const attempts = await attemptListData([listSnap()], { redact });
-    const failedItem = attempts.find((item) => item.evalId === "list/failed")!;
-    expect(failedItem.failureSummary).toContain("[redacted]");
-    expect(failedItem.evalId).toBe("list/failed");
-    expect(failedItem.experimentId).toBe("exp/list");
-    expect(failedItem.costUSD).toBe(0.1);
-
-    const evals = await evalListData([listSnap()], { redact });
-    const nested = evals.find((item) => item.evalId === "list/failed")!.attempts[0]!;
-    expect(nested.failureSummary).toContain("[redacted]");
-
-    const experiments = await experimentListData([listSnap()], { redact });
-    const nestedInExp = experiments[0]!.evalRows.find((row) => row.evalId === "list/failed")!.attempts[0]!;
-    expect(nestedInExp.failureSummary).toContain("[redacted]");
-  });
-
   it("experimentListData:evalVerdicts / endToEndPassRate / costUSD / durationMs / tokens 齐全,默认按端到端成功率降序", async () => {
     const winner = snap({ experimentId: "exp/win", results: [res("a", "passed"), res("b", "passed")] });
     const loser = snap({ experimentId: "exp/lose", results: [res("a", "failed"), res("b", "passed")] });

package/src/report/types.ts

@@ -394,14 +394,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/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/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;
-}

package/src/results/results.test.ts

@@ -552,7 +552,7 @@ describe("createResultsWriter", () => {
     expect(await q2.agentSetup()).toBeNull();
 
     const dest = join(await makeRoot(), "published");
-    await copySnapshots(results.latest(), dest, { ...{ artifacts: ["agentSetup"] }, redact: false });
+    await copySnapshots(results.latest(), dest, { artifacts: ["agentSetup"] });
     const copied = join(dest, "skill-ab_claude-effect", basename(snap.dir), "q1", "a1", "agent-setup.json");
     expect(JSON.parse(await readFile(copied, "utf-8"))).toEqual(manifest);
   });
@@ -737,7 +737,7 @@ describe("copySnapshots", () => {
 
     const results = await openResults(root);
     const dest = join(await makeRoot(), "site/data/run");
-    const copied = await copySnapshots(results.latest(), dest, { ...{ artifacts: ["events"] }, redact: false });
+    const copied = await copySnapshots(results.latest(), dest, { artifacts: ["events"] });
 
     expect(copied.warnings).toHaveLength(0);
     expect(copied.dir).toBe(dest);
@@ -775,15 +775,15 @@ describe("copySnapshots", () => {
 
     const occupied = await makeRoot();
     await writeFile(join(occupied, "existing.txt"), "x", "utf-8");
-    await expect(copySnapshots(results.latest(), occupied, { redact: false })).rejects.toThrow(/not empty/);
+    await expect(copySnapshots(results.latest(), occupied)).rejects.toThrow(/not empty/);
 
-    await expect(copySnapshots(results.latest(), join(await makeRoot(), "out"), { ...{ artifacts: ["evnets" as never] }, redact: false })).rejects.toThrow(/Unknown artifact kind/);
+    await expect(copySnapshots(results.latest(), join(await makeRoot(), "out"), { artifacts: ["evnets" as never] })).rejects.toThrow(/Unknown artifact kind/);
 
-    await expect(copySnapshots([], join(await makeRoot(), "out"), { redact: false })).rejects.toThrow(/no snapshots/);
+    await expect(copySnapshots([], join(await makeRoot(), "out"))).rejects.toThrow(/no snapshots/);
 
     // 手工传入同一 experiment 的两个快照(未走 latest 去重):只带最新,记 warning。
     const dest2 = join(await makeRoot(), "run2");
-    const collided = await copySnapshots(results.experiments[0].snapshots, dest2, { redact: false });
+    const collided = await copySnapshots(results.experiments[0].snapshots, dest2);
     expect(collided.warnings).toHaveLength(1);
     expect(collided.warnings[0]).toMatch(/multiple snapshots selected/);
     const destDirs = await readdir(join(dest2, "e"));
@@ -1005,7 +1005,7 @@ describe("AttemptLocator · 落盘 / 读取 / 携带 / 撞车", () => {
     const locator1 = a1!.locator!;
 
     const dest = join(await makeRoot(), "published");
-    await copySnapshots(results.latest(), dest, { ...{ artifacts: [] }, redact: false });
+    await copySnapshots(results.latest(), dest, { artifacts: [] });
 
     const destResults = await openResults(dest);
     expect(resolveLocator(destResults, locator0).result.attempt).toBe(0);
@@ -1192,7 +1192,7 @@ describe("sources · 快照级去重仓库", () => {
 
     const results = await openResults(root);
     const dest = join(await makeRoot(), "published");
-    await copySnapshots(results.latest(), dest, { ...{ artifacts: ["sources"] }, redact: false });
+    await copySnapshots(results.latest(), dest, { artifacts: ["sources"] });
 
     const destSnapDir = join(dest, "e", basename(snap.dir));
     const destStoreFiles = await readdir(join(destSnapDir, "sources"));

package/src/results/types.ts

@@ -44,11 +44,6 @@ export interface SnapshotMeta {
   completedAt?: string;
   /** 写入时刻该实验已知的 eval 并集 —— 残缺检测的分母随数据走(copySnapshots 自动补记,writer 可声明)。 */
   knownEvalIds?: string[];
-  /**
-   * 发布拷贝的自描述标记:copySnapshots 补记,消毒函数 → "applied"、redact: false → "none";
-   * 本地事实根没有此字段。只声明流程,不证明无秘密;view --out 据此分级防呆。
-   */
-  publish?: { redaction: "applied" | "none" };
   /** 项目名(来自 config.name),透传给 `niceeval view` 顶部 hero 显示。 */
   name?: LocalizedText;
 }
@@ -130,8 +125,6 @@ export interface Snapshot {
   dir: string;
   /** 写入时刻该实验已知的 eval 并集(可选);copySnapshots 自动补记,writer.snapshot() 也可声明。 */
   knownEvalIds?: string[];
-  /** 发布拷贝的自描述标记(见 SnapshotMeta.publish);本地事实根没有此字段。 */
-  publish?: { redaction: "applied" | "none" };
 }
 
 /** 一个实验的全部历史:同一 experiment id 的历次快照归在一起。 */

package/src/view/artifact-serving.test.ts

@@ -119,7 +119,7 @@ describe("index.ts · copyFetchedArtifacts(--out 静态导出)对 sources.json
     await seedDedupedSnapshot(root);
 
     const out = join(root, "site");
-    await buildView({ input: root, out , allowSensitiveArtifacts: true });
+    await buildView({ input: root, out  });
 
     const scan = await loadViewScan(root);
     const byId = new Map(scan.viewData.snapshots.flatMap((s) => s.results.map((r) => [r.id, r])));

package/src/view/data.ts

@@ -57,12 +57,6 @@ export interface ViewScan {
   reportPages: ViewReportPageHtml[];
   /** 外壳注入资产(styles / scripts;{src} 已按路径纪律解析成 inline 内容),只进 web 面。 */
   shellAssets: { styles: string[]; scripts: string[]; head: ResolvedHeadTag[] };
-  /**
-   * --out 的数据等级(见 docs/feature/reports/view.md「静态导出」):全部选中快照带
-   * publish:{redaction:"applied"} 才是 "applied",否则 "sensitive"(含本地事实根与
-   * redaction:"none"——上游声明过原文发布也不豁免导出时的确认)。
-   */
-  publishState: "applied" | "sensitive";
 }
 
 /** view 宿主输入的组合语义(与 show 对齐,docs/feature/reports/architecture.md「Scope 是计算入口」)。 */
@@ -292,17 +286,12 @@ export async function loadViewScan(input?: string, opts: ViewScanOptions = {}):
     skippedRuns: results.skipped.map(toSkippedNotice),
     report: slot.meta,
   };
-  const publishState =
-    selection.snapshots.length > 0 && selection.snapshots.every((snap) => snap.publish?.redaction === "applied")
-      ? ("applied" as const)
-      : ("sensitive" as const);
   return {
     viewData,
     artifactDirs,
     attemptsByBase,
     reportPages: slot.pages,
     shellAssets: slot.shellAssets,
-    publishState,
   };
 }
 

package/src/view/index.ts

@@ -88,23 +88,12 @@ export async function buildView(opts: ViewOptions = {}): Promise<string> {
       "--out exports the whole results root and cannot be combined with eval prefixes or --experiment.\n" +
         "To publish a site for one experiment, build a narrower results root and export that:\n" +
         '  const results = await openResults(".niceeval");\n' +
-        '  await copySnapshots(results.latest().filter((s) => s.experimentId.startsWith("<prefix>/")), "<publish-root>", { redact });\n' +
+        '  await copySnapshots(results.latest().filter((s) => s.experimentId.startsWith("<prefix>/")), "<publish-root>");\n' +
         "Then: niceeval view --results <publish-root> --out <site>",
     );
   }
   // 静态导出保持「任一页失败整体失败」(pageFailure 缺省 "throw"),不产出半套站点。
   const plan = await planSite(opts.input, opts.scan);
-  // --out 按发布防呆二分(见 docs/feature/reports/view.md「静态导出」):目标结果根的全部快照
-  // 带 publish:{redaction:"applied"}(copySnapshots 补记)时直接导出;redaction:"none"、
-  // 无标记结果或本地事实根,都必须显式传 --allow-sensitive-artifacts——静态站原样携带证据文件,
-  // 上游声明过原文发布也不豁免这里的确认。
-  if (!opts.allowSensitiveArtifacts && plan.scan.publishState !== "applied") {
-    throw new ViewInputError(
-      `--out refuses to export unredacted results: not every selected snapshot carries publish: { redaction: "applied" }. ` +
-        `Produce a publish root first with copySnapshots({ redact }) and export that (niceeval view --results <publish-root> --out <site>), ` +
-        `or pass --allow-sensitive-artifacts to explicitly export raw evidence (prompts, tool args, full outputs, sources).`,
-    );
-  }
   await writeSite(plan, out);
   return out;
 }

package/src/view/server.ts

@@ -13,8 +13,6 @@ export interface ViewOptions {
   input?: string;
   out?: string;
   port?: number;
-  /** `--out` 对非发布根(无 publish:applied 标记)导出时的显式确认;静态站原样携带证据文件。 */
-  allowSensitiveArtifacts?: boolean;
   /** 报告槽的组合语义(位置前缀 / --experiment / --report),透传给站点管线。 */
   scan?: ViewScanOptions;
 }

package/src/view/site-parity.test.ts

@@ -54,7 +54,7 @@ describe("站点管线奇偶:server 与 --out 是同一份产物", () => {
     await seedSnapshot(root, "exp", "q1");
 
     const out = await makeDir("niceeval-parity-out-");
-    await buildView({ input: root, out, allowSensitiveArtifacts: true });
+    await buildView({ input: root, out });
     server = await startViewServer({ input: root });
 
     // 清单驱动遍历:计划里的每一个路径,写盘字节 ≡ 服务字节。

package/src/view/site.ts

@@ -21,7 +21,7 @@ export interface SiteFile {
 export interface SitePlan {
   /** path → SiteFile;写盘按它遍历,server 按它查表(查不到即 404,不存在旁路取数)。 */
   files: Map<string, SiteFile>;
-  /** 构建这份产物用的扫描结果(publishState 等宿主前置校验用;不进产物)。 */
+  /** 构建这份产物用的扫描结果(宿主前置校验与调试用;不进产物)。 */
   scan: ViewScan;
 }
 

package/src/view/view-report.test.ts

@@ -398,7 +398,7 @@ describe("buildView · --out 与 --report", () => {
     await writeFile(join(artifactDir, "events.json"), "[]", "utf-8");
 
     const out = join(root, "site");
-    await buildView({ input: root, out, allowSensitiveArtifacts: true, scan: { report: { path: EXAM_REPORT, cwd: root } } });
+    await buildView({ input: root, out, scan: { report: { path: EXAM_REPORT, cwd: root } } });
 
     const html = await readFile(join(out, "index.html"), "utf-8");
     // 双语两个 <template> 静态块都在,壳按界面语言摆放。
@@ -424,7 +424,7 @@ describe("buildView · --out 与 --report", () => {
     await writeFile(join(artifactDir, "o11y.json"), "{}", "utf-8");
 
     const out = join(root, "site");
-    await buildView({ input: root, out, allowSensitiveArtifacts: true });
+    await buildView({ input: root, out });
     const exported = join(out, "artifact", "compare_codex/2026-07-09T10-00-00-000Z/weather/brooklyn/a0");
     expect(existsSync(join(exported, "diff.json"))).toBe(true);
     expect(existsSync(join(exported, "events.json"))).toBe(true);
@@ -435,10 +435,10 @@ describe("buildView · --out 与 --report", () => {
     const root = await seedRoot();
     const out = join(root, "site");
     for (const scan of [{ patterns: ["weather"] }, { experiment: "compare/bub" }]) {
-      const attempt = buildView({ input: root, out, allowSensitiveArtifacts: true, scan });
+      const attempt = buildView({ input: root, out, scan });
       await expect(attempt).rejects.toBeInstanceOf(ViewInputError);
       await expect(
-        buildView({ input: root, out, allowSensitiveArtifacts: true, scan }),
+        buildView({ input: root, out, scan }),
       ).rejects.toThrow(/copySnapshots/);
     }
     // 同参数不带 --out 时照常收窄报告槽(不报错)。
@@ -448,7 +448,7 @@ describe("buildView · --out 与 --report", () => {
   it("默认导出(无 --report):报告槽填充 ExperimentComparison,双语块与增强 runtime 恒内联", async () => {
     const root = await seedRoot();
     const out = join(root, "site");
-    await buildView({ input: root, out, allowSensitiveArtifacts: true });
+    await buildView({ input: root, out });
     const html = await readFile(join(out, "index.html"), "utf-8");
     expect(html).toContain('<template id="niceeval-report-report-en">');
     expect(html).toContain('<template id="niceeval-report-report-zh-CN">');