@@ -454,10 +454,11 @@ def evidence() -> SandboxEvidence:
     if publish_code is not None and tracker.last_code:
         final_code_artifact = publish_code(tracker.last_code)
 
+    # 改写过的文件每次运行都会再报一版：取最后一次运行的那份（工作区里就是它）
     metrics_source = next(
         (
             artifact_id
-            for artifact_id, name in tracker.artifact_names.items()
+            for artifact_id, name in reversed(tracker.artifact_names.items())
             if name == "metrics.json"
         ),
         None,
 
@@ -1799,21 +1799,40 @@ def language_env_fingerprint(probe: Mapping[str, Any], language: str) -> dict[st
 )
 
 
+def _artifact_key(ref: Any) -> tuple[str, str]:
+    """产物的同一性：kind + 文件名（引用里只剩 basename，工作区相对路径不在 ArtifactRef 上）。"""
+    name = str(getattr(ref, "uri", "") or "").replace("\\", "/").rstrip("/").rsplit("/", 1)[-1]
+    return str(getattr(ref, "kind", "") or ""), name
+
+
 class _SandboxCapture:
     """节点侧执行证据：最后一次 python_run 的 stdout/指标 + 全部产物 + 最终代码。
 
     sandbox-run-report.v1 不含 stdout 与指标本体（那是产物与断言的事），但
     节点输出（stage_outputs 正文）需要它们——在工具执行器上就地截获，不改
     执行体的报告形状。``code`` 由 publish 回调顺手记下：执行体只回传产物 id，
     节点要把脚本落到工作区固定路径还得有正文。
+
+    产物按 :func:`_artifact_key` 每个只留一份、位置按首次出现：沙盒新建和改写都采集，
+    同一个文件跑几次就报几版，留后一次运行的那版（工作区里就是它）；同一次运行里
+    重名的取第一个。
     """
 
     def __init__(self) -> None:
         self.stdout = ""
         self.metrics: dict[str, Any] = {}
         self.artifacts: list[Any] = []
         self.code = ""
-        self._seen: set[str] = set()
+        self._slots: dict[tuple[str, str], int] = {}
+
+    def add(self, ref: Any) -> None:
+        key = _artifact_key(ref)
+        slot = self._slots.get(key)
+        if slot is None:
+            self._slots[key] = len(self.artifacts)
+            self.artifacts.append(ref)
+        else:
+            self.artifacts[slot] = ref
 
     def observe(self, result: ToolResult) -> None:
         output = result.output or {}
@@ -1827,10 +1846,12 @@ def observe(self, result: ToolResult) -> None:
             if isinstance(candidate, dict):
                 parsed = candidate
         self.metrics = parsed
+        this_run: set[tuple[str, str]] = set()
         for ref in result.artifacts:
-            if ref.artifact_id not in self._seen:
-                self._seen.add(ref.artifact_id)
-                self.artifacts.append(ref)
+            key = _artifact_key(ref)
+            if key not in this_run:
+                this_run.add(key)
+                self.add(ref)
 
 
 def _sandbox_tool_executor(
@@ -1913,7 +1934,7 @@ def publish(code: str) -> str:
             media_type,
             ctx.step_id,
         )
-        capture.artifacts.append(ref)
+        capture.add(ref)
         return ref.artifact_id
 
     return publish
@@ -2078,8 +2099,8 @@ def _execute_cleaning(
     ) -> tuple[dict[str, Any], list[Any]]:
         """清洗沙盒（子代理）→ 验收通过后进生成者-评审者环；返回 (cleaning, 产物引用)。
 
-        产物引用取所有波的并集：修复波只重写 cleaned/ 同名文件，沙盒按「新建文件」
-        捕获产物，首波的清洗数据引用不能因为修复而丢。
+        产物引用取所有波的并集（:func:`_union_artifacts`）：修复波常只重写 cleaned/ 同名文件，
+        同名只留采用波那份，首波独有的清洗数据引用不能因为修复而丢。
         """
         def skipped(reason: str) -> tuple[dict[str, Any], list[Any]]:
             return {"executed": False, "reason": reason}, []
@@ -2419,21 +2440,28 @@ def _impact_stats_check(evidence) -> tuple[bool, str]:
 def _union_artifacts(
     waves: Sequence[_SandboxCapture], adopted: _SandboxCapture | None
 ) -> list[Any]:
-    """所有波的产物引用并集（按出现顺序、uri 去重），未被采用那些波的脚本除外。
+    """所有波的产物引用并集：同一产物（:func:`_artifact_key`）只留一份，位置按首次出现。
 
-    沙盒按「新建文件」捕获产物：修复波只重写同名文件时不会再报一次，首波产出的
-    数据 / 结果文件引用要留下来；脚本（kind=code）只留最终**采用**那一波的（僵持
-    时采用的可能不是最后一波）——其余版本在各波验收报告 ``final_code_artifact``
-    里仍可追溯。
+    修复波常重写首波的同名结果文件 / 图，沙盒每波都会再报一次：采用的那一波有就用它的
+    那版（和采用的指标对得上），没有就用最后一波的；只有首波产出过的数据 / 结果文件照样
+    留下。脚本（kind=code）只留最终**采用**那一波的（僵持时采用的可能不是最后一波）——
+    其余版本在各波验收报告 ``final_code_artifact`` 里仍可追溯。
     """
-    seen: set[str] = set()
     merged: list[Any] = []
+    slots: dict[tuple[str, str], tuple[int, bool]] = {}
     for capture in waves:
+        from_adopted = capture is adopted
         for ref in capture.artifacts:
-            if ref.uri in seen or (ref.kind == "code" and capture is not adopted):
+            if ref.kind == "code" and not from_adopted:
                 continue
-            seen.add(ref.uri)
-            merged.append(ref)
+            key = _artifact_key(ref)
+            slot = slots.get(key)
+            if slot is None:
+                slots[key] = (len(merged), from_adopted)
+                merged.append(ref)
+            elif from_adopted or not slot[1]:
+                merged[slot[0]] = ref
+                slots[key] = (slot[0], from_adopted)
     return merged
 
 
@@ -3389,7 +3417,7 @@ def stage_for_review(current: _SandboxCapture) -> None:
             script_path = staged["path"]
         else:
             script_path = _stage_final_script(ctx, services, capture.code, language)
-        # 所有波的产物并集：修复波重写同名结果文件时沙盒不再报新建，首波引用要留
+        # 所有波的产物并集：同名只留采用波那份，首波独有的引用要留
         artifacts = _union_artifacts(waves, capture)
 
         return NodeResult.succeeded(
@@ -4740,8 +4768,8 @@ def _figures_rendered_check(
 ):
     """断言：规划的每张图都在工作区 ``directory`` 下、被采集为非空 figure 产物。
 
-    看的是本波节点侧累计采集（沙盒只采集每次运行**新建**的文件：重画同名文件不会
-    再次采集，所以修复波换 ``figures/revN/`` 目录、只看最后一次运行会误判）。
+    看的是本波节点侧累计采集：一波里可能分几次运行才画完，只看最后一次运行会漏掉
+    早先画好的图；盘上有文件但本波没新建或改写过它（上一波 / 上一轮留下的）不算。
     """
 
     def check(evidence) -> tuple[bool, str]:
@@ -4755,7 +4783,7 @@ def check(evidence) -> tuple[bool, str]:
             if f"{directory}{name}" not in files:
                 problems.append(f"{name} 未保存到 {directory}")
             elif name not in captured:
-                problems.append(f"{name} 未被采集为非空图件产物（须由本次 python_run 新建、≥ {_PAPER_FIGURE_MIN_BYTES} 字节）")
+                problems.append(f"{name} 未被采集为非空图件产物（须由本波运行新建或改写、≥ {_PAPER_FIGURE_MIN_BYTES} 字节）")
         if problems:
             return False, "；".join(problems)
         return True, f"{len(expected)} 张图已渲染并采集：{'、'.join(expected)}"
@@ -5291,8 +5319,8 @@ def skipped(reason: str) -> _PaperFigureResult:
         def sandbox_wave(brief_suffix: str | None, max_runs: int) -> _SandboxWaveResult | None:
             """一次经监督者派发的补图沙盒波（首波 / 按审稿或静态检查意见修复）。
 
-            修复波换目录 ``figures/rev<N>/``：沙盒只采集**新建**文件，重画同名文件不会再次
-            采集，也就没法把修好的图当产物登记；文件名不变、目录带轮次，清单仍按 basename 记。
+            修复波换目录 ``figures/rev<N>/``：上一波的图原样留在盘上，僵持回落到上一波时盘上
+            文件与采用的产物仍是同一版；文件名不变、目录带轮次，清单仍按 basename 记。
             """
             wave_no["count"] += 1
             directory = _PAPER_FIGURE_DIR if wave_no["count"] == 1 else f"{_PAPER_FIGURE_DIR}rev{wave_no['count']}/"
@@ -5302,7 +5330,7 @@ def sandbox_wave(brief_suffix: str | None, max_runs: int) -> _SandboxWaveResult
             if wave_no["count"] > 1:
                 brief += (
                     f"\n\n本波修复请把全部图保存到 `{directory}` 目录（文件名不变；"
-                    "沙盒只采集新建文件，覆盖旧文件不算重新渲染）。"
+                    "上一波的图不要覆盖）。"
                 )
             if brief_suffix:
                 brief += "\n\n" + brief_suffix
 
@@ -6,7 +6,7 @@
 - a scrubbed environment (small Windows-safe allowlist; no user secrets),
 - a hard wall-clock timeout with process kill,
 - capped stdout/stderr capture,
-- automatic artifact capture of files the code creates in the workspace.
+- automatic artifact capture of files the code creates or rewrites in the workspace.
 
 The subprocess runs with cwd at the WORKSPACE ROOT, not the per-step script
 directory: every other surface the model sees (ws_list/ws_read/ws_write,
 
@@ -1,8 +1,8 @@
 """多语言 Runner（设计 §7.4，H7 切片 1）：统一 ``code_run`` 入口按 ``language`` 分发。
 
 统一执行契约（§7.4，语言中立）：脚本落到 ``steps/<step_id>/<main.ext>``、子进程
-cwd = 工作区根、环境白名单、超时杀进程、stdout / stderr 截断、新建文件按后缀
-归类采集为产物；指标协议同样语言中立——脚本自己打印 ``OMM_METRICS_JSON: {...}``
+cwd = 工作区根、环境白名单、超时杀进程、stdout / stderr 截断、新建或改写的文件
+按后缀归类采集为产物；指标协议同样语言中立——脚本自己打印 ``OMM_METRICS_JSON: {...}``
 行 / 落 ``metrics.json``，执行核不解析（那是执行体与节点的事）。
 
 每语言一个 :class:`LanguageSpec`（启动命令、脚本名、可执行文件候选、额外需要
@@ -622,6 +622,17 @@ def artifact_kind(name: str) -> str:
     return KIND_BY_SUFFIX.get(os.path.splitext(name)[1].lower(), "other")
 
 
+def _file_states(root: Path) -> dict[Path, tuple[int, int]]:
+    """``root`` 下每个文件的（大小, 修改时间 ns）：运行前后各取一次，新出现或变了的就是本次产物。"""
+    states: dict[Path, tuple[int, int]] = {}
+    for path in root.rglob("*"):
+        with contextlib.suppress(OSError):
+            if path.is_file():
+                stat = path.stat()
+                states[path] = (stat.st_size, stat.st_mtime_ns)
+    return states
+
+
 def clip_output(text: str, limit: int = OUTPUT_LIMIT) -> str:
     if len(text) > limit:
         return text[:limit] + f"\n...(+{len(text) - limit} chars truncated)"
@@ -634,7 +645,9 @@ class SubprocessRunner:
     与 python_run 的历史行为逐字节一致（PythonSandbox 现在只是它的薄壳）：脚本写到
     ``steps/<step_id>/<script_name>``、cwd = 工作区根（ws_* / 断言 / 下发数据都说
     工作区相对路径，生成代码里的相对路径必须落到同一个根）、快照在写脚本之后
-    （脚本本身不算产物）、扫全工作区（代码可在根下任意位置建文件）。
+    （脚本本身不算产物）、扫全工作区（代码可在根下任意位置建文件）。快照记每个文件的
+    大小与修改时间，新建和改写都算本次产物：回退重做那一轮重写上一轮同名的图 / 结果表，
+    只认新建就采集不到。
     """
 
     def __init__(
@@ -684,7 +697,7 @@ def run(
         )
 
         scan_root = self._workspace.root
-        before = {path for path in scan_root.rglob("*") if path.is_file()}
+        before = _file_states(scan_root)
 
         completed = run_process_tree(
             self.spec.command(executable, str(script_path)),
@@ -722,16 +735,14 @@ def run(
         return ToolResult(status="succeeded", output=output, artifacts=tuple(artifacts))
 
     def _collect_artifacts(
-        self, scan_root: Path, before: set[Path], ctx: ToolCallContext
+        self, scan_root: Path, before: dict[Path, tuple[int, int]], ctx: ToolCallContext
     ) -> tuple[list[ArtifactRef], list[str]]:
         artifacts: list[ArtifactRef] = []
         skipped: list[str] = []
-        created = sorted(
-            path
-            for path in scan_root.rglob("*")
-            if path.is_file() and path not in before
+        changed = sorted(
+            path for path, state in _file_states(scan_root).items() if before.get(path) != state
         )
-        for path in created:
+        for path in changed:
             if len(artifacts) >= MAX_ARTIFACTS:
                 skipped.append(f"{path.name} (artifact limit {MAX_ARTIFACTS})")
                 continue