niceeval 0.6.1 → 0.6.2

package/src/results/annotated-source.ts

@@ -6,16 +6,33 @@
 //
 // 泛化自 src/view/app/lib/transcript-data.tsx 的 indexAsserts()(Map<string, Assertion[]>
 // + noloc 兜底桶的先例)——同一套"按 loc 分桶、没有 loc 进兜底"的思路,换成源码行数组
-// (不是 Map)存放,外加 sourceSha256 / summary 计数。indexTurns() 那部分(events → 轮次)
-// 是 ExecutionTree 的地盘,不在这个模型里。
+// (不是 Map)存放,外加 sourceSha256 / summary 计数。轮次的完整展开(events → ExecutionTree)
+// 仍是 ExecutionTree 的地盘;这个模型只把每轮的头行事实标回 send 调用行(见 SendAnnotation),
+// 作为源码页指向 --execution 的跨面指针。
 //
 // 本模块不 import react/jsx,纯数据 + 纯函数,可以在任何 Node 语境(CLI 的 show、
 // view 的 server 端数据准备)调用。
 
-import type { AssertionResult } from "../types.ts";
+import type { AssertionResult, PhaseTiming, SourceLoc, StreamEvent } from "../types.ts";
 import { hashEvalSource, normalizeEvalSource } from "./source-hash.ts";
 
