Define prospective fragment-sequence protocol boundary

Archive_Specifications.md

@@ -2,22 +2,32 @@
 
 ## Scope and Protocol Version
 
-These specifications apply to recordings and drawings created beginning July
-13, 2025 unless a metadata row documents a deviation.
-
-The corresponding metadata identifier is:
-
-```text
-acquisition_protocol_version = standard-2025-07-13
-```
-
-The identifier records the governing protocol. It does not imply that every
-published file has identical encoded dimensions, orientation, codec, audio, or
-post-processing history.
+These specifications apply to recordings and drawings created beginning July
+13, 2025 unless a metadata row documents a deviation. Two protocol identifiers
+now distinguish the canonical workflows:
+
+- `standard-2025-07-13` — the earlier Standard workflow established July 13,
+  2025.
+- `standard-2026-08-27` — the prospective canonical fragment-sequence workflow
+  established August 27, 2026.
+
+Protocol assignment is not a blanket finish-date cutover. In the current
+index, `standard-2026-08-27` applies only to the 186 `canonical_fragment`
+`record_id` values in the six dated relationship sidecars from August 27
+through September 2, 2026. Every other Standard row remains
+`standard-2025-07-13`, including the 19 historical `RecNN` rows outside those
+sidecars. A `RecNN` filename suffix alone never assigns the prospective
+protocol.
+
+The identifier records the governing workflow. It does not imply that every
+published file has identical encoded dimensions, orientation, codec, audio, or
+post-processing history.
 
 ## Capture Configuration
 
-The owner-confirmed default workflow since July 13, 2025 is:
+The owner-confirmed capture default established under the earlier Standard
+workflow, and inherited by the prospective fragment-sequence workflow unless a
+row documents a deviation, is:
 
 - Device: Samsung Galaxy S23 Ultra, model `SM-S918U`
 - Application: Framelapse 2; observed current version 11.7
@@ -48,15 +58,20 @@ transformation should be asserted only when supported by provenance evidence.
 
 ### Acquisition evidence and canonical representation
 
-Framelapse source fragments are retained unchanged as acquisition evidence. A
-reviewed drawing may be represented canonically either by one selected
-chronological InShot assembly or by a complete, verified `RecNN` sequence of
-unchanged source fragments. In fragment-sequence mode, every source file has its
-own canonical metadata row while grouping, order, completeness, and derivative
-coverage remain in a separate noncanonical relationship manifest. This does not
-change the 29-field schema or retroactively redefine existing records. Dynamic
-browser previews and physical-reference photographs remain noncanonical access
-or evidence layers linked through persistent identity.
+Framelapse source fragments are retained unchanged as acquisition evidence. A
+reviewed drawing may be represented canonically either by one selected
+chronological InShot assembly or by a complete, verified `RecNN` sequence of
+unchanged source fragments. In fragment-sequence mode, every source file has its
+own canonical metadata row while grouping, order, completeness, and derivative
+coverage remain in a separate noncanonical relationship manifest. This does not
+change the 29-field schema or retroactively redefine existing records. Dynamic
+browser previews and physical-reference photographs remain noncanonical access
+or evidence layers linked through persistent identity.
+
+Under `standard-2026-08-27`, all `RecNN` members in one prospective grouping
+share the documented finish date and finish time of the complete
+grouping/physical work. That timestamp is not the individual end time of each
+fragment. `RecNN` records chronological position within the group.
 
 A 2160 × 3840 portrait H.264, 30-fps InShot processing profile is documented as
 a candidate. It does not become a canonical protocol boundary until one complete

CHANGELOG.md

@@ -1,5 +1,26 @@
 # Changelog
 
+## Unreleased — focused Standard protocol-version boundary
+
+- Defined `standard-2025-07-13` as the earlier Standard workflow and
+  `standard-2026-08-27` as the prospective canonical fragment-sequence
+  workflow without changing the 29-field metadata schema.
+- Applied `standard-2026-08-27` only to the 186 canonical-fragment
+  `record_id` values in the six dated relationship sidecars from August 27
+  through September 2, 2026. The remaining 363 Standard rows retain
+  `standard-2025-07-13`.
+- Left all 19 historical `RecNN` rows outside those sidecars on
+  `standard-2025-07-13`; a `RecNN` suffix alone does not assign the prospective
+  protocol or establish reviewed grouping completeness.
+- Defined prospective timestamp scope: all `RecNN` members in one grouping
+  share the documented finish date and finish time of the complete
+  grouping/physical work. The timestamp is not an individual fragment end
+  time; `RecNN` records chronological position within the group.
+- Added validation for exact sidecar-to-protocol membership and shared
+  prospective grouping timestamps. No MP4, path, `record_id`, Xet identity,
+  byte size, technical field, provenance relationship, or `SHA256SUMS` payload
+  entry changed.
+
 ## Unreleased — September 2 complete fragment-sequence ingestion, second batch
 
 - Added 29 creator-confirmed, unchanged canonical Framelapse source fragments

README.md

@@ -383,10 +383,12 @@ additions; metadata and release validation are required.
 
 Each canonical metadata row now includes:
 
