niceeval 0.6.1 → 0.7.0

package/src/report/web.ts

@@ -6,12 +6,20 @@ import * as React from "react";
 import type { ReactNode } from "react";
 import { renderToStaticMarkup } from "react-dom/server";
 import type { AttemptLocator } from "../results/locator.ts";
-import type { SelectionWarning } from "../results/types.ts";
-import { resolveReportTree, runWithWebContext, validateReportTree, type WebContext } from "./tree.ts";
+import type { Scope } from "../results/types.ts";
+import {
+  resolveReportTree,
+  runWithWebContext,
+  validateReportTree,
+  ResolveMemo,
+  type WebContext,
+} from "./tree.ts";
 import { DEFAULT_REPORT_LOCALE, type ReportLocale } from "./locale.ts";
-import type { ReportContext, ReportDefinition } from "./report.ts";
+import { buildReportMeta, pickReportPage, type ReportDefinition, type ReportHostContext } from "./report.ts";
 
 export interface StaticHtmlOptions {
+  /** 渲染哪一页;缺省第一页。未命中抛 ReportPageNotFoundError。 */
+  pageId?: string;
   /** 证据室深链;缺省用 view 的 attempt 路由 `#/attempt/@<locator>`(单段、不透明)。 */
   attemptHref?: (locator: AttemptLocator) => string;
   /** 官方组件 chrome 文案的 locale;默认 "en"。 */
@@ -19,12 +27,12 @@ export interface StaticHtmlOptions {
 }
 
 /**
- * 挑选警告的 HTML 形态:宿主级前置块,与 RunOverview 里的警告用同一套结构和类名
- * (`.nre nre-report-warnings` 外壳内一个 `ul.nre-warnings` + `li.nre-warning[data-kind]`,
- * 复用 styles.css 已有的 `.nre .nre-warnings` 样式)。经 renderToStaticMarkup 走 React,
- * message 文本自动转义,不裸拼 HTML。裸跑 / --report 都在报告顶上如实报残缺,不静默。
+ * 挑选警告的 HTML 形态:宿主级前置块(`.nre nre-report-warnings` 外壳内一个
+ * `ul.nre-warnings` + `li.nre-warning[data-kind]`,复用 styles.css 已有样式)。
+ * 带 `command` 的警告把命令渲染为可复制块(`.nre-warning-command`);无 command 的
+ * 只显示 message,不硬造动作。经 renderToStaticMarkup 走 React,文本自动转义。
  */
-function renderSelectionWarningsHtml(warnings: SelectionWarning[]): string {
+function renderScopeWarningsHtml(scope: Scope): string {
   return renderToStaticMarkup(
     React.createElement(
       "div",
@@ -32,8 +40,15 @@ function renderSelectionWarningsHtml(warnings: SelectionWarning[]): string {
       React.createElement(
         "ul",
         { className: "nre-warnings" },
-        warnings.map((w, i) =>
-          React.createElement("li", { key: i, className: "nre-warning", "data-kind": w.kind }, w.message),
+        scope.warnings.map((w, i) =>
+          React.createElement(
+            "li",
+            { key: i, className: "nre-warning", "data-kind": w.kind },
+            w.message,
+            "command" in w && w.command
+              ? React.createElement("code", { className: "nre-warning-command", "data-nre-copy": w.command }, w.command)
+              : null,
+          ),
         ),
       ),
     ),
@@ -41,27 +56,55 @@ function renderSelectionWarningsHtml(warnings: SelectionWarning[]): string {
 }
 
 /**
- * build → 渲染前解析数据组件(唯一的 await 边界)→ 树校验(与 text 宿主同一遍)→ 静态渲染
- * web 面;Selection 有挑选警告时在报告顶部前置一块警告 HTML；报告树里的 RunOverview
- * 已经渲染同一条时不重复。
+ * web 宿主的装载语义:选页 → resolve(组合展开 + spec 取数,唯一的 await 边界)→
+ * 树校验(与 text 宿主同一遍)→ 静态渲染 web 面;Scope 有挑选警告时在报告顶部前置
+ * 一块警告 HTML(宿主是 warning 的唯一呈现者,组件数据不复制 warning)。
  */
 export async function renderReportToStaticHtml(
   definition: ReportDefinition,
-  ctx: ReportContext,
+  ctx: ReportHostContext,
   options?: StaticHtmlOptions,
 ): Promise<string> {
-  const node = await definition.build(ctx);
-  const resolved = await resolveReportTree(node);
+  const page = pickReportPage(definition, options?.pageId);
+  const meta = buildReportMeta(definition, ctx.scope, page.id);
+  const resolved = await resolveReportTree(page.content, {
+    scope: ctx.scope,
+    results: ctx.results,
+    report: meta,
+    memo: new ResolveMemo(),
+  });
   validateReportTree(resolved);
   const webCtx: WebContext = {
     attemptHref: options?.attemptHref ?? ((locator) => `#/attempt/${locator}`),
     locale: options?.locale ?? DEFAULT_REPORT_LOCALE,
   };
   const body = runWithWebContext(webCtx, () => renderToStaticMarkup(resolved as ReactNode));
-  const missingWarnings = ctx.selection.warnings.filter((warning) => {
-    const escapedMessage = renderToStaticMarkup(React.createElement(React.Fragment, null, warning.message));
-    return !body.includes(escapedMessage);
+  const warnings = ctx.scope.warnings.length > 0 ? renderScopeWarningsHtml(ctx.scope) : "";
+  return warnings + body;
+}
+
+/**
+ * 渲染一页报告树的 web 面(宿主逐页调用;页选择归宿主):resolve → validate → 静态渲染。
+ * Scope 有挑选警告时在页顶前置警告块(带 command 的警告渲染为可复制命令)——宿主是
+ * warning 的唯一呈现者,组件数据不复制 warning。ctx.report 是宿主规范化后的声明。
+ */
+export async function renderReportTreeToStaticHtml(
+  tree: import("./tree.ts").ReportNode,
+  ctx: { scope: Scope; results: import("../results/types.ts").Results; report: import("./report.ts").ReportMeta },
+  options?: { attemptHref?: (locator: AttemptLocator) => string; locale?: ReportLocale },
+): Promise<string> {
+  const resolved = await resolveReportTree(tree, {
+    scope: ctx.scope,
+    results: ctx.results,
+    report: ctx.report,
+    memo: new ResolveMemo(),
   });
-  const warnings = missingWarnings.length > 0 ? renderSelectionWarningsHtml(missingWarnings) : "";
+  validateReportTree(resolved);
+  const webCtx: WebContext = {
+    attemptHref: options?.attemptHref ?? ((locator) => `#/attempt/${locator}`),
+    locale: options?.locale ?? DEFAULT_REPORT_LOCALE,
+  };
+  const body = runWithWebContext(webCtx, () => renderToStaticMarkup(resolved as ReactNode));
+  const warnings = ctx.scope.warnings.length > 0 ? renderScopeWarningsHtml(ctx.scope) : "";
   return warnings + body;
 }

package/src/results/annotated-source.test.ts

@@ -1,10 +1,11 @@
+// cases: docs/engineering/unit-tests/results/cases.md
 // buildAnnotatedEvalSource 的单测(定稿见 docs/concepts.md「标注 Eval 源码」)。
 // 覆盖:同一行多条断言、无 loc 断言进 unmapped、loc 指向别的文件/越界行也进 unmapped
 // (never silently dropped 的边界情况)、空断言数组、summary 计数、哈希与归一化行为。
 
 import { describe, expect, it } from "vitest";
-import type { AssertionResult } from "../types.ts";
-import { buildAnnotatedEvalSource } from "./annotated-source.ts";
+import type { AssertionResult, PhaseTiming, StreamEvent } from "../types.ts";
+import { buildAnnotatedEvalSource, deriveSendAnnotations, type SendAnnotation } from "./annotated-source.ts";
 import { hashEvalSource, normalizeEvalSource } from "./source-hash.ts";
 
 const SOURCE_PATH = "evals/weather.eval.ts";
@@ -13,9 +14,9 @@ function assertion(over: Partial<AssertionResult> & Pick<AssertionResult, "name"
   return {
     severity: "soft",
     score: 1,
-    passed: true,
+    outcome: "passed" as const,
     ...over,
-  };
+  } as AssertionResult;
 }
 
 describe("buildAnnotatedEvalSource", () => {
@@ -94,10 +95,10 @@ describe("buildAnnotatedEvalSource", () => {
   it("computes summary counts across passed/failed and gate/soft, mapped and unmapped alike", () => {
     const content = "line 1\nline 2\n";
     const assertions = [
-      assertion({ name: "a", severity: "gate", passed: true, loc: { file: SOURCE_PATH, line: 1 } }),
-      assertion({ name: "b", severity: "gate", passed: false, loc: { file: SOURCE_PATH, line: 1 } }),
-      assertion({ name: "c", severity: "soft", passed: true, loc: { file: SOURCE_PATH, line: 2 } }),
-      assertion({ name: "d", severity: "soft", passed: false }), // unmapped
+      assertion({ name: "a", severity: "gate", outcome: "passed" as const, loc: { file: SOURCE_PATH, line: 1 } }),
+      assertion({ name: "b", severity: "gate", outcome: "failed" as const, loc: { file: SOURCE_PATH, line: 1 } }),
+      assertion({ name: "c", severity: "soft", outcome: "passed" as const, loc: { file: SOURCE_PATH, line: 2 } }),
+      assertion({ name: "d", severity: "soft", outcome: "failed" as const }), // unmapped
     ];
 
     const model = buildAnnotatedEvalSource({ path: SOURCE_PATH, content }, assertions);
@@ -129,7 +130,7 @@ describe("buildAnnotatedEvalSource", () => {
 
   it("treats an empty source file as a single empty line", () => {
     const model = buildAnnotatedEvalSource({ path: SOURCE_PATH, content: "" }, []);
-    expect(model.lines).toEqual([{ line: 1, text: "", assertions: [] }]);
+    expect(model.lines).toEqual([{ line: 1, text: "", assertions: [], sends: [] }]);
   });
 
   it("sourceSha256 matches hashEvalSource(normalizeEvalSource(content)) and is stable across CRLF/LF", () => {
@@ -143,4 +144,56 @@ describe("buildAnnotatedEvalSource", () => {
     expect(modelLf.sourceSha256).toBe(modelCrlf.sourceSha256);
     expect(modelLf.lines.map((l) => l.text)).toEqual(modelCrlf.lines.map((l) => l.text));
   });
+
+  it("send 标注按 loc 落到对应行,一行多轮逐轮保留;别的文件或越界行直接丢(全量面在 --execution)", () => {
+    const content = "await t.send('a');\nawait t.send('b');\n";
+    const sends: SendAnnotation[] = [
+      { label: "s1/t1", status: "completed", durationMs: 1200, loc: { file: SOURCE_PATH, line: 1, column: 9 } },
+      { label: "s1/t2", status: "failed", durationMs: 800, loc: { file: SOURCE_PATH, line: 1, column: 9 } },
+      { label: "s1/t3", status: "completed", loc: { file: "evals/other.eval.ts", line: 1 } },
+      { label: "s1/t4", status: "completed", loc: { file: SOURCE_PATH, line: 99 } },
+    ];
+    const model = buildAnnotatedEvalSource({ path: SOURCE_PATH, content }, [], sends);
+    expect(model.lines[0]!.sends.map((s) => s.label)).toEqual(["s1/t1", "s1/t2"]);
+    expect(model.lines[1]!.sends).toEqual([]);
+  });
+});
+
+describe("deriveSendAnnotations", () => {
+  it("第 i 条用户消息配第 i 个 turn 节点(与 --execution 分轮同一规则);无 loc 的轮不产出", () => {
+    const events: StreamEvent[] = [
+      { type: "message", role: "user", text: "first", loc: { file: SOURCE_PATH, line: 3, column: 5 } },
+      { type: "message", role: "assistant", text: "reply" },
+      { type: "message", role: "user", text: "second (no loc)" },
+      { type: "message", role: "user", text: "third", loc: { file: SOURCE_PATH, line: 9, column: 5 } },
+    ];
+    const phases: PhaseTiming[] = [{
+      name: "eval.run" as PhaseTiming["name"],
+      durationMs: 5000,
+      children: [
+        { id: "n1", kind: "command", label: "git", startOffsetMs: 0, durationMs: 10 },
+        { id: "n2", kind: "turn", label: "s1/t1", startOffsetMs: 10, durationMs: 1500 },
+        { id: "n3", kind: "turn", label: "s1/t2", startOffsetMs: 1510, durationMs: 900, failed: true },
+        { id: "n4", kind: "turn", label: "s1/t3", startOffsetMs: 2410, durationMs: 300 },
+      ],
+    }];
+
+    const sends = deriveSendAnnotations(events, phases);
+    expect(sends).toEqual([
+      { label: "s1/t1", status: "completed", durationMs: 1500, loc: { file: SOURCE_PATH, line: 3, column: 5 } },
+      // 第二条用户消息没有 loc → 不产出;第三条配第 3 个 turn 节点,不因跳过而错位
+      { label: "s1/t3", status: "completed", durationMs: 300, loc: { file: SOURCE_PATH, line: 9, column: 5 } },
+    ]);
+  });
+
+  it("时间树缺 turn 节点时回退 t<i> 标签、无墙钟;没有事件时为空", () => {
+    const events: StreamEvent[] = [
+      { type: "message", role: "user", text: "only", loc: { file: SOURCE_PATH, line: 1 } },
+    ];
+    expect(deriveSendAnnotations(events, undefined)).toEqual([
+      { label: "t1", status: "completed", loc: { file: SOURCE_PATH, line: 1 } },
+    ]);
+    expect(deriveSendAnnotations(null, undefined)).toEqual([]);
+    expect(deriveSendAnnotations([], undefined)).toEqual([]);
+  });
 });

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(
@@ -68,11 +70,11 @@ async function seedAttempt(
 }
 
 describe("loadAttemptEvidence", () => {
-  it("四个 capability 全部具备:eval / execution / timing / diff", async () => {
+  it("四个 capability 全部具备:source / execution / timing / diff", async () => {
     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,12 +88,12 @@ 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 });
+    expect(evidence.capabilities).toEqual({ source: true, execution: true, timing: true, diff: true });
   });
 
-  it("四个 capability 全部缺失:没有 source / events / trace / diff,不崩溃", async () => {
+  it("四个 capability 全部缺失:没有 sources / events / trace / diff,不崩溃", async () => {
     const root = await makeRoot();
     const attempt = await seedAttempt(root, { id: "weather/queens" });
 
@@ -100,10 +102,10 @@ describe("loadAttemptEvidence", () => {
     expect(evidence.evalSource).toBeNull();
     expect(evidence.execution).toBeNull();
     expect(evidence.diff).toBeNull();
-    expect(evidence.capabilities).toEqual({ eval: false, execution: false, timing: false, diff: false });
+    expect(evidence.capabilities).toEqual({ source: 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

@@ -12,7 +12,7 @@
 // "有什么可看"这件事产生同一个答案(没有),只是原因不同,原因留给 unavailable 文案区分,
 // 不留给 capability 位区分(capability 位只回答"要不要显示这个证据切面")。
 //
-//   eval      —— evalSource 非空 AND (至少有一行源码 或 至少有一条断言);理论上
+//   source    —— evalSource 非空 AND (至少有一行源码 或 至少有一条断言);理论上
 //                buildAnnotatedEvalSource 对空文件也会产出一行 ""(split("\n") 的自然结果),
 //                所以这条件实践中约等于"evalSource 非空",按文档口径原样写出两个子句,
 //                不依赖这个实现细节。
@@ -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";
 
@@ -59,11 +59,11 @@ export interface EvidencePaths {
  * 对应的证据切面,不自己重新判断"这个 attempt 有没有 X"。
  */
 export interface AttemptEvidenceCapabilities {
-  /** evalSource 非空且有内容(源码行或断言二选一非空)。 */
-  eval: boolean;
+  /** evalSource 非空且有内容(源码行或断言二选一非空);对应 CLI 的 `--source` 证据切面。 */
+  source: boolean;
   /** events 非空数组——有骨架可看。 */
   execution: boolean;
-  /** execution 成立且这次运行接入过 OTel(ExecutionTree.timingAvailable)。 */
+  /** result.json 带 phases(阶段计时)——`--timing` 时间树可渲染。 */
   timing: boolean;
   /** diff 非空且至少改动/删除了一个文件。 */
   diff: boolean;
@@ -79,13 +79,15 @@ export interface AttemptEvidence {
    * 的调用方直接读结构化字段(如按 experimentId 分组、按时间排序)。 */
   identity: AttemptIdentity;
   result: EvalResult;
-  /** 运行时保存的 Eval 源码标注(`--eval` 切面);没有 sources() 就是 null,不伪造空文档。 */
+  /** 运行时保存的 Eval 源码标注(`--source` 切面);没有 sources() 就是 null,不伪造空文档。 */
   evalSource: AnnotatedEvalSource | null;
   /** 标准事件流 + OTel enrichment(`--execution` 切面);没有非空 events 就是 null,
    * 不产出一棵只剩 telemetry-only 节点、没有真实骨架的误导性树(见头注 execution 门槛)。 */
   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,
+      source: 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);
 }