-/** 一行源码 + 映射到这一行的全部断言(保持原始顺序;可以是空数组)。 */
+/**
+ * 标回 `t.send(...)` 调用行的一轮 turn 头行事实(契约见 docs/feature/reports/show.md
+ * 「--eval:把断言放回源码」)。身份标签与 --execution / --timing / diff windows 同一套;
+ * 回复全文与轮内卡片不进这个模型——源码页只回答「这行代码对应哪一轮、这一轮成了没成」。
+ */
+export interface SendAnnotation {
+  /** `s<session>/t<turn>`。 */
+  label: string;
+  /** 轮的终态;时间树只记 failed 位,waiting 需要事件流佐证时由派生方给。 */
+  status: "completed" | "failed" | "waiting";
+  /** 该轮墙钟;时间树缺这一轮的节点时省略。 */
+  durationMs?: number;
+  /** send 调用位置(用户消息事件的 loc)。 */
+  loc: SourceLoc;
+}
+
+/** 一行源码 + 映射到这一行的全部断言与 send 标注(保持原始顺序;可以是空数组)。 */
 export interface AnnotatedSourceLine {
   /** 1-indexed 行号,与 SourceLoc.line 同一坐标系。 */
   line: number;
@@ -28,6 +45,11 @@ export interface AnnotatedSourceLine {
    * 领域 model 的职责(与 indexAsserts() 的先例一致,它同样只分桶、不折叠)。
    */
   assertions: AssertionResult[];
+  /**
+   * 映射到这一行的 send 标注,按轮次顺序;循环里的 send 一行多轮。与断言的 never-drop
+   * 契约不同,定位不到行的轮不进任何兜底桶——轮次的全量面是 --execution,这里只是指针。
+   */
+  sends: SendAnnotation[];
 }
 
 export interface AnnotatedEvalSourceSummary {
@@ -67,6 +89,34 @@ export interface AnnotatedEvalSource {
   summary: AnnotatedEvalSourceSummary;
 }
 
+/**
+ * 从标准事件流与阶段时间树派生 send 标注:第 i 条用户消息开第 i 轮(与 --execution 的
+ * 分轮边界同一条规则,见 show/render.ts::executionText),头行事实取 `eval.run` 下第 i 个
+ * turn 节点;用户消息没有 loc 的轮不产出标注。纯函数,无 IO。
+ */
+export function deriveSendAnnotations(
+  events: readonly StreamEvent[] | null,
+  phases: readonly PhaseTiming[] | undefined,
+): SendAnnotation[] {
+  if (!events || events.length === 0) return [];
+  const turnNodes = (phases ?? []).flatMap((p) => p.children ?? []).filter((n) => n.kind === "turn");
+  const out: SendAnnotation[] = [];
+  let turnIndex = -1;
+  for (const event of events) {
+    if (event.type !== "message" || event.role !== "user") continue;
+    turnIndex += 1;
+    if (!event.loc) continue;
+    const turn = turnNodes[turnIndex];
+    out.push({
+      label: turn?.label ?? `t${turnIndex + 1}`,
+      status: turn?.failed ? "failed" : "completed",
+      ...(turn !== undefined ? { durationMs: turn.durationMs } : {}),
+      loc: event.loc,
+    });
+  }
+  return out;
+}
+
 /**
  * 纯函数:给定一份源码文本(未归一化也可以,内部会 normalizeEvalSource)与一批断言,
  * 产出标注好的 AnnotatedEvalSource。幂等 / 无 IO —— 可以在渲染路径上安全调用。
@@ -77,13 +127,21 @@ export interface AnnotatedEvalSource {
 export function buildAnnotatedEvalSource(
   source: { path: string; content: string },
   assertions: readonly AssertionResult[],
+  sends: readonly SendAnnotation[] = [],
 ): AnnotatedEvalSource {
   const normalized = normalizeEvalSource(source.content);
   // 末尾的单个换行符不产出幻影空行(源码文件几乎总以换行符收尾);中间的空行原样保留为一行。
   const body = normalized.endsWith("\n") ? normalized.slice(0, -1) : normalized;
   const rawLines = body.length === 0 && normalized.length === 0 ? [""] : body.split("\n");
 
-  const lines: AnnotatedSourceLine[] = rawLines.map((text, i) => ({ line: i + 1, text, assertions: [] }));
+  const lines: AnnotatedSourceLine[] = rawLines.map((text, i) => ({ line: i + 1, text, assertions: [], sends: [] }));
+
+  for (const send of sends) {
+    // 与断言同一条映射规则;不满足的轮直接丢(全量面在 --execution,见 SendAnnotation)。
+    if (send.loc.file === source.path && send.loc.line >= 1 && send.loc.line <= lines.length) {
+      lines[send.loc.line - 1]!.sends.push(send);
+    }
+  }
 
   const unmapped: AssertionResult[] = [];
   let mappedAssertions = 0;
@@ -93,7 +151,7 @@ export function buildAnnotatedEvalSource(
   let soft = 0;
 
   for (const assertion of assertions) {
-    if (assertion.passed) passed++;
+    if (assertion.outcome === "passed") passed++;
     else failed++;
     if (assertion.severity === "gate") gate++;
     else soft++;

package/src/results/attempt-evidence.test.ts

@@ -1,3 +1,4 @@
+// cases: docs/engineering/unit-tests/results/cases.md
 // loadAttemptEvidence 单测(定稿契约见 plan/attempt-evidence-feedback-loop.md「中性数据准备」、
 // src/results/attempt-evidence.ts 的头注)。用真实 createResultsWriter → openResults 的读写链路
 // 落一份最小 fixture(不手写 JSON 文件,理由同 loadAnnotatedEvalSource 的既有端到端测试:
@@ -7,6 +8,7 @@ import { afterEach, describe, expect, it } from "vitest";
 import { mkdtemp, rm } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import type { DiffArtifact } from "../types.ts";
 import {
   createResultsWriter,
   loadAttemptEvidence,
@@ -34,7 +36,7 @@ const SOURCE_PATH = "evals/a.eval.ts";
 const SOURCE_CONTENT = 'import { defineEval } from "niceeval";\nexport default defineEval({\n  test() {},\n});\n';
 
 const ASSERTIONS: EvalResult["assertions"] = [
-  { name: "check-1", passed: true, severity: "gate", score: 1, loc: { file: SOURCE_PATH, line: 3 } },
+  { name: "check-1", outcome: "passed" as const, severity: "gate", score: 1, loc: { file: SOURCE_PATH, line: 3 } },
 ];
 
 const EVENTS: StreamEvent[] = [
@@ -47,8 +49,8 @@ const TRACE: TraceSpan[] = [
   { traceId: "t1", spanId: "s1", name: "tool.get_weather", startMs: 0, endMs: 10, attributes: { call_id: "c1" } },
 ];
 
-const NONEMPTY_DIFF: DiffData = { generatedFiles: { "a.txt": "hello" }, deletedFiles: [] };
-const EMPTY_DIFF: DiffData = { generatedFiles: {}, deletedFiles: [] };
+const NONEMPTY_DIFF: DiffArtifact = [{ window: "s1/t1", changes: { "a.txt": { status: "added", after: "hello" } } }];
+const EMPTY_DIFF: DiffArtifact = [{ window: "s1/t1", changes: {} }];
 
 /** 起一个 writer,写一条 attempt,finish,再从头 openResults 读回它的 AttemptHandle。 */
 async function seedAttempt(
@@ -72,7 +74,7 @@ describe("loadAttemptEvidence", () => {
     const root = await makeRoot();
     const attempt = await seedAttempt(
       root,
-      { id: "weather/brooklyn", assertions: ASSERTIONS },
+      { id: "weather/brooklyn", assertions: ASSERTIONS, phases: [{ name: "eval.run", durationMs: 900 }] },
       { events: EVENTS, trace: TRACE, diff: NONEMPTY_DIFF, sources: [{ path: SOURCE_PATH, content: SOURCE_CONTENT }] },
     );
 
@@ -86,7 +88,7 @@ describe("loadAttemptEvidence", () => {
     const actionNode = evidence.execution!.nodes.find((n) => n.kind === "action");
     expect(actionNode).toBeDefined();
     expect((actionNode as { span?: TraceSpan }).span).toBeDefined();
-    expect(evidence.diff).toEqual(NONEMPTY_DIFF);
+    expect(evidence.diff?.windows).toEqual(NONEMPTY_DIFF);
 
     expect(evidence.capabilities).toEqual({ eval: true, execution: true, timing: true, diff: true });
   });
@@ -103,7 +105,7 @@ describe("loadAttemptEvidence", () => {
     expect(evidence.capabilities).toEqual({ eval: false, execution: false, timing: false, diff: false });
   });
 
-  it("有 events 没有 OTel spans:execution 为真、timing 为假", async () => {
+  it("有 events 没有 phases(旧 runner 产出):execution 为真、timing 为假", async () => {
     const root = await makeRoot();
     const attempt = await seedAttempt(root, { id: "weather/albany" }, { events: EVENTS });
 
@@ -122,7 +124,7 @@ describe("loadAttemptEvidence", () => {
 
     const evidence = await loadAttemptEvidence(attempt);
 
-    expect(evidence.diff).toEqual(EMPTY_DIFF);
+    expect(evidence.diff?.windows).toEqual(EMPTY_DIFF);
     expect(evidence.capabilities.diff).toBe(false);
   });
 

package/src/results/attempt-evidence.ts

@@ -31,7 +31,7 @@ import { join } from "node:path";
 import type { AttemptHandle } from "./types.ts";
 import { type AttemptIdentity, type AttemptLocator, encodeAttemptLocator } from "./locator.ts";
 import { loadAnnotatedEvalSource } from "./attempt-source.ts";
-import type { AnnotatedEvalSource } from "./annotated-source.ts";
+import { deriveSendAnnotations, type AnnotatedEvalSource } from "./annotated-source.ts";
 import { buildExecutionTree, type ExecutionTree } from "../o11y/execution-tree.ts";
 import type { DiffData, EvalResult } from "../types.ts";
 
@@ -63,7 +63,7 @@ export interface AttemptEvidenceCapabilities {
   eval: boolean;
   /** events 非空数组——有骨架可看。 */
   execution: boolean;
-  /** execution 成立且这次运行接入过 OTel(ExecutionTree.timingAvailable)。 */
+  /** result.json 带 phases(阶段计时)——`--timing` 时间树可渲染。 */
   timing: boolean;
   /** diff 非空且至少改动/删除了一个文件。 */
   diff: boolean;
@@ -86,6 +86,8 @@ export interface AttemptEvidence {
   execution: ExecutionTree | null;
   /** 被测 Agent 对 Sandbox 工作区的文件变化(`--diff` 切面);原样透传 attempt.diff()。 */
   diff: DiffData | null;
+  /** OTel spans(`--timing` 把 turn 节点下的 agent/model/tool spans 挂回时间树);没有 trace 就是 null。 */
+  trace: import("../types.ts").TraceSpan[] | null;
   artifactPaths: EvidencePaths;
   capabilities: AttemptEvidenceCapabilities;
 }
@@ -110,12 +112,17 @@ export async function loadAttemptEvidence(attempt: AttemptHandle): Promise<Attem
   };
   const locator = attempt.locator ?? encodeAttemptLocator(identity);
 
-  const [evalSource, events, trace, diff] = await Promise.all([
-    loadAnnotatedEvalSource(attempt),
+  const [events, trace, diff] = await Promise.all([
     attempt.events(),
     attempt.trace(),
     attempt.diff(),
   ]);
+  // send 标注要拿事件流里用户消息的 loc 与阶段时间树里的 turn 节点配对,所以在 events
+  // 就绪后再装配 evalSource;派生与分桶都是纯函数(annotated-source.ts),这里只接线。
+  const evalSource = await loadAnnotatedEvalSource(
+    attempt,
+    deriveSendAnnotations(events, attempt.result.phases),
+  );
 
   // execution 的 null 边界:没有非空事件骨架就是 null,即使 trace 里有 span(那些 span 在
   // buildExecutionTree 里只会全部落进 telemetry-only 桶,产出一棵没有骨架、只有遥测的树——
@@ -124,9 +131,8 @@ export async function loadAttemptEvidence(attempt: AttemptHandle): Promise<Attem
   const execution = hasEvents ? buildExecutionTree(events, trace ?? []) : null;
 
   const evalCapable = evalSource !== null && (evalSource.lines.length > 0 || evalSource.summary.totalAssertions > 0);
-  // 与 show/render.ts::diffText 的既有空判定同一口径:generatedFiles 与 deletedFiles 都空
-  // 才算"没有变化"。
-  const diffCapable = diff !== null && (Object.keys(diff.generatedFiles).length > 0 || diff.deletedFiles.length > 0);
+  // 与 show/render.ts::diffText 同一口径:任一窗口触及过任一文件才算"有变化"。
+  const diffCapable = diff !== null && Object.keys(diff.files).length > 0;
 
   return {
     locator,
@@ -135,11 +141,12 @@ export async function loadAttemptEvidence(attempt: AttemptHandle): Promise<Attem
     evalSource,
     execution,
     diff,
+    trace,
     artifactPaths: { dir: attemptArtifactDir(attempt) },
     capabilities: {
       eval: evalCapable,
       execution: execution !== null,
-      timing: execution !== null && execution.timingAvailable,
+      timing: (attempt.result.phases?.length ?? 0) > 0,
       diff: diffCapable,
     },
   };

package/src/results/attempt-source.ts

@@ -8,7 +8,7 @@
 // 或参照。
 
 import type { AttemptHandle } from "./types.ts";
-import { buildAnnotatedEvalSource, type AnnotatedEvalSource } from "./annotated-source.ts";
+import { buildAnnotatedEvalSource, type AnnotatedEvalSource, type SendAnnotation } from "./annotated-source.ts";
 
 /**
  * 给定一个 attempt,取回它的 eval 源码(经 sources() 解引用,可能来自本快照或
@@ -22,7 +22,10 @@ import { buildAnnotatedEvalSource, type AnnotatedEvalSource } from "./annotated-
  * 只服务这条打通链路的验证目的,不是最终选择策略(后续阶段如需要为每份引用到的文件
  * 都出一份 AnnotatedEvalSource,在这基础上很容易扩成返回数组)。
  */
-export async function loadAnnotatedEvalSource(attempt: AttemptHandle): Promise<AnnotatedEvalSource | null> {
+export async function loadAnnotatedEvalSource(
+  attempt: AttemptHandle,
+  sends: readonly SendAnnotation[] = [],
+): Promise<AnnotatedEvalSource | null> {
   const sources = await attempt.sources();
   if (!sources || sources.length === 0) return null;
 
@@ -44,5 +47,5 @@ export async function loadAnnotatedEvalSource(attempt: AttemptHandle): Promise<A
     }
   }
 
-  return buildAnnotatedEvalSource(primary, assertions);
+  return buildAnnotatedEvalSource(primary, assertions, sends);
 }

package/src/results/copy.ts

@@ -7,20 +7,38 @@
 // knownEvalIds(复制时刻该实验已知的 eval 并集),发布目录上重新 openResults().latest(),
 // 残缺警告被同一套机制重新算出来,不靠发布者转述。
 
-import { copyFile, mkdir, readdir, stat, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
-import type { EvalResult } from "../types.ts";
+import type { EvalResult, StreamEvent, TraceSpan } 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 type { ArtifactKind, AttemptHandle, Selection, Snapshot, SnapshotMeta } from "./types.ts";
-import { ARTIFACT_KINDS } from "./types.ts";
+
+/** 缺省携带的 artifact:events / trace / o11y / agentSetup / sources;diff 不截断、可达百 MB,缺省不带。 */
+const DEFAULT_PUBLISH_ARTIFACTS: ArtifactKind[] = ["events", "trace", "o11y", "agentSetup", "sources"];
+const VALID_ARTIFACTS: ArtifactKind[] = ["events", "trace", "o11y", "agentSetup", "diff", "sources"];
 
 export interface CopySnapshotsOptions {
-  /** 要带上的 artifact 种类;省略 = 全部六类。diff 可达百 MB,发布时常见地不带;o11y 只有几 KB,报告用 turns 这类 artifact 档指标(见 docs/feature/reports/library.md「内置指标」)时记得带上。 */
+  /** 要带上的 artifact 种类;缺省带 events / trace / o11y / agentSetup / sources,不带 diff。 */
   artifacts?: ArtifactKind[];
+  /**
+   * 发布消毒(必填,没有隐式默认):传函数逐值消毒自由文本字段,或显式传 `false` 声明
+   * 「这批数据可以原文发布」——「不消毒」必须是写在代码里的选择,不是忘了传参数的副作用。
+   * 结构字段(格式、判定、身份、路径、哈希)永不经过 redactor。
+   */
+  redact: Redactor | false;
 }
 
 export interface CopySnapshotsResult {
@@ -38,7 +56,7 @@ export interface CopySnapshotsResult {
 export async function copySnapshots(
   selection: Selection | Snapshot[],
   destDir: string,
-  opts?: CopySnapshotsOptions,
+  opts: CopySnapshotsOptions,
 ): Promise<CopySnapshotsResult> {
   const selected = Array.isArray(selection) ? selection : selection.snapshots;
   if (selected.length === 0) {
@@ -46,11 +64,17 @@ export async function copySnapshots(
       "copySnapshots got no snapshots to copy. Check the experiments filter, or pass snapshots from openResults().latest().",
     );
   }
-  const kinds = opts?.artifacts ?? [...ARTIFACT_KINDS];
+  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 (!ARTIFACT_KINDS.includes(kind)) {
+    if (!VALID_ARTIFACTS.includes(kind)) {
       throw new Error(
-        `Unknown artifact kind "${String(kind)}" in copySnapshots options. Valid kinds: ${ARTIFACT_KINDS.join(", ")}.`,
+        `Unknown artifact kind "${String(kind)}" in copySnapshots options. Valid kinds: ${VALID_ARTIFACTS.join(", ")}.`,
       );
     }
   }
@@ -73,96 +97,162 @@ export async function copySnapshots(
     if (isNewerSnapshot(snapshot, existing)) byExperiment.set(snapshot.experimentId, snapshot);
   }
 
-  await mkdir(dest, { recursive: true });
+  // 发布前整文件预检:先规划并序列化全部目标文件(消毒发生在序列化后、写盘前),任一文件
+  // 超过 PUBLISH_FILE_MAX_BYTES 就整体失败,不留半成品目标目录。
+  const planned: PlannedFile[] = [];
   for (const snapshot of byExperiment.values()) {
-    await copyOneSnapshot(snapshot, selected, dest, kinds);
+    planned.push(...(await planOneSnapshot(snapshot, selected, dest, kinds, redactor)));
+  }
+  const oversized = planned.filter((f) => f.bytes.byteLength > PUBLISH_FILE_MAX_BYTES);
+  if (oversized.length > 0) {
+    const lines = oversized.map(
+      (f) =>
+        `  ${f.source ?? f.path}: ${f.bytes.byteLength} bytes (limit ${PUBLISH_FILE_MAX_BYTES}). Exclude that artifact kind from "artifacts", or regenerate the history with the current writer.`,
+    );
+    throw new Error(`copySnapshots publish precheck failed; ${oversized.length} file(s) exceed the 50 MiB publish budget:\n${lines.join("\n")}`);
+  }
+
+  await mkdir(dest, { recursive: true });
+  for (const file of planned) {
+    await mkdir(dirname(file.path), { recursive: true });
+    await writeFile(file.path, file.bytes);
   }
 
   return { dir: dest, warnings };
 }
 
-async function copyOneSnapshot(snapshot: Snapshot, selected: Snapshot[], destRoot: string, kinds: ArtifactKind[]): Promise<void> {
+interface PlannedFile {
+  /** 目标绝对路径。 */
+  path: string;
+  /** 序列化(且已消毒)后的字节。 */
+  bytes: Buffer;
+  /** 源文件路径(预检报错定位用);重建的 json 没有单一源。 */
+  source?: string;
+}
+
+async function planOneSnapshot(
+  snapshot: Snapshot,
+  selected: Snapshot[],
+  destRoot: string,
+  kinds: ArtifactKind[],
+  redactor: Redactor | undefined,
+): Promise<PlannedFile[]> {
   const destSnapDir = join(destRoot, experimentDirOf(snapshot.experimentId), basename(snapshot.dir));
-  await mkdir(destSnapDir, { recursive: true });
+  const planned: PlannedFile[] = [];
 
   // sources 的去重仓库(sources/<sha256>.json)是快照级的:同一份源码被多个 attempt 引用时,
-  // 复制到目的地也只应该有一份——这个 Set 记录本快照已经落过盘的 hash,整快照的 attempt 共享。
-  const copiedSourceHashes = new Set<string>();
+  // 复制到目的地也只应该有一份——这个 Set 记录本快照已经规划过的 hash,整快照的 attempt 共享。
+  const plannedSourceHashes = new Set<string>();
   for (const attempt of snapshot.attempts) {
-    await copyOneAttempt(attempt, destSnapDir, kinds, copiedSourceHashes);
+    planned.push(...(await planOneAttempt(attempt, destSnapDir, kinds, plannedSourceHashes, redactor)));
   }
 
   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,
-    ...(snapshot.experiment !== undefined ? { experiment: snapshot.experiment } : {}),
+    ...(experiment !== undefined ? { 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: snapshot.name } : {}),
+    ...(snapshot.name !== undefined
+      ? { name: redactor && typeof snapshot.name === "string" ? redactor(snapshot.name) : snapshot.name }
+      : {}),
+    // 发布根标记只声明流程,不证明结果:applied = 消毒函数对全部自由文本字段跑过;
+    // none = 作者显式的原文发布声明。view --out 的防呆据此分级。
+    publish: { redaction: redactor ? "applied" : "none" },
   };
-  await writeFile(join(destSnapDir, SNAPSHOT_FILE), JSON.stringify(meta, null, 2), "utf-8");
+  planned.push({ path: join(destSnapDir, SNAPSHOT_FILE), bytes: Buffer.from(JSON.stringify(meta, null, 2), "utf-8") });
+  return planned;
 }
 
-async function copyOneAttempt(
+async function planOneAttempt(
   attempt: AttemptHandle,
   destSnapDir: string,
   kinds: ArtifactKind[],
-  copiedSourceHashes: Set<string>,
-): Promise<void> {
+  plannedSourceHashes: Set<string>,
+  redactor: Redactor | undefined,
+): Promise<PlannedFile[]> {
   const destAttemptDir = join(destSnapDir, attempt.ref.attempt);
-  await mkdir(destAttemptDir, { recursive: true });
+  const planned: PlannedFile[] = [];
 
   // sources 是唯一「两层」的 artifact(attempt 级引用 + 快照级去重仓库),不能像其它四类那样
-  // 单文件 copyFile 原字节完事——原字节只是引用,不带内容。走读取面已经会解引用+回退的
-  // attempt.sources() 拿到完整内容,再在目的地按内容哈希重新去重落盘,天然吸收 artifactBase
-  // 回退链(携带条目复制后,原快照可能不在目的地里,必须此刻把内容落到自己脚下)。
+  // 单文件原字节完事——原字节只是引用,不带内容。走读取面已经会解引用+回退的 attempt.sources()
+  // 拿到完整内容,消毒后按(消毒后)内容哈希重新去重落盘——发布根里引用与内容永远一致。
   const genericKinds = kinds.filter((k) => k !== "sources");
   const files = await findArtifactFiles(attempt, genericKinds);
-  await Promise.all(files.map(({ kind, source }) => copyFile(source, join(destAttemptDir, artifactFileOf(kind)))));
   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 });
+  }
 
   if (kinds.includes("sources")) {
-    const wroteSources = await copySources(attempt, destSnapDir, destAttemptDir, copiedSourceHashes);
-    if (wroteSources) copied.add("sources");
+    const sources = await attempt.sources();
+    if (sources && sources.length > 0) {
+      copied.add("sources");
+      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));
+        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"),
+          });
+          plannedSourceHashes.add(sha256);
+        }
+      }
+      planned.push({
+        path: join(destAttemptDir, artifactFileOf("sources")),
+        bytes: Buffer.from(JSON.stringify(refs), "utf-8"),
+      });
+    }
   }
 
-  const record = slimForCopy(attempt.result, copied);
-  await writeFile(join(destAttemptDir, RESULT_FILE), JSON.stringify(record, null, 2), "utf-8");
+  let record = slimForCopy(attempt.result, copied);
+  if (redactor) record = redactResultRecord(record, redactor);
+  planned.push({ path: join(destAttemptDir, RESULT_FILE), bytes: Buffer.from(JSON.stringify(record, null, 2), "utf-8") });
+  return planned;
 }
 
-/**
- * sources 的复制:经 attempt.sources() 拿到已解引用的完整内容(null / 空数组 = 没有,不写任何
- * 文件,与其它 artifact「空数据不落文件」的约定一致),按内容 sha256 写进目的快照的
- * `sources/<sha256>.json`(同一快照内已经写过的 hash 不重写),attempt 目录下落一份引用。
- */
-async function copySources(
-  attempt: AttemptHandle,
-  destSnapDir: string,
-  destAttemptDir: string,
-  copiedSourceHashes: Set<string>,
-): Promise<boolean> {
-  const sources = await attempt.sources();
-  if (!sources || sources.length === 0) return false;
-
-  const destStoreDir = join(destSnapDir, "sources");
-  const refs: { path: string; sha256: string }[] = [];
-  for (const src of sources) {
-    const sha256 = hashEvalSource(normalizeEvalSource(src.content));
-    refs.push({ path: src.path, sha256 });
-    if (!copiedSourceHashes.has(sha256)) {
-      await mkdir(destStoreDir, { recursive: true });
-      await writeFile(join(destStoreDir, `${sha256}.json`), JSON.stringify({ content: src.content }), "utf-8");
-      copiedSourceHashes.add(sha256);
+/** 单个 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;
   }
-  await writeFile(join(destAttemptDir, artifactFileOf("sources")), JSON.stringify(refs), "utf-8");
-  return true;
 }
 
 /** 目标目录非空即报错:盘上不该出现「我没写的东西被动过」的惊讶;发布脚本要幂等就自己先清目录。 */

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

@@ -1,3 +1,4 @@
+// cases: docs/engineering/unit-tests/results/cases.md
 // show / view 宿主等价契约(设计契约:plan/show-view-equivalence.md 完成定义;
 // docs/feature/reports/architecture.md「Selection 是计算入口」;docs/feature/results/library.md「选择快照」)。
 //
@@ -339,7 +340,7 @@ describe("selectCurrentResults · 现刻水位结构化身份", () => {
     const rootA = await makeRoot();
     const rootB = await makeRoot();
     // 失败 eval 让 id 现于两面(通过 eval 只进折叠子行,不便断言);qa / qb 各根独有。
-    const boom = { assertions: [{ name: "succeeded()", severity: "gate" as const, score: 0, passed: false, detail: "boom" }] };
+    const boom = { assertions: [{ name: "succeeded()", severity: "gate" as const, score: 0, outcome: "failed" as const, detail: "boom" }] };
     await writeSnapshot(rootA, "2026-07-01T08-00-00-000Z", { experimentId: "onlyA/bub", startedAt: "2026-07-01T08:00:00.000Z" }, [res("qa", "failed", boom)]);
     await writeSnapshot(rootB, "2026-07-02T08-00-00-000Z", { experimentId: "onlyB/bub", startedAt: "2026-07-02T08:00:00.000Z" }, [res("qb", "failed", boom)]);
     const normB = normalizeSelection(selectCurrentResults(await openResults(rootB)));
@@ -389,7 +390,7 @@ async function seedPartialRerun(): Promise<string> {
   const root = await makeRoot();
   await writeSnapshot(root, "2026-07-01T08-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-01T08:00:00.000Z" }, [
     res("q1", "passed"),
-    res("q2", "failed", { assertions: [{ name: 'fileChanged("q2.tsx")', severity: "gate", score: 0, passed: false, detail: "file was not modified" }] }),
+    res("q2", "failed", { assertions: [{ name: 'fileChanged("q2.tsx")', severity: "gate", score: 0, outcome: "failed" as const, detail: "file was not modified" }] }),
   ]);
   await writeSnapshot(root, "2026-07-02T08-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-02T08:00:00.000Z" }, [
     res("q1", "passed"),
@@ -404,7 +405,7 @@ async function seedPartialCoverage(): Promise<string> {
     root,
     "2026-07-01T08-00-00-000Z",
     { experimentId: "compare/bub", startedAt: "2026-07-01T08:00:00.000Z", knownEvalIds: ["q1", "q2"] },
-    [res("q1", "failed", { assertions: [{ name: "succeeded()", severity: "gate", score: 0, passed: false, detail: "boom" }] })],
+    [res("q1", "failed", { assertions: [{ name: "succeeded()", severity: "gate", score: 0, outcome: "failed" as const, detail: "boom" }] })],
   );
   return root;
 }
@@ -415,9 +416,10 @@ describe("宿主接线 · show text 面与 view web 面反映同一批事实", (
     const text = await showText(root, []);
     const html = await viewHtml(root);
     for (const face of [text, html]) {
-      expect(face).toContain("compare/bub");
       expect(face).toContain("q2"); // 周一补齐的失败 eval,若宿主回退 results.latest() 就会消失
     }
+    expect(text).toMatch(/\bbub\s+default\s+bub\s+1s\s+50%/);
+    expect(html).toContain('data-sort-value="compare/bub"');
     expect(text).toContain("1 passed / 1 failed");
     expect(html).toContain("50%");
     // 现刻水位覆盖齐全 → 两面都不出 partial-coverage(text: "verdicts cover"; html: data-kind)。
@@ -431,7 +433,7 @@ describe("宿主接线 · show text 面与 view web 面反映同一批事实", (
   it("位置前缀收窄:两扇门都只见范围内的 eval,范围外一致排除", async () => {
     const root = await makeRoot();
     await writeSnapshot(root, "2026-07-01T08-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-01T08:00:00.000Z" }, [
-      res("weather/brooklyn", "failed", { assertions: [{ name: "succeeded()", severity: "gate", score: 0, passed: false, detail: "boom" }] }),
+      res("weather/brooklyn", "failed", { assertions: [{ name: "succeeded()", severity: "gate", score: 0, outcome: "failed" as const, detail: "boom" }] }),
       res("weather/queens", "passed"),
       res("algebra/quadratic", "passed"),
     ]);
@@ -497,7 +499,7 @@ function hasPartialCoverageHtml(html: string): boolean {
   it("通过计数一致:同一 fixture 两面反映 3 过 1 败", async () => {
     const root = await makeRoot();
     await writeSnapshot(root, "2026-07-01T08-00-00-000Z", { experimentId: "compare/bub", startedAt: "2026-07-01T08:00:00.000Z" }, [
-      res("q1", "failed", { durationMs: 40_000, estimatedCostUSD: 0.04, assertions: [{ name: "succeeded()", severity: "gate", score: 0, passed: false, detail: "boom" }] }),
+      res("q1", "failed", { durationMs: 40_000, estimatedCostUSD: 0.04, assertions: [{ name: "succeeded()", severity: "gate", score: 0, outcome: "failed" as const, detail: "boom" }] }),
       res("q2", "passed", { durationMs: 2_000, estimatedCostUSD: 0.02 }),
       res("q3", "passed", { durationMs: 2_000, estimatedCostUSD: 0.02 }),
       res("q4", "passed", { durationMs: 2_000, estimatedCostUSD: 0.02 }),

package/src/results/index.ts

@@ -29,9 +29,11 @@ export {
 } from "./locator.ts";
 export {
   buildAnnotatedEvalSource,
+  deriveSendAnnotations,
   type AnnotatedEvalSource,
   type AnnotatedEvalSourceSummary,
   type AnnotatedSourceLine,
+  type SendAnnotation,
 } from "./annotated-source.ts";
 export { loadAnnotatedEvalSource } from "./attempt-source.ts";
 export {