-- a persistent `record_id`
-- `collection_tier = standard`
-- `is_canonical = true`
-- `acquisition_protocol_version = standard-2025-07-13`
+- a persistent `record_id`
+- `collection_tier = standard`
+- `is_canonical = true`
+- an `acquisition_protocol_version`: 363 earlier-workflow rows use
+  `standard-2025-07-13`, while the 186 canonical fragments in the six dated
+  relationship sidecars use `standard-2026-08-27`
 - descriptive session fields
 - encoded video properties
 - repository content hash and size
@@ -482,20 +484,27 @@ downloadable. See the [sidecar schema](Physical_References/SCHEMA.md) and
 
 ## Acquisition and Stored-Video Orientation
 
-The acquisition protocol effective July 13, 2025 is documented in
-`Archive_Specifications.md`. Framelapse source fragments remain unchanged
-acquisition evidence. For reviewed fragment ingestions, a drawing may be
-represented canonically either by one selected chronological assembly or by a
-complete, verified `RecNN` sequence of unchanged source fragments. Grouping,
-order, completeness, and noncanonical derivative coverage for those ingestions
-remain in separate dated relationship manifests; the active 29-field metadata
-schema is unchanged. The manifests do not backfill every historical `RecNN`
-record. Outside them, `RecNN` establishes recording order only, and any
-grouping or completeness claim is limited to evidence explicitly recorded in
-`notes` or other documentation. A documented 4K/30-fps InShot processing
-profile remains a candidate and does not retroactively redefine existing
-records. See the
-[capture and ingest protocol](Physical_References/CAPTURE_AND_INGEST_PROTOCOL.md).
+The earlier Standard workflow established July 13, 2025 is identified as
+`standard-2025-07-13`. The prospective canonical fragment-sequence workflow
+established August 27, 2026 is identified as `standard-2026-08-27`; this is a
+sidecar-defined membership boundary, not a blanket finish-date cutover.
+Framelapse source fragments remain unchanged acquisition evidence. For reviewed
+fragment ingestions, a drawing may be represented canonically either by one
+selected chronological assembly or by a complete, verified `RecNN` sequence of
+unchanged source fragments. Grouping, order, completeness, and noncanonical
+derivative coverage for those ingestions remain in separate dated relationship
+manifests; the active 29-field metadata schema is unchanged.
+
+All `RecNN` members in one prospective grouping share the documented finish
+date and finish time of the complete grouping/physical work. The timestamp is
+not the individual end time of each fragment; `RecNN` records chronological
+position within the group. The manifests do not backfill every historical
+`RecNN` record. The 19 historical `RecNN` rows outside the six sidecars retain
+`standard-2025-07-13`; their grouping or completeness claims remain limited to
+evidence explicitly recorded in `notes` or other documentation. A documented
+4K/30-fps InShot processing profile remains a candidate and does not
+retroactively redefine existing records. See the
+[capture and ingest protocol](Physical_References/CAPTURE_AND_INGEST_PROTOCOL.md).
 
 The dated relationship sidecars preserve each ingestion as a separate pinned
 observation layer. The
@@ -517,8 +526,9 @@ rows. The
 [`2026-09-02 sidecar`](Standard_Time_Lapses/Provenance/2026-09-02/fragment_sequence_relationships.csv)
 has 61 canonical fragments across five complete sequences and no derivative
 rows. In all six, `fragment_set_label` is a descriptive grouping label, not a
-global `work_id`. The nested derivative payloads are not included in the 677
-active rows or the active byte and duration totals.
+global `work_id`. Together they identify exactly 186 canonical fragments for
+`standard-2026-08-27`. The nested derivative payloads are not included in the
+677 active rows or the active byte and duration totals.
 
 The protocol's capture orientation and a file's stored pixel orientation are
 different concepts. The `orientation`, `width_px`, and `height_px` metadata
@@ -720,8 +730,9 @@ For reproducible work:
 Run the included validator before publishing a metadata change:
 
 ```bash
-python tools/validate_metadata.py metadata.csv \
-  --pre-standard-metadata Pre_Standard_Time_Lapses/metadata.csv
+python tools/validate_metadata.py metadata.csv \
+  --pre-standard-metadata Pre_Standard_Time_Lapses/metadata.csv \
+  --fragment-relationships-root Standard_Time_Lapses/Provenance
 ```
 
 `tools/enrich_prestandard.py` reproduces the Pre-Standard technical fields

SCHEMA.md

@@ -30,7 +30,9 @@ Examples:
   orientation, such as `9x12` or `12x9`.
 - `RecNN` — optional recording-sequence identifier used when documented order
   must be preserved or otherwise identical filenames require distinction.
-  Numbering begins with `Rec01` and may continue across finish dates.
+  Numbering begins with `Rec01`. Historical numbering may continue across
+  finish-date labels; the prospective protocol has the narrower timestamp rule
+  defined below.
 - `ext` — file extension.
 
 ### Filename rules
@@ -44,7 +46,10 @@ Examples:
 - `0000` is reserved for a documented midnight finish time.
 - `RecNN` identifies recording order only. It does not by itself establish a
   separate drawing, session, or completion state, and it does not reset merely
