niceeval 0.11.0 → 0.11.1-canary.8

package/dist/i18n/en.d.ts

@@ -134,6 +134,7 @@ export declare const en: {
     "define.experimentAgentRequired": string;
     "define.experimentFlagNotJson": string;
     "define.experimentLabelInvalid": string;
+    "define.experimentProvenanceFlagsInvalid": string;
     "define.experimentSetupNotFunction": string;
     "define.experimentClassifyFailureNotFunction": string;
     "define.experimentIdRejected": string;

package/dist/i18n/en.js

@@ -202,6 +202,7 @@ export const en = {
     "define.experimentAgentRequired": "defineExperiment requires agent.",
     "define.experimentFlagNotJson": "experiment.flags.{{key}} is not JSON-serializable (functions / undefined / cycles / bigint are not allowed); flags are persisted verbatim into result snapshots and must be plain JSON.",
     "define.experimentLabelInvalid": "experiment.labels.{{key}} must be a string or a finite number; labels are report-side grouping coordinates persisted verbatim into result snapshots.",
+    "define.experimentProvenanceFlagsInvalid": "experiment.provenanceFlags must be an array of flag key names (strings); it lists the flags recorded for provenance only, which stay out of the cache fingerprint.",
     "define.experimentSetupNotFunction": "experiment.setup must be a function ((ctx) => void); use experiment.teardown for cleanup; to prepare the in-sandbox environment per experiment, chain .setup() hooks on the sandbox spec instead.",
     "define.experimentClassifyFailureNotFunction": "experiment.classifyFailure must be a function ((failure) => FailureClass | undefined); it classifies failures that surface as third-party errors and must return undefined for anything it does not recognize.",
     "define.experimentIdRejected": "defineExperiment does not accept id; ids are derived from file paths.",

package/dist/i18n/zh-CN.d.ts

@@ -134,6 +134,7 @@ export declare const zhCN: {
     readonly "define.experimentAgentRequired": "defineExperiment 需要 agent。";
     readonly "define.experimentFlagNotJson": "experiment.flags.{{key}} 不是可 JSON 序列化的值(函数 / undefined / 循环引用 / bigint 不允许);flags 会原样进入结果快照,必须是纯 JSON。";
     readonly "define.experimentLabelInvalid": "experiment.labels.{{key}} 必须是字符串或有限数字;labels 是报告侧的归类坐标,会原样进入结果快照。";
+    readonly "define.experimentProvenanceFlagsInvalid": "experiment.provenanceFlags 必须是 flag 键名(字符串)数组;它列出只作为出处记录、不进缓存指纹的那些 flag。";
     readonly "define.experimentSetupNotFunction": "experiment.setup 必须是函数((ctx) => void);要清理请挂 experiment.teardown;要按实验准备沙箱内环境请挂 sandbox spec 的 .setup() 钩子链。";
     readonly "define.experimentClassifyFailureNotFunction": "experiment.classifyFailure 必须是函数((failure) => FailureClass | undefined):它识别以第三方错误形态浮出的失败,认不出的一律返回 undefined 交给后续链路。";
     readonly "define.experimentIdRejected": "defineExperiment 不接受 id —— id 由文件路径推导。";

package/dist/i18n/zh-CN.js

@@ -198,6 +198,7 @@ export const zhCN = {
     "define.experimentAgentRequired": "defineExperiment 需要 agent。",
     "define.experimentFlagNotJson": "experiment.flags.{{key}} 不是可 JSON 序列化的值(函数 / undefined / 循环引用 / bigint 不允许);flags 会原样进入结果快照,必须是纯 JSON。",
     "define.experimentLabelInvalid": "experiment.labels.{{key}} 必须是字符串或有限数字;labels 是报告侧的归类坐标,会原样进入结果快照。",
+    "define.experimentProvenanceFlagsInvalid": "experiment.provenanceFlags 必须是 flag 键名(字符串)数组;它列出只作为出处记录、不进缓存指纹的那些 flag。",
     "define.experimentSetupNotFunction": "experiment.setup 必须是函数((ctx) => void);要清理请挂 experiment.teardown;要按实验准备沙箱内环境请挂 sandbox spec 的 .setup() 钩子链。",
     "define.experimentClassifyFailureNotFunction": "experiment.classifyFailure 必须是函数((failure) => FailureClass | undefined):它识别以第三方错误形态浮出的失败,认不出的一律返回 undefined 交给后续链路。",
     "define.experimentIdRejected": "defineExperiment 不接受 id —— id 由文件路径推导。",

package/dist/runner/fingerprint.d.ts

@@ -1,14 +1,25 @@
-import type { DiscoveredEval, EvalResult, SandboxOption } from "../types.ts";
+import type { DiscoveredEval, EvalResult, JsonValue, SandboxOption } from "../types.ts";
 import type { AgentRun } from "./types.ts";
 export declare function cacheKey(run: AgentRun, evalId: string): string;
 /**
  * @param sourceCache 按 sourcePath 缓存文件内容:一个矩阵(实验 × eval)会对同一批源文件
  * 反复算指纹,不带缓存会在任何 attempt 起跑前做 E×N 次重复文件读。
+ * @param flagsOverride 用这份 flags 代替 `run.flags` 的指纹口径算一遍。只有一个用途:
+ * 对已落盘结果做**反事实重算**——「把 flags 换成它当时那份,指纹还相等吗」等价于问
+ * 「除 flags 外的一切是否都没变」,`acceptableFingerprints` 用它判定某条历史结果与本次
+ * 规划的差异是否完全落在 provenance flag 上。
  */
-export declare function computeFingerprint(evalDef: DiscoveredEval, run: AgentRun, sourceCache?: Map<string, Promise<string>>, configSandbox?: SandboxOption): Promise<string>;
+export declare function computeFingerprint(evalDef: DiscoveredEval, run: AgentRun, sourceCache?: Map<string, Promise<string>>, configSandbox?: SandboxOption, flagsOverride?: Record<string, JsonValue>): Promise<string>;
 export interface CarryPlan {
     /** `cacheKey(run, evalId)` → 本次规划出的指纹,供调用方按同一口径判断"这条要不要携入"。 */
     plannedFingerprints: Map<string, string>;
+    /**
+     * `cacheKey(run, evalId)` → 这条组合**可以携带的全部指纹**:本次规划的那个,加上
+     * 「只在 provenance flag 上与本次不同」的历史口径(见 `acceptableFingerprints`)。
+     * 没声明 provenance flag 时恒是单元素集合 = `plannedFingerprints` 的那一个。
+     * 携带判定一律读这个集合,`plannedFingerprints` 只用来给新跑的 attempt 落盘打戳。
+     */
+    acceptableFingerprints: Map<string, Set<string>>;
     /**
      * 携带以 attempt 为粒度:命中携入条件(该 attempt 自身 passed/failed 终态 + 指纹匹配)的
      * `${experimentId}|${evalId}` → 该 eval 下具体携入的 attempt 序号集合(0-based)。同一个
@@ -35,14 +46,16 @@ export declare function resolvedTimeoutMsForCarry(run: AgentRun, evalDef: Discov
  * 1. 该 attempt 自己是终态(`passed` / `failed`)。`errored` 是框架/环境层面的不确定失败,
  *    判定本身不可信;`skipped` 根本没跑。同一 eval 的别的序号命中不能连带把它捎上
  *    (反例与修法见 memory 的 carry-must-be-per-attempt-not-whole-eval-key)。
- * 2. 该 attempt 落盘的 `fingerprint` 与本次规划的 `fingerprint` 相等。
+ * 2. 该 attempt 落盘的 `fingerprint` 落在本次的可携带指纹集合里(`CarryPlan.acceptableFingerprints`
+ *    的那一条,通常只有本次规划出的那一个;声明了 provenance flag 时还含「只在这些键上与本次
+ *    不同」的历史口径)。
  * 3. 该 attempt 的 `durationMs` 不超过本次 resolved 的 `timeoutMs`——`timeoutMs` 是携带资格
  *    判据、不进指纹哈希(docs/runner.md「缓存:指纹去重」)。
  *
  * `planCarry`(整场静态规划)与 run.ts 派发时刻的携带重查共用这一个函数:两条路径一旦把判据
  * 各写一份就会分叉,重查会携入静态规划判过不可携带的条目(或反过来)。
  */
-export declare function carriableAttempts(priorResults: EvalResult[] | undefined, key: string, fingerprint: string | undefined, timeoutMs: number): EvalResult[];
+export declare function carriableAttempts(priorResults: EvalResult[] | undefined, key: string, fingerprints: ReadonlySet<string> | undefined, timeoutMs: number): EvalResult[];
 /**
  * 算出这一批 (agentRun × eval) 的指纹,并据此从 priorResults 里筛出可以携入(跳过重跑)的结果。
  * run.ts 与 cli.ts(live 表格构建)必须共用这同一份计算 —— 否则两边一旦对"哪些携入"的判断
@@ -58,4 +71,35 @@ export declare function carriableAttempts(priorResults: EvalResult[] | undefined
  * `resolvedTimeoutMsForCarry`)。省略时按未配置处理,不是当作 0——只有 `run.timeoutMs` /
  * `evalDef.timeoutMs` 都缺席时才轮到它兜底。
  */
-export declare function planCarry(evals: DiscoveredEval[], agentRuns: AgentRun[], priorResults: EvalResult[] | undefined, configSandbox?: SandboxOption, configTimeoutMs?: number): Promise<CarryPlan>;
+export declare function planCarry(evals: DiscoveredEval[], agentRuns: AgentRun[], priorResults: EvalResult[] | undefined, configSandbox?: SandboxOption, configTimeoutMs?: number, flagBagsByExperiment?: Map<string, Record<string, JsonValue>[]>): Promise<CarryPlan>;
+/**
+ * 这条 `(experimentId, evalId)` 本次可以携带的指纹全集。
+ *
+ * 没声明 provenance flag 时就是 `{ primary }`——判据与「指纹相等」逐字等价,一条历史结果都
+ * 不会因此多携入。声明了之后多出一类:**只在 provenance flag 上与本次不同**的历史口径。
+ *
+ * 判定不靠比对两串哈希的差异(哈希不可差分),而是**反事实重算**:取该历史结果所属快照记下的
+ * `ExperimentRunInfo.flags`(整袋原样,`applySnapshotDefaults` 已把它挂在 `EvalResult.experiment`
+ * 上),用它替换本次的 flags 口径重算一遍指纹——算出来等于历史那一串,就证明「除 flags 外的
+ * 一切(eval 源码、agent、model、sandbox、strict…)都没变」。再要求两袋 flags 抹掉 provenance
+ * 键之后逐字相等,才把这串历史指纹计入可携带集合:真改了某个影响行为的 flag(`webResearch`
+ * 从 true 改成 false)照旧作废,不会被这条通道放行。
+ *
+ * 历史结果落盘时的指纹口径是「整袋 flags」(provenance 概念引入之前),所以两个口径都要试:
+ * 整袋(老结果)与抹掉 provenance 键的那袋(声明之后跑出来的结果,与 primary 相同则自然去重)。
+ */
+export declare function acceptableFingerprints(args: {
+    evalDef: DiscoveredEval;
+    run: AgentRun;
+    key: string;
+    priorResults: EvalResult[] | undefined;
+    /** 本次规划出的指纹(新跑的 attempt 用它落盘打戳)。 */
+    primary: string;
+    /**
+     * 该实验历史快照记下过的 flags(见 `loadCarryInputs`)。候选假设的来源之一,与结果自带的那袋
+     * 并列——携带条目带着**产出它那一轮**的指纹合入新快照,那一轮的 flags 只在更早的快照里留着。
+     */
+    historicalFlagBags?: readonly Record<string, JsonValue>[];
+    sourceCache?: Map<string, Promise<string>>;
+    configSandbox?: SandboxOption;
+}): Promise<Set<string>>;

package/dist/runner/types.d.ts

@@ -500,6 +500,21 @@ export interface ExperimentDef {
      *  (defineExperiment 解析时校验,非 JSON 直接报错),经 ctx.flags 透传给 adapter、
      *  t.flags 暴露给 eval,并原样进入结果快照的 ExperimentRunInfo.flags。 */
     flags?: Record<string, JsonValue>;
+    /**
+     * `flags` 里只作为**出处记录**的键名:照常落盘、照常透给 `ctx.flags` / `t.flags`,但不参与
+     * 可比性配置——值变了不作废任何已有结果,已跑完的照常携带(carry)。
+     *
+     * 给的是「每次跑都可能换、但换了不改变 attempt 里发生什么」的坐标:隧道 / 反向代理 URL、
+     * 服务端实例地址、跑批时刻这类。它们要留在 `flags` 里(报告要按 `flag()` 看这轮连的是哪个,
+     * eval 或 adapter 也可能要读),又不该像 `webResearch: true → false` 那样让缓存全部失效。
+     *
+     * 声明前跑出来的结果同样携带得到:携带判定按快照记下的历史 flags 做一次反事实重算,
+     * 确认差异完全落在这些键上(见 `runner/fingerprint.ts` 的 `acceptableFingerprints`)。
+     * 键不必存在于 `flags` 里——把一个键从 `flags` 移走时留着这条声明,历史结果照样不作废。
+     *
+     * 完全不需要在运行时被看见的事实用 `labels`,那是报告侧坐标(本来就不进指纹)。
+     */
+    provenanceFlags?: readonly string[];
     /**
      * 报告归类标注:实验在各对比轴上的坐标(如 `{ line: "codex", memory: "mempal" }`)。
      * 值域 string | number(解析时校验)。与 `flags` 的分界是「会不会改变 attempt 里发生的事」:
@@ -669,6 +684,8 @@ export interface AgentRun {
     model?: string;
     reasoningEffort?: string;
     flags: Record<string, JsonValue>;
+    /** 只作为出处记录、不进指纹的 flag 键(来自 ExperimentDef.provenanceFlags);见该字段说明。 */
+    provenanceFlags?: readonly string[];
     runs: number;
     earlyExit: boolean;
     sandbox?: SandboxOption;
@@ -794,8 +811,14 @@ export interface ActiveAttempt {
     /** 展示 label,等价 `runWho()` 的结果;渲染要用,但绝不作为 identity/key。 */
     who: string;
     phase: LifecyclePhase;
-    /** 进入当前 phase 的墙钟时间(epoch ms),用于渲染阶段耗时;每次 phase 变化都会更新。 */
-    phaseStartedAt: number;
+    /**
+     * 这条 attempt 被派发的墙钟时间(epoch ms,取 `attempt:start` 的 `at`)—— active 行时间列的
+     * **唯一**基准,`attempt:phase` 不得改写它:live 面板不做 spinner 动画,存活性完全由这一列
+     * 持续增长证明(见 docs/feature/experiments/cli.md「active 行的列序」),一列会归零的时间既
+     * 证明不了存活,也让人误以为这条 eval 重跑了。阶段各自的耗时不进这里——它由结果的
+     * `timing.phases` 完整落盘,live 面板要回答的是「这条还活着吗、跑了多久、正在干什么」。
+     */
+    startedAt: number;
     detail?: string;
 }
 /** 实验级钩子只有 setup 与它返回的 teardown 两员,同一实验内两者永不并发

package/docs-site/zh/tutorials/write-experiment.mdx

@@ -117,6 +117,7 @@ npx niceeval exp prompts/concise
 | `model` | 单个模型名，经 `ctx.model` 透传 |
 | `reasoningEffort` | 单个推理努力程度（如 `"high"`），经 `ctx.reasoningEffort` / `t.reasoningEffort` 透传，归属与 `model` 一致 |
 | `flags` | 实验条件（A/B 里的 feature flag），任意 JSON 对象，经 `ctx.flags` / `t.flags` 透传 |
+| `provenanceFlags` | 列出只作出处记录的 flag 键名：照常落盘和透传，但不进缓存指纹，值变了不作废已跑完的结果（见下） |
 | `runs` | 每个评估用例 × 配置最多跑几次 |
 | `earlyExit` | 多次运行里通过一次就提前停止；默认关，`runs` 默认跑满测完整通过率 |
 | `evals` | `"*"`、id 前缀数组，或遍历只读 eval 描述并返回 boolean 的函数 |
@@ -127,6 +128,39 @@ npx niceeval exp prompts/concise
 | `setup` | 实验级 Hook：整个实验只跑一次、在你自己的机器上执行，启动全部 Attempt 共享的服务（见下） |
 | `teardown` | 与 `setup` 成对的实验级 Hook：全部 Attempt 收尾后执行一次，当且仅当 `setup` 的时点已经走到（见下） |
 
+## 记下这轮连的是哪个地址，又不让它作废缓存
+
+把服务地址记进 `flags`，报告里就能按它分组、看出这轮连的是哪个实例。但隧道 URL 每次重启就换一个，而 `flags` 变了等于配置变了——下一次跑，已经跑完的结果一条都复用不上，全部重跑。
+
+在 `provenanceFlags` 里点名这个键，它就只作记录、不进缓存指纹：
+
+```ts
+export default defineExperiment({
+  agent: nowledgeAgent(),
+  evals: ["memory/"],
+  flags: {
+    memory: "nowledge",
+    memoryVersion: "0.10.39",
+    memoryEndpoint: process.env.NMEM_URL!,  // 隧道重启就换一个
+  },
+  provenanceFlags: ["memoryEndpoint"],
+});
+```
+
+换了 URL 再跑，已完成的照常复用，只跑还缺的：
+
+```bash
+$ pnpm exec niceeval exp compare/codex--nowledge
+╭─ PLAN ──────────────────────────────────────────╮
+│ 36 attempts · 36 evals × 1 configs              │
+│ 24 of 36 carried in from cache · 12 to run      │
+╰─────────────────────────────────────────────────╯
+```
+
+`memoryVersion` 没点名——服务端换了版本，行为可能真的不一样，那种变化就该让结果重跑。加上声明之前跑的结果也复用得到，不用为了「洗」旧结果先空跑一轮。
+
+完全不需要在 Adapter 或评估用例里被读到的事实，直接写 `labels`：那是报告侧坐标，本来就不进指纹。
+
 ## 启动 Experiment 共享服务
 
 有些资源是「一个实验一份、所有 Attempt 共用」的：一条到内网记忆服务的隧道、一个实验专用的 mock server、一个 license 租约。这类资源写进一对实验级 Hook `setup` / `teardown`：整场至多各跑一次。`setup` 在这个实验第一个要派发的 Attempt 前执行；`teardown` 在全部 Attempt 收尾后执行（运行被中断也执行），当且仅当 `setup` 的时点已经走到才触发——`setup` 抛错同样要走到 `teardown`，收尾代码要对可能未赋值的变量做防御。上一次的结果全部被复用、这个实验一个 Attempt 都不需要真正运行时，`setup` 和 `teardown` 都不会执行：

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "niceeval",
-  "version": "0.11.0",
+  "version": "0.11.1-canary.8",
   "description": "Agent-native eval tool — eval agents, services, functions, and coding-agent fixtures",
   "type": "module",
   "license": "MIT",

package/src/cli.ts

@@ -43,7 +43,7 @@ import {
 import {
   buildView,
   startViewServer,
-  loadLatestResultsPerEval,
+  loadCarryInputs,
   resolveViewInput,
   IncompatibleResultsError,
   ViewInputError,
@@ -874,6 +874,7 @@ async function main(): Promise<void> {
         model: exp.model,
         reasoningEffort: exp.reasoningEffort,
         flags: exp.flags ?? {},
+        ...(exp.provenanceFlags !== undefined ? { provenanceFlags: exp.provenanceFlags } : {}),
         runs: flags.runs ?? envNumber("NICEEVAL_RUNS") ?? exp.runs ?? 1,
         earlyExit: flags.earlyExit ?? exp.earlyExit ?? false,
         sandbox: exp.sandbox ?? config.sandbox,
@@ -943,9 +944,10 @@ async function main(): Promise<void> {
   // `--dry`(两种形态)都需要这份计算:`--dry --json` 的 `ExpPlanDocument.matrix[].reused`,
   // 人读 `--dry` 首行的携入摘要(见 docs/feature/experiments/cli.md 开头示例与「事件与计划
   // 文档的 TypeScript 形状」),口径必须与真正开跑时一致。
-  const priorResults = flags.force ? undefined : await loadLatestResultsPerEval(join(cwd, ".niceeval"));
+  const carryInputs = flags.force ? undefined : await loadCarryInputs(join(cwd, ".niceeval"));
+  const priorResults = carryInputs?.results;
   const carryPlan = priorResults?.length
-    ? await planCarry(evals, agentRuns, priorResults, config.sandbox, config.timeoutMs)
+    ? await planCarry(evals, agentRuns, priorResults, config.sandbox, config.timeoutMs, carryInputs?.flagBagsByExperiment)
     : undefined;
 
   if (flags.dry) {

package/src/define.ts

@@ -128,6 +128,12 @@ export function defineExperiment(def: ExperimentDef): ExperimentDef {
       }
     }
   }
+  // provenanceFlags 只接受字符串键名数组:写错形状(误传对象、误传 flags 本身)在解析时就报,
+  // 不等到携带判定悄悄按「没声明」处理——那会表现成缓存莫名其妙全失效,极难查。
+  if (def.provenanceFlags !== undefined) {
+    const ok = Array.isArray(def.provenanceFlags) && def.provenanceFlags.every((k) => typeof k === "string" && k.length > 0);
+    if (!ok) throw new Error(t("define.experimentProvenanceFlagsInvalid"));
+  }
   // labels 是报告归类坐标(进 ExperimentRunInfo.labels,不透传 ctx/t):值域 string | number,
   // 解析时即校验,布尔 / 对象 / NaN 直接报错,不等到落盘或报告分组才炸。
   if (def.labels !== undefined) {

package/src/i18n/en.ts

@@ -243,6 +243,7 @@ export const en = {
   "define.experimentAgentRequired": "defineExperiment requires agent.",
   "define.experimentFlagNotJson": "experiment.flags.{{key}} is not JSON-serializable (functions / undefined / cycles / bigint are not allowed); flags are persisted verbatim into result snapshots and must be plain JSON.",
   "define.experimentLabelInvalid": "experiment.labels.{{key}} must be a string or a finite number; labels are report-side grouping coordinates persisted verbatim into result snapshots.",
+  "define.experimentProvenanceFlagsInvalid": "experiment.provenanceFlags must be an array of flag key names (strings); it lists the flags recorded for provenance only, which stay out of the cache fingerprint.",
   "define.experimentSetupNotFunction": "experiment.setup must be a function ((ctx) => void); use experiment.teardown for cleanup; to prepare the in-sandbox environment per experiment, chain .setup() hooks on the sandbox spec instead.",
   "define.experimentClassifyFailureNotFunction": "experiment.classifyFailure must be a function ((failure) => FailureClass | undefined); it classifies failures that surface as third-party errors and must return undefined for anything it does not recognize.",
   "define.experimentIdRejected": "defineExperiment does not accept id; ids are derived from file paths.",

package/src/i18n/zh-CN.ts

@@ -236,6 +236,7 @@ export const zhCN = {
   "define.experimentAgentRequired": "defineExperiment 需要 agent。",
   "define.experimentFlagNotJson": "experiment.flags.{{key}} 不是可 JSON 序列化的值(函数 / undefined / 循环引用 / bigint 不允许);flags 会原样进入结果快照,必须是纯 JSON。",
   "define.experimentLabelInvalid": "experiment.labels.{{key}} 必须是字符串或有限数字;labels 是报告侧的归类坐标,会原样进入结果快照。",
+  "define.experimentProvenanceFlagsInvalid": "experiment.provenanceFlags 必须是 flag 键名(字符串)数组;它列出只作为出处记录、不进缓存指纹的那些 flag。",
   "define.experimentSetupNotFunction": "experiment.setup 必须是函数((ctx) => void);要清理请挂 experiment.teardown;要按实验准备沙箱内环境请挂 sandbox spec 的 .setup() 钩子链。",
   "define.experimentClassifyFailureNotFunction": "experiment.classifyFailure 必须是函数((failure) => FailureClass | undefined):它识别以第三方错误形态浮出的失败,认不出的一律返回 undefined 交给后续链路。",
   "define.experimentIdRejected": "defineExperiment 不接受 id —— id 由文件路径推导。",

package/src/runner/feedback/human.test.ts

@@ -186,7 +186,7 @@ describe("live dashboard — 接线到 panel.ts", () => {
       failed: 2,
       elapsedMs: 134_000,
       estimatedCostUSD: 0.84,
-      active: new Map([[key, { identity, who: "compare/bub-e2b", phase: "eval.run", phaseStartedAt: 0 }]]),
+      active: new Map([[key, { identity, who: "compare/bub-e2b", phase: "eval.run", startedAt: 0 }]]),
     };
     renderer.onLifecycle?.({ type: "attempt:start", at: 0, identity, who: "compare/bub-e2b", phase: "eval.run" }, state);
     renderer.redrawDynamic?.(state);
@@ -265,7 +265,7 @@ describe("live dashboard — 宽终端下 ACTIVE 行与身份列分配", () => {
       failed: 2,
       elapsedMs: 134_000,
       active: new Map([
-        [key, { identity, who: "compare/bub-e2b", phase: "eval.run", phaseStartedAt: 0, detail: longDetail }],
+        [key, { identity, who: "compare/bub-e2b", phase: "eval.run", startedAt: 0, detail: longDetail }],
       ]),
     };
     renderer.onLifecycle?.(
@@ -315,7 +315,7 @@ describe("live dashboard — 宽终端下 ACTIVE 行与身份列分配", () => {
       ...createInitialRunFeedbackState(),
       total: 1,
       running: 1,
-      active: new Map([[key, { identity, who: "w1", phase: "eval.run", phaseStartedAt: 0 }]]),
+      active: new Map([[key, { identity, who: "w1", phase: "eval.run", startedAt: 0 }]]),
     };
     renderer.onLifecycle?.({ type: "attempt:start", at: 0, identity, who: "w1", phase: "eval.run" }, state);
     renderer.redrawDynamic?.(state);
@@ -326,6 +326,35 @@ describe("live dashboard — 宽终端下 ACTIVE 行与身份列分配", () => {
     expect(plain).toContain("● e1  w1  ");
   });
 
+  it("时间列从 attempt 派发起算:阶段推进只换标签,不把时钟归零(存活性证明必须单调)", () => {
+    const { io, stderr, advance } = createFakeFeedbackIO({ stderr: { isTTY: true, columns: 200, rows: 30 } });
+    const renderer = createHumanRenderer({ io, command: "niceeval exp compare" });
+    const identity = { experimentId: "compare", evalId: "react-tooltip/pr-1271", attempt: 0 };
+    const who = "compare/codex--nowledge";
+    let state = reduceRunFeedback(createInitialRunFeedbackState(), {
+      type: "plan",
+      at: 0,
+      plan: { shape: { evals: 1, configs: 1, totalAttempts: 1, maxConcurrency: 1 }, reused: 0, reusedFailures: [] },
+    });
+    const start = { type: "attempt:start", at: 0, identity, who, phase: "eval.run" } as const;
+    state = reduceRunFeedback(state, start);
+    renderer.onLifecycle?.(start, state);
+    advance(262_000);
+    renderer.redrawDynamic?.(state);
+    expect(stripAnsi(stderr.writes.join(""))).toContain("4m 22s  running eval");
+
+    // eval.run(几分钟)→ workspace.diff(秒级)是真实运行里最刺眼的一跳:旧实现按当前 phase
+    // 计时,这里回到 0s,读起来像这条 eval 重跑了。时间列答的是「这条派发多久了」,不是
+    // 「当前阶段跑了多久」——阶段各自的耗时由结果的 timing.phases 负责。
+    const mark = stderr.writes.length;
+    state = reduceRunFeedback(state, { type: "attempt:phase", at: 262_000, identity, phase: "workspace.diff" });
+    advance(1_000);
+    renderer.redrawDynamic?.(state);
+    const frame2 = stripAnsi(stderr.writes.slice(mark).join(""));
+    expect(frame2).toContain("4m 23s  capturing diff");
+    expect(frame2).not.toContain(" 0s  ");
+  });
+
   it("身份列跨帧单调:长 id 出现后,后续短 id 所在帧的列宽不回缩", () => {
     const { io, stderr } = createFakeFeedbackIO({ stderr: { isTTY: true, columns: 200, rows: 30 } });
     const renderer = createHumanRenderer({ io, command: "niceeval exp compare" });
@@ -340,7 +369,7 @@ describe("live dashboard — 宽终端下 ACTIVE 行与身份列分配", () => {
       total: 2,
       running: 1,
       queued: 1,
-      active: new Map([[longKey, { identity: longIdentity, who, phase: "eval.run", phaseStartedAt: 0 }]]),
+      active: new Map([[longKey, { identity: longIdentity, who, phase: "eval.run", startedAt: 0 }]]),
     };
     renderer.onLifecycle?.(
       { type: "attempt:start", at: 0, identity: longIdentity, who, phase: "eval.run" },
@@ -361,7 +390,7 @@ describe("live dashboard — 宽终端下 ACTIVE 行与身份列分配", () => {
       total: 2,
       running: 1,
       passed: 1,
-      active: new Map([[shortKey, { identity: shortIdentity, who, phase: "eval.run", phaseStartedAt: 1 }]]),
+      active: new Map([[shortKey, { identity: shortIdentity, who, phase: "eval.run", startedAt: 1 }]]),
     };
     renderer.onLifecycle?.(
       { type: "attempt:start", at: 1, identity: shortIdentity, who, phase: "eval.run" },
@@ -389,7 +418,7 @@ describe("live dashboard — 宽终端下 ACTIVE 行与身份列分配", () => {
       ...createInitialRunFeedbackState(),
       total: 1,
       running: 1,
-      active: new Map([[key, { identity, who: longWho, phase: "eval.run", phaseStartedAt: 0 }]]),
+      active: new Map([[key, { identity, who: longWho, phase: "eval.run", startedAt: 0 }]]),
     };
     renderer.onLifecycle?.({ type: "attempt:start", at: 0, identity, who: longWho, phase: "eval.run" }, state);
     renderer.redrawDynamic?.(state);

package/src/runner/feedback/human.ts

@@ -718,7 +718,9 @@ function formatActiveRow(
   evalWidth: number,
   whoWidth: number,
 ): string {
-  const elapsed = formatElapsed(io.clock.now() - active.phaseStartedAt).padStart(6);
+  // 时间列从 attempt 派发起算,阶段推进不重置(见 ActiveAttempt.startedAt):这一列是存活性的
+  // 唯一证明,归零会被读成「这条 eval 重跑了」。
+  const elapsed = formatElapsed(io.clock.now() - active.startedAt).padStart(6);
   const sym = "● ";
   const evalCol = padTrunc(active.identity.evalId, evalWidth);
   const whoCol = padTrunc(active.who, whoWidth);

package/src/runner/feedback/reducer.test.ts

@@ -460,6 +460,25 @@ describe("reduceRunFeedback: 守恒公式", () => {
     expect(activeAfterPhase?.phase).toBe("workspace.diff");
     expect(activeAfterPhase?.detail).toBeUndefined();
   });
+
+  it("phase 变化不重置 startedAt:时间列是 attempt 的存活性证明,阶段边界只换标签", () => {
+    const a = ref("memory/a");
+    let state = reduceRunFeedback(createInitialRunFeedbackState(), {
+      type: "plan",
+      at: 0,
+      plan: { shape: { evals: 1, configs: 1, totalAttempts: 1, maxConcurrency: 1 }, reused: 0, reusedFailures: [] },
+    });
+    state = reduceRunFeedback(state, { type: "attempt:start", at: 1_000, identity: a, who: "codex", phase: "sandbox.queue" });
+    for (const [at, phase] of [
+      [3_000, "sandbox.create"],
+      [9_000, "sandbox.setup"],
+      [21_000, "eval.run"],
+      [283_000, "workspace.diff"],
+    ] as const) {
+      state = reduceRunFeedback(state, { type: "attempt:phase", at, identity: a, phase });
+      expect([...state.active.values()][0]?.startedAt).toBe(1_000);
+    }
+  });
 });
 
 describe("reduceRunFeedback: judge 预检运行级行", () => {

package/src/runner/feedback/reducer.ts

@@ -96,7 +96,9 @@ export function reduceRunFeedback(state: RunFeedbackState, event: RunFeedbackEve
         identity: event.identity,
         who: event.who,
         phase: event.phase,
-        phaseStartedAt: event.at,
+        // active 行时间列的基准只在这里写一次:一条 attempt 的时间从派发起算,之后的阶段推进
+        // 只换标签不重置时钟(见 ActiveAttempt.startedAt 与下面的 attempt:phase 分支)。
+        startedAt: event.at,
       });
       return {
         ...state,
@@ -112,8 +114,9 @@ export function reduceRunFeedback(state: RunFeedbackState, event: RunFeedbackEve
       if (!existing) return state; // 防御:识别不到的 attempt 静默忽略,不让 renderer 崩
       const active = new Map(state.active);
       // 进入新 phase 清空旧 detail —— 次要文本是绑定到具体 phase 的(如 running 阶段的
-      // "tool: shell"),不该原样带进下一个 phase 显示。
-      active.set(key, { ...existing, phase: event.phase, phaseStartedAt: event.at, detail: undefined });
+      // "tool: shell"),不该原样带进下一个 phase 显示。`startedAt` 原样带过去(spread 保留):
+      // 阶段边界换的是「正在干什么」,不是「这条跑了多久」。
+      active.set(key, { ...existing, phase: event.phase, detail: undefined });
       return { ...state, active };
     }
 

package/src/runner/fingerprint.test.ts

@@ -238,3 +238,127 @@ describe("planCarry · timeoutMs 是携带资格判据,不进指纹哈希", () =
     expect(plan.carriedResults).toEqual([]);
   });
 });
+
+// 覆盖「缓存」分区的 provenanceFlags 行:声明为出处记录的 flag 不进指纹,只有这些键取值不同的
+// 历史终态照常携带。fixture 里的历史结果一律按**整袋 flags** 算指纹——那正是声明之前落盘的口径,
+// 这条通道要能把它们救回来(现实反例:隧道 URL 每次重启就换,换一次全部已完成结果作废重跑)。
+describe("planCarry · provenanceFlags 不进指纹", () => {
+  const OLD_FLAGS = { memory: "nowledge", endpoint: "https://old.example" };
+  const NEW_FLAGS = { memory: "nowledge", endpoint: "https://new.example" };
+
+  function runWith(flags: Record<string, string>, provenanceFlags?: string[]): AgentRun {
+    return {
+      ...makeRun("exp", ["e"], 1),
+      flags,
+      ...(provenanceFlags !== undefined ? { provenanceFlags } : {}),
+    };
+  }
+
+  /** 声明之前的落盘:指纹按整袋 flags 算,快照记下当时那袋 flags。 */
+  async function priorFrom(evalDef: DiscoveredEval, flags: Record<string, string>): Promise<EvalResult> {
+    return result({
+      id: "e",
+      attempt: 0,
+      verdict: "passed",
+      fingerprint: await computeFingerprint(evalDef, runWith(flags)),
+      experiment: { flags, runs: 1, earlyExit: false, selectedEvalIds: ["e"] },
+    });
+  }
+
+  it("只有 provenance flag 的取值不同时,历史终态照常携带", async () => {
+    const evals = [makeEval("e")];
+    const prior = await priorFrom(evals[0]!, OLD_FLAGS);
+
+    // 没声明:endpoint 变了就是配置变了,全部作废重跑(修改前的行为)。
+    const without = await planCarry(evals, [runWith(NEW_FLAGS)], [prior]);
+    expect(without.carriedAttemptsByKey.get("exp|e")).toBeUndefined();
+
+    // 声明之后:同一份历史结果照常携带,不需要重跑一轮来"洗"它,也不动已落盘的文件。
+    const with_ = await planCarry(evals, [runWith(NEW_FLAGS, ["endpoint"])], [prior]);
+    expect(with_.carriedAttemptsByKey.get("exp|e")).toEqual(new Set([0]));
+  });
+
+  it("其余 flag 有任一不同则照旧作废——放行只限声明过的键", async () => {
+    const evals = [makeEval("e")];
+    const prior = await priorFrom(evals[0]!, OLD_FLAGS);
+    // endpoint 声明为 provenance,但 memory 这个真影响行为的 flag 也变了:不能携带。
+    const run = runWith({ memory: "baseline", endpoint: "https://new.example" }, ["endpoint"]);
+
+    const plan = await planCarry(evals, [run], [prior]);
+
+    expect(plan.carriedAttemptsByKey.get("exp|e")).toBeUndefined();
+  });
+
+  it("声明之后落盘的结果(指纹已按抹掉 provenance 的口径算)在下一次换值后照常携带", async () => {
+    const evals = [makeEval("e")];
+    // 上一轮已经带着声明跑:落盘指纹 = 抹掉 endpoint 之后算的那个。
+    const prior = result({
+      id: "e",
+      attempt: 0,
+      verdict: "passed",
+      fingerprint: await computeFingerprint(evals[0]!, runWith(OLD_FLAGS, ["endpoint"])),
+      experiment: { flags: OLD_FLAGS, runs: 1, earlyExit: false, selectedEvalIds: ["e"] },
+    });
+
+    const plan = await planCarry(evals, [runWith(NEW_FLAGS, ["endpoint"])], [prior]);
+
+    expect(plan.carriedAttemptsByKey.get("exp|e")).toEqual(new Set([0]));
+  });
+
+  it("候选 flags 可以来自实验的历史快照——携带条目背着更早那轮的指纹,本轮快照的 flags 对不上它", async () => {
+    const evals = [makeEval("e")];
+    // 现实形态:上一轮把这条结果**携带**进了自己的快照,指纹还是更早那轮(OLD_FLAGS)算的,
+    // 而它所在快照记的 flags 已经是中间那轮(MID)的。只看结果自带的那袋永远对不上。
+    const MID_FLAGS = { memory: "nowledge", endpoint: "https://mid.example" };
+    const prior = result({
+      id: "e",
+      attempt: 0,
+      verdict: "passed",
+      fingerprint: await computeFingerprint(evals[0]!, runWith(OLD_FLAGS)),
+      experiment: { flags: MID_FLAGS, runs: 1, earlyExit: false, selectedEvalIds: ["e"] },
+    });
+    const run = runWith(NEW_FLAGS, ["endpoint"]);
+
+    const withoutHistory = await planCarry(evals, [run], [prior]);
+    expect(withoutHistory.carriedAttemptsByKey.get("exp|e")).toBeUndefined();
+
+    const withHistory = await planCarry(evals, [run], [prior], undefined, undefined, new Map([["exp", [OLD_FLAGS]]]));
+    expect(withHistory.carriedAttemptsByKey.get("exp|e")).toEqual(new Set([0]));
+  });
+
+  it("历史候选袋子同样只放行 provenance 键上的差异", async () => {
+    const evals = [makeEval("e")];
+    const prior = result({
+      id: "e",
+      attempt: 0,
+      verdict: "passed",
+      fingerprint: await computeFingerprint(evals[0]!, runWith({ memory: "baseline", endpoint: "https://old.example" })),
+      experiment: { flags: { memory: "baseline", endpoint: "https://old.example" }, runs: 1, earlyExit: false, selectedEvalIds: ["e"] },
+    });
+    // 历史袋子里 memory=baseline,本次 memory=nowledge:抹掉 endpoint 后仍不相等,不放行。
+    const plan = await planCarry(
+      evals,
+      [runWith(NEW_FLAGS, ["endpoint"])],
+      [prior],
+      undefined,
+      undefined,
+      new Map([["exp", [{ memory: "baseline", endpoint: "https://old.example" }]]]),
+    );
+
+    expect(plan.carriedAttemptsByKey.get("exp|e")).toBeUndefined();
+  });
+
+  it("落盘缺 ExperimentRunInfo.flags(第三方 harness)时无从反事实重算,保守不携带", async () => {
+    const evals = [makeEval("e")];
+    const prior = result({
+      id: "e",
+      attempt: 0,
+      verdict: "passed",
+      fingerprint: await computeFingerprint(evals[0]!, runWith(OLD_FLAGS)),
+    });
+
+    const plan = await planCarry(evals, [runWith(NEW_FLAGS, ["endpoint"])], [prior]);
+
+    expect(plan.carriedAttemptsByKey.get("exp|e")).toBeUndefined();
+  });
+});

package/src/runner/fingerprint.ts

@@ -4,7 +4,7 @@
 import { createHash } from "node:crypto";
 import { readFile } from "node:fs/promises";
 import { sandboxRunInfo } from "../sandbox/resolve.ts";
-import type { DiscoveredEval, EvalResult, SandboxOption } from "../types.ts";
+import type { DiscoveredEval, EvalResult, JsonValue, SandboxOption } from "../types.ts";
 import type { AgentRun } from "./types.ts";
 import { prepareRunSandboxes, sandboxForEval } from "./sandbox-selection.ts";
 import { selectedEvalsForRun } from "./eval-selection.ts";
@@ -13,15 +13,33 @@ export function cacheKey(run: AgentRun, evalId: string): string {
   return `${run.experimentId ?? ""}|${evalId}`;
 }
 
+/**
+ * 指纹口径里的 flags:去掉实验声明为出处记录的键(`ExperimentDef.provenanceFlags`)。
+ * 这些键照常落盘、照常透传 `ctx.flags` / `t.flags`,只是不参与可比性——隧道 URL、跑批时刻
+ * 这类连接坐标每次都变,把它们算进指纹会让每一次坐标轮换作废全部已完成结果。
+ */
+function fingerprintFlags(flags: Record<string, JsonValue>, provenanceFlags: readonly string[] | undefined): Record<string, JsonValue> {
+  if (!provenanceFlags?.length) return flags;
+  const drop = new Set(provenanceFlags);
+  const out: Record<string, JsonValue> = {};
+  for (const [k, v] of Object.entries(flags)) if (!drop.has(k)) out[k] = v;
+  return out;
+}
+
 /**
  * @param sourceCache 按 sourcePath 缓存文件内容:一个矩阵(实验 × eval)会对同一批源文件
  * 反复算指纹,不带缓存会在任何 attempt 起跑前做 E×N 次重复文件读。
+ * @param flagsOverride 用这份 flags 代替 `run.flags` 的指纹口径算一遍。只有一个用途:
+ * 对已落盘结果做**反事实重算**——「把 flags 换成它当时那份,指纹还相等吗」等价于问
+ * 「除 flags 外的一切是否都没变」,`acceptableFingerprints` 用它判定某条历史结果与本次
+ * 规划的差异是否完全落在 provenance flag 上。
  */
 export async function computeFingerprint(
   evalDef: DiscoveredEval,
   run: AgentRun,
   sourceCache?: Map<string, Promise<string>>,
   configSandbox?: SandboxOption,
+  flagsOverride?: Record<string, JsonValue>,
 ): Promise<string> {
   let sourcePromise = sourceCache?.get(evalDef.sourcePath);
   if (!sourcePromise) {
@@ -41,7 +59,7 @@ export async function computeFingerprint(
       experimentId: run.experimentId,
       agent: run.agent.name,
       model: run.model,
-      flags: run.flags,
+      flags: flagsOverride ?? fingerprintFlags(run.flags, run.provenanceFlags),
       sandbox: sandboxRunInfo(sandboxForEval(run, evalDef, configSandbox)),
       strict: run.strict,
     },
@@ -56,6 +74,13 @@ export async function computeFingerprint(
 export interface CarryPlan {
   /** `cacheKey(run, evalId)` → 本次规划出的指纹,供调用方按同一口径判断"这条要不要携入"。 */
   plannedFingerprints: Map<string, string>;
+  /**
+   * `cacheKey(run, evalId)` → 这条组合**可以携带的全部指纹**:本次规划的那个,加上
+   * 「只在 provenance flag 上与本次不同」的历史口径(见 `acceptableFingerprints`)。
+   * 没声明 provenance flag 时恒是单元素集合 = `plannedFingerprints` 的那一个。
+   * 携带判定一律读这个集合,`plannedFingerprints` 只用来给新跑的 attempt 落盘打戳。
+   */
+  acceptableFingerprints: Map<string, Set<string>>;
   /**
    * 携带以 attempt 为粒度:命中携入条件(该 attempt 自身 passed/failed 终态 + 指纹匹配)的
    * `${experimentId}|${evalId}` → 该 eval 下具体携入的 attempt 序号集合(0-based)。同一个
@@ -86,7 +111,9 @@ export function resolvedTimeoutMsForCarry(run: AgentRun, evalDef: DiscoveredEval
  * 1. 该 attempt 自己是终态(`passed` / `failed`)。`errored` 是框架/环境层面的不确定失败,
  *    判定本身不可信;`skipped` 根本没跑。同一 eval 的别的序号命中不能连带把它捎上
  *    (反例与修法见 memory 的 carry-must-be-per-attempt-not-whole-eval-key)。
- * 2. 该 attempt 落盘的 `fingerprint` 与本次规划的 `fingerprint` 相等。
+ * 2. 该 attempt 落盘的 `fingerprint` 落在本次的可携带指纹集合里(`CarryPlan.acceptableFingerprints`
+ *    的那一条,通常只有本次规划出的那一个;声明了 provenance flag 时还含「只在这些键上与本次
+ *    不同」的历史口径)。
  * 3. 该 attempt 的 `durationMs` 不超过本次 resolved 的 `timeoutMs`——`timeoutMs` 是携带资格
  *    判据、不进指纹哈希(docs/runner.md「缓存:指纹去重」)。
  *
@@ -96,15 +123,15 @@ export function resolvedTimeoutMsForCarry(run: AgentRun, evalDef: DiscoveredEval
 export function carriableAttempts(
   priorResults: EvalResult[] | undefined,
   key: string,
-  fingerprint: string | undefined,
+  fingerprints: ReadonlySet<string> | undefined,
   timeoutMs: number,
 ): EvalResult[] {
-  if (!priorResults?.length || fingerprint === undefined) return [];
+  if (!priorResults?.length || fingerprints === undefined || fingerprints.size === 0) return [];
   const out: EvalResult[] = [];
   for (const r of priorResults) {
     if (!r.experimentId || `${r.experimentId}|${r.id}` !== key) continue;
     const isTerminalVerdict = r.verdict === "passed" || r.verdict === "failed";
-    if (!isTerminalVerdict || r.fingerprint === undefined || r.fingerprint !== fingerprint) continue;
+    if (!isTerminalVerdict || r.fingerprint === undefined || !fingerprints.has(r.fingerprint)) continue;
     // `durationMs` 在 `EvalResult` 上是必填字段,正常落盘不会缺失;这里的 `typeof` 防御只处理
     // 磁盘数据损坏等异常情形——保守地判不可携带,而不是当 0 处理(当 0 会让所有旧记录都通过
     // 判据,把「数据缺失」悄悄伪装成「跑得很快」)。
@@ -136,6 +163,7 @@ export async function planCarry(
   priorResults: EvalResult[] | undefined,
   configSandbox?: SandboxOption,
   configTimeoutMs?: number,
+  flagBagsByExperiment?: Map<string, Record<string, JsonValue>[]>,
 ): Promise<CarryPlan> {
   prepareRunSandboxes(evals, agentRuns, configSandbox);
   const sourceCache = new Map<string, Promise<string>>();
@@ -144,15 +172,32 @@ export async function planCarry(
   // 这次的携带资格线是多少」——同一个 key 在同一次 planCarry 调用里只对应一个 (run, evalDef)
   // 组合,与 plannedFingerprints 的 key 语义一致。
   const plannedTimeoutMs = new Map<string, number>();
+  const acceptable = new Map<string, Set<string>>();
   const jobs: Promise<void>[] = [];
   for (const run of agentRuns) {
     for (const evalDef of selectedEvalsForRun(evals, run)) {
       const key = cacheKey(run, evalDef.id);
       plannedTimeoutMs.set(key, resolvedTimeoutMsForCarry(run, evalDef, configTimeoutMs));
       jobs.push(
-        computeFingerprint(evalDef, run, sourceCache, configSandbox).then((fp) => {
+        (async () => {
+          const fp = await computeFingerprint(evalDef, run, sourceCache, configSandbox);
           plannedFingerprints.set(key, fp);
-        }),
+          acceptable.set(
+            key,
+            await acceptableFingerprints({
+              evalDef,
+              run,
+              key,
+              priorResults,
+              primary: fp,
+              sourceCache,
+              configSandbox,
+              ...(run.experimentId !== undefined && flagBagsByExperiment?.has(run.experimentId)
+                ? { historicalFlagBags: flagBagsByExperiment.get(run.experimentId)! }
+                : {}),
+            }),
+          );
+        })(),
       );
     }
   }
@@ -162,8 +207,8 @@ export async function planCarry(
   // 不可能对「哪些携入」得出不同结论。
   const carriedAttemptsByKey = new Map<string, Set<number>>();
   const hit = new Set<EvalResult>();
-  for (const [key, fingerprint] of plannedFingerprints) {
-    const carried = carriableAttempts(priorResults, key, fingerprint, plannedTimeoutMs.get(key) ?? Infinity);
+  for (const key of plannedFingerprints.keys()) {
+    const carried = carriableAttempts(priorResults, key, acceptable.get(key), plannedTimeoutMs.get(key) ?? Infinity);
     if (carried.length === 0) continue;
     const indices = new Set<number>();
     for (const r of carried) {
@@ -174,7 +219,61 @@ export async function planCarry(
   }
   // 按 priorResults 的原始顺序输出(调用方的展示顺序不因分组而抖动)。
   const carriedResults = (priorResults ?? []).filter((r) => hit.has(r));
-  return { plannedFingerprints, carriedAttemptsByKey, carriedResults };
+  return { plannedFingerprints, acceptableFingerprints: acceptable, carriedAttemptsByKey, carriedResults };
+}
+
+/**
+ * 这条 `(experimentId, evalId)` 本次可以携带的指纹全集。
+ *
+ * 没声明 provenance flag 时就是 `{ primary }`——判据与「指纹相等」逐字等价,一条历史结果都
+ * 不会因此多携入。声明了之后多出一类:**只在 provenance flag 上与本次不同**的历史口径。
+ *
+ * 判定不靠比对两串哈希的差异(哈希不可差分),而是**反事实重算**:取该历史结果所属快照记下的
+ * `ExperimentRunInfo.flags`(整袋原样,`applySnapshotDefaults` 已把它挂在 `EvalResult.experiment`
+ * 上),用它替换本次的 flags 口径重算一遍指纹——算出来等于历史那一串,就证明「除 flags 外的
+ * 一切(eval 源码、agent、model、sandbox、strict…)都没变」。再要求两袋 flags 抹掉 provenance
+ * 键之后逐字相等,才把这串历史指纹计入可携带集合:真改了某个影响行为的 flag(`webResearch`
+ * 从 true 改成 false)照旧作废,不会被这条通道放行。
+ *
+ * 历史结果落盘时的指纹口径是「整袋 flags」(provenance 概念引入之前),所以两个口径都要试:
+ * 整袋(老结果)与抹掉 provenance 键的那袋(声明之后跑出来的结果,与 primary 相同则自然去重)。
+ */
+export async function acceptableFingerprints(args: {
+  evalDef: DiscoveredEval;
+  run: AgentRun;
+  key: string;
+  priorResults: EvalResult[] | undefined;
+  /** 本次规划出的指纹(新跑的 attempt 用它落盘打戳)。 */
+  primary: string;
+  /**
+   * 该实验历史快照记下过的 flags(见 `loadCarryInputs`)。候选假设的来源之一,与结果自带的那袋
+   * 并列——携带条目带着**产出它那一轮**的指纹合入新快照,那一轮的 flags 只在更早的快照里留着。
+   */
+  historicalFlagBags?: readonly Record<string, JsonValue>[];
+  sourceCache?: Map<string, Promise<string>>;
+  configSandbox?: SandboxOption;
+}): Promise<Set<string>> {
+  const { evalDef, run, key, priorResults, primary, historicalFlagBags, sourceCache, configSandbox } = args;
+  const out = new Set([primary]);
+  if (!run.provenanceFlags?.length) return out;
+  const currentStripped = stableJson(fingerprintFlags(run.flags, run.provenanceFlags));
+  const candidates: Record<string, JsonValue>[] = [];
+  for (const r of priorResults ?? []) {
+    if (!r.experimentId || `${r.experimentId}|${r.id}` !== key) continue;
+    // 第三方落盘 / 缺 ExperimentRunInfo 时这里没有袋子可试,只能靠 historicalFlagBags。
+    if (r.experiment?.flags !== undefined) candidates.push(r.experiment.flags);
+  }
+  candidates.push(...(historicalFlagBags ?? []));
+  const seen = new Set<string>();
+  for (const bag of candidates) {
+    const bagJson = stableJson(bag);
+    if (seen.has(bagJson)) continue;
+    seen.add(bagJson);
+    // 抹掉 provenance 键之后必须逐字相等:差异只准落在这些键上。
+    if (stableJson(fingerprintFlags(bag, run.provenanceFlags)) !== currentStripped) continue;
+    out.add(await computeFingerprint(evalDef, run, sourceCache, configSandbox, bag));
+  }
+  return out;
 }
 
 /** 键序稳定的 JSON 序列化(对象键排序),保证同一 payload 永远同一指纹。 */

package/src/runner/run.test.ts

@@ -460,6 +460,7 @@ describe("runEvals · fresh EvalResult.locator 在 reporter 观察到之前已
     const { summary, root } = await run([evalDef], [agentRun], {
       carryPlan: {
         plannedFingerprints: new Map(),
+        acceptableFingerprints: new Map(),
         carriedAttemptsByKey: new Map([[`${experimentId}|${evalId}`, new Set([0])]]),
         carriedResults: [carried],
       },
@@ -812,6 +813,7 @@ describe("runEvals · 携入数量少于本次请求的 runs 时,差额必须真
       const { summary } = await run([evalDef], [agentRun], {
         carryPlan: {
           plannedFingerprints: new Map(),
+          acceptableFingerprints: new Map(),
           carriedAttemptsByKey: new Map([[`${experimentId}|${evalId}`, new Set([0])]]),
           carriedResults: [carried],
         },
@@ -882,6 +884,7 @@ describe("runEvals · 携入数量少于本次请求的 runs 时,差额必须真
       const { summary } = await run([evalDef], [agentRun], {
         carryPlan: {
           plannedFingerprints: new Map(),
+          acceptableFingerprints: new Map(),
           carriedAttemptsByKey: new Map([[`${experimentId}|${evalId}`, new Set([0])]]),
           carriedResults: [carried],
         },
@@ -941,6 +944,7 @@ describe("runEvals · 携入数量少于本次请求的 runs 时,差额必须真
     const { summary } = await run([evalDef], [agentRun], {
       carryPlan: {
         plannedFingerprints: new Map(),
+        acceptableFingerprints: new Map(),
         carriedAttemptsByKey: new Map([[`${experimentId}|${evalId}`, new Set([1])]]),
         carriedResults: [carried],
       },
@@ -1068,6 +1072,7 @@ describe("runEvals · 实验级 setup/teardown", () => {
     const { summary } = await run([evalDef], [agentRun], {
       carryPlan: {
         plannedFingerprints: new Map(),
+        acceptableFingerprints: new Map(),
         carriedAttemptsByKey: new Map([[`${experimentId}|done`, new Set([0])]]),
         carriedResults: [carried],
       },
@@ -2197,6 +2202,49 @@ describe("runEvals · 用例锁: 取锁时机", () => {
     expect(await lockFilesRemaining(root)).toEqual([]);
   });
 
+  it("携带条目合入本次快照时指纹按本次规划重新打戳,不背着产出它那一轮的旧指纹", async () => {
+    const evalId = "carry-restamp-eval";
+    const experimentId = "carry-restamp-exp";
+    const evalDef = makeEval(evalId, async () => {
+      throw new Error("carried attempt must not be dispatched");
+    });
+    const base = {
+      agent: makeAgent("agent-carry-restamp"),
+      runs: 1,
+      earlyExit: true,
+      sandbox: fakeSandboxSpec(),
+      timeoutMs: 5_000,
+      selectedEvalIds: [evalId],
+      experimentId,
+    };
+    // 上一轮的 endpoint 与本轮不同,但它声明成 provenance flag:结果照常携带,
+    // 而它落盘的指纹是**整袋 flags**(含旧 endpoint)算的,与本轮规划的那个不相等。
+    const oldFlags = { endpoint: "https://old.example" };
+    const agentRun: AgentRun = { ...base, flags: { endpoint: "https://new.example" }, provenanceFlags: ["endpoint"] };
+    const oldFingerprint = await computeFingerprint(evalDef, { ...base, flags: oldFlags });
+    const plannedFingerprint = await computeFingerprint(evalDef, agentRun);
+    expect(oldFingerprint).not.toBe(plannedFingerprint);
+
+    const prior: EvalResult = {
+      id: evalId,
+      experimentId,
+      agent: agentRun.agent.name,
+      verdict: "passed",
+      attempt: 0,
+      fingerprint: oldFingerprint,
+      experiment: { flags: oldFlags, runs: 1, earlyExit: false, selectedEvalIds: [evalId] },
+      startedAt: new Date().toISOString(),
+      durationMs: 1,
+      assertions: [],
+    };
+
+    const { summary } = await runWithPriorResults([evalDef], [agentRun], { priorResults: [prior] });
+
+    expect(summary.results).toHaveLength(1);
+    expect(summary.results[0]!.verdict).toBe("passed");
+    expect(summary.results[0]!.fingerprint).toBe(plannedFingerprint);
+  });
+
   it("等锁用例不触发实验级 setup:等待期间 setup 计数保持 0,接管后才恰好执行一次", async () => {
     vi.useFakeTimers();
     try {

package/src/runner/run.ts

@@ -133,10 +133,23 @@ export async function runEvals(opts: RunOptions): Promise<InvocationSummary> {
   // 等),判定本身不可信,必须重跑。跳过/fingerprint 不匹配同样重跑。--force 跳过此逻辑
   // (cli.ts 在 --force 时不传 priorResults,也不算 carryPlan)。
   // carryPlan 优先用调用方(cli.ts,为了 live 表格)已经算好的那份,不重算一遍。
-  const { plannedFingerprints, carriedAttemptsByKey, carriedResults } =
+  const { plannedFingerprints, acceptableFingerprints, carriedAttemptsByKey, carriedResults: planCarriedResults } =
     opts.carryPlan ??
     (await planCarry(opts.evals, opts.agentRuns, opts.priorResults, opts.config.sandbox, opts.config.timeoutMs));
 
+  /**
+   * 携带条目合入本次快照时,指纹按**本次**口径重新打戳。携带的含义就是「这条已落盘的结果对
+   * 本次规划的输入依然成立」,那它在新快照里就该带本次的指纹——否则携带条目会一直背着产出
+   * 它那一轮的指纹漂下去,而新快照记的是本轮的 `ExperimentRunInfo.flags`,两者对不上,
+   * 下一轮的反事实重算(见 fingerprint.ts 的 `acceptableFingerprints`)就得靠翻更早的快照
+   * 才能对上号。判定面不受影响:能走到这里,说明这条已经过了携带资格判据。
+   */
+  const restampCarried = (r: EvalResult): EvalResult => {
+    const fp = plannedFingerprints.get(`${r.experimentId ?? ""}|${r.id}`);
+    return fp === undefined || fp === r.fingerprint ? r : { ...r, fingerprint: fp };
+  };
+  const carriedResults = planCarriedResults.map(restampCarried);
+
   // 展开 attempts
   // 外层按「round」(run index)迭代,内层按 eval 迭代:同一 key 的第 i+1 次 attempt 排在
   // 所有 eval 的第 i 次之后,earlyExit 开启时第 0 轮通过的 eval,其后续轮大多还没入池就被跳过。
@@ -1053,9 +1066,9 @@ export async function runEvals(opts: RunOptions): Promise<InvocationSummary> {
    * + 用例锁的状态下做的,per-case 的问题("这条用例现在还缺哪些 attempt")不能用全根扫描去
    * 回答——实测 110 ms/条 vs 0.3 ms/条,后者才付得起「每次取锁都重查」。
    *
-   * 判据不重跑 `planCarry`:本次 Invocation 的 `plannedFingerprints` 整场是常量,重查只需要
-   * 逐条 attempt 过 `carriableAttempts`(终态 + 指纹相等 + durationMs ≤ resolved timeoutMs),
-   * 与静态规划共用同一个函数。
+   * 判据不重跑 `planCarry`:本次 Invocation 的 `acceptableFingerprints` 整场是常量,重查只需要
+   * 逐条 attempt 过 `carriableAttempts`(终态 + 指纹在可携带集合里 + durationMs ≤ resolved
+   * timeoutMs),与静态规划共用同一个函数。
    */
   const recheckCarry = async (
     st: CaseLockState,
@@ -1076,7 +1089,7 @@ export async function runEvals(opts: RunOptions): Promise<InvocationSummary> {
       const carried = carriableAttempts(
         freshPrior,
         key,
-        plannedFingerprints.get(key),
+        acceptableFingerprints.get(key),
         resolvedTimeoutMsForCarry(a0.run, a0.evalDef, opts.config.timeoutMs),
       );
       for (const r of carried) {
@@ -1084,7 +1097,7 @@ export async function runEvals(opts: RunOptions): Promise<InvocationSummary> {
         st.pending.delete(r.attempt);
         st.carried.add(r.attempt);
         newlyCarried.push(r.attempt);
-        lateCarriedResults.push(r);
+        lateCarriedResults.push(restampCarried(r));
         if (r.verdict === "passed") {
           passedKeys.add(`${experimentId}|${a0.run.agent.name}|${a0.run.model ?? ""}|${evalId}`);
         }

package/src/runner/types.ts

@@ -525,6 +525,21 @@ export interface ExperimentDef {
    *  (defineExperiment 解析时校验,非 JSON 直接报错),经 ctx.flags 透传给 adapter、
    *  t.flags 暴露给 eval,并原样进入结果快照的 ExperimentRunInfo.flags。 */
   flags?: Record<string, JsonValue>;
+  /**
+   * `flags` 里只作为**出处记录**的键名:照常落盘、照常透给 `ctx.flags` / `t.flags`,但不参与
+   * 可比性配置——值变了不作废任何已有结果,已跑完的照常携带(carry)。
+   *
+   * 给的是「每次跑都可能换、但换了不改变 attempt 里发生什么」的坐标:隧道 / 反向代理 URL、
+   * 服务端实例地址、跑批时刻这类。它们要留在 `flags` 里(报告要按 `flag()` 看这轮连的是哪个,
+   * eval 或 adapter 也可能要读),又不该像 `webResearch: true → false` 那样让缓存全部失效。
+   *
+   * 声明前跑出来的结果同样携带得到:携带判定按快照记下的历史 flags 做一次反事实重算,
+   * 确认差异完全落在这些键上(见 `runner/fingerprint.ts` 的 `acceptableFingerprints`)。
+   * 键不必存在于 `flags` 里——把一个键从 `flags` 移走时留着这条声明,历史结果照样不作废。
+   *
+   * 完全不需要在运行时被看见的事实用 `labels`,那是报告侧坐标(本来就不进指纹)。
+   */
+  provenanceFlags?: readonly string[];
   /**
    * 报告归类标注:实验在各对比轴上的坐标(如 `{ line: "codex", memory: "mempal" }`)。
    * 值域 string | number(解析时校验)。与 `flags` 的分界是「会不会改变 attempt 里发生的事」:
@@ -698,6 +713,8 @@ export interface AgentRun {
   model?: string;
   reasoningEffort?: string;
   flags: Record<string, JsonValue>;
+  /** 只作为出处记录、不进指纹的 flag 键(来自 ExperimentDef.provenanceFlags);见该字段说明。 */
+  provenanceFlags?: readonly string[];
   runs: number;
   earlyExit: boolean;
   sandbox?: SandboxOption;
@@ -841,8 +858,14 @@ export interface ActiveAttempt {
   /** 展示 label,等价 `runWho()` 的结果;渲染要用,但绝不作为 identity/key。 */
   who: string;
   phase: LifecyclePhase;
-  /** 进入当前 phase 的墙钟时间(epoch ms),用于渲染阶段耗时;每次 phase 变化都会更新。 */
-  phaseStartedAt: number;
+  /**
+   * 这条 attempt 被派发的墙钟时间(epoch ms,取 `attempt:start` 的 `at`)—— active 行时间列的
+   * **唯一**基准,`attempt:phase` 不得改写它:live 面板不做 spinner 动画,存活性完全由这一列
+   * 持续增长证明(见 docs/feature/experiments/cli.md「active 行的列序」),一列会归零的时间既
+   * 证明不了存活,也让人误以为这条 eval 重跑了。阶段各自的耗时不进这里——它由结果的
+   * `timing.phases` 完整落盘,live 面板要回答的是「这条还活着吗、跑了多久、正在干什么」。
+   */
+  startedAt: number;
   detail?: string;
 }
 

package/src/view/data.ts

@@ -22,7 +22,7 @@ import {
 } 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 { EvalResult, JsonValue } from "../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";
@@ -163,8 +163,39 @@ export function viewRoot(input?: string): string {
  * 携带条目要能被 view 找回 artifact,这里同时把 artifactBase(相对结果根)拼好(runner 依赖它)。
  */
 export async function loadLatestResultsPerEval(root = ".niceeval"): Promise<EvalResult[]> {
+  return (await loadCarryInputs(root)).results;
+}
+
+/**
+ * 携带规划要的两份输入,一次扫描出齐(`openResults` 会 parse 全根每一个 `result.json`,读两遍不划算):
+ *
+ * - `results` —— 每 `(experimentId, evalId)` 最新一份的 `EvalResult`,口径见 `loadLatestResultsPerEval`。
+ * - `flagBagsByExperiment` —— 该实验**全部历史快照**记下过的 `ExperimentRunInfo.flags`(按内容去重)。
+ *   [provenance flag](../../docs/feature/experiments/library.md) 的反事实重算拿它当候选假设:
+ *   「把 flags 换成这一袋,指纹还相等吗」。候选来自哪个快照不重要——重算相等本身就是证明。
+ *   必须扫全历史而不是只看结果所在的那一份:携带条目原样带着**产出它那一轮**的指纹合入新快照,
+ *   而新快照记的是**本轮**的 flags,两者在坐标轮换后天然对不上;产出那一轮的 flags 只在更早的
+ *   快照里留着。
+ */
+export async function loadCarryInputs(
+  root = ".niceeval",
+): Promise<{ results: EvalResult[]; flagBagsByExperiment: Map<string, Record<string, JsonValue>[]> }> {
   const results = await openResults(root);
   const out: EvalResult[] = [];
+  const flagBagsByExperiment = new Map<string, Record<string, JsonValue>[]>();
+  for (const exp of results.experiments) {
+    const bags: Record<string, JsonValue>[] = [];
+    const seenBags = new Set<string>();
+    for (const snapshot of exp.snapshots) {
+      const flags = snapshot.experiment?.flags;
+      if (flags === undefined) continue;
+      const key = JSON.stringify(Object.entries(flags).sort());
+      if (seenBags.has(key)) continue;
+      seenBags.add(key);
+      bags.push(flags);
+    }
+    if (bags.length > 0) flagBagsByExperiment.set(exp.id, bags);
+  }
   for (const exp of results.experiments) {
     // exp.snapshots 已按新→旧排序;同一快照内先收本轮的 eval id,收完再整体入 claimed,
     // 保证同 (experiment, eval) 的多 attempt 整批取自同一个快照。
@@ -179,7 +210,7 @@ export async function loadLatestResultsPerEval(root = ".niceeval"): Promise<Eval
       for (const id of takenThisSnapshot) claimed.add(id);
     }
   }
-  return out;
+  return { results: out, flagBagsByExperiment };
 }
 
 /**

package/src/view/index.ts

@@ -16,6 +16,7 @@ export {
   ViewInputError,
   incompatibleHint,
   incompatibleViewCommand,
+  loadCarryInputs,
   loadLatestResultsPerEval,
   loadViewScan,
   type IncompatibleRun,