niceeval 0.11.4-canary.20 → 0.12.0

package/src/report/assets/styles.css

@@ -61,6 +61,38 @@
 .niceeval-report .niceeval-locator.niceeval-verdict-skipped { color: var(--soft); }
 .niceeval-report .niceeval-locator-mark { font-weight: 650; }
 
+/* ---- 时效:降饱和样式,与判定色同一条路径(experiment-table.md「时效不写字」) ----
+   历史执行(locator 格 staleSinceMs 在场)与覆盖缺口的过期结论参考共用同一条降饱和纪律:
+   判定色与 currentColor 混入中性 --soft,不额外发明第二套色板。 */
+.niceeval-report .niceeval-locator.niceeval-stale,
+.niceeval-report .niceeval-locator.niceeval-stale .niceeval-locator-mark {
+  color: color-mix(in oklch, currentColor, var(--soft) 55%);
+}
+.niceeval-report .niceeval-stale-distance {
+  margin-left: 2px;
+  font-variant-numeric: tabular-nums;
+  color: var(--soft);
+}
+.niceeval-report .niceeval-missing-reason { color: var(--muted); }
+
+/* ---- 构成格:一条分段条,按计数占比分宽,hover 出段名与计数(table.md「构成格」) ----
+   段的业务含义住在投影层,这里只按声明序给一条位置驱动的渐隐色阶,不认识任何段名。 */
+.niceeval-report .niceeval-composition {
+  display: flex;
+  align-items: stretch;
+  height: 8px;
+  min-width: 72px;
+  border-radius: 4px;
+  overflow: hidden;
+  background: var(--line);
+}
+.niceeval-report .niceeval-composition-segment {
+  display: block;
+  height: 100%;
+  min-width: 2px;
+  background: color-mix(in oklch, var(--accent), var(--soft) calc(var(--composition-step, 0) * 22%));
+}
+
 /* ---- 维度键上色:同一个 key 在任何块里同色(文字) ---- */
 .niceeval-report .niceeval-c0 { color: var(--c0); }
 .niceeval-report .niceeval-c1 { color: var(--c1); }
@@ -78,6 +110,41 @@
 .niceeval-report .niceeval-series-c5 { --series: var(--c5); }
 .niceeval-report .niceeval-series-none { --series: var(--muted); }
 
+/*
+ * HTML 横向柱的 variant 填充图案(CSS 等效 SVG <pattern>)。
+ * variant 1 = 实心(默认 .niceeval-chart-bar-fill);2 对角斜线 / 3 水平条纹 / 4 点阵。
+ * 颜色始终读 --series,换主题令牌自动换色,不写死 hex。
+ */
+.niceeval-report .niceeval-series-fill-v2 {
+  background-color: transparent;
+  background-image: repeating-linear-gradient(
+    -45deg,
+    color-mix(in srgb, var(--series) 78%, var(--panel)),
+    color-mix(in srgb, var(--series) 78%, var(--panel)) 2px,
+    color-mix(in srgb, var(--series) 28%, var(--panel)) 2px,
+    color-mix(in srgb, var(--series) 28%, var(--panel)) 5px
+  );
+}
+.niceeval-report .niceeval-series-fill-v3 {
+  background-color: transparent;
+  background-image: repeating-linear-gradient(
+    0deg,
+    color-mix(in srgb, var(--series) 78%, var(--panel)),
+    color-mix(in srgb, var(--series) 78%, var(--panel)) 2px,
+    color-mix(in srgb, var(--series) 28%, var(--panel)) 2px,
+    color-mix(in srgb, var(--series) 28%, var(--panel)) 5px
+  );
+}
+.niceeval-report .niceeval-series-fill-v4 {
+  background-color: color-mix(in srgb, var(--series) 28%, var(--panel));
+  background-image: radial-gradient(
+    circle at 25% 25%,
+    color-mix(in srgb, var(--series) 88%, var(--panel)) 1.2px,
+    transparent 1.3px
+  );
+  background-size: 6px 6px;
+}
+
 /* ---- 表格通用:圆角 panel、细分隔线、tabular-nums 数字、uppercase 小标签 ---- */
 table.niceeval-report,
 .niceeval-report table {
@@ -160,6 +227,23 @@ table.niceeval-report,
 }
 .niceeval-table-wrap > .niceeval-filter:focus { border-color: var(--line-strong); }
 .niceeval-table-wrap > .niceeval-filter::placeholder { color: var(--soft); }