-  because the documented finish date changes.
+  because a historical documented finish-date label changes. Under
+  `standard-2026-08-27`, all members of one documented prospective grouping
+  instead share the grouping timestamp and `RecNN` records chronological
+  position within that group.
 - `UnknownTime` records uncertainty; it is not replaced by an inferred time.
 - Paper-surface variants such as `HotPress` and `ColdPress` may remain encoded
   in filenames until a dedicated metadata field is added.
@@ -82,7 +87,7 @@ legacy files canonical.
 | `record_id` | string | Persistent identity in the form `tla-` plus 16 lowercase hexadecimal characters. |
 | `collection_tier` | enum | `standard` for this index. |
 | `is_canonical` | boolean | `true` for every row in this index. |
-| `acquisition_protocol_version` | string | Protocol identifier; Standard rows use `standard-2025-07-13`. |
+| `acquisition_protocol_version` | enum | Governing Standard workflow: `standard-2025-07-13` for the earlier Standard workflow or `standard-2026-08-27` for canonical fragments reviewed into the prospective fragment-sequence workflow. Assignment is based on documented sidecar membership, not finish date or a `RecNN` suffix alone. |
 
 The initial `record_id` values were generated from a namespaced SHA-256 of the
 published repository path. Once assigned, the stored value is authoritative and
@@ -108,8 +113,8 @@ uncertainty, not failed technical ingestion.
 
 | Field | Type | Meaning |
 | --- | --- | --- |
-| `date` | `YYYY-MM-DD` | Documented finish date label associated with the record; temporal scope is not normalized. |
-| `time` | `HH:MM` or blank | Documented finish time label associated with the record; blank means unknown and temporal scope is not normalized. |
+| `date` | `YYYY-MM-DD` | Documented finish date. For `standard-2026-08-27`, this is the finish date of the complete grouping/physical work shared by every member; earlier records retain their historically documented label. |
+| `time` | `HH:MM` or blank | Documented finish time; blank means unknown. For `standard-2026-08-27`, this is the finish time of the complete grouping/physical work shared by every member. |
 | `tool` | semicolon list | Ordered unique set of documented tools. |
 | `medium` | semicolon list | Ordered unique set of documented media. |
 | `support` | string | Physical drawing surface. |
@@ -128,11 +133,15 @@ to one value. A future paired representation should use a structured field and
 must be based on documented evidence rather than token position.
 
 `date` and `time` preserve the best documented finish labels associated with a
-row. The current 29-field schema does not distinguish whether the source
-documentation scoped a label to an individual recording, a recording session,
-a reviewed fragment sequence, or the physical work. Equal values, differing
-values, and `RecNN` suffixes do not resolve that scope. Use `notes` and
-revision-pinned sidecars only where they make a narrower claim.
+row. For the earlier Standard workflow, the current 29-field schema does not
+distinguish whether the source documentation scoped a label to an individual
+recording, a recording session, a reviewed fragment sequence, or the physical
+work. Equal values, differing values, and `RecNN` suffixes do not resolve that
+historical scope. For `standard-2026-08-27`, the scope is explicit: every
+`RecNN` member in one prospective grouping carries the documented finish date
+and finish time of the complete grouping/physical work. The timestamp is not
+the individual end time of each fragment; `RecNN` records chronological
+position within the group.
 
 ### Encoded-video fields
 
@@ -251,6 +260,12 @@ belong to the same fragment set. Derivative rows and payloads remain outside
 the canonical metadata and Viewer configurations even when stored in the
 repository.
 
+For canonical fragments governed by `standard-2026-08-27`, every member of a
+`fragment_set_label` must have the same metadata `date` and `time`. Those values
+document the finish of the complete grouping/physical work, not the individual
+end time of each fragment. `sequence_position` and its matching `RecNN` suffix
+carry chronological position.
+
 Canonical-fragment evidence requires `owner-confirmed`, `checksum-computed`,
 `media-probed`, `demux-verified`, and `sampled-decode-verified`.
 `boundary-frame-verified` is included only when that separate visual check was
@@ -265,11 +280,17 @@ moving branch, placeholder, or inferred value is invalid. Remote inventory,
 Xet-identity, and relationship-join validation must be completed against that
 commit. The captured inventory also binds the exact bytes of that revision's
 `metadata.csv`, so a local join cannot substitute metadata from a different
-commit. A dated sidecar does not introduce `work_id`, backfill
-historical rows, change `standard-2025-07-13`, or create a new dataset version.
-Consequently, an active `RecNN` row absent from these dated sidecars has not
-been reviewed into this relationship layer; absence does not establish that no
-relationship exists.
+commit. The pinned receipt remains historical evidence and is not rewritten
+when the active metadata later records a protocol boundary.
+
+The canonical-fragment `record_id` values in the six sidecars dated
+`2026-08-27`, `2026-08-29`, `2026-08-30`, `2026-08-31`, `2026-09-01`, and
+`2026-09-02` are the current membership authority for
+`standard-2026-08-27`. Noncanonical derivative rows do not receive a canonical
+protocol value. A dated sidecar does not introduce `work_id`, change any
+`record_id`, or backfill unrelated historical rows. Consequently, an active
+`RecNN` row absent from these dated sidecars retains
+`standard-2025-07-13`; absence does not establish that no relationship exists.
 
 ## Physical-reference sidecar
 
