Fix the review's four findings in the VISOR v1.1 acceptance tools

9 files rewritten, 0 added; the release's file set is unchanged (35726 paths).

Every finding is a checker gap or an evidence-overwrite path, not a defect in the published data. verify now resolves each contact relation target in the same frame (identity, name and source string), pins the raw archive identity for full runs, refuses an empty selection/census, and compares the complete source attribute set; validate and read_sequence apply the same relation and attribute checks. Non-formal runs can no longer write the publication manifest, the acceptance report, the review pages or the reader sweep. Defect-injection regression suite: tmp/visor-tools/test_v1_1_review_fixes.py (24 cases). Acceptance steps 2-8 re-run: data/** byte-identical, 0 files added or deleted.

Co-Authored-By: Claude Code <noreply@anthropic.com>

EPIC-KITCHENS-VISOR/shared-v1.1/doc/FULL_MIGRATION_SUMMARY.json

@@ -1,7 +1,7 @@
 {
   "phase": "local_finalized_not_uploaded",
   "completed_views": 179,
-  "created_utc": "2026-10-17T04:49:39.044050+00:00",
+  "created_utc": "2026-10-20T05:54:00.964996+00:00",
   "dataset_id": "EPIC-KITCHENS-VISOR",
   "release_id": "shared-v1.1",
   "final_root": "/data1/yanghonglei/Datasets/hand-warehouse/EPIC-KITCHENS-VISOR/shared-v1.1",
@@ -101,11 +101,11 @@
       "script/provenance/operations/build_visor_docs.py": "5a3e45bc7957975444f41b58dc84ca63b877312769f8d7c54ede22e5c631dc9e",
       "script/visor_v1_1/convert.py": "edf64d192966167b4598ab6840ca458948e27f415c25c752e211d3229c26612b",
       "script/visor_v1_1/media.py": "f6372167e59fe2be1d8786fd14aee5c3edfe8297d9d126848a09d2adab485650",
-      "script/visor_v1_1/read_sequence.py": "24489f7b99398045af6dc84bc4f6691ee9e2e2e0b33c63548d99a9a712a248bc",
-      "script/visor_v1_1/render.py": "b11ac823138bd5cb44aaa3c55e463ede97a810d8750a97afd64c9c7c42e3c554",
-      "script/visor_v1_1/validate.py": "22a805a6a521a85039d0808e6fdf747a7d2c09cbd56024da4a5f64f8d96cad53",
-      "script/visor_v1_1/verify.py": "0a70793b23214fd4d75f253e6ed46928f7e4aa2c94e2b13ec3e7a84d15e348a2",
-      "script/visor_v1_1/visor_common.py": "e5a382a38430f487e27196fa0a8fa3e4c1bfe3a3e8aafad77b8b20c9d8c06ae6",
+      "script/visor_v1_1/read_sequence.py": "91617a19aeda714b3e71164b62be6693c9d26c7f765d19ec078af21b24ce0c14",
+      "script/visor_v1_1/render.py": "f1d15c10839a46aae35f910dc54563c90762f1d711f764a8de28b321969f6659",
+      "script/visor_v1_1/validate.py": "613678ea8ec9f8e4d48e1e6db9a2e1c0f2ca3f8f4f5df738843925b23819c40b",
+      "script/visor_v1_1/verify.py": "e3722458a600bf0cd84c21c5a9ad357ace95d8fa2107a598e22bdf330e52d4c7",
+      "script/visor_v1_1/visor_common.py": "7ca3958f0c28b25ddb5649439e24c9acbe4ab55559c42d9f157e12d940b56366",
       "script/visor_v1_1/warehouse.py": "fe62f79f9228475e23764d57c923e781422951ad5ed6680337bf67e120a63db2"
     },
     "release_spec": {
@@ -199,7 +199,7 @@
   "source_files": 1,
   "source_bytes": 30572126007,
   "target_files": 35725,
-  "target_bytes": 20364233254,
+  "target_bytes": 20364259941,
   "tree_totals_scope": "source_files/source_bytes are the one deposit archive the release was converted from (the archive is the source; no v1.0 tree exists). target_files counts every release file except this one, and target_bytes their bytes, with bytecode caches (__pycache__/) excluded exactly as the release manifest excludes them. The manifest is built last, so it also covers what is written after this line: its entry count is target_files plus manifest_extra_files.count, and its byte total exceeds target_bytes by this file plus the size deltas of the files rewritten after it (doc/validation/validate_report.json, which step 8 rewrites on both paths, and doc/CONTRACT.md, which step 7 rewrites from the canonical spec plus this dataset's section -- on a first full run the doc set does not exist yet, so its whole size is the delta). The review pages are rendered in step 5, before this file, so they are on both sides of that comparison",
   "manifest_extra_files": {
     "count": 1,
@@ -451,7 +451,7 @@
     },
     "failed": [],
     "passed": true,
-    "wall_seconds": 128.58,
+    "wall_seconds": 175.53,
     "tool": "script/visor_v1_1/read_sequence.py",
     "driver": "tmp/visor-tools/read_sequence_sweep.py (outside the release)",
     "scope": "shared-v1.1 read through the released reader over its declared paths; RGB demuxed and first/last frame decoded, no polygon compared and no mask judged; the raw deposit is not opened here"

EPIC-KITCHENS-VISOR/shared-v1.1/doc/PUBLICATION_PLAN.md

@@ -37,13 +37,13 @@
 
 - **只新增 `EPIC-KITCHENS-VISOR/shared-v1.1/`**：`data/`（179 个视图）+ `script/visor_v1_1/`（含 `spec/` 原件）+ `doc/`。`raw/` 与其他数据集路径**一字不动**。
 - 媒体是**源 JPEG 码流的原样封装**（`media.py` 的包级 stream copy，不重编码、不缩放、不旋转），179 个视图的 `observation/rgb.mkv` 合计约等于源那 179 个帧图 zip 的未压缩字节 19,223,392,600 B。数值侧**零 bundle**：本发布唯一的 `.pt` 是逐帧独立有效性（`rgb_valid.pt`、`segment/mask_valid.pt`、`contact/relations_valid.pt`）。
-- **LFS 跟踪行**：仓库既有的 `.gitattributes` 已有通用 glob `*.zip`、`*.pt`、`*.png`、`*.jpg`（raw 整包与全部 `*_valid.pt` 因此已被覆盖），但 `*.mkv` **不是**通用 glob——每个带媒体的数据集各有一行 `<dataset>/shared-v1.1/**/*.mkv`。所以本次需要补**一行**：
+- **LFS 跟踪行**：仓库既有的 `.gitattributes` 已有通用 glob `*.zip`、`*.pt`、`*.png`、`*.jpg`（raw 整包与全部 `*_valid.pt` 因此已被覆盖），但 `*.mkv` **不是**通用 glob——每个带媒体的数据集各有一行 `<dataset>/shared-v1.1/**/*.mkv`。本次手工补的是这一行：
 
   ```
   EPIC-KITCHENS-VISOR/shared-v1.1/**/*.mkv filter=lfs diff=lfs merge=lfs -text
   ```
 
-  `doc/`、`script/` 与全部 JSON/JSONL/HTML 走普通 git（这些扩展名不在 LFS 里），逐字节可比、可 diff。
+  但这**不是**分支上的全部 VISOR 行：实测 PR 分支的 `.gitattributes` 有 **27** 条 VISOR 行 = 上面 1 条 MKV glob + Hub 在推送后自动追加的 **26** 条逐路径行（23 个 `annotation/segment/polygons.jsonl` + 3 个复核页 HTML，都是 >10 MiB、现有 glob 覆盖不到的文件）。`script/`、`.json` 与低于 10 MiB 的 JSONL/HTML 走普通 git，逐字节可比、可 diff；超过 10 MiB 的 JSONL/HTML 由 Hub 以**逐路径** LFS 跟踪。这 3 个复核页在普通克隆里是 LFS 指针，所以本轮**不**以它们作完整视觉验收依据（页面在带 LFS 的检出里可正常查看）。这份计划最初只写了「补一行」，是当时的计划而非事后实测，现按实测更正。
 - **发布清单不是发布内容**：它按已发布 H2O、dex-ycb 的约定保存在发布树**之外**的 `tmp/visor-tools/PUBLISH_MANIFEST.json`（树内副本无法描述自己的最终字节，见 `script/visor_v1_1/README.md` 的「收尾验收顺序」）。清单在最后一步由 `validate.py` 生成，覆盖它之前落盘的每一份最终字节。
 
 ## 工具链与验收顺序

EPIC-KITCHENS-VISOR/shared-v1.1/doc/validation/read_sequence_sweep.json

@@ -26,7 +26,7 @@
   "view_types": [
     "ego"
   ],
-  "wall_seconds": 128.58,
+  "wall_seconds": 175.53,
   "accepted": true,
   "failed": [],
   "records": [

EPIC-KITCHENS-VISOR/shared-v1.1/script/visor_v1_1/README.md

@@ -178,7 +178,7 @@ python shared-v1.1/script/visor_v1_1/validate.py --expect-views 179 --rewrite-ch
 - **许可证在源里就不一致，如实并列。** `README.txt` 声明 CC BY-NC 4.0，而同一份 `.info.json` 声明 Non-Commercial Government Licence。发布文档把两者并列写出，不替数据源选一个（记录在 `VISOR-deposit-record.json` 的 `declared_license`）。
 - **源自己的两处不干净，原样保留、不做清洗。** `on_which_hand` 在源里是列表或字符串两种类型，且存在官方拼写错误 `["left hand", "rigth hand"]`（13 条，`right` 拼成 `rigth`）；另有 34 条直接写字符串 `"inconclusive"`。这些都在 `instances.jsonl` 的 `source_attributes` 里逐字保留——清洗会改语义。
 - **状态标志的含义要按字面读。** 逐视图的 `pilot: false`、`pilot_complete: true`、`pilot_human_review: "not_applicable"` 说的是本数据集没有派洛特阶段（没有过一版部分发布）；`production_complete: true` 说的是「这个视图来自生产转换、不是试跑产物」，不是「整个发布已经验收完成」；发布级状态在汇总与清单里。`full_output_human_review` 仍是 `"pending"`、`upload_authorized` 仍是 `false`——人工真看过之前一个字都不改。
-- **反向对照（往副本里注入缺陷、确认校验器逐条具名抓到）还没有做。** ARCTIC 有一份 `negative_controls.txt`，本数据集目前没有。这里的对应证据是 `verify.py` 对 raw 档案本身的源真值比对——它读真实源字节、不是自证——但那证明的是「转换忠实」，不证明「校验器的检查不空转」。要做就做成往硬链接副本里注入缺陷、逐项确认具名失败的脚本，跑完再并入 `doc/validation/`。
+- **反向对照已补（PR #9 审查后）。** ARCTIC 有一份 `negative_controls.txt`；本数据集的对应物是**树外**的缺陷注入套件 `tmp/visor-tools/test_v1_1_review_fixes.py`（不随发布，因为它要改写发布副本）。它逐条复现审查提出的四个缺陷——接触目标错配、空归档/空选择被当成完整验收、源属性丢失、局部运行覆盖正式证据——并断言校验器**具名失败**；每组都用「未注入应通过、注入后必须失败」的正反例。`verify.py` 对 raw 档案的源真值比对证明「转换忠实」，这套件证明「检查器不空转」，两者不能互相替代。
 
 ## 证据
 

EPIC-KITCHENS-VISOR/shared-v1.1/script/visor_v1_1/read_sequence.py

@@ -246,13 +246,14 @@ def read_view(view: Path, table: dict) -> dict:
                     problem(f"rgb: decoded {list(shape[:2])}, storage declares {encoded}")
 
     #: the per-frame tables, which only an annotated view has
-    frame_entities, objects = {}, set()
+    frame_entities, frame_labels, objects = {}, {}, set()
     if (components.get("segment") or {}).get("available", False):
-        frame_entities, objects = check_segment(view, meta, rows, table, record, problem)
+        frame_entities, frame_labels, objects = check_segment(
+            view, meta, rows, table, record, problem)
     elif (view / "annotation" / "segment").exists():
         problem("segment: not declared available but annotation/segment/ exists")
     if (components.get("relations") or {}).get("available", False):
-        check_relations(view, meta, rows, frame_entities, record, problem)
+        check_relations(view, meta, rows, frame_entities, frame_labels, record, problem)
     elif (view / "annotation" / "contact").exists():
         problem("relations: not declared available but annotation/contact/ exists")
     if (view / POLYGONS_REF).is_file() and not frame_entities:
@@ -318,8 +319,8 @@ def check_segment(view: Path, meta: dict, rows: list, table: dict, record: dict,
     if not (len(polygons) == len(instances) == frames):
         problem(f"segment: {len(polygons)} polygon rows and {len(instances)} instance rows "
                 f"for {frames} frames")
-        return {}, set()
-    frame_entities, objects = {}, set()
+        return {}, {}, set()
+    frame_entities, frame_labels, objects = {}, {}, set()
     shapes_total = 0
     for index, (shape_row, label_row) in enumerate(zip(polygons, instances)):
         if shape_row.get("frame_index") != index or label_row.get("frame_index") != index:
@@ -338,6 +339,7 @@ def check_segment(view: Path, meta: dict, rows: list, table: dict, record: dict,
         subsequence = (rows[index].get("source_locator") or {}).get("subsequence") \
             if index < len(rows) else None
         frame_entities[index] = set()
+        frame_labels[index] = {}
         for label, shape in zip(labels, shapes):
             attributes = label.get("source_attributes") or {}
             name = attributes.get("name")
@@ -363,6 +365,12 @@ def check_segment(view: Path, meta: dict, rows: list, table: dict, record: dict,
                         f"the (subsequence, entity name) identity {expected!r}")
             if label.get("entity_id"):
                 frame_entities[index].add(label["entity_id"])
+            source_id = label.get("source_instance_id")
+            if isinstance(source_id, str):
+                if source_id in frame_labels[index]:
+                    problem(f"segment: frame {index} repeats source instance {source_id}")
+                frame_labels[index][source_id] = {
+                    "entity_id": label.get("entity_id"), "name": name}
             for ring in shape.get("polygons") or []:
                 shapes_total += 1
                 if not isinstance(ring, list) or len(ring) < 3:
@@ -375,11 +383,11 @@ def check_segment(view: Path, meta: dict, rows: list, table: dict, record: dict,
     record["counts"].update({"rings": shapes_total, "objects": len(objects),
                              "annotated_frames": sum(1 for index in frame_entities
                                                      if frame_entities[index])})
-    return frame_entities, objects
+    return frame_entities, frame_labels, objects
 
 
 def check_relations(view: Path, meta: dict, rows: list, frame_entities: dict,
-                    record: dict, problem) -> None:
+                    frame_labels: dict, record: dict, problem) -> None:
     """The contact table: three states plus "no record", original string preserved."""
     path = view / RELATIONS_REF
     relations = vc.read_jsonl(path) if path.is_file() else []
@@ -416,20 +424,44 @@ def check_relations(view: Path, meta: dict, rows: list, frame_entities: dict,
             elif status == "positive":
                 if not HEX32.match(value):
                     problem(f"relations: frame {frame} positive contact drops the source id")
-                if relation.get("object_id") not in frame_entities.get(frame, set()):
-                    problem(f"relations: frame {frame} target {relation.get('object_id')!r} "
-                            f"does not resolve inside the same frame")
+                #: the row must point at the instance the source id resolves to, not
+                #: merely at some instance that happens to exist in the frame
+                #: (PR #9 review finding 1)
+                target = frame_labels.get(frame, {}).get(value)
+                if target is None:
+                    problem(f"relations: frame {frame} positive target {value!r} is not a "
+                            f"source instance of the same frame")
+                elif relation.get("object_id") != target["entity_id"]:
+                    problem(f"relations: frame {frame} positive target "
+                            f"{relation.get('object_id')!r} is not the source instance's "
+                            f"entity {target['entity_id']!r} ({value})")
             elif vc.CONTACT_STATUS.get(value) != status:
                 problem(f"relations: frame {frame} source string {value!r} means a different "
                         f"state than {status!r}")
             if locator.get("source_frame_name") != rows[frame].get("source_frame_id"):
                 problem(f"relations: frame {frame} names source frame "
                         f"{locator.get('source_frame_name')!r}")
+            if locator.get("source_annotation_index") != rows[frame].get("source_annotation_index"):
+                problem(f"relations: frame {frame} points at source annotation "
+                        f"{locator.get('source_annotation_index')!r}")
             subject = relation.get("subject_id")
             if subject not in frame_entities.get(frame, set()):
                 problem(f"relations: frame {frame} subject {subject!r} is not in that frame")
             elif not is_contact_subject(subject):
                 problem(f"relations: frame {frame} subject {subject!r} is not a hand or glove")
+            source_id = locator.get("source_instance_id")
+            subject_label = frame_labels.get(frame, {}).get(source_id)
+            if subject_label is None:
+                problem(f"relations: frame {frame} does not name a source subject instance "
+                        f"of its own frame ({source_id!r})")
+            else:
+                if subject != subject_label["entity_id"]:
+                    problem(f"relations: frame {frame} subject {subject!r} is not the source "
+                            f"instance's entity {subject_label['entity_id']!r} ({source_id})")
+                if locator.get("subject_entity_name") != subject_label["name"]:
+                    problem(f"relations: frame {frame} subject name "
+                            f"{locator.get('subject_entity_name')!r} is not the source "
+                            f"instance's name {subject_label['name']!r} ({source_id})")
     record["counts"].update({f"contact_{name}": value for name, value in counts.items()})
 
 
@@ -492,6 +524,12 @@ def main(argv=None):
 
     table = load_source_table()
     views = view_dirs(args.root, args.sequence)
+    if not views:
+        raise SystemExit(f"{args.root}/data/{args.sequence} has no view directory: "
+                         "a run over nothing is not a pass")
+    #: 单序列读取器永远不是发布级验收：它的报告不得覆盖正式证据（finding 4）。
+    if args.report is not None:
+        vc.guard_output(args.report, False, set(), "read_sequence")
     records = [read_view(view, table) for view in views]
 
     problems = check_recording(records)
@@ -531,7 +569,7 @@ def main(argv=None):
                  "paths, media included; not visual acceptance, and not an independent "
                  "check against the raw deposit (the converter owns that evidence)",
     }
-    if args.report:
+    if args.report is not None:
         args.report.parent.mkdir(parents=True, exist_ok=True)
         args.report.write_text(json.dumps(report, ensure_ascii=False, indent=2),
                                encoding="utf-8")

EPIC-KITCHENS-VISOR/shared-v1.1/script/visor_v1_1/render.py

@@ -67,9 +67,13 @@ from visor_common import (
     REGISTRY,
     RELEASE_ID,
     RELATIONS_REF,
+    RELEASE_ROOT,
+    TMP_ROOT,
     check_view,
+    guard_directory,
     load,
     read_jsonl,
+    same_path,
     save,
 )
 from warehouse import Registry
@@ -1185,7 +1189,19 @@ def main(argv=None):
         parser.error("at most 8 workers and one decoder thread each")
 
     root = args.root.resolve()
-    destination = (args.out or root / "doc/validation").resolve()
+    #: 发布级复核 = 正式树的抽样运行。``--views`` 是局部重渲：它既不是抽样，也不得
+    #: 默认落进正式复核目录、更不得改写正式报告（PR #9 审查 finding 4）。
+    explicit = args.views is not None
+    formal = same_path(root, RELEASE_ROOT) and not explicit
+    if args.out is not None:
+        destination = args.out.resolve()
+    elif formal:
+        destination = (root / "doc" / "validation").resolve()
+    else:
+        destination = (TMP_ROOT / "render-partial").resolve()
+    #: 在 ProcessPoolExecutor / mkdir 之前判定：局部运行不能借用正式证据目录，
+    #: 别名、符号链接、硬链接都按解析后的实际路径拒绝。
+    guard_directory(destination, formal, {"review pages"}, "render")
 
     allocation = {"test": 2, "val": 4, "train": 6}
     if sum(allocation.values()) != args.reference_sequences:
@@ -1195,7 +1211,7 @@ def main(argv=None):
         )
 
     facts = {}
-    if args.views:
+    if explicit:
         views = []
         for token in args.views:
             sequence, _, camera = token.partition("/")
@@ -1278,20 +1294,39 @@ def main(argv=None):
             )
         )
 
-    report = {
-        "review_kind": "全量后抽样",
-        "views": len(views),
-        "sequences": len(sequences),
-        "dataset_id": DATASET_ID,
-        "release_id": RELEASE_ID,
-        "sampling": sampling,
-        "wall_seconds": round(time.monotonic() - start, 3),
-        "decode_scope": DECODE_SCOPE,
-        "reports": reports,
-        "scope": "post-full sampled complete sequences, all cameras (one ego view per "
-                 "sequence), read directly from the release through visor_common.check_view; "
-                 "evidence for human acceptance, not training input; manual review pending",
-    }
+    if explicit:
+        #: 显式选视图的重渲不是发布级复核证据：``review_kind`` 明确区分，且不写
+        #: ``sampling.seed``/``selections``，汇总工具无法把它当成抽样证据。
+        report = {
+            "review_kind": "显式视图重渲",
+            "partial": True,
+            "views": len(views),
+            "sequences": len(sequences),
+            "dataset_id": DATASET_ID,
+            "release_id": RELEASE_ID,
+            "sampling": sampling,
+            "wall_seconds": round(time.monotonic() - start, 3),
+            "decode_scope": DECODE_SCOPE,
+            "reports": reports,
+            "scope": "explicit view re-render; not the release-wide sampled review and not "
+                     "acceptance evidence; manual review pending",
+            "output": str(destination),
+        }
+    else:
+        report = {
+            "review_kind": "全量后抽样",
+            "views": len(views),
+            "sequences": len(sequences),
+            "dataset_id": DATASET_ID,
+            "release_id": RELEASE_ID,
+            "sampling": sampling,
+            "wall_seconds": round(time.monotonic() - start, 3),
+            "decode_scope": DECODE_SCOPE,
+            "reports": reports,
+            "scope": "post-full sampled complete sequences, all cameras (one ego view per "
+                     "sequence), read directly from the release through visor_common.check_view; "
+                     "evidence for human acceptance, not training input; manual review pending",
+        }
     save(destination / "V1_1_VALIDATION.json", report)
 
     links = sorted(p.name for p in destination.glob("*.html") if p.name != "index.html")
@@ -1333,17 +1368,29 @@ def main(argv=None):
         + "</td><td>" + html.escape(str(entry["camera"]["model"])) + "</td></tr>"
         for entry in sorted(reports, key=lambda e: e["sequence_id"])
     )
+    if explicit:
+        heading = "显式视图重渲（非发布证据）"
+        intro = (
+            "<p>本页由 <code>--views</code> 指定的视图生成，只用于复查这些视图；"
+            "它不是发布级抽样复核，也不作为验收证据。抽样规则与入选序列见正式树的 "
+            "<code>doc/validation/V1_1_VALIDATION.json</code>。</p>"
+        )
+    else:
+        heading = "全量后抽样人工复查"
+        intro = (
+            "<p>数值按字节一致（CONTRACT §6 第 2 条）；媒体不重新编码（第 4 条）。本页是第 5 条"
+            "要求的『用新读取器运行代表性完整序列』那一步：抽样规则、种子与每一段被抽中的原因见 "
+            "<code>V1_1_VALIDATION.json</code>，本页所列视图即全部入选视图："
+            + str(len(views)) + " 个视图 / " + str(len(sequences)) + " 段，共抽样 "
+            + str(sampled) + " 帧，其中 " + str(unannotated) + " 段只有 RGB 与帧序（官方测试"
+            "标注未发布）。所有视图都没有相机标定（camera.model=unknown），页面因此不做任何 "
+            "3D 投影，叠加的是源自己的像素多边形。</p>"
+        )
     index = (
         '<!doctype html><html lang="zh"><meta charset="utf-8">'
         "<title>EPIC-KITCHENS-VISOR shared-v1.1 review</title><style>" + index_css + "</style>"
-        "<h1>EPIC-KITCHENS-VISOR shared-v1.1 全量后抽样人工复查</h1>"
-        "<p>数值按字节一致（CONTRACT §6 第 2 条）；媒体不重新编码（第 4 条）。本页是第 5 条"
-        "要求的『用新读取器运行代表性完整序列』那一步：抽样规则、种子与每一段被抽中的原因见 "
-        "<code>V1_1_VALIDATION.json</code>，本页所列视图即全部入选视图："
-        + str(len(views)) + " 个视图 / " + str(len(sequences)) + " 段，共抽样 "
-        + str(sampled) + " 帧，其中 " + str(unannotated) + " 段只有 RGB 与帧序（官方测试"
-        "标注未发布）。所有视图都没有相机标定（camera.model=unknown），页面因此不做任何 "
-        "3D 投影，叠加的是源自己的像素多边形。</p>"
+        "<h1>EPIC-KITCHENS-VISOR shared-v1.1 " + heading + "</h1>"
+        + intro
         + colour_legend()
         + "<p>逐视图页面的每帧面板与逐帧数值都在页面内；抽样帧之外的帧不在页面里。"
         "分割与接触的完整坐标在发布树的 <code>data/&lt;sequence&gt;/ego/annotation/</code> "

EPIC-KITCHENS-VISOR/shared-v1.1/script/visor_v1_1/validate.py

@@ -89,10 +89,10 @@ from visor_common import (  # noqa: E402
 #: The full release's census.  Claims about the *whole* release, so they are asserted on
 #: a full run only; a --views/--limit run checks its own selection and says so in every
 #: place its result is reported.
-EXPECTED_VIEWS = 179
-EXPECTED_SEQUENCES = 179
+EXPECTED_VIEWS = vc.EXPECTED_SOURCE_SEQUENCES
+EXPECTED_SEQUENCES = vc.EXPECTED_SOURCE_SEQUENCES
 EXPECTED_SPLITS = {"train": 115, "val": 43, "test": 21}
-EXPECTED_ANNOTATED_VIEWS = 158
+EXPECTED_ANNOTATED_VIEWS = vc.EXPECTED_SOURCE_ANNOTATED
 
 CONTACT_STATUSES = {"positive", "negative", "target_unannotated", "unknown"}
 #: Measured over every released annotation: only hands and gloves ever carry an
@@ -188,14 +188,16 @@ def check_segment(view_dir, meta, rows, table):
 
     每个标签的 ``entity_id`` 必须与同帧的 ``subsequence`` 加实体名推出的身份一致——
     这是"帧序 / 身份 / 分割"三条线唯一能对上账的地方，也正是 (subsequence, 实体名)
-    这个身份规则的可验证形式。返回 ``({frame_index: {entity_id}}, {object_id})``。
+    这个身份规则的可验证形式。返回
+    ``({frame_index: {entity_id}}, {frame_index: {source_instance_id: label}}, {object_id})``：
+    第二张表让接触关系能按源实例 ID 核对真实目标，而不只是"目标在同帧存在"。
     """
     polygons = read_jsonl(view_dir / POLYGONS_REF)
     instances = read_jsonl(view_dir / INSTANCES_REF)
     valid = torch.load(view_dir / SEGMENT_VALID_REF, map_location="cpu", weights_only=True)
     assert len(polygons) == len(instances) == meta["num_frames"], (
         view_dir, len(polygons), len(instances), meta["num_frames"])
-    frame_entities, objects = {}, set()
+    frame_entities, frame_labels, objects = {}, {}, set()
     for index, (polygon_row, instance_row) in enumerate(zip(polygons, instances)):
         assert polygon_row["frame_index"] == index == instance_row["frame_index"], (view_dir, index)
         labels, shapes = instance_row["labels"], polygon_row["instances"]
@@ -207,6 +209,7 @@ def check_segment(view_dir, meta, rows, table):
         assert bool(valid[index]) == bool(shapes), (
             view_dir, index, "segment validity must be source_annotation_present")
         frame_entities[index] = set()
+        frame_labels[index] = {}
         subsequence = rows[index]["source_locator"].get("subsequence")
         for label, shape in zip(labels, shapes):
             for key in ("mask_value", "category_id", "entity_id", "part_id",
@@ -227,6 +230,11 @@ def check_segment(view_dir, meta, rows, table):
                 view_dir, index, "entity id must follow (subsequence, entity name)",
                 label["entity_id"], expected)
             frame_entities[index].add(expected)
+            assert label["source_instance_id"] not in frame_labels[index], (
+                view_dir, index, "source instance id repeats inside a frame",
+                label["source_instance_id"])
+            frame_labels[index][label["source_instance_id"]] = {
+                "entity_id": expected, "name": name}
             for ring in shape["polygons"]:
                 assert isinstance(ring, list), (view_dir, index, type(ring))
                 for point in ring:
@@ -234,10 +242,10 @@ def check_segment(view_dir, meta, rows, table):
                     assert all(isinstance(value, (int, float)) for value in point), (view_dir, index, point)
                     assert all(value == value and abs(value) != float("inf") for value in point), (
                         view_dir, index, "non-finite polygon coordinate", point)
-    return frame_entities, objects
+    return frame_entities, frame_labels, objects
 
 
-def check_relations(view_dir, meta, rows, frame_entities):
+def check_relations(view_dir, meta, rows, frame_entities, frame_labels):
     """接触关系：三态映射、原始字符串保留、positive 必须同帧可解析。
 
     ``relations.jsonl`` 只为"有源记录"的帧写行，所以它的 ``frame_index`` 是帧范围的子集；
@@ -275,15 +283,40 @@ def check_relations(view_dir, meta, rows, frame_entities):
             assert isinstance(value, str), (view_dir, frame, value)
             if status == "positive":
                 assert HEX32.match(value), (view_dir, frame, "a positive contact keeps the source mask id", value)
-                assert relation["object_id"] in frame_entities[frame], (
-                    view_dir, frame, "a positive target must resolve inside the same frame",
-                    relation["object_id"])
+                #: "target exists in the frame" was not enough: any other instance of the
+                #: same frame passed (PR #9 review finding 1). Resolve the declared source
+                #: instance and compare the entity the row actually points at.
+                target = frame_labels[frame].get(value)
+                assert target is not None, (
+                    view_dir, frame, "a positive contact target must be a source instance "
+                    "of the same frame", value)
+                assert relation["object_id"] == target["entity_id"], (
+                    view_dir, frame, "a positive contact must point at the source target",
+                    relation["object_id"], target["entity_id"], value)
             else:
                 assert vc.CONTACT_STATUS.get(value) == status, (
                     view_dir, frame, "the original string must be preserved verbatim", value, status)
             subject = relation["subject_id"]
             assert subject in frame_entities[frame], (view_dir, frame, subject)
             assert is_contact_subject(subject), (view_dir, frame, "unexpected contact subject", subject)
+            #: the locator names the source subject instance; it must be an instance of
+            #: this same frame and agree with the released subject_id / entity name
+            source_id = locator.get("source_instance_id")
+            assert isinstance(source_id, str) and HEX32.match(source_id), (
+                view_dir, frame, "the locator must name its source subject instance", source_id)
+            subject_label = frame_labels[frame].get(source_id)
+            assert subject_label is not None, (
+                view_dir, frame, "the source subject instance must be an instance of the same frame",
+                source_id)
+            assert subject == subject_label["entity_id"], (
+                view_dir, frame, "subject_id does not match the source subject instance",
+                subject, subject_label["entity_id"])
+            assert locator.get("subject_entity_name") == subject_label["name"], (
+                view_dir, frame, "subject name does not match the source subject instance",
+                locator.get("subject_entity_name"), subject_label["name"])
+            assert locator.get("source_annotation_index") == rows[frame]["source_annotation_index"], (
+                view_dir, frame, "the locator must point at its own frame's source annotation",
+                locator.get("source_annotation_index"), rows[frame]["source_annotation_index"])
             counts[status] += 1
     return counts
 
@@ -394,31 +427,46 @@ def main(argv=None):
                         help=f"do not rebuild the release manifest ({MANIFEST_PATH})")
     args = parser.parse_args(argv)
 
+    #: ``nargs="*"`` 的空列表、``--limit 0`` 都能解析成功，但它们不是"选了东西"；
+    #: 以前会被当成假值→全量运行（PR #9 审查 finding 2）。
+    if args.views is not None and not args.views:
+        parser.error("--views needs at least one view; an empty selection cannot pass")
+    if args.limit is not None and args.limit < 1:
+        parser.error("--limit must be positive")
+
     root = args.root
     if root.resolve() != RELEASE_ROOT.resolve():
-        assert args.views or args.limit, (
+        assert args.views is not None or args.limit is not None, (
             f"--root points at {root}, so pass --views/--limit: the release-wide census "
             "and the release manifest are claims about the adjacent release")
     all_views = sorted((root / "data").glob("*/*/metainfo.json"))
-    wanted = set(args.views) if args.views else None
+    if not all_views:
+        raise SystemExit(f"no views under {root / 'data'}: a run over nothing is not a pass")
+    wanted = set(args.views) if args.views is not None else None
     if wanted is not None:
         known = {view.parent.parent.name for view in all_views}
         assert wanted <= known, ("no such view", sorted(wanted - known))
         views = [view for view in all_views if view.parent.parent.name in wanted]
     else:
         views = all_views
-    if args.limit:
+    if args.limit is not None:
         views = views[: args.limit]
+    if not views:
+        raise SystemExit("the selection resolved to no views: a run over nothing is not a pass")
 
-    full = wanted is None and not args.limit
+    full = wanted is None and args.limit is None
     expect_views = args.expect_views if args.expect_views is not None else (
         EXPECTED_VIEWS if full else len(views))
     full_release_root = root.resolve() == RELEASE_ROOT.resolve()
-    report_path = args.report or (ACCEPTANCE_REPORT if (full and full_release_root) else PARTIAL_REPORT)
-    assert full or report_path.resolve() != ACCEPTANCE_REPORT.resolve(), (
-        f"--report names the release's acceptance report ({ACCEPTANCE_REPORT}), but "
-        "--views/--limit makes this a subset run; drop --report to write "
-        f"{PARTIAL_REPORT} instead, or drop the selection to run the acceptance pass")
+    if full and full_release_root:
+        assert len(all_views) == EXPECTED_VIEWS, (
+            "a release-wide run must see the full census", len(all_views), EXPECTED_VIEWS)
+    formal = full and full_release_root and len(views) == EXPECTED_VIEWS
+    report_path = args.report if args.report is not None else (
+        ACCEPTANCE_REPORT if formal else PARTIAL_REPORT)
+    #: 局部运行（以及任何 --report 别名）都不得覆盖正式验收报告；渲染/校验的默认
+    #: 输出同样先过守卫，��� mkdir/写盘（PR #9 审查 finding 4）。
+    vc.guard_output(report_path, formal, {"validate report"}, "validate")
 
     table = load_source_table()
     counts, sequences, flags = collections.Counter(), {}, {}
@@ -443,13 +491,13 @@ def main(argv=None):
         rows = check_frames(view_dir, meta)
         consumed, fields, _ = check_view(view_dir, meta, REGISTRY)
 
-        frame_entities = {}
+        frame_entities, frame_labels = {}, {}
         objects = set()
         if vc.published(meta["components"], "segment"):
-            frame_entities, objects = check_segment(view_dir, meta, rows, table)
+            frame_entities, frame_labels, objects = check_segment(view_dir, meta, rows, table)
             assert vc.published(meta["components"], "relations"), (
                 path, "an annotated view must also publish its contact records")
-            contact.update(check_relations(view_dir, meta, rows, frame_entities))
+            contact.update(check_relations(view_dir, meta, rows, frame_entities, frame_labels))
         else:
             assert not (view_dir / POLYGONS_REF).exists(), (path, "image-only view has segment files")
             assert not (view_dir / RELATIONS_REF).exists(), (path, "image-only view has relation files")
@@ -525,6 +573,7 @@ def main(argv=None):
         print(json.dumps(result, ensure_ascii=False, indent=2))
         return 0 if result["passed"] else 1
 
+    vc.guard_output(MANIFEST_PATH, formal, {"publication manifest"}, "validate")
     result["release_manifest"] = {
         "path": str(MANIFEST_PATH),
         "in_release_tree": False,

EPIC-KITCHENS-VISOR/shared-v1.1/script/visor_v1_1/verify.py

@@ -26,8 +26,9 @@ What it proves, per view, against real source bytes:
    ``id``, ``class_id`` and the same attribute values including ``exhaustive``,
    ``in_contact_object`` and ``on_which_hand`` -- verbatim, source typos included.
 5. **relations** -- the released rows are exactly the source instances that carry a
-   contact verdict, with the same per-frame status, and every positive target resolves
-   inside its own frame.
+   contact verdict, keyed on the source instance id, with the same per-frame status and
+   source string, and every positive target is the entity that the *declared* source
+   target resolves to -- not merely some instance that happens to exist in the frame.
 6. **metainfo** -- ``num_frames``, ``sampling.type``, the absent calibration and the
    split are the source's own facts, not the converter's choices.
 
@@ -37,6 +38,9 @@ and it is not human visual acceptance (CONTRACT 6.5).
 
 Run: python shared-v1.1/script/visor_v1_1/verify.py --raw raw/data/'EPIC-KITCHENS VISOR.zip'
 A run restricted with ``--views``/``--sample`` is a partial run and says so in its report.
+A *formal* run is one with no selection whose archive matches the published deposit in
+size and SHA-256 and whose census is the published 179 sequences / 158 annotated views;
+anything else is reported as ``partial`` and is never ``accepted``.
 """
 
 from __future__ import annotations
@@ -253,7 +257,9 @@ def check_frames(view, rows, source, mapping, record, problem) -> None:
 
 def check_polygons(view, rows, source, released, record, problem) -> None:
     """Claim 3: the geometry is the source's, to the bit."""
+    bit_ok = True
     if len(released) != len(rows):
+        bit_ok = False
         problem(f"polygons: {len(released)} rows for {len(rows)} frames")
         return
     rings = points = 0
@@ -262,6 +268,7 @@ def check_polygons(view, rows, source, released, record, problem) -> None:
         annotations = source[source_index]["annotations"]
         shapes = polygon_row["instances"]
         if len(shapes) != len(annotations):
+            bit_ok = False
             problem(f"segment: frame {polygon_row['frame_index']} has {len(shapes)} shapes for "
                     f"{len(annotations)} source instances")
             continue
@@ -269,12 +276,14 @@ def check_polygons(view, rows, source, released, record, problem) -> None:
             expected = annotation.get("segments") or []
             actual = shape.get("polygons") or []
             if len(actual) != len(expected):
+                bit_ok = False
                 problem(f"segment: frame {polygon_row['frame_index']} instance "
                         f"{shape.get('mask_value')} has {len(actual)} rings, source {len(expected)}")
                 continue
             for ring_index, (ring, expected_ring) in enumerate(zip(actual, expected)):
                 rings += 1
                 if len(ring) != len(expected_ring):
+                    bit_ok = False
                     problem(f"segment: frame {polygon_row['frame_index']} ring {ring_index} has "
                             f"{len(ring)} points, source {len(expected_ring)}")
                     continue
@@ -282,11 +291,12 @@ def check_polygons(view, rows, source, released, record, problem) -> None:
                     points += 1
                     if len(point) != 2 or bits(point[0]) != bits(expected_point[0]) \
                             or bits(point[1]) != bits(expected_point[1]):
+                        bit_ok = False
                         problem(f"segment: frame {polygon_row['frame_index']} ring {ring_index} "
                                 f"point {point_index} is not the source coordinate")
                         break
     record["polygons"] = {"rows": len(released), "rings": rings, "points": points,
-                          "bit_identical": True}
+                          "bit_identical": bit_ok}
 
 
 def check_instances(view, rows, source, released, record, problem, table) -> None:
@@ -315,16 +325,25 @@ def check_instances(view, rows, source, released, record, problem, table) -> Non
             if label.get("category_id") not in table:
                 problem(f"identity: frame {label_row['frame_index']} class_id is not in the noun table")
             #: the attributes are the source's own keys, with the source's own values --
-            #: including the source's typos; nothing is normalized or added
+            #: including the source's typos; nothing is normalized, added **or dropped**.
+            #: Compare both directions, because iterating only the released keys let a
+            #: converter silently discard ``exhaustive``/``on_which_hand``/
+            #: ``in_contact_object`` (PR #9 review finding 3). ``id`` and ``segments``
+            #: have dedicated fields (``source_instance_id`` / the polygons row) and are
+            #: the only source keys intentionally not repeated here.
             attributes = label.get("source_attributes") or {}
-            for key, value in attributes.items():
-                if key not in annotation:
-                    problem(f"identity: frame {label_row['frame_index']} adds attribute {key!r} "
-                            f"the source does not carry")
-                    continue
-                if annotation[key] != value:
+            expected_attributes = {key: value for key, value in annotation.items()
+                                   if key not in {"id", "segments"}}
+            for key in sorted(set(expected_attributes) - set(attributes)):
+                problem(f"identity: frame {label_row['frame_index']} drops source attribute "
+                        f"{key!r} (source value {expected_attributes[key]!r})")
+            for key in sorted(set(attributes) - set(expected_attributes)):
+                problem(f"identity: frame {label_row['frame_index']} adds attribute {key!r} "
+                        f"the source does not carry")
+            for key in sorted(set(expected_attributes) & set(attributes)):
+                if not vc.same_json(attributes[key], expected_attributes[key]):
                     problem(f"identity: frame {label_row['frame_index']} attribute {key!r} "
-                            f"is {value!r}, source {annotation[key]!r}")
+                            f"is {attributes[key]!r}, source {expected_attributes[key]!r}")
             expected_name = annotation["name"]
             expected = HAND_ENTITY_BY_NAME.get(expected_name) or vc.object_id(expected_name, subsequence)
             if label.get("entity_id") != expected:
@@ -334,36 +353,136 @@ def check_instances(view, rows, source, released, record, problem, table) -> Non
                           "entities": len(entities)}
 
 
+def frame_entity_id(name, subsequence):
+    """源实体名 → 本发布的 entity_id（手映射到固定槽，其余按 ``(name, subsequence)``）。"""
+    return HAND_ENTITY_BY_NAME.get(name) or vc.object_id(name, subsequence)
+
+
 def check_relations(view, rows, source, released, record, problem) -> None:
-    """Claim 5: the rows are exactly the source's verdicts, status by status."""
-    expected = collections.Counter()
+    """Claim 5: the rows are exactly the source's verdicts, subject *and* target.
+
+    Counting ``(frame, subject name, status)`` was not enough: a released row could
+    point at any other instance of the same frame and still match (PR #9 review
+    finding 1). The key here is the source instance id, and every field of the row is
+    compared -- status, raw source value (type-strict), subject id/name, and, for a
+    positive verdict, the target entity resolved from the declared source instance.
+    """
+    expected: dict[tuple[int, str], dict] = {}
     for row in rows:
-        if row["source_locator"].get("source_annotation_index") is None:
+        locator = row["source_locator"]
+        if locator.get("source_annotation_index") is None:
             continue
-        annotations = source[row["source_locator"]["source_annotation_index"]]["annotations"]
+        frame_index = row["frame_index"]
+        subsequence = locator["subsequence"]
+        source_frame = source[locator["source_annotation_index"]]
+        annotations = source_frame["annotations"]
+        frame_name = (source_frame.get("image") or {}).get("name")
+        by_id: dict[str, dict] = {}
+        for annotation in annotations:
+            if annotation["id"] in by_id:
+                problem(f"relations: frame {frame_index} repeats source instance id "
+                        f"{annotation['id']!r}")
+            by_id[annotation["id"]] = annotation
         for annotation in annotations:
             value = annotation.get("in_contact_object")
             status, resolves = vc.contact_status(value)
             if status is None:
                 continue
-            expected[(row["frame_index"], annotation["name"], status)] += 1
+            target = None
+            if resolves:
+                target = by_id.get(value)
+                if target is None:
+                    problem(f"relations: frame {frame_index} source contact target {value!r} "
+                            "does not resolve to an instance of its own frame")
+                    continue
+            key = (frame_index, annotation["id"])
+            if key in expected:
+                problem(f"relations: frame {frame_index} source instance {annotation['id']!r} "
+                        "carries more than one contact verdict")
+            expected[key] = {
+                "status": status,
+                "source_value": value,
+                "subject_entity_name": annotation["name"],
+                "subject_id": frame_entity_id(annotation["name"], subsequence),
+                "target_source_instance_id": value if resolves else None,
+                "target_entity_id": frame_entity_id(target["name"], subsequence)
+                if resolves else None,
+                "source_annotation_index": locator["source_annotation_index"],
+                "source_frame_name": frame_name,
+            }
     #: relations.jsonl is one row per frame, with that frame's relations inside it; the
     #: comparison is on the relations themselves, since a frame's row exists precisely
     #: when the source recorded something there
-    found = collections.Counter()
+    found: dict[tuple[int, str], dict] = {}
     entries = 0
     for row in released:
+        frame_index = row["frame_index"]
         for relation in row.get("relations") or []:
             entries += 1
-            name = (relation.get("source_locator") or {}).get("subject_entity_name")
-            found[(row["frame_index"], name, relation["status"])] += 1
-    record["relations"] = {"frames_with_rows": len(released), "relations": entries,
-                           "by_status": dict(collections.Counter(k[2] for k in found.elements()))}
-    if expected != found:
-        missing = expected - found
-        extra = found - expected
-        problem(f"relations: the released verdicts are not the source's; "
-                f"missing {dict(list(missing.items())[:4])}, extra {dict(list(extra.items())[:4])}")
+            locator = relation.get("source_locator") or {}
+            source_id = locator.get("source_instance_id")
+            key = (frame_index, source_id)
+            if key in found:
+                problem(f"relations: frame {frame_index} releases source instance "
+                        f"{source_id!r} more than once")
+            found[key] = {
+                "status": relation.get("status"),
+                "source_value": locator.get("source_value"),
+                "subject_entity_name": locator.get("subject_entity_name"),
+                "subject_id": relation.get("subject_id"),
+                "object_id": relation.get("object_id"),
+                "source_annotation_index": locator.get("source_annotation_index"),
+                "source_frame_name": locator.get("source_frame_name"),
+            }
+    record["relations"] = {
+        "frames_with_rows": len(released),
+        "relations": entries,
+        "by_status": dict(collections.Counter(item["status"] for item in found.values())),
+    }
+
+    for key in sorted(set(expected) - set(found)):
+        problem(f"relations: frame {key[0]} source instance {key[1]!r} "
+                f"({expected[key]['subject_entity_name']}, {expected[key]['status']}) "
+                "is missing from the release")
+    for key in sorted(set(found) - set(expected)):
+        problem(f"relations: frame {key[0]} source instance {key[1]!r} has a released "
+                f"verdict ({found[key]['status']}) the source does not carry")
+    for key in sorted(set(expected) & set(found)):
+        wanted, actual = expected[key], found[key]
+        frame_index, source_id = key
+        if actual["status"] != wanted["status"]:
+            problem(f"relations: frame {frame_index} source instance {source_id!r} is "
+                    f"{actual['status']!r}, source {wanted['status']!r}")
+        if not vc.same_json(actual["source_value"], wanted["source_value"]):
+            problem(f"relations: frame {frame_index} source instance {source_id!r} keeps "
+                    f"source value {actual['source_value']!r}, source {wanted['source_value']!r}")
+        if actual["subject_entity_name"] != wanted["subject_entity_name"]:
+            problem(f"relations: frame {frame_index} source instance {source_id!r} has "
+                    f"subject name {actual['subject_entity_name']!r}, source "
+                    f"{wanted['subject_entity_name']!r}")
+        if actual["subject_id"] != wanted["subject_id"]:
+            problem(f"relations: frame {frame_index} source instance {source_id!r} has "
+                    f"subject_id {actual['subject_id']!r}, expected {wanted['subject_id']!r}")
+        if actual["source_annotation_index"] != wanted["source_annotation_index"]:
+            problem(f"relations: frame {frame_index} source instance {source_id!r} points at "
+                    f"source annotation {actual['source_annotation_index']!r}, expected "
+                    f"{wanted['source_annotation_index']!r}")
+        if wanted["source_frame_name"] is None:
+            problem(f"relations: frame {frame_index} has no source image name to compare "
+                    "the locator against")
+        elif actual["source_frame_name"] != wanted["source_frame_name"]:
+            problem(f"relations: frame {frame_index} source instance {source_id!r} names "
+                    f"source frame {actual['source_frame_name']!r}, expected "
+                    f"{wanted['source_frame_name']!r}")
+        if wanted["status"] == "positive":
+            if actual["object_id"] != wanted["target_entity_id"]:
+                problem(f"relations: frame {frame_index} subject {source_id!r} "
+                        f"({wanted['subject_entity_name']}) targets {actual['object_id']!r}, "
+                        f"source target {wanted['target_entity_id']!r} "
+                        f"(source instance {wanted['target_source_instance_id']})")
+        elif actual["object_id"] is not None:
+            problem(f"relations: frame {frame_index} source instance {source_id!r} is "
+                    f"{wanted['status']!r} but carries a target {actual['object_id']!r}")
 
 
 def check_view(archive, view, view_dir, mapping, table) -> dict:
@@ -403,6 +522,38 @@ def check_view(archive, view, view_dir, mapping, table) -> dict:
     return record
 
 
+def source_evidence(release):
+    """映射表随发布树走；沙盒副本没带 ``script/source_evidence`` 时才回退到正式树。
+
+    以前无条件从 ``RELEASE_ROOT`` 读：``--release`` 指向沙盒时，检查的是沙盒的数据、
+    却悄悄借用正式树的证据（PR #9 审查 finding 1 的复现条件之一）。"""
+    evidence = Path(release) / "script" / "source_evidence"
+    return evidence if evidence.is_dir() else RELEASE_ROOT / "script" / "source_evidence"
+
+
+def archive_identity(raw, check_digest):
+    """源归档身份：大小永远核对；完整运行（没有选择参数）还必须核对摘要。
+
+    30.6 GB 顺序读一次约 1–4 分钟，只在正式运行时做。返回的 ``trusted`` 是报告里
+    ``formal`` 的必要条件——截取过的有效 ZIP 通不过它。"""
+    size = raw.stat().st_size
+    identity = {
+        "size": size,
+        "expected_size": vc.RAW_ARCHIVE_SIZE,
+        "digest": None,
+        "expected_digest": vc.RAW_ARCHIVE_SHA256,
+        "digest_checked": bool(check_digest),
+        "trusted": False,
+    }
+    if check_digest:
+        print(f"hashing the source archive ({size} bytes) ...", flush=True)
+        identity["digest"] = vc.stream_sha256(
+            raw, progress=lambda done: print(f"  hashed {done / 1024**3:.1f} GiB", flush=True))
+    identity["trusted"] = size == vc.RAW_ARCHIVE_SIZE and (
+        not check_digest or identity["digest"] == vc.RAW_ARCHIVE_SHA256)
+    return identity
+
+
 def main(argv=None):
     parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
     parser.add_argument("--raw", type=Path, default=vc.RAW_ARCHIVE,
@@ -417,25 +568,55 @@ def main(argv=None):
     parser.add_argument("--report", type=Path, help="write the acceptance report here")
     args = parser.parse_args(argv)
 
+    #: ``nargs="*"`` 的空列表与 ``--sample 0`` 都是合法的解析结果，但都不是「选了东西」。
+    if args.views is not None and not args.views:
+        parser.error("--views needs at least one sequence id; an empty selection "
+                     "cannot report a pass over nothing")
+    if args.sample is not None and args.sample < 1:
+        parser.error("--sample must be positive")
+
     if not args.raw.is_file():
         raise SystemExit(f"the raw deposit is not there: {args.raw}")
     census = deposit_census(args.raw)
-    print(f"deposit: {len(census)} sequences, "
-          f"{sum(1 for v in census.values() if v.annotated)} annotated")
+    if not census:
+        raise SystemExit(f"the deposit census is empty: {args.raw} -- a probe archive "
+                         "is never a full acceptance source")
+    annotated = sum(1 for view in census.values() if view.annotated)
+    print(f"deposit: {len(census)} sequences, {annotated} annotated")
 
     wanted = sorted(census)
-    if args.views:
+    if args.views is not None:
         unknown = sorted(set(args.views) - set(census))
         if unknown:
             raise SystemExit(f"not sequences of this deposit: {unknown}")
         wanted = sorted(args.views)
-    if args.sample:
+    if args.sample is not None:
+        if args.sample > len(wanted):
+            parser.error(f"--sample {args.sample} exceeds the {len(wanted)} selected sequences")
         wanted = wanted[: args.sample]
 
-    mapping = vc.load(RELEASE_ROOT / "script" / "source_evidence" / "VISOR-frame_mapping.json")
+    no_selection = args.views is None and args.sample is None
+    identity = archive_identity(args.raw, check_digest=no_selection)
+    if no_selection and not identity["trusted"]:
+        raise SystemExit(
+            f"the archive is not the published deposit (size {identity['size']} vs "
+            f"{identity['expected_size']}, sha256 {identity['digest']} vs "
+            f"{identity['expected_digest']}); restricted runs must use --views/--sample "
+            "and are reported as partial"
+        )
+    census_ok = (len(census) == vc.EXPECTED_SOURCE_SEQUENCES
+                 and annotated == vc.EXPECTED_SOURCE_ANNOTATED)
+    #: 只有「没有选择参数 + 正式树 + 可信归档 + 完整普查」才是正式验收；其余一律
+    #: partial，报告与退出码都不再声称 accepted（PR #9 审查 finding 2）。
+    formal = no_selection and vc.same_path(args.release, RELEASE_ROOT) \
+        and identity["trusted"] and census_ok
+    if args.report is not None:
+        vc.guard_output(args.report, formal, {"verify acceptance"}, "verify")
+
+    evidence = source_evidence(args.release)
+    mapping = vc.load(evidence / "VISOR-frame_mapping.json")
     table = {}
-    with open(RELEASE_ROOT / "script" / "source_evidence" / "VISOR-noun-classes.csv",
-              encoding="utf-8-sig") as handle:
+    with open(evidence / "VISOR-noun-classes.csv", encoding="utf-8-sig") as handle:
         for row in csv.DictReader(handle):
             try:
                 table[int(row["id"])] = row["key"].strip()
@@ -462,26 +643,55 @@ def main(argv=None):
     for sequence_id in absent:
         print(f"ABSENT {sequence_id}: not in the release", file=sys.stderr)
 
+    #: 「没有发现问题」不等于「检查确实做完了」：records 必须覆盖被选中的每一个序列，
+    #: 且没有 absent。accepted 还要求这是正式运行（findings 2 / 4）。
+    passed = (bool(records) and not problems and not absent
+              and len(records) == len(wanted))
+    accepted = passed and formal
     report = {
         "raw": str(args.raw),
         "release": str(args.release),
         "raw_size": args.raw.stat().st_size,
         "deposit_sequences": len(census),
+        "deposit_annotated": annotated,
         "checked": [record["view"] for record in records],
         "absent": absent,
         "views": records,
         "problems": {record["view"]: record["problems"] for record in records},
-        "accepted": not problems and not absent,
-        "partial": bool(args.views or args.sample),
+        "accepted": accepted,
+        "partial": not formal,
+        "formal": formal,
+        "passed": passed,
+        "archive_identity": identity,
+        "coverage": {
+            "expected_sequences": vc.EXPECTED_SOURCE_SEQUENCES,
+            "expected_annotated": vc.EXPECTED_SOURCE_ANNOTATED,
+            "census_sequences": len(census),
+            "census_annotated": annotated,
+            "views_selected": len(wanted),
+            "views_checked": len(records),
+            "selection": "all" if no_selection else "restricted",
+        },
+        "checks": {
+            "problem_count": len(problems),
+            "absent_count": len(absent),
+            "views_checked": len(records),
+            "views_selected": len(wanted),
+        },
         "scope": "the released numbers are the deposit's numbers, per view and per packet; "
                  "not a judgement of source annotation correctness and not visual acceptance",
     }
-    if args.report:
+    if args.report is not None:
         args.report.parent.mkdir(parents=True, exist_ok=True)
         args.report.write_text(json.dumps(report, ensure_ascii=False, indent=2), encoding="utf-8")
         print(f"wrote {args.report}")
-    print("VERIFY_PASS" if report["accepted"] else "VERIFY_FAIL")
-    return 0 if report["accepted"] else 1
+    if accepted:
+        print("VERIFY_PASS")
+    elif passed:
+        print("VERIFY_PARTIAL_PASS")
+    else:
+        print("VERIFY_FAIL")
+    return 0 if passed else 1
 
 
 if __name__ == "__main__":

EPIC-KITCHENS-VISOR/shared-v1.1/script/visor_v1_1/visor_common.py

@@ -36,6 +36,7 @@ from __future__ import annotations
 import collections
 import hashlib
 import json
+import os
 import re
 import sys
 import zipfile
@@ -73,6 +74,10 @@ RAW_ARCHIVE_REF = "raw/data/EPIC-KITCHENS VISOR.zip"
 RAW_ARCHIVE = DATASET_ROOT / RAW_ARCHIVE_REF
 RAW_ARCHIVE_SIZE = 30_572_126_007
 RAW_ARCHIVE_SHA256 = "9e15bb03b408acd28b5ef54f1b752c18909fd995464f1267dc3081711c2e0a7c"
+#: 全量源应有的视图数 / 标注段数。正式验收要求恰好这么多：截取过的归档即便能解析，
+#: 也只能产出 partial 报告（PR #9 审查 finding 2）。
+EXPECTED_SOURCE_SEQUENCES = 179
+EXPECTED_SOURCE_ANNOTATED = 158
 #: 整包所有成员都裹在这个平台上导出目录下（Figshare record id），成员名以它开头。
 DEPOSIT_ROOT = "2v6cgv1x04ol22qp9rm9x2j6a7/"
 
@@ -177,6 +182,41 @@ def sha256(path):
     return sha256_file(Path(path))
 
 
+def stream_sha256(path, chunk=64 * 1024**2, progress=None):
+    """分块顺序哈希：30.6 GB 的源归档不能一次读进内存。``progress`` 每 2 GiB 调一次。"""
+    digest = hashlib.sha256()
+    done = 0
+    step = 2 * 1024**3
+    next_report = step
+    with Path(path).open("rb") as handle:
+        while True:
+            block = handle.read(chunk)
+            if not block:
+                break
+            digest.update(block)
+            done += len(block)
+            if progress is not None and done >= next_report:
+                progress(done)
+                next_report += step
+    return digest.hexdigest()
+
+
+def same_json(left, right):
+    """JSON 值严格相等：键集合、列表长度、**类型**和值都要一致。
+
+    普通的 ``==`` 会把 ``True``/``1``、``1``/``1.0`` 混为一谈；源属性里有 ``None``
+    与字符串之分，不能靠它判断"原样保留"。"""
+    if isinstance(left, dict) or isinstance(right, dict):
+        if not (isinstance(left, dict) and isinstance(right, dict)):
+            return False
+        return set(left) == set(right) and all(same_json(left[k], right[k]) for k in left)
+    if isinstance(left, list) or isinstance(right, list):
+        if not (isinstance(left, list) and isinstance(right, list)):
+            return False
+        return len(left) == len(right) and all(same_json(a, b) for a, b in zip(left, right))
+    return type(left) is type(right) and left == right
+
+
 # --------------------------------------------------------------------------- 源
 class SequenceSource:
     """一个 EPIC 视频在源里的三条成员路径（标注 / 稀疏帧图 / 密集插值）。"""
@@ -480,6 +520,93 @@ STATUS_FLAGS = (
 MANIFEST_PATH = TMP_ROOT / "PUBLISH_MANIFEST.json"
 
 
+# ----------------------------------------------------------- 正式证据的输出守卫
+#: PR #9 审查 finding 4：局部调试运行可以覆盖发布清单与正式复核报告。这里把**正式
+#: 验收证据**登记成只读角色；每个写盘的工具在 mkdir/写文件之前先过守卫。判定按解析
+#: 后的实际路径（``resolve()`` + ``samefile``），符号链接、硬链接、``..`` 别名都拦得住。
+def protected_outputs():
+    """角色 → 正式证据文件。每次调用现算，测试可 monkeypatch ``RELEASE_ROOT``。"""
+    review = RELEASE_ROOT / "doc" / "validation"
+    return {
+        "publication manifest": MANIFEST_PATH,
+        "validate report": review / "validate_report.json",
+        "review report": review / "V1_1_VALIDATION.json",
+        "review index": review / "index.html",
+        "reader sweep": review / "read_sequence_sweep.json",
+        "verify acceptance": TMP_ROOT / "acceptance.json",
+    }
+
+
+def protected_directories():
+    return {"review pages": RELEASE_ROOT / "doc" / "validation"}
+
+
+def same_path(left, right):
+    """解析后相等，或指向同一个 inode（硬链接、符号链接别名）。"""
+    left, right = Path(left).resolve(), Path(right).resolve()
+    if left == right:
+        return True
+    try:
+        return left.exists() and right.exists() and os.path.samefile(left, right)
+    except OSError:
+        return False
+
+
+def _within(path, directory):
+    path, directory = Path(path).resolve(), Path(directory).resolve()
+    return path == directory or directory in path.parents
+
+
+def _protected_roles(path):
+    return [role for role, value in protected_outputs().items() if same_path(path, value)]
+
+
+def guard_output(path, formal, writable, label):
+    """拒绝会覆盖正式验收证据的文件输出。必须在任何 ``mkdir`` 之前调用。
+
+    ``formal=False`` 的运行一个字节都不得落到正式证据上；``formal=True`` 也只能写
+    ``writable`` 点名的角色。写到保护目录里的新文件同样拒绝——那会破坏"目录内容
+    与报告自洽"的前提。
+    """
+    target = Path(path)
+    roles = _protected_roles(target)
+    if roles:
+        if formal and set(writable).intersection(roles):
+            return
+        reason = "正式运行不改写该角色" if formal else "局部运行不得写正式证据"
+        raise SystemExit(f"{label}: {reason} {roles[0]} -> {target}（写到 {TMP_ROOT}）")
+    for name, directory in protected_directories().items():
+        if _within(target, directory):
+            raise SystemExit(
+                f"{label}: {name} 目录内只允许正式运行按角色写文件 -> {target}"
+            )
+    for value in protected_outputs().values():
+        if _within(value, target):
+            raise SystemExit(f"{label}: 目标包含正式证据 {value} -> {target}")
+
+
+def guard_directory(path, formal, writable, label):
+    """目录输出版（``render.py``）。规则同 :func:`guard_output`，另外拒绝把整个
+    正式证据目录当渲染输出目录，以及把它的父目录交给局部运行。"""
+    target = Path(path)
+    roles = _protected_roles(target)
+    if roles:
+        raise SystemExit(f"{label}: 目标是文件不是输出目录 {roles[0]} -> {target}")
+    for name, directory in protected_directories().items():
+        if same_path(target, directory):
+            if formal and set(writable).intersection({name}):
+                return
+            reason = "正式运行不改写该角色" if formal else "局部运行不得写正式证据"
+            raise SystemExit(f"{label}: {reason} {name} -> {target}（写到 {TMP_ROOT}）")
+        if _within(target, directory):
+            raise SystemExit(f"{label}: 正式证据目录只允许正式运行按角色写 -> {target}")
+        if _within(directory, target):
+            raise SystemExit(f"{label}: 输出目录包含正式证据 {directory} -> {target}")
+    for value in protected_outputs().values():
+        if _within(value, target):
+            raise SystemExit(f"{label}: 输出目录包含正式证据 {value} -> {target}")
+
+
 def published(components, name):
     """该视图是否提供了这个组件：没有，或提供了但标 unavailable。"""
     component = components.get(name)