niceeval 0.9.1 → 0.10.2

package/src/view/data.test.ts

@@ -14,10 +14,19 @@ import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { afterEach, describe, expect, it } from "vitest";
-import { IncompatibleResultsError, ViewInputError, loadLatestResultsPerEval, loadViewScan } from "./data.ts";
+import { IncompatibleResultsError, ViewInputError, loadLatestResultsPerEval, loadViewScan, type ViewScan } from "./data.ts";
+import type { AttemptHandle } from "../results/index.ts";
 import { RESULTS_FORMAT, RESULTS_SCHEMA_VERSION, type EvalResult, type Verdict } from "../types.ts";
 import { encodeAttemptLocator } from "../results/locator.ts";
 
+/** scan.attemptsByBase 按 base 建索引;测试按 eval id 找回单个 attempt(该 eval 在本 fixture 里唯一时用)。 */
+function attemptByEvalId(scan: ViewScan, evalId: string): AttemptHandle {
+  for (const handle of scan.attemptsByBase.values()) {
+    if (handle.evalId === evalId) return handle;
+  }
+  throw new Error(`no attempt found for eval id "${evalId}"`);
+}
+
 const roots: string[] = [];
 async function makeRoot(): Promise<string> {
   const root = await mkdtemp(join(tmpdir(), "niceeval-viewdata-"));
@@ -132,9 +141,9 @@ describe("loadViewScan · skipped 三种原因进 viewData", () => {
     const incomplete = [...byReason.values()].find((s) => s.reason === "incomplete")!;
     expect(incomplete.dir).toContain("2026-07-05T08-00-00-000Z");
 
-    // 正常快照照常进报告槽(默认报告的榜单),坏快照不拖垮整页。
+    // 正常快照照常进报告槽(默认报告的榜单),坏快照不拖垮整页;证据室索引也只有 exp/a 一条。
     expect(reportHtml.en).toContain("exp/a");
-    expect(viewData.snapshots.map((s) => s.experimentId)).toEqual(["exp/a"]);
+    expect([...scan.attemptsByBase.values()].map((a) => a.experimentId)).toEqual(["exp/a"]);
   });
 
   it("单文件模式指向版本不同的报告:抛 IncompatibleResultsError(CLI 打印提示退出)", async () => {
@@ -182,24 +191,29 @@ describe("loadViewScan · 报告槽是现刻水位口径,裸跑与局部收窄
       evalId: "q2",
       attempt: 0,
     });
-    expect(reportHtml.en).toContain(`#/attempt/${q1Locator}`); // q1 来自周二
-    expect(reportHtml.en).toContain(`#/attempt/${q2Locator}`); // q2 来自周一
+    expect(reportHtml.en).toContain(`attempt/${encodeURIComponent(q1Locator)}.html`); // q1 来自周二
+    expect(reportHtml.en).toContain(`attempt/${encodeURIComponent(q2Locator)}.html`); // q2 来自周一
 
     // 两题都有真实判定,不是伪残缺:报告槽不再出 partial-coverage 警告。
     expect(reportHtml.en).not.toContain('data-kind="partial-coverage"');
 
-    // 证据室的 latest 标记仍按 results.latest() 口径(周二快照),与报告槽 Selection 无关。
-    const latest = viewData.snapshots.filter((s) => s.latest);
-    expect(latest).toHaveLength(1);
-    expect(latest[0]!.startedAt).toBe("2026-07-02T08:00:00.000Z");
     expect(viewData.lastRunAt).toBe("2026-07-02T08:00:00.000Z");
     // 合成 Selection 的 attempts 来自周一、周二两个物理 run。
     expect(viewData.composedRuns).toBe(2);
 
-    // 历史快照仍在(Runs / Traces 吃全部),但不是 latest。
-    const historical = viewData.snapshots.filter((s) => !s.latest);
-    expect(historical).toHaveLength(1);
-    expect(historical[0]!.results.map((r) => r.id).sort()).toEqual(["q1", "q2"]);
+    // 历史 attempt 仍各自可达(attempt/<locator>.html 的证据室索引,不随报告槽 Selection 收窄):
+    // 周二的 q1(现刻水位选中的那份)、周一的 q2(唯一一次,现刻水位也选它)都在;
+    // 周一自己的 q1(被周二顶替,不再是现刻水位选中的那份)locator 不同,dedup 也不吞它——
+    // 它是独立的历史事实,不是 --resume 字面携带的复印件。
+    expect(scan.attemptPages!.locators.has(q1Locator)).toBe(true);
+    expect(scan.attemptPages!.locators.has(q2Locator)).toBe(true);
+    const q1MondayLocator = encodeAttemptLocator({
+      experimentId: "exp/a",
+      snapshotStartedAt: "2026-07-01T08:00:00.000Z",
+      evalId: "q1",
+      attempt: 0,
+    });
+    expect(scan.attemptPages!.locators.has(q1MondayLocator)).toBe(true);
   });
 });
 