@@ -323,6 +344,9 @@ Before publication, the validator must confirm:
   from both active indexes
 - fragment-sequence positions are contiguous and complete-sequence derivative
   source lists exactly match their own ordered fragment set
+- `standard-2026-08-27` appears on exactly the canonical-fragment IDs in the
+  supplied dated sidecars, every other Standard row remains
+  `standard-2025-07-13`, and each prospective group shares one finish timestamp
 - noncanonical derivative payloads remain absent from both active indexes and
   Viewer configurations
 - relationship paths, Xet identities, sizes, and canonical `record_id` joins
@@ -334,7 +358,8 @@ Run:
 
 ```bash
 python tools/validate_metadata.py metadata.csv \
-  --pre-standard-metadata Pre_Standard_Time_Lapses/metadata.csv
+  --pre-standard-metadata Pre_Standard_Time_Lapses/metadata.csv \
+  --fragment-relationships-root Standard_Time_Lapses/Provenance
 
 python tools/validate_sha256sums.py SHA256SUMS \
   --repo-json repo_api_blobs.json \

VALIDATION.md

@@ -1,6 +1,48 @@
-# Validation Report
-
-## Scope and publication boundary
+# Validation Report
+
+## Current local protocol-boundary candidate
+
+Branch `codex/protocol-version-boundary-2026-08-27` starts at exact Hub `main`
+revision `9cfe7996247900b3b3f69ef3cc78cf54ce734266`. The candidate is local only;
+it has not been pushed, merged, tagged, or released. No MP4 was materialized in
+the working checkout.
+
+The focused change keeps the 29-field schema and assigns protocol versions from
+documented relationship membership rather than a date cutoff or filename
+inference:
+
+| Check | Result |
+| --- | ---: |
+| Canonical Standard rows | 549 |
+| Earlier workflow, `standard-2025-07-13` | 363 |
+| Prospective workflow, `standard-2026-08-27` | 186 |
+| Dated fragment sidecars | 6 |
+| Prospective groupings with one shared finish timestamp | 25 / 25 |
+| Historical `RecNN` rows outside the sidecars, retained on the earlier protocol | 19 / 19 |
+| Metadata columns before / after | 29 / 29 |
+| Non-protocol metadata field changes | 0 |
+| MP4 path or payload changes | 0 |
+| Relationship-sidecar changes | 0 |
+| `SHA256SUMS` byte changes | 0 |
+| Regression tests | 35 / 35 passed |
+
+The candidate `metadata.csv` remains 370,833 bytes and has ordinary SHA-256
+`d516da7a4341dddf0b2b5ad50f6200f283ea0cdefc6de465882fbc021abfba8a`.
+Exactly 186 `acquisition_protocol_version` values changed; every other field in
+every row is byte-for-byte equivalent after CSV parsing. In particular, all
+`record_id`, `file_name`, `hub_xet_hash`, `size_bytes`, encoded-video fields,
+and provenance fields are unchanged. `SHA256SUMS` remains byte-identical at
+SHA-256 `21e9c6dd4cb976754a73201cf5a5dcab8b4402a03781b9afe9ae8ea5f2c4b351`.
+
+The metadata validator passed against the base revision's 732-file Hub
+inventory with zero path, Xet-identity, or size mismatches. All six fragment
+sidecars passed both current structural/metadata joins and their original
+pinned-revision inventory checks using the metadata bytes from each declared
+`source_hub_revision`. Checksum coverage passed for all 683 payloads (682 MP4
+and one ZIP), totaling 2,100,077,836,521 bytes. The 309-row physical-reference
+relationship validation also passed against its pinned source metadata.
+
+## Scope and publication boundary
 
 Hugging Face PR #45 begins at exact Hub `main` revision
 `81d5675113fcd5e26eac0289c228f7ccfe552e42`. It adds 29 unchanged canonical
@@ -204,16 +246,17 @@ visual authentication of absent media.
 
 ## Regression tests
 
-The dependency-free suites currently run 30 tests covering repository receipt
-binding, fragment-size joins and verification levels, semantic documentation
-and metadata invariants, and physical-reference identity, hash-state, pairing,
-manifest, and metadata-join failures.
+The dependency-free suites currently run 35 tests covering repository receipt
+binding, fragment-size joins and verification levels, semantic documentation
+and metadata invariants, the exact protocol-version boundary and prospective
+timestamp scope, and physical-reference identity, hash-state, pairing, manifest,
+and metadata-join failures.
 
 ```bash
 python -m unittest discover -s tools -p "test_*.py"
 ```
 
-Result: **30/30 passed**.
+Result: **35/35 passed**.
 
 ## Outstanding curator questions and limitations
 
@@ -221,11 +264,14 @@ These remain explicit; validation must not guess their answers:
 
 1. One Pre-Standard record has no support token or independent support evidence;
    its `support` remains blank and its `notes` state the limitation.
-2. The current schema does not normalize whether a documented finish label
-   applies to a recording, session, reviewed fragment sequence, or physical work.
+2. The earlier Standard and Pre-Standard workflows do not normalize whether a
+   documented finish label applies to a recording, session, reviewed fragment
+   sequence, or physical work. Under `standard-2026-08-27`, the scope is the
+   complete prospective grouping/physical work.
 3. Nineteen active Standard `RecNN` rows are outside the six dated fragment
-   sidecars. Their existing notes and changelog evidence remain authoritative;
-   sidecar absence does not establish no relationship or sequence completeness.
+   sidecars and retain `standard-2025-07-13`. Their existing notes and changelog
+   evidence remain authoritative; sidecar absence does not establish no
+   relationship or sequence completeness.
 4. Twenty-seven physical-reference rows retain explicit conflict evidence.
    Conflict language is an adjudication queue, not proof that 27 canonical
    timestamps are wrong.
@@ -243,8 +289,9 @@ These remain explicit; validation must not guess their answers:
 Validate both active indexes locally:
 
 ```bash
