Fix the validator findings from review on ARCTIC/shared-v1.1

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

ARCTIC/shared-v1.1/doc/FULL_MIGRATION_SUMMARY.json

@@ -1,7 +1,7 @@
 {
   "phase": "local_finalized_not_uploaded",
   "completed_views": 3051,
-  "created_utc": "2026-10-14T13:33:02.127894+00:00",
+  "created_utc": "2026-10-16T07:29:09.348304+00:00",
   "dataset_id": "ARCTIC",
   "final_root": "/data1/yanghonglei/Datasets/hand-warehouse/ARCTIC/shared-v1.1",
   "source_revision": "d4e2bb40cd30071e4f6483877889c1857b41b707",
@@ -36,7 +36,7 @@
   "source_files": 91713,
   "source_bytes": 791999867773,
   "target_files": 55416,
-  "target_bytes": 792210999386,
+  "target_bytes": 792211007511,
   "tree_totals_scope": "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 -- so the manifest lists one more entry than target_files, and its byte total exceeds target_bytes by this file plus the size deltas of the two files rewritten after it (doc/*.md in step 7, doc/validation/validate_report.json in step 8, both before the manifest, which is built last so that it covers them). The review pages are rendered in step 5, before this file, so they are on both sides of that comparison. The manifest itself is outside the release tree (tmp/arctic-tools/PUBLISH_MANIFEST.json), so it appears on neither side of this comparison: the tree's own totals are what that manifest records. source_* describe v1.0, which nothing writes after the pull",
   "elapsed_seconds": 1041.0,
   "elapsed_scope": "sum of 7 incremental migrate runs' own wall time; the pull-driven gaps between them are not migration time, and runs before the loop started are not in this log",

ARCTIC/shared-v1.1/doc/validation/validate_report.json

@@ -1,5 +1,6 @@
 {
   "passed": true,
+  "coverage": "full release",
   "dataset_id": "ARCTIC",
   "schema_version": "hand-warehouse/1.1",
   "release_id": "shared-v1.1",

ARCTIC/shared-v1.1/script/arctic_v1_1/README.md

@@ -10,7 +10,7 @@ script/arctic_v1_1/
 ├── arctic_common.py    ARCTIC 适配：路径、形状符号解析、逐组件结构校验、畸变规则、游离文件检测
 ├── migrate.py          v1.0 → v1.1 迁移（可断点续跑）
 ├── verify.py           验收：逐视图对 v1.0 源做字节级比对（CONTRACT §6）
-├── validate.py         全量结构校验 + 重新生成 release manifest
+├── validate.py         全量结构校验 + 重新生成 release manifest（--views/--limit 为子集模式）
 ├── read_sequence.py    读取器路径验收：整条序列、全部相机（CONTRACT §6.5）
 ├── render.py           全量后抽样的人工复核页：54 个视图的 HTML + QC 报告 + index
 ├── spec/               本版规范原文：CONTRACT.md、MIGRATION.md、schema.json
@@ -54,8 +54,26 @@ python shared-v1.1/script/arctic_v1_1/read_sequence.py s01_box_grab_01 \
 
 # 全量结构校验（只读发布树，不需要 v1.0 源；重建树外发布清单 tmp/arctic-tools/PUBLISH_MANIFEST.json）
 python shared-v1.1/script/arctic_v1_1/validate.py --expect-views 3051 --rewrite-check 2
+
+# 干活时只想看一段：--views/--limit 是子集运行，报告写 tmp、不碰清单
+python shared-v1.1/script/arctic_v1_1/validate.py --views s01_box_grab_01
 ```
 
+**子集运行与验收运行是两件事。** `--views`/`--limit` 一旦用上，这一次就是**子集运行**：它只断言自己
+选中的视图能支持的东西，报告标 `coverage: "partial subset"`、scope 里写明「不是全量验收那一次」，写到
+树外的 `tmp/arctic-tools/validate-partial.json`，并且**不重建发布清单**——清单是一句关于整棵树的话
+（它哈希每个文件），子集运行重建它只会让清单与报告对不上。所以「57 个视图都通过」不会被读成
+「发布通过」。三条边界是硬的：
+
+* `--views` 里写了发布树里不存在的序列名，直接报错（`no such view`），不会退化成「0 个视图、通过」；
+* 子集运行**不允许**把报告写到 `doc/validation/validate_report.json`，即使显式 `--report` 指名它——
+  那份报告描述整个发布，`FULL_MIGRATION_SUMMARY.json` 引用它，子集的数字是它的一个零头；
+* 不带任何选择的那一次才是**验收运行**：断言 3051 个视图、339 条序列、每序列九机位就位，并最后重建
+  清单（`--expect-views` 在不带选择时默认就是 3051；子集运行则默认断言自己选中的数量）。
+
+`verify.py` 的 `--views` 同样拒绝不存在的序列名——同一类「选择落到空集、却报通过」的洞，两个工具都堵上。
+它的名字是拿**v1.0 源树**校对的，所以「源里有、还没迁」是合法选择，会被记成 absent，这正是增量运行要的。
+
 ### 收尾验收顺序
 
 发布清单**不在发布树里**。它记录发布树每个文件的 sha256，而树内的副本描述不了自己写下去之后的树——

ARCTIC/shared-v1.1/script/arctic_v1_1/validate.py

@@ -19,6 +19,17 @@ on top:
 
 Scope: this checks the released content and layout.  It does not independently prove
 official source correctness, and it is not human visual acceptance (CONTRACT 6).
+
+Run: python shared-v1.1/script/arctic_v1_1/validate.py --expect-views 3051 \
+        --rewrite-check 2
+
+``--views``/``--limit`` are for checking a corner of the tree while working on it, and a
+run that uses either is a *subset* run: it asserts only what its selected views can
+support, marks its report partial, writes that report to ``tmp`` rather than over the
+acceptance report, and leaves the release manifest alone.  A name passed to ``--views``
+that matches no released sequence is an error, not an empty selection.  The acceptance
+pass is the run with no selection: that is the one that checks the 3,051-view /
+339-sequence census and rebuilds the manifest.
 """
 
 from __future__ import annotations
@@ -55,6 +66,23 @@ CAMERA_IDS = {str(index) for index in range(9)}
 EGO_CAMERA = "0"
 FRAMES_REF = "camera/frames.jsonl"
 
+#: The full release's view and sequence counts.  Both are claims about the *whole*
+#: release, so they are asserted on a full run only: a --views/--limit run validates the
+#: views it selected and reports itself as partial, because nine sound views say nothing
+#: about whether the other 3,042 exist.  The two scopes below keep that distinction in
+#: the report the manifest is built from.
+EXPECTED_VIEWS = 3051
+EXPECTED_SEQUENCES = 339
+SCOPE = ("released content and layout; does not independently prove official source "
+         "correctness or visual quality")
+PARTIAL_SCOPE = (SCOPE + "; this run covered a selected subset of the release, so it is "
+                 "not the release-wide acceptance run")
+#: where a subset run writes instead of the release's own report path.  The name is load
+#: bearing: it must not be the acceptance report, which describes the whole release and is
+#: what FULL_MIGRATION_SUMMARY.json cites.
+PARTIAL_REPORT = TMP_ROOT / "validate-partial.json"
+ACCEPTANCE_REPORT = RELEASE_ROOT / "doc/validation/validate_report.json"
+
 
 def release_files():
     """Every file of the release, in path order -- one definition, used twice.
@@ -284,28 +312,68 @@ def rewrite_check(view_dir, meta, tmp):
 
 def main(argv=None):
     parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
-    parser.add_argument("--views", nargs="*", default=None, help="restrict to these sequences")
-    parser.add_argument("--limit", type=int, default=None, help="validate at most N views")
+    parser.add_argument("--views", nargs="*", default=None,
+                        help="restrict to these sequences.  A name that matches no released "
+                             "sequence is an error, and a run that uses this or --limit is a "
+                             "subset run: partial report, no manifest")
+    parser.add_argument("--limit", type=int, default=None,
+                        help="validate at most N views (a subset run, as --views is)")
     parser.add_argument("--expect-views", type=int, default=None, metavar="N",
-                        help="fail unless exactly N views are released")
+                        help=f"fail unless exactly N views are released (default: "
+                             f"{EXPECTED_VIEWS}, the full ARCTIC release, for a run with no "
+                             "--views/--limit; a subset run defaults to the number of views "
+                             "it selected).  Without it a run that silently covered a "
+                             "fraction of the tree would still report a pass.")
     parser.add_argument("--rewrite-check", type=int, default=0, metavar="N",
                         help="also re-serialise N views with the adapted writer and compare field bytes")
-    parser.add_argument("--report", type=Path, default=RELEASE_ROOT / "doc/validation/validate_report.json")
+    parser.add_argument("--report", type=Path, default=None,
+                        help="where the structural report is written (default: the release's "
+                             "doc/validation/validate_report.json for a full run, "
+                             f"{PARTIAL_REPORT} for a subset run, which must not overwrite "
+                             "the acceptance report)")
     parser.add_argument("--no-manifest", action="store_true",
                         help=f"do not rebuild the release manifest ({MANIFEST_PATH}). It "
                              "hashes the whole release tree whatever --views says, so an "
                              "incremental check would pay minutes for a manifest the final "
-                             "run overwrites anyway. The accepting run must not pass this "
+                             "run rebuilds anyway; a subset run skips it for the same reason "
+                             "without being asked. The accepting run must not pass this "
                              "(CONTRACT 6.4).")
     args = parser.parse_args(argv)
 
-    views = sorted((RELEASE_ROOT / "data").glob("*/*/metainfo.json"))
-    if args.views:
-        wanted = set(args.views)
-        views = [view for view in views if view.parent.parent.name in wanted]
+    all_views = sorted((RELEASE_ROOT / "data").glob("*/*/metainfo.json"))
+    wanted = set(args.views) if args.views else None
+    if wanted is not None:
+        #: a name that matches nothing is a typo, and silently checking the views that are
+        #: left would let it pass as a green run over the wrong set -- which is how a
+        #: sequence that is not in the release at all once read as "passed, 0 views"
+        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:
         views = views[: args.limit]
 
+    #: "is this release complete?" and "is this view sound?" are different questions.  The
+    #: sequence/view census is a claim about the whole tree, so a run with --views/--limit
+    #: checks its own selection instead and says so everywhere its result is reported (see
+    #: SCOPE/PARTIAL_SCOPE, the report's ``coverage``, and the manifest it deliberately
+    #: does not rebuild).
+    full = wanted is None and not args.limit
+    expect_views = args.expect_views if args.expect_views is not None else (
+        EXPECTED_VIEWS if full else len(views))
+    report_path = args.report or (ACCEPTANCE_REPORT if full else PARTIAL_REPORT)
+    #: Naming the acceptance report explicitly does not make a subset run an acceptance
+    #: run: that report describes the whole release and is what FULL_MIGRATION_SUMMARY.json
+    #: cites, while a subset's counts are a fraction of it by construction, and the release
+    #: manifest is built from its ``scope``.  So the mistake is refused before anything is
+    #: read or written rather than honoured.
+    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"
+    )
+
     counts, sequences, flags, gaps, assets = {}, {}, {}, {}, {"dependencies": {}, "unreferenced": {}}
     models, uncalibrated = {}, []
     frames_total, files_total = 0, 0
@@ -364,11 +432,15 @@ def main(argv=None):
         if len(rewrites) < args.rewrite_check:
             rewrites.append(rewrite_check(view_dir, meta, TMP_ROOT / "rewrite-check"))
 
-    if not (args.views or args.limit):
+    if full:
+        #: the release-wide census, asserted only where it can hold: a subset's counts are
+        #: a fraction of these by construction, and comparing them would fail a working
+        #: check for a reason that has nothing to do with the views it read.  Every
+        #: sequence carries all nine cameras, and the release carries 339 of them.
         for sequence, cameras in sorted(sequences.items()):
             assert cameras == CAMERA_IDS, (sequence, sorted(cameras))
-    if args.expect_views is not None:
-        assert len(views) == args.expect_views, (len(views), args.expect_views)
+        assert len(sequences) == EXPECTED_SEQUENCES, (len(sequences), EXPECTED_SEQUENCES)
+    assert len(views) == expect_views, (len(views), expect_views)
     #: ARCTIC's status flags are per-view claims and the release is NOT uniform:
     #: ``media_validation_policy`` is null on some sequences and a policy string on
     #: others, and that is the v1.0 content, not a migration defect.  That each view
@@ -383,6 +455,10 @@ def main(argv=None):
 
     result = {
         "passed": True,
+        #: read by the reader before any number in here: a subset run's "views": 9 is not a
+        #: smaller release, it is a smaller *check*, and the release manifest carries this
+        #: same word as its own scope
+        "coverage": "full release" if full else "partial subset",
         "dataset_id": DATASET_ID,
         "schema_version": REGISTRY.schema["view_metadata"]["schema_version"],
         "release_id": REGISTRY.schema["view_metadata"]["release_id"],
@@ -404,8 +480,7 @@ def main(argv=None):
         "unreferenced_files": sorted(assets["unreferenced"]),
         "unreferenced_file_views": assets["unreferenced"],
         "rewrite_check": rewrites,
-        "scope": "released content and layout; does not independently prove official source "
-                 "correctness or visual quality",
+        "scope": SCOPE if full else PARTIAL_SCOPE,
     }
     #: The tmp copy is a convenience for the migration loop, and its *name* is load
     #: bearing.  It must not be "acceptance.json": the documented chain writes
@@ -414,15 +489,25 @@ def main(argv=None):
     #: FULL_MIGRATION_SUMMARY.json is built from -- which is exactly what happened
     #: once, and cost a re-run of the whole acceptance to recover.
     save(TMP_ROOT / "validate-latest.json", result)
-    save(args.report, result)
+    save(report_path, result)
 
+    skip_manifest = None
     if args.no_manifest:
         #: reported as skipped rather than as a manifest of 0 files, which would
         #: read like an empty release
-        result["release_manifest"] = {"skipped": "incremental check; not an acceptance run",
-                                      "path": str(MANIFEST_PATH)}
+        skip_manifest = "incremental check; not an acceptance run"
+    elif not full:
+        #: The manifest is a claim about the whole release -- it hashes every file -- and
+        #: the documented chain reads it together with the acceptance report.  A subset run
+        #: must not leave the two disagreeing about what was accepted, so it reports the
+        #: manifest as skipped instead of rebuilding one to sit beside a partial report.
+        #: This is also what keeps a one-sequence check from paying an hour of hashing for
+        #: a manifest the acceptance run rebuilds anyway.
+        skip_manifest = "partial run; the release manifest is rebuilt by the full acceptance run"
+    if skip_manifest:
+        result["release_manifest"] = {"skipped": skip_manifest, "path": str(MANIFEST_PATH)}
         save(TMP_ROOT / "validate-latest.json", result)
-        save(args.report, result)
+        save(report_path, result)
         print(json.dumps(result, ensure_ascii=False, indent=2))
         return 0 if result["passed"] else 1
 
@@ -439,7 +524,7 @@ def main(argv=None):
                 "inside it cannot hash itself",
     }
     save(TMP_ROOT / "validate-latest.json", result)
-    save(args.report, result)
+    save(report_path, result)
 
     manifest = []
     for path in release_files():

ARCTIC/shared-v1.1/script/arctic_v1_1/verify.py

@@ -364,7 +364,9 @@ def main(argv=None):
     parser.add_argument("--sample", type=int, default=None,
                         help="verify at most N views (default: all migrated)")
     parser.add_argument("--views", nargs="*", default=None,
-                        help="restrict to these sequence ids")
+                        help="restrict to these sequence ids.  A name that matches no "
+                             "sequence of the v1.0 source is an error: an empty selection "
+                             "would report a pass over no views at all")
     parser.add_argument("--complete", action="store_true",
                         help="fail when a source view has no migrated counterpart")
     parser.add_argument("--no-manifest", action="store_true",
@@ -392,6 +394,13 @@ def main(argv=None):
         (migrated if (target_data / relative / "metainfo.json").is_file() else absent).append(view)
     if args.views:
         wanted = set(args.views)
+        #: A name that matches nothing is a typo, and an empty selection would produce a
+        #: report with no views and no failures -- a green run over nothing.  The names are
+        #: checked against the *source* tree, so a sequence that exists there but has not
+        #: been migrated yet is still a valid selection: it is reported as absent, which is
+        #: what an incremental run is for.
+        known = {view.parent.name for view in source_views}
+        assert wanted <= known, ("no such view", sorted(wanted - known))
         migrated = [v for v in migrated if v.parent.name in wanted]
     if args.sample:
         migrated = migrated[:args.sample]