@@ -224,20 +238,19 @@ describe("loadViewScan · 跨快照去重(--resume 携带的复印件只算一
       res("q2", "passed"),
     ]);
 
-    const { viewData, artifactDirs } = await loadViewScan(root);
-    // 全部快照(Runs/Traces 的数据面)里 q1 只出现一次:复印件不灌票。
-    const allResults = viewData.snapshots.flatMap((s) => s.results);
-    expect(allResults.filter((r) => r.id === "q1")).toHaveLength(1);
-    const q1 = allResults.find((r) => r.id === "q1")!;
+    const scan = await loadViewScan(root);
+    const { artifactDirs, attemptsByBase } = scan;
+    // 全部落盘(证据室索引的数据面)里 q1 只出现一次:复印件不灌票。
+    const allAttempts = [...attemptsByBase.values()];
+    expect(allAttempts.filter((a) => a.evalId === "q1")).toHaveLength(1);
+    const q1 = allAttempts.find((a) => a.evalId === "q1")!;
     // 证据身份(locator)跟着最新落盘走:身份元组里的 snapshotStartedAt 是新快照的 startedAt。
     expect(q1.locator).toBe(
       encodeAttemptLocator({ experimentId: "exp/a", snapshotStartedAt: "2026-07-02T08:00:00.000Z", evalId: "q1", attempt: 0 }),
     );
-    expect(q1.artifactBase).toBe("exp_a/2026-07-01T08-00-00-000Z/q1/a0"); // artifact 仍指原快照
+    expect(q1.result.artifactBase).toBe("exp_a/2026-07-01T08-00-00-000Z/q1/a0"); // artifact 仍指原快照
     // 静态导出(--out)能把携带条目的 artifact 一并带走。
     expect(artifactDirs.get("exp_a/2026-07-01T08-00-00-000Z/q1/a0")).toBe(join(oldDir, "q1", "a0"));
-    // 条目全被吸走的旧快照不再出现。
-    expect(viewData.snapshots.filter((s) => !s.latest)).toHaveLength(0);
   });
 });
 
@@ -256,28 +269,27 @@ describe("loadViewScan · 新布局落盘直接可读(写入面 / 读取面同
     );
 
     const scan = await loadViewScan(root);
-    const { viewData } = scan;
     const reportHtml = scan.reportPages[0]!.html;
     // 报告槽(ExperimentComparison 的 web 面):Experiment 工作台行 + 官方通过率格子(1 过 1 败 = 50%)。
     expect(reportHtml.en).toContain("compare/bub");
     expect(reportHtml.en).toContain("50%");
-    const snapshot = viewData.snapshots[0]!;
-    expect(snapshot.latest).toBe(true);
-    expect(snapshot.agent).toBe("bub");
-    expect(snapshot.run).toBe("compare_bub/2026-07-03T08-00-00-000Z");
+    const attempts = [...scan.attemptsByBase.values()];
+    expect(attempts.every((a) => a.snapshot.agent === "bub")).toBe(true);
+    expect(attempts.every((a) => a.snapshot.startedAt === "2026-07-03T08:00:00.000Z")).toBe(true);
     // 每条结果的 locator 都能由身份元组(experimentId/快照 startedAt/evalId/attempt 下标)独立复算,
     // 证明它不是随手塞的占位值,而是真从落盘产物(snapshot.json + result.json)算出来的。
-    expect(snapshot.results.every((r) => r.locator === encodeAttemptLocator({
-      experimentId: snapshot.experimentId,
-      snapshotStartedAt: snapshot.startedAt,
-      evalId: r.id,
-      attempt: r.attempt,
+    expect(attempts.every((a) => a.locator === encodeAttemptLocator({
+      experimentId: a.experimentId,
+      snapshotStartedAt: a.snapshot.startedAt,
+      evalId: a.evalId,
+      attempt: a.result.attempt,
     }))).toBe(true);
-    // 本快照跑出的条目落盘没有 artifactBase 字段:读取面按 `${ref.snapshot}/${ref.attempt}` 现算,
-    // ref.snapshot 恒等于 snapshot.run,ref.attempt 恒是 `${evalId}/a${attempt}`。
-    const q1 = snapshot.results.find((r) => r.id === "q1")!;
-    expect(q1.hasEvents).toBe(true);
-    expect(q1.artifactBase).toBe(`${snapshot.run}/q1/a0`);
+    // 本快照跑出的条目落盘没有 artifactBase 字段:读取面按 `${ref.snapshot}/${ref.attempt}` 现算——
+    // scan.attemptsByBase 正是按这份现算出的 base 建的索引,q1 应恰好落在这个 key 上。
+    const q1Base = "compare_bub/2026-07-03T08-00-00-000Z/q1/a0";
+    const q1 = scan.attemptsByBase.get(q1Base)!;
+    expect(q1).toBeTruthy();
+    expect(q1.result.hasEvents).toBe(true);
   });
 });
 