-python tools/validate_metadata.py metadata.csv \
-  --pre-standard-metadata Pre_Standard_Time_Lapses/metadata.csv
+python tools/validate_metadata.py metadata.csv \
+  --pre-standard-metadata Pre_Standard_Time_Lapses/metadata.csv \
+  --fragment-relationships-root Standard_Time_Lapses/Provenance
 ```
 
 Validate the payload checksum manifest against a blob-enabled repository
@@ -268,13 +315,16 @@ python tools/capture_hub_inventory.py \
   --validation-file metadata.csv \
   --validation-file Pre_Standard_Time_Lapses/metadata.csv
 
-python tools/validate_metadata.py metadata.csv \
-  --pre-standard-metadata Pre_Standard_Time_Lapses/metadata.csv \
-  --repo-inventory-json repo_inventory_xet.json
+python tools/validate_metadata.py metadata.csv \
+  --pre-standard-metadata Pre_Standard_Time_Lapses/metadata.csv \
+  --fragment-relationships-root Standard_Time_Lapses/Provenance \
+  --repo-inventory-json repo_inventory_xet.json
 ```
 
-Validate the dated fragment sidecars separately because each preserves its own
-source revision:
+Validate the dated fragment sidecars against current metadata for structural
+joins. For a pinned-inventory check, use the exact historical `metadata.csv`
+downloaded from that sidecar's `source_hub_revision`; substituting the current
+metadata bytes would invalidate the receipt:
 
 ```bash
 python tools/validate_fragment_relationships.py \
@@ -285,24 +335,24 @@ python tools/validate_fragment_relationships.py \
   --relationships Standard_Time_Lapses/Provenance/2026-08-29/fragment_sequence_relationships.csv \
   --metadata metadata.csv
 
-python tools/validate_fragment_relationships.py \
-  --relationships Standard_Time_Lapses/Provenance/2026-08-30/fragment_sequence_relationships.csv \
-  --metadata metadata.csv \
-  --repo-inventory-json repo_inventory_7293edcc.json
+python tools/validate_fragment_relationships.py \
+  --relationships Standard_Time_Lapses/Provenance/2026-08-30/fragment_sequence_relationships.csv \
+  --metadata pinned/7293edccff883b4c604d710addbf26c85910cfcc/metadata.csv \
+  --repo-inventory-json repo_inventory_7293edcc.json
 
-python tools/validate_fragment_relationships.py \
-  --relationships Standard_Time_Lapses/Provenance/2026-08-31/fragment_sequence_relationships.csv \
-  --metadata metadata.csv \
-  --repo-inventory-json repo_inventory_480bc7e2.json
+python tools/validate_fragment_relationships.py \
+  --relationships Standard_Time_Lapses/Provenance/2026-08-31/fragment_sequence_relationships.csv \
+  --metadata pinned/480bc7e24261e6d3bbcacd261a00782b7e40211a/metadata.csv \
+  --repo-inventory-json repo_inventory_480bc7e2.json
 
 python tools/validate_fragment_relationships.py \
   --relationships Standard_Time_Lapses/Provenance/2026-09-01/fragment_sequence_relationships.csv \
-  --metadata metadata.csv \
+  --metadata pinned/fe66d1dbb117486c2046376423316fd2cc25d488/metadata.csv \
   --repo-inventory-json repo_inventory_fe66d1db.json
 
 python tools/validate_fragment_relationships.py \
   --relationships Standard_Time_Lapses/Provenance/2026-09-02/fragment_sequence_relationships.csv \
-  --metadata metadata.csv \
+  --metadata pinned/7fca6fcc36d873b92a6c64fff5980e8d5afde5a6/metadata.csv \
   --repo-inventory-json repo_inventory_7fca6fcc.json
 ```
 

tools/test_semantic_consistency.py

@@ -4,12 +4,16 @@
 from __future__ import annotations
 
 import csv
+import importlib.util
 import re
+import tempfile
 import unittest
 from pathlib import Path
+from types import ModuleType
 
 
 ROOT = Path(__file__).resolve().parents[1]