+
+/* ---- 「只看新执行」开关(experiment-table.md「只看新执行」) ----
+   增强层:初始 HTML 是关闭态的完整表(niceeval-fresh-all 可见,niceeval-fresh-only 隐藏),
+   开关只切换这两块的可见性,不重新请求或重新计算任何数据。 */
+.niceeval-report .niceeval-fresh-toggle {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  margin: 0 0 12px;
+  color: var(--muted);
+  font-size: 12.5px;
+  cursor: pointer;
+}
+.niceeval-report .niceeval-fresh-toggle input[type="checkbox"] { margin: 0; }
+.niceeval-report .niceeval-fresh-only { display: none; }
+.niceeval-report.niceeval-experiment-table:has(.niceeval-fresh-toggle input:checked) .niceeval-fresh-all { display: none; }
+.niceeval-report.niceeval-experiment-table:has(.niceeval-fresh-toggle input:checked) .niceeval-fresh-only { display: block; }
 .niceeval-report .niceeval-cell-text { display: block; min-width: 0; }
 .niceeval-report .niceeval-cell-detail {
   display: block;
@@ -963,6 +1047,7 @@ table.niceeval-report,
 }
 .niceeval-command-evidence--failed { border-left-color: var(--bad); }
 .niceeval-command-evidence--observed { border-left-color: var(--muted); }
+.niceeval-command-evidence--succeeded { border-left-color: var(--good); }
 .niceeval-command-evidence-card .niceeval-conversation-turn-head {
   display: flex;
   flex-wrap: wrap;
@@ -1133,12 +1218,19 @@ table.niceeval-report,
   align-items: center;
   gap: 5px;
 }
-.niceeval-chart .niceeval-chart-legend-item::before {
-  content: "";
-  width: 6px;
-  height: 6px;
+/* 图例色块由 renderer 显式输出(含 variant 图案 / 线型 / marker),不再用 ::before 单色方块。 */
+.niceeval-chart .niceeval-chart-legend-swatch {
+  display: inline-block;
+  width: 10px;
+  height: 10px;
+  flex: 0 0 auto;
   border-radius: var(--radius);
-  background: var(--series);
+  background: color-mix(in srgb, var(--series) 74%, var(--panel));
+}
+.niceeval-chart .niceeval-chart-legend-swatch-svg {
+  display: block;
+  flex: 0 0 auto;
+  overflow: visible;
 }
 .niceeval-chart .niceeval-chart-missing {
   max-width: 880px;

package/src/report/built-in/result-components.tsx

@@ -22,6 +22,7 @@ import {
 import { HeroCard } from "../components/site-components/index.tsx";
 import { AttemptSummary } from "../components/attempt-detail/index.tsx";
 import { experimentListContent } from "../components/entity-lists/content.ts";
+import { ExperimentTableView } from "../components/entity-lists/index.tsx";
 import {
   attemptAssertionsContent,
   attemptConversationContent,
@@ -39,7 +40,7 @@ import {
   formatReportDateTimeRange,
 } from "../model/format.ts";
 import { DEFAULT_REPORT_LOCALE, localeText, type ReportLocale } from "../model/locale.ts";
-import type { Dataset, UsageTableData } from "../model/types.ts";
+import type { AttemptFactsData, Dataset, UsageTableData } from "../model/types.ts";
 import type { MetricValue } from "../model/calculation.ts";
 import type {
   AttemptDetailsResult,
@@ -135,6 +136,7 @@ export const StandardOverviewResultView = defineComponent<{
   result: StandardOverviewResult;
 }>(async ({ result }, ctx) => {
   const table = experimentListContent(result.experiments);
+  const freshTable = result.freshExperiments ? experimentListContent(result.freshExperiments) : null;
   const hasPassRate = table.columns.some((column) => column.key === "passRate");
   const hasTotalScore = table.columns.some((column) => column.key === "totalScore");
   const defaultSort = hasPassRate === hasTotalScore
@@ -178,7 +180,11 @@ export const StandardOverviewResultView = defineComponent<{
           ),
         )}
       </Col>
-      <TableContentView data={table} sort={defaultSort} searchable />
+      {freshTable === null ? (
+        <TableContentView data={table} sort={defaultSort} searchable />
+      ) : (
+        <ExperimentTableView fullContent={table} freshContent={freshTable} sort={defaultSort} searchable />
+      )}
     </Col>
   );
 });
@@ -340,6 +346,20 @@ const TaskUsageKpi = defineComponent<{ label: string; value: string }>({
 });
 TaskUsageKpi.displayName = "TaskUsageKpi";
 
+/** attempt 级 `ctx.fact()` 运行事实的完整键值表(docs/feature/record/architecture.md#facts运行事实);
+ *  没有 facts 时零输出,不摆空表。 */
+const TaskFactsResultView = defineComponent<{ data: AttemptFactsData | null }>(({ data }) => {
+  if (data === null || data.facts.length === 0) return null;
+  return (
+    <Grid className="niceeval-facts-table">
+      {data.facts.map(({ key, value }) => (
+        <TaskUsageKpi key={key} label={key} value={String(value)} />
+      ))}
+    </Grid>
+  );
+});
+TaskFactsResultView.displayName = "TaskFactsResultView";
+
 export const AttemptDetailsResultView = defineComponent<{
   result: AttemptDetailsResult;
 }>(({ result }) => {
@@ -369,6 +389,7 @@ export const AttemptDetailsResultView = defineComponent<{
       <CopyBlock content={attemptFixPromptContent(result.fixPrompt)} />
       <Waterfall nodes={timeline ?? []} title={{ en: "Execution timeline", "zh-CN": "执行时间轴" }} />
       <TaskUsageResultView data={result.usage} />
+      <TaskFactsResultView data={result.facts} />
       {conversation === null ? (
         <Callouts items={executionEvidenceUnavailableCallouts} />
       ) : embedded.conversation !== null ? (

package/src/report/components/attempt-detail/attempt-components.test.tsx

@@ -36,6 +36,7 @@ import {
   attemptDiagnosticsData,
   attemptDiffData,
   attemptErrorData,
+  attemptFactsData,
   attemptFixPromptData,
   attemptSummaryData,
   attemptTimelineData,
@@ -485,6 +486,7 @@ describe("AttemptCommandEvidence:命令与 Conversation 分离、错误提示只
     stderr: "",
   };
   const failed = { ...observed, timingNodeId: "failed-command", checked: true };
+  const succeeded = { ...observed, timingNodeId: "succeeded-command", exitCode: 0, checked: false };
 
   it("无 events 时 Conversation 仍为空,独立命令证据保留并排序", () => {
     const evidence = evidenceOf({ commands: [failed, observed] });
@@ -492,6 +494,11 @@ describe("AttemptCommandEvidence:命令与 Conversation 分离、错误提示只
     expect(attemptCommandEvidenceData(evidence)?.commands.map((command) => command.classification)).toEqual(["failed", "observed"]);
   });
 
+  it("exitCode 0 分类为 succeeded,即使 checked 为 true 也不推导成 failed", () => {
+    const evidence = evidenceOf({ commands: [succeeded, { ...succeeded, timingNodeId: "checked-zero", checked: true }] });
+    expect(attemptCommandEvidenceData(evidence)?.commands.map((command) => command.classification)).toEqual(["succeeded", "succeeded"]);
+  });
+
   it("observed 非零不触发截断错误摘要提示,failed 才触发", () => {
     const observedError = attemptErrorData(evidenceOf({
       commands: [observed],
@@ -507,6 +514,23 @@ describe("AttemptCommandEvidence:命令与 Conversation 分离、错误提示只
   });
 });
 
+describe("attemptFactsData:facts 完整键值表投影", () => {
+  it("按落盘 key 插入顺序投影为数组;没有 facts 或空对象时返回 null,不摆空表", () => {
+    expect(attemptFactsData(evidenceOf())).toBeNull();
+    expect(attemptFactsData(evidenceOf({ result: resultOf({ facts: {} }) }))).toBeNull();
+    const withFacts = evidenceOf({
+      result: resultOf({ facts: { "memory.notesLoaded": 73, "nowledge.endpoint": "https://tunnel.example", ready: true } }),
+    });
+    expect(attemptFactsData(withFacts)).toEqual({
+      facts: [
+        { key: "memory.notesLoaded", value: 73 },
+        { key: "nowledge.endpoint", value: "https://tunnel.example" },
+        { key: "ready", value: true },
+      ],
+    });
+  });
+});
+
 describe("standardAttemptRender:执行证据投影", () => {
   it("source 与 events 同时存在时仍保留 Conversation", async () => {
     const events: StreamEvent[] = [
@@ -553,6 +577,23 @@ describe("standardAttemptRender:执行证据投影", () => {
     const tree = await resolveOnAttemptPage(<AttemptDetails />, evidence);
     expectEmbeddedConversationHtml(renderAttemptHtml(tree));
   });
+
+  it("有 facts 时标准结果视图与公开 AttemptDetails 都渲染完整键值表;没有 facts 时零输出", async () => {
+    const withFacts = evidenceOf({ result: resultOf({ facts: { "memory.notesLoaded": 73 } }) });
+    const standardTree = await resolveOnAttemptPage(await standardAttemptRender(withFacts), withFacts);
+    const standardText = renderNodeToText(standardTree, createTextContext({ width: 120 }));
+    expect(standardText).toContain("memory.notesLoaded");
+    expect(standardText).toContain("73");
+
+    const publicTree = await resolveOnAttemptPage(<AttemptDetails />, withFacts);
+    const publicText = renderNodeToText(publicTree, createTextContext({ width: 120 }));
+    expect(publicText).toContain("memory.notesLoaded");
+    expect(publicText).toContain("73");
+
+    const withoutFacts = evidenceOf();
+    const emptyTree = await resolveOnAttemptPage(await standardAttemptRender(withoutFacts), withoutFacts);
+    expect(renderNodeToText(emptyTree, createTextContext({ width: 120 }))).not.toContain("notesLoaded");
+  });
 });
 // 「Attempt 证据数据源」——timeline / trace 投影的时间树语义
 // (docs/engineering/testing/unit/reports.md)。

package/src/report/components/attempt-detail/compute.ts

@@ -16,6 +16,7 @@ import type {
   AttemptDiagnosticsData,
   AttemptDiffData,
   AttemptErrorData,
+  AttemptFactsData,
   AttemptFixPromptData,
   AttemptSummaryData,
   AttemptTimelineData,
@@ -80,8 +81,9 @@ function looksLikeTruncatedCommandTail(message: string, commands: readonly Comma
 }
 
 /** 展示层唯一的命令分类规则;Record 只保存 checked 与 exitCode。 */
-function commandClassification(command: Pick<CommandExitEvidence, "checked" | "exitCode">): "observed" | "failed" {
-  return command.checked && command.exitCode !== 0 ? "failed" : "observed";
+function commandClassification(command: Pick<CommandExitEvidence, "checked" | "exitCode">): "succeeded" | "observed" | "failed" {
+  if (command.exitCode === 0) return "succeeded";
+  return command.checked ? "failed" : "observed";
 }
 
 export function attemptErrorData(evidence: AttemptEvidence): AttemptErrorData | null {
@@ -432,6 +434,22 @@ export function usageTableData(evidence: AttemptEvidence): UsageTableData | null
   };
 }
 
+// ───────────────────────── AttemptFacts ─────────────────────────
+
+/**
+ * attempt 级 `ctx.fact()` 运行事实的完整键值表;`AttemptRecord.facts` 缺失或为空对象时返回
+ * null,不渲染空表(与其余叶子同一条「没有证据时零输出」规则)。
+ * `facts` 落盘就是 `Record<string, string | number | boolean>`,JS 对象的字符串键天然保留
+ * 写入顺序,这里按该顺序投影成数组,不重新排序。
+ */
+export function attemptFactsData(evidence: AttemptEvidence): AttemptFactsData | null {
+  const facts = evidence.result.facts;
+  if (!facts) return null;
+  const entries = Object.entries(facts);
+  if (entries.length === 0) return null;
+  return { facts: entries.map(([key, value]) => ({ key, value })) };
+}
+
 // ───────────────────────── AttemptTrace ─────────────────────────
 
 export function attemptTraceData(evidence: AttemptEvidence): AttemptTraceData | null {

package/src/report/components/attempt-detail/index.tsx

@@ -15,13 +15,14 @@ import {
   Waterfall,
 } from "../../definition/primitives.tsx";
 import type { CommandEvidenceContent } from "../../definition/primitives/conversation.tsx";
-import type { AttemptSummaryData, UsageTableData } from "../../model/types.ts";
+import type { AttemptFactsData, AttemptSummaryData, UsageTableData } from "../../model/types.ts";
 import { formatDurationMs, formatInstant, formatPoints, formatUSD } from "../../model/format.ts";
 import { localeText } from "../../model/locale.ts";
 import { cx, type ValueProps } from "../shared.ts";
 import type { PageContext } from "../../definition/tree.ts";
 import {
   toAttemptAssertions,
+  toAttemptFacts,
   toAttemptFixPrompt,
   toAttemptNotices,
   toAttemptSource,
@@ -154,6 +155,33 @@ const AttemptUsage = defineComponent<UsageProps>({
 });
 AttemptUsage.displayName = "AttemptUsage";
 
+type FactsProps = ValueProps<AttemptFactsData | null, { className?: string }>;
+
+/** attempt 级 `ctx.fact()` 运行事实的完整键值表(docs/feature/record/architecture.md#facts运行事实);
+ *  没有 facts 时零输出,不摆空表。 */
+const AttemptFacts = defineComponent<FactsProps>({
+  dimensions: () => ({}),
+  web(props) {
+    const d = props.data;
+    if (d === null || d === undefined || d.facts.length === 0) return null;
+    return (
+      <Grid className={cx("niceeval-facts-table", props.className)}>
+        {d.facts.map(({ key, value }) => (
+          <Kpi key={key} label={key} value={String(value)} />
+        ))}
+      </Grid>
+    );
+  },
+  text(props) {
+    const d = props.data;
+    if (d === null || d === undefined || d.facts.length === 0) return "";
+    const lines = ["facts:"];
+    for (const { key, value } of d.facts) lines.push(`  ${key}  ${value}`);
+    return lines.join("\n");
+  },
+});
+AttemptFacts.displayName = "AttemptFacts";
+
 function evidenceOf(props: { attempt?: AttemptEvidence }, ctx: { page: PageContext }): AttemptEvidence {
   if (props.attempt !== undefined) return props.attempt;
   const input = ctx.page.input;
@@ -208,7 +236,7 @@ AttemptAssessment.displayName = "AttemptAssessment";
 export const AttemptDetails = defineComponent<AttemptDetailsProps>(async (props, ctx) => {
   const evidence = evidenceOf(props, ctx);
   const hasSource = evidence.capabilities.source;
-  const [notices, source, assertions, summary, fixPrompt, timeline, usage, commandEvidence, conversation, diff] = await Promise.all([
+  const [notices, source, assertions, summary, fixPrompt, timeline, usage, facts, commandEvidence, conversation, diff] = await Promise.all([
     toAttemptNotices(evidence),
     hasSource ? toAttemptSource(evidence) : Promise.resolve(null),
     hasSource ? Promise.resolve(null) : toAttemptAssertions(evidence),
@@ -216,6 +244,7 @@ export const AttemptDetails = defineComponent<AttemptDetailsProps>(async (props,
     toAttemptFixPrompt(evidence),
     toTimelineNodes(evidence),
     toAttemptUsage(evidence),
+    toAttemptFacts(evidence),
     toCommandEvidence(evidence),
     toConversationTurns(evidence),
     toDiffFiles(evidence),
@@ -240,6 +269,7 @@ export const AttemptDetails = defineComponent<AttemptDetailsProps>(async (props,
         title={{ en: "Execution timeline", "zh-CN": "执行时间轴" }}
       />
       <AttemptUsage data={usage} />
+      <AttemptFacts data={facts} />
       {conversation === null ? (
         <Callouts items={executionEvidenceUnavailableCallouts} />
       ) : embedded.conversation !== null ? (

package/src/report/components/attempt-detail/validate.test.ts

@@ -174,6 +174,7 @@ describe("validateConversationData — AttemptConversationReply 判别联合", (
       ],
     };
     expect(validateCommandEvidenceData(withCommands)).toBeNull();
+    expect(validateCommandEvidenceData({ ...withCommands, commands: [{ ...withCommands.commands[0], exitCode: 0, classification: "succeeded" }] })).toBeNull();
     expect(validateCommandEvidenceData({ ...withCommands, commands: [{ ...withCommands.commands[0], classification: "unknown" }] })).toMatch(/"commands\[0\]\.classification"/);
     expect(validateCommandEvidenceData({ ...withCommands, commands: [{ ...withCommands.commands[0], exitCode: "1" }] })).toMatch(/"commands\[0\]\.exitCode"/);
   });

package/src/report/components/attempt-detail/validate.tsx

@@ -242,7 +242,9 @@ function commandEvidenceProblem(value: unknown, path: string): string | null {
   if (typeof value.phase !== "string") return `"${path}.phase" must be a string`;
   if (typeof value.display !== "string") return `"${path}.display" must be a string`;
   if (typeof value.exitCode !== "number") return `"${path}.exitCode" must be a number`;
-  if (value.classification !== "observed" && value.classification !== "failed") return `"${path}.classification" must be observed | failed`;
+  if (value.classification !== "succeeded" && value.classification !== "observed" && value.classification !== "failed") {
+    return `"${path}.classification" must be succeeded | observed | failed`;
+  }
   if (value.durationMs !== undefined && typeof value.durationMs !== "number") return `"${path}.durationMs" must be a number`;
   if (typeof value.stdout !== "string") return `"${path}.stdout" must be a string`;
   if (typeof value.stderr !== "string") return `"${path}.stderr" must be a string`;

package/src/report/components/compute.test.ts

@@ -16,6 +16,10 @@ import type { AssertionResult, AttemptError, EvalResult, O11ySummary, Verdict }
 import { completeEvidenceCoverage } from "../../assertions/coverage.ts";
 import type { AttemptHandle, Sample, SampleIssue, Run } from "../../record/index.ts";
 import { attemptHandleOf, scopeOf } from "./scope.harness.ts";
+import { makeSample } from "../../sample/index.ts";
+import { encodeAttemptLocator } from "../../record/locator.ts";
+import { COVERAGE_ROW_PREFIX, experimentListContent } from "./entity-lists/content.ts";
+import { formatCellText, type Cell } from "../definition/cell.ts";
 import type { Record } from "../../record/types.ts";
 import {
   assistantTurns,
@@ -712,6 +716,198 @@ describe("实体列表 data", () => {
     });
   });
 
+  // ─────── 覆盖缺口的两档占位与过期结论参考(experiment-table.md「覆盖缺口的两档占位行」) ───────
+
+  describe("覆盖缺口的两档占位与过期结论参考", () => {
+    /**
+     * 区分力场景:evalId "b" 只在两份旧 configHash 快照下跑过(与当前基准不可比,过期结论候选
+     * 多于一条),"c" 从未在任何快照出现过(未跑到)。`current` 是当前基准,只贡献 "a"。
+     */
+    function staleScope(opts: { fresh?: boolean } = {}): { scope: Sample; older: Run; newerStale: Run } {
+      const current = snap({ experimentId: "exp/stale", results: [res("a", "passed")] });
+      current.configHash = "cfg-2";
+      const older = snap({
+        experimentId: "exp/stale",
+        results: [res("b", "failed")],
+        runStartedAt: "2026-01-01T00:00:00.000Z",
+      });
+      older.configHash = "cfg-1";
+      const newerStale = snap({
+        experimentId: "exp/stale",
+        results: [res("b", "passed")],
+        runStartedAt: "2026-02-01T00:00:00.000Z",
+      });
+      newerStale.configHash = "cfg-1"; // 同样不可比,但比 older 晚出现——参考要取这一条
+      const coverage = [
+        { experimentId: "exp/stale", run: current, knownEvalIds: ["a", "b", "c"], missingEvalIds: ["b", "c"] },
+      ];
+      const scope = makeSample(
+        "current",
+        [current],
+        [...current.attempts],
+        [],
+        coverage,
+        opts.fresh ?? false,
+        [...current.attempts, ...older.attempts, ...newerStale.attempts],
+      );
+      return { scope, older, newerStale };
+    }
+
+    function recordCellOf(row: { cells: Readonly<globalThis.Record<string, Cell>> }): Cell {
+      return row.cells.record!;
+    }
+
+    it("两档占位行的结果格都是 missing 且都带补跑命令;只有过期结论的那档带 reference,取候选中最新的一条", async () => {
+      const { scope, newerStale } = staleScope();
+      const items = await experimentListData(scope);
+      const content = experimentListContent(items);
+      const sub = content.rows[0]!.subRows!;
+      const staleRow = sub.find((row) => row.key.endsWith("b:missing"))!;
+      const notRunRow = sub.find((row) => row.key.endsWith("c:missing"))!;
+      expect(staleRow.variant).toBe("placeholder");
+      expect(notRunRow.variant).toBe("placeholder");
+
+      const staleCell = recordCellOf(staleRow);
+      const notRunCell = recordCellOf(notRunRow);
+      if (staleCell.kind !== "missing" || notRunCell.kind !== "missing") throw new Error("expected missing cells");
+      expect(staleCell.code).toBe("noCurrentResult");
+      expect(notRunCell.code).toBe("noCurrentResult");
+      expect(staleCell.detail).toBe("niceeval exp exp/stale");
+      expect(notRunCell.detail).toBe("niceeval exp exp/stale");
+      expect(notRunCell.reference).toBeUndefined();
+      expect(staleCell.reference).toBeDefined();
+      // 两档必须给出不同的格——把两档折成同一种占位的实现在这里失败。
+      expect(staleCell).not.toEqual(notRunCell);
+      // 候选多于一条(older 与 newerStale 都不可比)时取最新那条:newerStale 的判定是 "passed"。
+      expect(staleCell.reference!.verdict).toBe("passed");
+      expect(staleCell.reference!.locator).toBe(
+        encodeAttemptLocator({ runId: newerStale.runId, evalId: "b", attempt: 0 }),
+      );
+
+      // text 面:带参考时用参考替代原因文案,不把「当前配置下无结果」再说一遍。
+      expect(formatCellText(staleCell, "en")).toMatch(/^✓ /);
+      expect(formatCellText(notRunCell, "en")).toBe("no result for current config · niceeval exp exp/stale");
+      expect(formatCellText(notRunCell, "zh-CN")).toBe("当前配置下无结果 · niceeval exp exp/stale");
+    });
+
+    it("reference 不进任何计数:带参考前后,该 experiment 的判定计票、通过率与覆盖分母逐字不变", async () => {
+      const { scope } = staleScope();
+      const [item] = await experimentListData(scope);
+      // 分母只数 "a" 这一道有 attempt 的题,"b" 的参考不进 evals/attempts/passRate 分母。
+      expect(item!.evals).toBe(1);
+      expect(item!.attempts).toBe(1);
+      expect(item!.endToEndPassRate).toMatchObject({ value: 1, samples: 1, total: 1 });
+      expect(item!.evalVerdicts).toEqual({ passed: 1, failed: 0, errored: 0, skipped: 0 });
+    });
+
+    it("sample.fresh 为 true 时两档占位行都不带 reference", async () => {
+      const nonFresh = experimentListContent(await experimentListData(staleScope({ fresh: false }).scope));
+      const fresh = experimentListContent(await experimentListData(staleScope({ fresh: true }).scope));
+      const staleCellNonFresh = recordCellOf(nonFresh.rows[0]!.subRows!.find((row) => row.key.endsWith("b:missing"))!);
+      const staleCellFresh = recordCellOf(fresh.rows[0]!.subRows!.find((row) => row.key.endsWith("b:missing"))!);
+      if (staleCellNonFresh.kind !== "missing" || staleCellFresh.kind !== "missing") throw new Error("expected missing cells");
+      expect(staleCellNonFresh.reference).toBeDefined();
+      expect(staleCellFresh.reference).toBeUndefined();
+    });
+  });
+
+  // ─────── 覆盖构成的四段与两面(experiment-table.md「覆盖构成」) ───────
+
+  describe("覆盖构成的四段与两面", () => {
+    /**
+     * 区分力场景:"retry" 重试两次,第一次携带(历史执行)、第二次新执行——按 attempt 计数的
+     * 错误实现会让合计超过题数;"solo" 只有历史执行;"stale" 只有过期结论;"gone" 未跑到。
+     */
+    function compositionScope(): Sample {
+      const current = snap({
+        experimentId: "exp/composition",
+        results: [
+          res("retry", "passed", { artifactBase: "exp/composition/old/retry/a0" }), // 携带,attempt 0
+          res("retry", "passed", { attempt: 1 }), // 新执行,attempt 1
+          res("solo", "passed", { artifactBase: "exp/composition/old/solo/a0" }),
+        ],
+      });
+      current.configHash = "cfg-current";
+      const staleRun = snap({ experimentId: "exp/composition", results: [res("stale", "failed")] });
+      staleRun.configHash = "cfg-old";
+      const coverage = [
+        {
+          experimentId: "exp/composition",
+          run: current,
+          knownEvalIds: ["retry", "solo", "stale", "gone"],
+          missingEvalIds: ["stale", "gone"],
+        },
+      ];
+      return makeSample("current", [current], [...current.attempts], [], coverage, false, [
+        ...current.attempts,
+        ...staleRun.attempts,
+      ]);
+    }
+
+    /** experiment 行的覆盖构成副行(subRows 末尾,key 以 `coverage:` 起头)的 record 格。 */
+    function coverageCellOf(content: ReturnType<typeof experimentListContent>, experimentId: string): Cell {
+      const row = content.rows[0]!.subRows!.find((r) => r.key === `${COVERAGE_ROW_PREFIX}${experimentId}`)!;
+      return row.cells.record!;
+    }
+
+    it("四段互斥且合计等于已知题数;一题同时有新执行与携带 attempt 时只落新执行段", async () => {
+      const [item] = await experimentListData(compositionScope());
+      const content = experimentListContent([item!]);
+      const coverageCell = coverageCellOf(content, "exp/composition");
+      if (coverageCell.kind !== "composition") throw new Error("expected composition cell");
+      const byLabel = new Map(
+        coverageCell.segments.map((segment) => [
+          typeof segment.label === "string" ? segment.label : segment.label.en,
+          segment.count,
+        ]),
+      );
+      expect(byLabel.get("fresh")).toBe(1); // retry 只落新执行段,不因为它也有携带 attempt 而重复计
+      expect(byLabel.get("historical")).toBe(1); // solo
+      expect(byLabel.get("stale")).toBe(1); // stale
+      expect(byLabel.get("not run")).toBe(1); // gone
+      const total = [...coverageCell.segments].reduce((sum, s) => sum + s.count, 0);
+      expect(total).toBe(4); // 合计 = knownEvalIds 数,不是 attempts 数
+    });
+
+    it("计数为零的段不出现在两面输出里,与判定计票同一条规则", async () => {
+      const s = snap({ experimentId: "exp/all-fresh", results: [res("q", "passed")] });
+      const [item] = await experimentListData([s]);
+      const content = experimentListContent([item!]);
+      const coverageCell = coverageCellOf(content, "exp/all-fresh");
+      if (coverageCell.kind !== "composition") throw new Error("expected composition cell");
+      expect(coverageCell.segments.filter((s) => s.count > 0)).toHaveLength(1);
+      expect(formatCellText(coverageCell, "en")).toBe("1 fresh");
+      expect(formatCellText(coverageCell, "zh-CN")).toBe("1 新执行");
+    });
+
+    it("段名走 LocalizedText:zh-CN 与 en 取同一份 segments,只有文案不同,计数与段序逐字相同", async () => {
+      const [item] = await experimentListData(compositionScope());
+      const content = experimentListContent([item!]);
+      const coverageCell = coverageCellOf(content, "exp/composition");
+      if (coverageCell.kind !== "composition") throw new Error("expected composition cell");
+      const en = formatCellText(coverageCell, "en");
+      const zh = formatCellText(coverageCell, "zh-CN");
+      expect(en).toBe("1 fresh · 1 historical · 1 stale · 1 not run");
+      expect(zh).toBe("1 新执行 · 1 历史执行 · 1 过期结论 · 1 未跑到");
+      expect(coverageCell.segments.map((s) => s.count)).toEqual([1, 1, 1, 1]);
+    });
+
+    it("构成格不携带业务语义:它是 experiment 副行独有的格,换一套无关段名照常渲染,渲染面不认识段含义", async () => {
+      const [item] = await experimentListData(compositionScope());
+      const content = experimentListContent([item!]);
+      // 副行紧跟在 Eval / 组行之后,key 前缀把它与题目行区分开——它不是又一道 "retry" 之类的题。
+      const rowKeys = content.rows[0]!.subRows!.map((r) => r.key);
+      expect(rowKeys.at(-1)).toBe(`${COVERAGE_ROW_PREFIX}exp/composition`);
+      expect(rowKeys).toContain("retry");
+
+      const arbitrarySegments: Cell = {
+        kind: "composition",
+        segments: [{ label: "x", count: 2 }, { label: "y", count: 0 }],
+      };
+      expect(formatCellText(arbitrarySegments)).toBe("2 x");
+    });
+  });
+
   // ─────── 计分制字段:evaluationKind 定义期投影 / totalScore 的两级聚合方向 / 预排 ───────
 
   it('ExperimentListItem.evaluationKind 是定义期事实投影,不从 attempt 判定推断:failed 的计分制 eval 仍读 "points",passed 的通过制 eval 仍读 "pass"', async () => {