package/src/view/data.ts

@@ -7,29 +7,23 @@
 // 见 docs/feature/reports/view.md「打开与收窄」。
 
 import { readFileSync, statSync } from "node:fs";
-import { basename, dirname, extname, join, relative, resolve } from "node:path";
-import { dedupeAttempts, openResults } from "../results/index.ts";
+import { dirname, extname, join, relative, resolve } from "node:path";
+import { dedupeAttempts, loadAttemptEvidence, openResults } from "../results/index.ts";
 import type { AttemptHandle, Results, Scope, Snapshot, SkippedDir } from "../results/index.ts";
+import type { AttemptLocator } from "../results/locator.ts";
 import {
+  buildHostReportMeta,
   loadHostReport,
   renderHostPageHtml,
-  reportMetaFor,
-  resolveReportTitle,
-  type HostHeadTag,
-  type HostReport,
-  type HostReportAsset,
-} from "../show/report-host.ts";
+  type ReportAsset,
+  type ReportDefinition,
+  type ReportPage,
+  type HeadTag,
+} from "../report/runtime/host.ts";
 import { selectCurrentResults, filterExperiments } from "../results/select.ts";
 import { evalPrefixPredicate } from "../shared/aggregate.ts";
 import type { EvalResult } from "../types.ts";
-import type {
-  SkippedRunNotice,
-  ViewData,
-  ViewEvalResult,
-  ViewReportMeta,
-  ViewReportPageHtml,
-  ViewSnapshot,
-} from "./shared/types.ts";
+import type { SkippedRunNotice, ViewData, ViewReportMeta, ViewReportPageHtml } from "./shared/types.ts";
 import { t } from "../i18n/index.ts";
 import { RESULTS_SCHEMA_VERSION } from "../types.ts";
 
@@ -58,8 +52,26 @@ export interface ViewScan {
   reportPages: ViewReportPageHtml[];
   /** 外壳注入资产(styles / scripts;{src} 已按路径纪律解析成 inline 内容),只进 web 面。 */
   shellAssets: { styles: string[]; scripts: string[]; head: ResolvedHeadTag[] };
+  /**
+   * 报告声明了 attempt-input page 时才存在(architecture.md「Attempt 详情是一张参数化 page」)。
+   * `locators` 是收窄后有效根内可达的 locator → AttemptHandle(与 scope-input pages 同一份
+   * `scopedExperiments ∩ matchEval ∩ survivors` 口径——去重只吞掉 `--resume` 携带的字面重复,
+   * 不排除真实历史 attempt,见 view.md「打开与收窄」);站点管线(site.ts)据此为每个可达
+   * locator 生成一份 `attempt/<locator>.html`,不在这份索引里的 locator 不出站。
+   * `render` 装配一个 locator 的 `AttemptEvidence` 并渲染该 page 两种语言的内容 HTML(不含外层
+   * 文档 —— 独立 HTML 文档的组装是 site.ts 的事);pageFailure 语义与 scope pages 一致。
+   */
+  attemptPages?: {
+    page: ReportPage;
+    locators: Map<AttemptLocator, AttemptHandle>;
+    render(locator: AttemptLocator, handle: AttemptHandle): Promise<{ en: string; "zh-CN": string }>;
+  };
 }
 