+TOOLS = ROOT / "tools"
 
 
 def read_rows(path: Path) -> list[dict[str, str]]:
@@ -17,6 +21,18 @@ def read_rows(path: Path) -> list[dict[str, str]]:
         return list(csv.DictReader(handle))
 
 
+def load_module(name: str, path: Path) -> ModuleType:
+    spec = importlib.util.spec_from_file_location(name, path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"unable to load {path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+validate_metadata = load_module("validate_metadata", TOOLS / "validate_metadata.py")
+
+
 class SemanticConsistencyTests(unittest.TestCase):
     @classmethod
     def setUpClass(cls) -> None:
@@ -24,6 +40,40 @@ class SemanticConsistencyTests(unittest.TestCase):
         cls.pre_standard_rows = read_rows(
             ROOT / "Pre_Standard_Time_Lapses" / "metadata.csv"
         )
+        cls.fragment_sidecars = sorted(
+            (ROOT / "Standard_Time_Lapses" / "Provenance").glob(
+                "*/fragment_sequence_relationships.csv"
+            )
+        )
+        cls.fragment_rows = [
+            row
+            for path in cls.fragment_sidecars
+            for row in read_rows(path)
+            if row["object_role"] == "canonical_fragment"
+        ]
+        cls.fragment_record_ids = {row["record_id"] for row in cls.fragment_rows}
+        cls.standard_by_id = {row["record_id"]: row for row in cls.standard_rows}
+
+    def validate_standard_rows(
+        self, rows: list[dict[str, str]]
+    ) -> dict[str, object]:
+        with tempfile.TemporaryDirectory(prefix="tla-protocol-test-") as temp_dir:
+            metadata_path = Path(temp_dir) / "metadata.csv"
+            with metadata_path.open("w", encoding="utf-8", newline="") as handle:
+                writer = csv.DictWriter(
+                    handle,
+                    fieldnames=list(rows[0]),
+                    lineterminator="\n",
+                )
+                writer.writeheader()
+                writer.writerows(rows)
+            return validate_metadata.validate(
+                metadata_path,
+                None,
+                None,
+                None,
+                ROOT / "Standard_Time_Lapses" / "Provenance",
+            )
 
     def test_pre_standard_tool_medium_contract_is_independent(self) -> None:
         schema = (ROOT / "Pre_Standard_Time_Lapses" / "SCHEMA.md").read_text(
@@ -63,6 +113,109 @@ class SemanticConsistencyTests(unittest.TestCase):
                 self.assertEqual(row["support"], "IllustrationBoard")
                 self.assertIn(".IllustrationBoard.30x40.", row["file_name"])
 
+    def test_protocol_boundary_matches_six_fragment_sidecars(self) -> None:
+        prospective_ids = {
+            row["record_id"]
+            for row in self.standard_rows
+            if row["acquisition_protocol_version"] == "standard-2026-08-27"
+        }
+        earlier_ids = {
+            row["record_id"]
+            for row in self.standard_rows
+            if row["acquisition_protocol_version"] == "standard-2025-07-13"
+        }
+
+        self.assertEqual(
+            [path.parent.name for path in self.fragment_sidecars],
+            [
+                "2026-08-27",
+                "2026-08-29",
+                "2026-08-30",
+                "2026-08-31",
+                "2026-09-01",
+                "2026-09-02",
+            ],
+        )
+        self.assertEqual(len(self.fragment_rows), 186)
+        self.assertEqual(len(self.fragment_record_ids), 186)
+        self.assertEqual(prospective_ids, self.fragment_record_ids)
+        self.assertEqual(
+            earlier_ids,
+            set(self.standard_by_id).difference(prospective_ids),
+        )
+
+    def test_historical_recnn_rows_keep_the_earlier_protocol(self) -> None:
+        recnn_ids = {
+            row["record_id"]
+            for row in self.standard_rows
+            if re.search(r"\.Rec\d+\.mp4$", row["file_name"])
+        }
+        historical_ids = recnn_ids.difference(self.fragment_record_ids)
+
+        self.assertEqual(len(historical_ids), 19)
+        self.assertEqual(
+            {
+                self.standard_by_id[record_id]["acquisition_protocol_version"]
+                for record_id in historical_ids
+            },
+            {"standard-2025-07-13"},
+        )
+
+    def test_prospective_group_timestamps_are_shared(self) -> None:
+        groups: dict[str, set[tuple[str, str]]] = {}
+        for row in self.fragment_rows:
+            metadata = self.standard_by_id[row["record_id"]]
+            groups.setdefault(row["fragment_set_label"], set()).add(
+                (metadata["date"], metadata["time"])
+            )
+
+        self.assertEqual(len(groups), 25)
+        self.assertTrue(all(len(timestamps) == 1 for timestamps in groups.values()))
+        schema = (ROOT / "SCHEMA.md").read_text(encoding="utf-8")
+        normalized_schema = re.sub(r"\s+", " ", schema)
+        self.assertIn("complete grouping/physical work", normalized_schema)
+        self.assertIn(
+            "not the individual end time of each fragment", normalized_schema
+        )
+
+    def test_metadata_validator_rejects_protocol_boundary_drift(self) -> None:
+        rows = [dict(row) for row in self.standard_rows]
+        prospective_row = next(
+            row for row in rows if row["record_id"] in self.fragment_record_ids
+        )
+        prospective_row["acquisition_protocol_version"] = "standard-2025-07-13"
+        report = self.validate_standard_rows(rows)
+
+        self.assertFalse(report["ok"])
+        self.assertTrue(
+            any("sidecar-defined boundary" in error for error in report["errors"]),
+            report["errors"],
+        )
+
+    def test_metadata_validator_rejects_prospective_timestamp_drift(self) -> None:
+        rows = [dict(row) for row in self.standard_rows]
+        prospective_row = next(
+            row for row in rows if row["record_id"] in self.fragment_record_ids
+        )
+        original_time = prospective_row["time"]
+        changed_time = "23:59" if original_time != "23:59" else "23:58"
+        prospective_row["time"] = changed_time
+        prospective_row["file_name"] = prospective_row["file_name"].replace(
+            f".{original_time.replace(':', '')}.",
+            f".{changed_time.replace(':', '')}.",
+            1,
+        )
+        report = self.validate_standard_rows(rows)
+
+        self.assertFalse(report["ok"])
+        self.assertTrue(
+            any(
+                "do not share one documented finish date and time" in error
+                for error in report["errors"]
+            ),
+            report["errors"],
+        )
+
     def test_readme_audio_count_matches_active_indexes(self) -> None:
         active = self.standard_rows + self.pre_standard_rows
         audio_count = sum(row["has_audio"].lower() == "true" for row in active)

tools/validate_metadata.py

@@ -23,6 +23,12 @@ TIME_RE = re.compile(r"^(?:[01]\d|2[0-3]):[0-5]\d$")
 DIMENSIONS_RE = re.compile(r"^\d+(?:\.\d+)?x\d+(?:\.\d+)?$")
 DIRECT_STANDARD_RE = re.compile(r"^Standard_Time_Lapses/[^/]+\.mp4$")
 DIRECT_PRE_STANDARD_RE = re.compile(r"^Pre_Standard_Time_Lapses/[^/]+\.mp4$")
+EARLIER_STANDARD_PROTOCOL = "standard-2025-07-13"
+PROSPECTIVE_FRAGMENT_PROTOCOL = "standard-2026-08-27"
+STANDARD_PROTOCOLS = {
+    EARLIER_STANDARD_PROTOCOL,
+    PROSPECTIVE_FRAGMENT_PROTOCOL,
+}
 
 REQUIRED_FIELDS = [
     "file_name",
@@ -90,6 +96,69 @@ def valid_calendar_date(value: str) -> bool:
     return True
 
 
+def load_fragment_protocol_membership(
+    relationships_root: Path,
+    errors: list[str],
+) -> tuple[set[str], dict[str, list[str]], int]:
+    """Load canonical-fragment membership from dated relationship sidecars."""
+
+    sidecars = sorted(
+        relationships_root.glob("*/fragment_sequence_relationships.csv")
+    )
+    if not sidecars:
+        errors.append(
+            f"no dated fragment relationship sidecars found under {relationships_root}"
+        )
+        return set(), {}, 0
+
+    required_fields = {
+        "fragment_set_label",
+        "object_role",
+        "record_id",
+    }
+    prospective_ids: set[str] = set()
+    groups: dict[str, list[str]] = {}
+
+    for sidecar in sidecars:
+        try:
+            fields, relationship_rows = load_csv(sidecar)
+        except (OSError, ValueError) as exc:
+            errors.append(f"{sidecar}: unable to load fragment relationships: {exc}")
+            continue
+        missing_fields = sorted(required_fields.difference(fields))
+        if missing_fields:
+            errors.append(
+                f"{sidecar}: missing protocol-boundary fields: {missing_fields}"
+            )
+            continue
+
+        for index, relationship in enumerate(relationship_rows, start=2):
+            if relationship.get("object_role") != "canonical_fragment":
+                continue
+            record_id = relationship.get("record_id", "")
+            label = relationship.get("fragment_set_label", "")
+            row_label = f"{sidecar} row {index}"
+            if not RECORD_ID_RE.fullmatch(record_id):
+                errors.append(f"{row_label}: canonical fragment has invalid record_id")
+                continue
+            if not label:
+                errors.append(
+                    f"{row_label}: canonical fragment has no fragment_set_label"
+                )
+                continue
+            if record_id in prospective_ids:
+                errors.append(
+                    f"{row_label}: canonical record_id {record_id} occurs in "
+                    "multiple dated sidecars"
+                )
+                continue
+            prospective_ids.add(record_id)
+            group_key = f"{sidecar.parent.name}/{label}"
+            groups.setdefault(group_key, []).append(record_id)
+
+    return prospective_ids, groups, len(sidecars)
+
+
 def validate_multi_value(
     row: dict[str, str], label: str, field: str, errors: list[str]
 ) -> None:
@@ -180,6 +249,7 @@ def validate(
     viewer_json: Path | None,
     pre_standard_metadata: Path | None,
     repo_files_json: Path | None,
+    fragment_relationships_root: Path | None = None,
 ) -> dict[str, object]:
     fields, rows = load_csv(metadata_csv)
     errors: list[str] = []
@@ -188,6 +258,16 @@ def validate(
     repo_counts: dict[str, int] = {}
     repo_unindexed_standard: list[str] = []
     repo_unindexed_pre_standard: list[str] = []
+    prospective_fragment_ids: set[str] = set()
+    prospective_fragment_groups: dict[str, list[str]] = {}
+    fragment_sidecar_count = 0
+
+    if fragment_relationships_root:
+        (
+            prospective_fragment_ids,
+            prospective_fragment_groups,
+            fragment_sidecar_count,
+        ) = load_fragment_protocol_membership(fragment_relationships_root, errors)
 
     missing_fields = [field for field in REQUIRED_FIELDS if field not in fields]
     if missing_fields:
@@ -212,7 +292,19 @@ def validate(
             errors.append(f"{label}: collection_tier must be standard")
         if row.get("is_canonical", "").lower() != "true":
             errors.append(f"{label}: is_canonical must be true")
-        if row.get("acquisition_protocol_version") != "standard-2025-07-13":
+        protocol = row.get("acquisition_protocol_version", "")
+        if fragment_relationships_root:
+            expected_protocol = (
+                PROSPECTIVE_FRAGMENT_PROTOCOL
+                if row.get("record_id") in prospective_fragment_ids
+                else EARLIER_STANDARD_PROTOCOL
+            )
+            if protocol != expected_protocol:
+                errors.append(
+                    f"{label}: acquisition protocol {protocol!r} does not match "
+                    f"sidecar-defined boundary {expected_protocol!r}"
+                )
+        elif protocol not in STANDARD_PROTOCOLS:
             errors.append(f"{label}: unexpected acquisition protocol version")
         if not valid_calendar_date(row.get("date", "")):
             errors.append(f"{label}: invalid or missing finish date")
@@ -240,6 +332,38 @@ def validate(
 
         validate_technical_row(row, label, errors)
 
+    if fragment_relationships_root:
+        rows_by_id = {
+            row.get("record_id", ""): row for row in rows if row.get("record_id")
+        }
+        missing_fragment_ids = sorted(prospective_fragment_ids.difference(rows_by_id))
+        if missing_fragment_ids:
+            errors.append(
+                f"{len(missing_fragment_ids)} sidecar-defined canonical fragments are absent "
+                "from metadata.csv"
+            )
+        for group_label, record_ids in prospective_fragment_groups.items():
+            group_rows = [
+                rows_by_id[record_id]
+                for record_id in record_ids
+                if record_id in rows_by_id
+            ]
+            timestamps = {
+                (row.get("date", ""), row.get("time", "")) for row in group_rows
+            }
+            if len(group_rows) == len(record_ids) and len(timestamps) != 1:
+                errors.append(
+                    f"{group_label}: prospective fragment members do not share one "
+                    "documented finish date and time"
+                )
+            elif len(group_rows) == len(record_ids) and timestamps:
+                finish_date, finish_time = next(iter(timestamps))
+                if not finish_date or not finish_time:
+                    errors.append(
+                        f"{group_label}: prospective fragment grouping must have a "
+                        "documented finish date and time"
+                    )
+
     standard_30x40_non_board = sum(
         row.get("dimensions") == "30x40"
         and row.get("support") != "IllustrationBoard"
@@ -547,6 +671,19 @@ def validate(
             ),
             "unknown_finish_dates": sum(not row.get("date") for row in all_active_rows),
             "unknown_finish_times": sum(not row.get("time") for row in all_active_rows),
+            "protocol_version_counts": dict(
+                sorted(
+                    Counter(
+                        row.get("acquisition_protocol_version", "") for row in rows
+                    ).items()
+                )
+            ),
+            "protocol_boundary": {
+                "checked": fragment_relationships_root is not None,
+                "fragment_relationship_sidecars": fragment_sidecar_count,
+                "prospective_record_ids": len(prospective_fragment_ids),
+                "earlier_standard_rows": len(rows) - len(prospective_fragment_ids),
+            },
             "orientation_counts": dict(sorted(orientations.items())),
             "audio_counts": dict(sorted(audio.items())),
             "playback_hours": round(sum(durations) / 3600, 2),
@@ -567,6 +704,14 @@ def main() -> None:
         dest="repo_files_json",
         type=Path,
     )
+    parser.add_argument(
+        "--fragment-relationships-root",
+        type=Path,
+        help=(
+            "directory containing dated fragment_sequence_relationships.csv "
+            "sidecars that define the Standard protocol-version boundary"
+        ),
+    )
     parser.add_argument("--output", type=Path)
     args = parser.parse_args()
 
@@ -575,6 +720,7 @@ def main() -> None:
         args.viewer_json,
         args.pre_standard_metadata,
         args.repo_files_json,
+        args.fragment_relationships_root,
     )
     rendered = json.dumps(report, indent=2, sort_keys=True)
     if args.output: