niceeval 0.7.1 → 0.8.1

package/src/report/shell-head.test.ts

@@ -0,0 +1,102 @@
+// cases: docs/engineering/unit-tests/reports/cases.md
+// 覆盖登记行:外壳 head 通道的白名单/宿主单例/attrs/children/scheme 分流装载校验,
+// 与 scripts {src} 外链拒绝。
+// defineReport 是装载校验的第一期(shell.md「校验分两期」),全部用例不落盘、不进渲染。
+
+import { describe, expect, it } from "vitest";
+
+import type { Scope } from "../results/index.ts";
+import { buildReportMeta, defineReport } from "./report.ts";
+
+const emptyScope = { snapshots: [] } as unknown as Scope;
+
+describe("defineReport head 通道(装载校验)", () => {
+  it("tag 白名单是 meta/link/script/style,白名单外装载报错;title 指引到 title 字段", () => {
+    expect(() => defineReport({ content: null, head: [{ tag: "base", attrs: {} } as never] })).toThrow(
+      /not allowed/,
+    );
+    expect(() => defineReport({ content: null, head: [{ tag: "title", attrs: {} } as never] })).toThrow(
+      /"title" field/,
+    );
+    expect(() => defineReport({ content: null, head: [{ tag: "iframe", attrs: {} } as never] })).toThrow(
+      /meta.*link.*script.*style/,
+    );
+  });
+
+  it("宿主自有单例:meta charset 与 meta name=viewport 装载报错", () => {
+    expect(() => defineReport({ content: null, head: [{ tag: "meta", attrs: { charset: "utf-8" } }] })).toThrow(
+      /owned by the host shell/,
+    );
+    expect(() =>
+      defineReport({ content: null, head: [{ tag: "meta", attrs: { name: "Viewport", content: "x" } }] }),
+    ).toThrow(/owned by the host shell/);
+  });
+
+  it("children:meta/link 不收;script children 含 </script> 装载报错(该上下文无法转义)", () => {
+    expect(() =>
+      defineReport({ content: null, head: [{ tag: "link", attrs: { rel: "icon" }, children: "x" } as never] }),
+    ).toThrow(/void element/);
+    expect(() =>
+      defineReport({
+        content: null,
+        head: [{ tag: "script", children: 'document.write("</script>")' }],
+      }),
+    ).toThrow(/cannot be escaped/);
+    expect(() =>
+      defineReport({ content: null, head: [{ tag: "style", children: "</StYlE>" }] }),
+    ).toThrow(/cannot be escaped/);
+  });
+
+  it("attrs:值只收 string 或 true(裸布尔属性);非法属性名装载报错", () => {
+    expect(() =>
+      defineReport({ content: null, head: [{ tag: "script", attrs: { async: 1 } as never }] }),
+    ).toThrow(/string or true/);
+    expect(() =>
+      defineReport({ content: null, head: [{ tag: "meta", attrs: { 'bad name"': "x" } }] }),
+    ).toThrow(/attribute name/);
+    expect(() =>
+      defineReport({
+        content: null,
+        head: [{ tag: "script", attrs: { async: true, "data-project": "p1", src: "https://cdn.example/x.js" } }],
+      }),
+    ).not.toThrow();
+  });
+
+  it("src/href 按 scheme 分流:http(s) 外链与本地相对路径合法;protocol-relative 与其它 scheme 装载报错", () => {
+    expect(() =>
+      defineReport({ content: null, head: [{ tag: "link", attrs: { rel: "icon", href: "./favicon.svg" } }] }),
+    ).not.toThrow();
+    expect(() =>
+      defineReport({ content: null, head: [{ tag: "script", attrs: { src: "//cdn.example/x.js" } }] }),
+    ).toThrow(/protocol-relative/);
+    expect(() =>
+      defineReport({ content: null, head: [{ tag: "script", attrs: { src: "data:text/javascript,1" } }] }),
+    ).toThrow(/scheme other than http/);
+    expect(() =>
+      defineReport({ content: null, head: [{ tag: "link", attrs: { rel: "icon", href: "../up.svg" } }] }),
+    ).toThrow(/".." segments/);
+    expect(() =>
+      defineReport({ content: null, head: [{ tag: "link", attrs: { rel: "icon", href: "/abs.svg" } }] }),
+    ).toThrow(/absolute paths/);
+  });
+
+  it("scripts/styles 的 {src} 只收本地路径:外链装载报错并给出 head 写法", () => {
+    expect(() => defineReport({ content: null, scripts: [{ src: "https://cdn.example/x.js" }] })).toThrow(
+      /Declare third-party external tags in "head"/,
+    );
+    expect(() => defineReport({ content: null, styles: [{ src: "//fonts.example/a.css" }] })).toThrow(
+      /Declare third-party external tags in "head"/,
+    );
+  });
+
+  it("规范化:省略 head 恒为空数组,声明原样进产物;head 是注入资产,不进 ctx.report", () => {
+    expect(defineReport({ content: null }).head).toEqual([]);
+    const head = [
+      { tag: "script" as const, attrs: { async: true as const, src: "https://cdn.example/x.js" } },
+      { tag: "script" as const, children: "window.x = 1;" },
+    ];
+    const definition = defineReport({ content: null, head });
+    expect(definition.head).toEqual(head);
+    expect(buildReportMeta(definition, emptyScope, "report")).not.toHaveProperty("head");
+  });
+});

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/show/report-host.ts

@@ -44,11 +44,21 @@ export interface HostReportLink {
 /** `{src}` 与 `{inline}` 两种形态不可同时出现(shell.md「字段穷尽」)。 */
 export type HostReportAsset = { src: string; inline?: never } | { inline: string; src?: never };
 
+/**
+ * 结构化 head 标签(shell.md「字段穷尽」):白名单闭集(meta/link/script/style),
+ * attrs 值 true 渲染裸布尔属性、字符串转义后渲染 `key="value"`;script/style 的
+ * children 原样落进标签。形状与闭合序列在 defineReport 装载期已校验。
+ */
+export type HostHeadTag =
+  | { tag: "meta" | "link"; attrs: Record<string, string | true>; children?: never }
+  | { tag: "script" | "style"; attrs?: Record<string, string | true>; children?: string };
+
 /** 装载规范化产物:外壳 + 非空页列表。show 只消费 title / pages;其余是 web 面属性。 */
 export interface HostReport {
   title?: LocalizedText;
   links: HostReportLink[];
   footer?: LocalizedText;
+  head: HostHeadTag[];
   scripts: HostReportAsset[];
   styles: HostReportAsset[];
   pages: HostReportPage[];
@@ -193,6 +203,7 @@ export function normalizeHostReport(definition: unknown, sourceLabel: string): H
       title?: LocalizedText;
       links?: HostReportLink[];
       footer?: LocalizedText;
+      head?: HostHeadTag[];
       scripts?: HostReportAsset[];
       styles?: HostReportAsset[];
       content?: unknown;
@@ -231,6 +242,7 @@ export function normalizeHostReport(definition: unknown, sourceLabel: string): H
       ...(def.title !== undefined ? { title: def.title } : {}),
       links: def.links ?? [],
       ...(def.footer !== undefined ? { footer: def.footer } : {}),
+      head: def.head ?? [],
       scripts: def.scripts ?? [],
       styles: def.styles ?? [],
       pages,
@@ -241,6 +253,7 @@ export function normalizeHostReport(definition: unknown, sourceLabel: string): H
   if (isLegacyDefinition(definition)) {
     return {
       links: [],
+      head: [],
       scripts: [],
       styles: [],
       pages: [{ id: SINGLE_PAGE_ID, title: BUILT_IN_PAGE_TITLE, content: definition }],