+/** attempt 页面内容(不是 index.html 的 scope-input page)链去同目录 attempt/ 下的兄弟文档,
+ *  不带 `attempt/` 目录前缀(site.ts「站点管线」;两处 href 的对应关系与拆分只住在那)。 */
+const SIBLING_ATTEMPT_HREF = (locator: AttemptLocator): string => `${encodeURIComponent(locator)}.html`;
+
 /** view 宿主输入的组合语义(与 show 对齐,docs/feature/reports/architecture.md「Scope 是计算入口」)。 */
 export interface ViewScanOptions {
   /** eval id 前缀(位置参数):把根滤成有效根,页面 Scope 与证据(快照明细、artifact 清单)一致收窄。 */
@@ -213,9 +225,6 @@ export async function loadViewScan(input?: string, opts: ViewScanOptions = {}):
 
   // 报告槽 Selection:恒经现刻水位选择器合成,与 show 裸跑同口径(两扇门判定不分叉)。
   const selection = selectCurrentResults(results, { experiment: opts.experiment, patterns });
-  // latestPerExperiment 只服务证据室 UI 的 latest 标记(ViewSnapshot.latest / viewData.snapshots),
-  // 与报告槽 Selection 完全无关,绝不复用为报告 Selection。
-  const latestPerExperiment = results.latest();
 
   if (patterns.length > 0 && selection.snapshots.every((s) => s.evals.length === 0)) {
     const known = [
@@ -238,44 +247,21 @@ export async function loadViewScan(input?: string, opts: ViewScanOptions = {}):
   const matchEval = patterns.length > 0 ? evalPrefixPredicate(patterns) : () => true;
 
   // 跨快照按身份键去重:--resume 携带的条目在多份落盘里重复,只保留最新快照里的那份
-  // (与官方计算函数的聚合口径一致,Runs / Traces 的计数因此不被复印件灌票)。
+  // (与官方计算函数的聚合口径一致,attempt/<locator>.html 的计数因此不被复印件灌票)。
   const artifactDirs = new Map<string, string>();
   const attemptsByBase = new Map<string, AttemptHandle>();
-  // latest 标记恒按 results.latest() 口径打(ViewSnapshot.latest 的声明语义),
-  // 与报告槽 Selection(现刻水位,可能合成自更早快照)是两个独立概念,不混用。
-  const latestSet = new Set(latestPerExperiment.snapshots);
+  // 报告没有 attempt-input page 时不建这份索引:没有 attempt/ 目录,站点管线不需要它
+  // (view.md「静态导出」)。
+  const attemptsByLocator = slot.attemptPage ? new Map<AttemptLocator, AttemptHandle>() : undefined;
   const allAttempts: AttemptHandle[] = [];
   for (const exp of scopedExperiments) {
     for (const snap of exp.snapshots) allAttempts.push(...snap.attempts.filter((a) => matchEval(a.evalId)));
   }
-  const survivors = new Set(dedupeAttempts(allAttempts).attempts);
-
-  const snapshots: ViewSnapshot[] = [];
-  for (const exp of scopedExperiments) {
-    // 整个实验没有匹配 eval 时不携带:有效根里没有它,连快照元数据也不烘进页面。
-    if (patterns.length > 0 && !exp.evalIds.some((id) => matchEval(id))) continue;
-    for (const snap of exp.snapshots) {
-      const kept = snap.attempts.filter((a) => survivors.has(a));
-      const latest = latestSet.has(snap);
-      // 条目全被去重吸走的历史快照不再携带(它的内容原样活在更新的落盘里)。
-      if (kept.length === 0 && !latest) continue;
-      snapshots.push({
-        experimentId: snap.experimentId,
-        agent: snap.agent,
-        ...(snap.model !== undefined ? { model: snap.model } : {}),
-        startedAt: snap.startedAt,
-        // 与 reader 的 AttemptRef.snapshot 同一公式(祖父目录名/自身目录名),不依赖 root——
-        // 单文件模式的 root 是从目标文件上跳算出的,两条计算各自独立更不容易踩偏差。
-        run: `${basename(dirname(snap.dir))}/${basename(snap.dir)}`,
-        latest,
-        results: kept.map((a) => {
-          const { annotated, base, abs } = annotateResult(a, root);
-          artifactDirs.set(base, abs);
-          attemptsByBase.set(base, a);
-          return annotated;
-        }),
-      });
-    }
+  for (const attempt of dedupeAttempts(allAttempts).attempts) {
+    const { base, abs } = artifactLocation(attempt, root);
+    artifactDirs.set(base, abs);
+    attemptsByBase.set(base, attempt);
+    if (attemptsByLocator && attempt.locator !== undefined) attemptsByLocator.set(attempt.locator, attempt);
   }
 
   // 全局最新快照(跨有效根内全部实验):viewData.lastRunAt 从这里取。页内 hero 的「最后运行」
@@ -293,7 +279,6 @@ export async function loadViewScan(input?: string, opts: ViewScanOptions = {}):
     // 反向引用取——每个 attempt 的 .snapshot 恒指向它真实所在的贡献快照(无论 Scope
     // 是否合成),所以这条对裸跑与收窄一律成立,不需要分支。
     composedRuns: new Set(selection.snapshots.flatMap((s) => s.attempts.map((a) => a.snapshot.dir))).size,
-    snapshots,
     skippedRuns: results.skipped.map(toSkippedNotice),
     report: slot.meta,
   };
@@ -303,6 +288,9 @@ export async function loadViewScan(input?: string, opts: ViewScanOptions = {}):
     attemptsByBase,
     reportPages: slot.pages,
     shellAssets: slot.shellAssets,
+    ...(slot.attemptPage && attemptsByLocator
+      ? { attemptPages: { page: slot.attemptPage, locators: attemptsByLocator, render: slot.renderAttemptPage } }
+      : {}),
   };
 }
 
@@ -345,7 +333,7 @@ export interface ResolvedHeadTag {
 }
 
 /** head 标签 attrs 的 src/href 解析:外链透传,本地路径按 `{src}` 同一路径纪律落成绝对路径并验存在。 */
-function resolveShellHead(tags: HostHeadTag[], baseDir: string | undefined): ResolvedHeadTag[] {
+function resolveShellHead(tags: readonly HeadTag[], baseDir: string | undefined): ResolvedHeadTag[] {
   const out: ResolvedHeadTag[] = [];
   for (const entry of tags) {
     const attrs = { ...(entry.attrs ?? {}) };
@@ -378,7 +366,7 @@ function resolveShellHead(tags: HostHeadTag[], baseDir: string | undefined): Res
 }
 
 /** 外壳 `{src}` 资产的路径纪律(shell.md「行为约束」):相对报告文件解析;拒绝 `..` 路径段、绝对路径与 `~`。 */
-function resolveShellAssets(assets: HostReportAsset[], baseDir: string | undefined, kind: "styles" | "scripts"): string[] {
+function resolveShellAssets(assets: readonly ReportAsset[], baseDir: string | undefined, kind: "styles" | "scripts"): string[] {
   const out: string[] = [];
   for (const asset of assets) {
     if (asset.inline !== undefined) {
@@ -421,17 +409,32 @@ async function renderReportSlot(
   meta: ViewReportMeta;
   pages: ViewReportPageHtml[];
   shellAssets: { styles: string[]; scripts: string[]; head: ResolvedHeadTag[] };
+  attemptPage: ReportPage | undefined;
+  renderAttemptPage: (locator: AttemptLocator, handle: AttemptHandle) => Promise<{ en: string; "zh-CN": string }>;
 }> {
   // 报告 runtime 走预编译产物(dist/report/**,`pnpm run build:report` 产出),不受 view
-  // 消费方 cwd/tsconfig 影响;装载与渲染统一经 ../show/report-host.ts(两个宿主共用的联系面)。
-  const hostReport: HostReport = await loadHostReport(report?.cwd ?? process.cwd(), report?.path, {
+  // 消费方 cwd/tsconfig 影响;装载与渲染统一经 ../report/runtime/host.ts(两个宿主共用的中性联系面)。
+  const hostReport: ReportDefinition = await loadHostReport(report?.cwd ?? process.cwd(), report?.path, {
     freshImport: true,
   });
 
-  const initialPageId = page ?? hostReport.pages[0]!.id;
-  if (!hostReport.pages.some((p) => p.id === initialPageId)) {
+  // scope-input pages 只有这些参与本函数的「全部烘进 index.html」渲染;attempt-input page(如果
+  // 报告声明了)没有 locator 就不能 resolve,它的每-locator 静态文档是独立机制,不在这里渲染
+  // (docs/feature/reports/architecture.md「Attempt 详情是一张参数化 page」)。
+  const scopePages = hostReport.pages.filter((p) => p.input !== "attempt");
+  const navigablePages = scopePages.filter((p) => p.navigation !== false);
+
+  const initialPageId = page ?? navigablePages[0]?.id ?? scopePages[0]?.id;
+  const initialPage = initialPageId !== undefined ? scopePages.find((p) => p.id === initialPageId) : undefined;
+  if (initialPageId === undefined || !initialPage) {
+    const requested = hostReport.pages.find((p) => p.id === page);
+    if (requested?.input === "attempt") {
+      throw new ViewInputError(
+        `error: page "${page}" in ${report?.path ?? "the built-in report"} is an attempt-input page and needs a locator — it cannot be opened as the initial page directly.`,
+      );
+    }
     throw new ViewInputError(
-      `error: page "${page}" not found in ${report?.path ?? "the built-in report"}. Available pages: ${hostReport.pages.map((p) => p.id).join(", ")}`,
+      `error: page "${page}" not found in ${report?.path ?? "the built-in report"}. Available pages: ${navigablePages.map((p) => p.id).join(", ")}`,
     );
   }
 
@@ -442,10 +445,10 @@ async function renderReportSlot(
     head: resolveShellHead(hostReport.head, reportDir),
   };
 
+  const hostMeta = await buildHostReportMeta(hostReport, selection);
   const pages: ViewReportPageHtml[] = [];
-  for (const hostPage of hostReport.pages) {
-    const meta = reportMetaFor(hostReport, hostPage.id, selection.snapshots);
-    const ctx = { scope: selection, results, report: meta };
+  for (const hostPage of scopePages) {
+    const ctx = { scope: selection, results, report: hostMeta, page: { id: hostPage.id, input: "scope" as const } };
     try {
       pages.push({
         id: hostPage.id,
@@ -464,13 +467,42 @@ async function renderReportSlot(
   }
 
   const meta: ViewReportMeta = {
-    title: resolveReportTitle(hostReport.title, selection.snapshots),
-    links: hostReport.links,
+    title: hostMeta.title,
+    links: [...hostReport.links],
     ...(hostReport.footer !== undefined ? { footer: hostReport.footer } : {}),
-    pages: hostReport.pages.map((p) => ({ id: p.id, title: p.title })),
+    pages: scopePages.map((p) => ({ id: p.id, title: p.title })),
     initialPageId,
   };
-  return { meta, pages, shellAssets };
+
+  const attemptPage = hostReport.pages.find((p) => p.input === "attempt");
+  // 装配一个 locator 的 AttemptEvidence 并渲染该 page 两种语言的内容 HTML(不含外层文档);
+  // pageFailure 语义与 scope pages 相同 —— 本地 server 折成该文档的完整错误反馈块,
+  // 静态导出直接抛出(writeSite 侧汇总成「整体失败,不留半套目录」)。
+  const renderAttemptPage = async (
+    locator: AttemptLocator,
+    handle: AttemptHandle,
+  ): Promise<{ en: string; "zh-CN": string }> => {
+    const evidence = await loadAttemptEvidence(handle);
+    const ctx = {
+      scope: selection,
+      results,
+      report: hostMeta,
+      page: { id: attemptPage!.id, input: "attempt" as const, locator, evidence },
+    };
+    try {
+      return {
+        en: await renderHostPageHtml(attemptPage!, ctx, { locale: "en", attemptHref: SIBLING_ATTEMPT_HREF }),
+        "zh-CN": await renderHostPageHtml(attemptPage!, ctx, { locale: "zh-CN", attemptHref: SIBLING_ATTEMPT_HREF }),
+      };
+    } catch (e) {
+      if (pageFailure !== "embed") throw e;
+      const message = e instanceof Error ? e.message : String(e);
+      const block = `<div class="nre nre-page-error"><pre>${escapeHtml(message)}</pre></div>`;
+      return { en: block, "zh-CN": block };
+    }
+  };
+
+  return { meta, pages, shellAssets, attemptPage, renderAttemptPage };
 }
 
 /**
@@ -504,24 +536,14 @@ function assertSingleFileReadable(results: Results, target: string): void {
 }
 
 /**
- * 给单条 attempt 注入 view 侧标注:
- * - locator:不透明的 AttemptLocator(与 Reports 的 MetricCell.refs / `ctx.attemptHref` 同一身份),
- *   `#/attempt/@<locator>` 深链路由的参数——证据室按它在 viewData.snapshots 里定位回同一条 attempt。
- * - artifactBase:相对 view 根的 artifact 目录(前端据此 fetch trace.json 等)。本快照跑出的
- *   条目落盘没有这个字段,按 `${ref.snapshot}/${ref.attempt}` 现算;携带条目(--resume 合入)
- *   落盘自带 artifactBase,指向原快照,原样沿用。
- * 返回新对象,不 mutate 读入的结果;宿主机绝对路径只回给调用方写进 artifactDirs
- * (server 端内存),不挂到 result 上,避免随 viewData 进静态 HTML。
+ * 一条 attempt 的 artifact 目录:相对 view 根的 base(前端据此 fetch trace.json 等)与宿主机
+ * 绝对路径。本快照跑出的条目落盘没有 artifactBase 字段,按 `${ref.snapshot}/${ref.attempt}`
+ * 现算;携带条目(--resume 合入)落盘自带 artifactBase,指向原快照,原样沿用。绝对路径只
+ * 回给调用方写进 artifactDirs(server 端内存),不进 viewData,避免随静态 HTML 泄漏宿主机路径。
  */
-function annotateResult(
-  attempt: AttemptHandle,
-  root: string,
-): { annotated: ViewEvalResult; base: string; abs: string } {
-  const r = attempt.result;
-  const base = r.artifactBase ?? `${attempt.ref.snapshot}/${attempt.ref.attempt}`;
-  const abs = join(root, base);
-  const annotated: ViewEvalResult = { ...r, locator: attempt.locator, artifactBase: base };
-  return { annotated, base, abs };
+function artifactLocation(attempt: AttemptHandle, root: string): { base: string; abs: string } {
+  const base = attempt.result.artifactBase ?? `${attempt.ref.snapshot}/${attempt.ref.attempt}`;
+  return { base, abs: join(root, base) };
 }
 
 /**

package/src/view/index.ts

@@ -10,7 +10,7 @@ import { planSite, writeSite } from "./site.ts";
 import type { ViewOptions } from "./server.ts";
 
 export { startViewServer, type ViewOptions, type ViewServer } from "./server.ts";
-export { planSite, writeSite, renderHtml, type SitePlan, type SiteFile } from "./site.ts";
+export { planSite, writeSite, renderHtml, renderStandaloneAttemptDocument, type SitePlan, type SiteFile } from "./site.ts";
 export {
   IncompatibleResultsError,
   ViewInputError,

package/src/view/server.ts

@@ -5,9 +5,19 @@
 // (pageFailure: "embed")。位置参数 / --exp 收窄是管线输入,不是宿主语义——两宿主同义。
 
 import { createServer, type Server } from "node:http";
-import { type ViewScanOptions } from "./data.ts";
-import { planSite, readSiteFile, type SitePlan } from "./site.ts";
+import { loadViewScan, type ViewScanOptions } from "./data.ts";
+import { planSite, readSiteFile, renderStandaloneAttemptDocument, type SitePlan } from "./site.ts";
 import { formatThrown } from "../util.ts";
+import type { AttemptLocator } from "../results/locator.ts";
+
+const HTML_TYPE = "text/html; charset=utf-8";
+
+/** `attempt/<locator>.html` 站点路径 → 磁盘/清单键用的原始 locator(未编码,含字面 `@`;
+ *  见 site.ts「站点管线」对编码边界的说明)。不是这个形状返回 undefined。 */
+function attemptLocatorFromSitePath(sitePath: string): AttemptLocator | undefined {
+  if (!sitePath.startsWith("attempt/") || !sitePath.endsWith(".html")) return undefined;
+  return sitePath.slice("attempt/".length, -".html".length) as AttemptLocator;
+}
 
 export interface ViewOptions {
   input?: string;
@@ -70,6 +80,21 @@ export async function startViewServer(opts: ViewOptions = {}): Promise<ViewServe
         file = plan.files.get(sitePath);
       }
       if (!file) {
+        // 本地宿主的 attempt 详情路由越过收窄,对完整结果根解析(docs/engineering/unit-tests/
+        // reports/cases.md 第 198/220 行;与 `show @<locator>` 同一套「各自结果根语义寻址」,
+        // 不是 SitePlan 清单之外的旁路取数——这条路由本来就不该受 --exp/eval 前缀收窄限制,
+        // 与「server 不提供清单之外的路径」的奇偶保证不冲突,那条保证只约束收窄之内的路径)。
+        const locator = attemptLocatorFromSitePath(sitePath);
+        if (locator !== undefined) {
+          const fullScan = await loadViewScan(input, { ...scanOptions, experiment: undefined, patterns: [] }).catch(() => undefined);
+          const handle = fullScan?.attemptPages?.locators.get(locator);
+          if (fullScan && handle) {
+            const body = await renderStandaloneAttemptDocument(fullScan, locator, handle);
+            res.writeHead(200, { "content-type": HTML_TYPE, "cache-control": "no-store" });
+            res.end(body);
+            return;
+          }
+        }
         res.writeHead(404, { "content-type": "text/plain; charset=utf-8" });
         res.end("not found");
         return;
@@ -80,6 +105,11 @@ export async function startViewServer(opts: ViewOptions = {}): Promise<ViewServe
         res.end("not found");
         return;
       }
+      // 同一路径同一 plan 生命周期内不重复求值(architecture.md「管线以 page 实例为单位执行」):
+      // lazy 产出器求值一次后把结果写回清单,下一次同路径请求(未触发 rebuild 之前)直接命中。
+      if (file.source.kind === "lazy") {
+        plan.files.set(sitePath, { ...file, source: { kind: "content", body: body as string } });
+      }
       res.writeHead(200, { "content-type": file.contentType, "cache-control": "no-store" });
       res.end(body);
     } catch (e) {

package/src/view/shared/types.ts

@@ -1,12 +1,13 @@
 // server(data.ts)与前端(app/)共用的 view 数据形状。
 // viewData 会被序列化进静态 HTML,两边必须对同一份声明编程;只允许 type import。
 //
-// viewData 只携带证据室与壳需要的东西:快照明细(locator / artifactBase 已注入)、
-// skipped、项目名与 run 元信息。统计口径(KPI / 榜单 / 挑选警告)整体住在报告槽的
-// 静态 HTML 里(ExperimentComparison 或 --report 的报告自己算),壳与报告之间没有第二条数据通道。
+// viewData 只携带壳需要的东西:skipped、项目名与 run 元信息。attempt 明细不在这里——
+// 每份 attempt/<locator>.html 是独立静态文档(site.ts),不通过 viewData 这条通道下发;
+// 统计口径(KPI / 榜单 / 挑选警告)整体住在报告槽的静态 HTML 里(ExperimentComparison 或
+// --report 的报告自己算),壳与报告之间没有第二条数据通道。
 
-import type { EvalResult, LocalizedText } from "../../types.ts";
-import type { ReportLocale } from "../../report/locale.ts";
+import type { LocalizedText } from "../../types.ts";
+import type { ReportLocale } from "../../report/model/locale.ts";
 import type { AttemptLocator } from "../../results/locator.ts";
 
 export type { AttemptLocator };
@@ -47,30 +48,6 @@ export interface ViewReportMeta {
   initialPageId: string;
 }
 
-/** view 侧的 attempt 结果 = 瘦身后的 EvalResult + loader 注入的深链身份(不透明 AttemptLocator,
- * `#/attempt/@<locator>` 路由的参数,与 Reports 的 MetricCell.refs / `ctx.attemptHref` 同一身份契约)
- * 与 artifact 基址。 */
-export type ViewEvalResult = EvalResult & { locator?: AttemptLocator };
-
-/**
- * 快照 = 单次跑的实验(experiment × 一次运行),与 niceeval/results 的 Snapshot 同口径。
- * 携带 attempt 明细供证据室(钻取 / AttemptModal / Runs / Traces)渲染;
- * 榜单统计不从这里算,吃 ViewData.table / overview 的官方产物。
- */
-export interface ViewSnapshot {
-  experimentId: string;
-  agent: string;
-  model?: string;
-  startedAt: string;
-  /** 快照的根相对路径(= niceeval/results 的 AttemptRef.snapshot,两段:`<experiment-dir>/<snapshot-dir>`)。 */
-  run: string;
-  /** 是否为该实验在 results.latest() 口径下的最新一次快照 —— 证据室的 latest 标记,与报告槽 Selection
-   (现刻水位,可能合成自更早快照)是两个独立概念,不要混用。 */
-  latest: boolean;
-  /** 该快照的 attempt 明细(跨快照去重后的幸存条目;locator / artifactBase 已注入)。 */
-  results: ViewEvalResult[];
-}
-
 /**
  * 目录扫描里被跳过的 run 的结构化条目;三种原因与 niceeval/results 的 skipped 一致。
  * 页面上的呈现不走它:不可读快照已形成 `unreadable-snapshot` Scope warning,由报告页内的
@@ -99,8 +76,6 @@ export interface ViewData {
   lastRunAt?: string;
   /** 报告槽 Selection 合成自几个物理 run。 */
   composedRuns: number;
-  /** 全部历史快照(跨快照按身份键去重后);attempt 详情路由对这份完整集合解析,不随报告 Scope 收窄。 */
-  snapshots: ViewSnapshot[];
   /** 读不了的落盘(三种原因);呈现走报告页内的 ScopeWarnings(unreadable-snapshot warning)。 */
   skippedRuns?: SkippedRunNotice[];
   /** 报告外壳与页导航的声明(规范化后);缺省时前端按单页 `report` 兜底。 */

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

@@ -35,7 +35,7 @@ async function seedSnapshot(root: string, experimentId: string, evalId: string):
         { type: "message", role: "user", text: "hi", loc: { file: "evals/a.eval.ts", line: 3 } },
         { type: "message", role: "assistant", text: "hello there" },
       ],
-      trace: [{ name: "turn", kind: "turn" } as never],
+      trace: [{ traceId: "t1", spanId: "s1", name: "turn", kind: "turn", startMs: 0, endMs: 100 }],
       diff: [{ window: "s1/t1", changes: { "a.txt": { status: "added", after: "1" } } }] as never,
     },
   );
@@ -114,4 +114,27 @@ describe("站点管线奇偶:server 与 --out 是同一份产物", () => {
     const direct = await (await fetch(new URL(`/${eventsPath}`, server.url))).text();
     expect(await res.text()).toBe(direct);
   });
+
+  it("本地宿主的 attempt 详情路由越过 --exp 收窄,对完整结果根解析(cases.md 第 198/220 行,与 show @<locator> 同一套「各自结果根语义寻址」)", async () => {
+    const root = await makeDir("niceeval-parity-unnarrowed-");
+    await seedSnapshot(root, "exp-a", "q1");
+    await seedSnapshot(root, "exp-b", "q2");
+    server = await startViewServer({ input: root, scan: { experiment: "exp-a" } });
+
+    const full = await planSite(root); // 不收窄,拿到两个实验各自的 attempt 路径
+    const attemptPaths = [...full.files.keys()].filter((p) => p.startsWith("attempt/"));
+    expect(attemptPaths).toHaveLength(2);
+
+    // 收窄后的 plan 只剩 exp-a 的那份(row 205 已覆盖导出侧的同一断言;这里确认 plan 本身也收窄)。
+    const narrowed = await planSite(root, { experiment: "exp-a" });
+    const narrowedPaths = new Set(narrowed.files.keys());
+    const outsideScopePath = attemptPaths.find((p) => !narrowedPaths.has(p))!;
+    expect(outsideScopePath).toBeTruthy();
+
+    // 但本地 server 仍能直接打开它:路由越过收窄,对完整结果根解析。
+    const res = await fetch(new URL(`/${outsideScopePath}`, server.url));
+    expect(res.status).toBe(200);
+    const body = await res.text();
+    expect(body).toContain("q2"); // exp-b 的证据内容真的解析出来了,不是空白/占位
+  });
 });