feat: define sealed wall-clock evidence ledgers

Standard_Time_Lapses/Provenance/Wall_Clock_Declarations/SCHEMA.md

@@ -0,0 +1,99 @@
+# Wall-clock declaration ledger schemas, version 1
+
+These immutable weekly text packets classify only `claim_type=recording_start`.
+`timing_supported` means a traceable claim-specific observation. It does not
+establish calibrated clock accuracy, elapsed drawing time, continuous capture,
+or a recording stop. Encoded PTS, playback duration, frame count, and frame rate
+cannot create or strengthen a claim and have no declaration basis in this schema.
+
+## Common packet metadata
+
+Every packet has exactly its documented fields. All three packet types contain:
+
+| Field | Contract |
+| --- | --- |
+| `schema` | Exact versioned schema below |
+| `ledger_id` | Nonempty ID matching `[A-Za-z0-9][A-Za-z0-9._-]*` |
+| `ingestion_week` | Valid ISO week in `YYYY-Www` form |
+| `source_revision` | Lowercase 40-hex Git source revision |
+| `cohort` | `active_ingest` or `historical_backfill` |
+
+Candidate, event, and seal metadata must agree within a sealed week. The cohort
+identifies membership; active-ingest and historical-backfill denominators remain
+separate. Candidate snapshots may be empty in weeks containing only updates.
+
+## Text receipts
+
+A receipt is exactly `{ "path": "...", "size_bytes": 123, "sha256": "..." }`.
+`path` is a canonical repository-relative POSIX path: no absolute paths, `..`,
+dot components, repeated or trailing separators, backslashes, colons, or control
+characters. Text artifacts use `.json`, `.csv`, `.md`, `.txt` (case-insensitive),
+or the basename `SHA256SUMS`. Other names are rejected before filesystem access.
+All path components must be free of symlinks. Artifacts must decode as UTF-8
+(an optional BOM is accepted). `size_bytes` is a positive integer, never a boolean;
+`sha256` is lowercase 64-hex. Both bind the exact original bytes without newline,
+encoding, or whitespace normalization. Media payloads must never be opened,
+probed, statted, decoded, or hashed.
+
+`receipt(root, relative)` computes a text receipt. `check_receipt(root, declared)`
+verifies a receipt and returns its filesystem path. Invalid data raises `ValueError`.
+
+## Candidate packet: `wall-clock-candidates/v1`
+
+In addition to common metadata, the packet has `source_files` (a list of text
+receipts binding source indexes) and `candidates` (a list). Each candidate has
+exactly `record_id` (nonblank string), `work_id` (string, empty if unknown), and
+`claim_type` (`recording_start`). `(record_id, claim_type)` must be unique.
+Source receipt paths must be unique. `validate_candidates(packet)` returns the
+validated candidate list without changing it.
+
+## Event packet: `wall-clock-events/v1`
+
+In addition to common metadata, the packet has an ordered `events` list.
+Every event has exactly these fields:
+
+| Field | Contract |
+| --- | --- |
+| `event_id` | Nonblank string, unique within the packet |
+| `record_id` | Nonblank stable record identity |
+| `claim_type` | `recording_start` |
+| `status` | `timing_supported` or `timing_unresolved` |
+| `event_type` | `initial_classification`, `resolution`, or `correction` |
+| `prior_event_id` | `null` for initial events; nonblank preceding event ID for updates |
+| `declared_value` | Explicit-offset ISO-8601 literal for supported events; otherwise `""` |
+| `declaration_basis` | Accepted basis below for supported events; otherwise `""` |
+| `evidence` | List of text receipts with unique paths; nonempty for supported events |
+| `unresolved_reason` | Accepted unresolved reason below; `""` for supported events |
+| `qualification` | String containing any claim qualification; may be empty |
+| `created_at` | Explicit-offset ISO-8601 creation timestamp |
+
+The only supported bases are `device_filename_interpreted_in_declared_timezone`,
+`creator_declared_recording_start`, and `contemporaneous_capture_log`. An
+unresolved event requires `missing_declaration`, `conflicting_declarations`, or
+`unverifiable_declaration`. Unresolved evidence may be empty or record the text
+behind a conflict. Timestamp literals use `YYYY-MM-DDTHH:MM:SS[.fraction]` followed
+by `Z` or `+HH:MM` / `-HH:MM`; values are retained literally, never inferred.
+
+`validate_events(packet)` returns the validated event list. It checks event
+shape, receipt shape, timestamps, and local event-ID uniqueness. Current-event
+references, candidate coverage, cross-ledger uniqueness, and state transitions
+belong to the later cumulative reduction layer. A self-reference is invalid.
+
+## Seal packet: `wall-clock-ledger-seal/v1`
+
+In addition to common metadata, the seal has `candidates` and `events` (receipts
+for sibling `candidates.json` and `events.json`), `previous_seal_sha256` (the
+preceding registered seal's exact digest, or `null` for the first seal), and
+`created_at` (an explicit-offset ISO-8601 timestamp). Its filename is `SEAL.json`.
+The ordered registry pins each seal with its own text receipt. Files and seals
+are immutable after registration; later resolution or correction adds an event
+in a later ledger rather than rewriting existing packets.
+
+`validate_seal(root, declared_seal, previous_sha256)` validates the seal receipt,
+prior digest, both member receipts and schemas, matching metadata, source-index
+receipts, and every event evidence receipt. It returns `(candidates_packet,
+events_packet)`. Registry order supplies `previous_sha256`; reordering, omission,
+or mutation in the middle of the registered chain fails validation. Anchoring
+the registry and detecting removal of its final entry are registry-level duties.
+All validation is read-only. No authoring or generated projections are defined
+by this foundational contract.

tools/test_wall_clock_declarations.py

@@ -0,0 +1,186 @@
+"""Text-only contracts for sealed recording-start declaration ledgers."""
+import copy
+import hashlib
+import json
+import tempfile
+import unittest
+from pathlib import Path
+
+try:
+    from tools import wall_clock_declarations as ledger
+except ImportError:
+    ledger = None
+
+
+REVISION = '6fed0d073bdc307cdb81ea1dd8d4db6b1ecb04c7'
+STAMP = '2026-10-24T12:00:00+00:00'
+
+
+class WallClockDeclarationTests(unittest.TestCase):
+    def setUp(self):
+        self.assertIsNotNone(ledger, 'Wall-clock declaration validation is not implemented')
+        self.directory = tempfile.TemporaryDirectory()
+        self.addCleanup(self.directory.cleanup)
+        self.root = Path(self.directory.name)
+        (self.root / 'evidence.txt').write_text('Creator declared recording start.\n', encoding='utf-8')
+        self.evidence = self.write_receipt('evidence.txt')
+        self.metadata = dict(ledger_id='2026-W43-active', ingestion_week='2026-W43',
+                             source_revision=REVISION, cohort='active_ingest')
+        self.candidates = dict(schema='wall-clock-candidates/v1', **self.metadata,
+                               source_files=[self.evidence], candidates=[dict(
+                                   record_id='record-1', work_id='', claim_type='recording_start')])
+        self.event = dict(event_id='2026-W43-active:record-1:initial', record_id='record-1',
+                          claim_type='recording_start', status='timing_supported',
+                          event_type='initial_classification', prior_event_id=None,
+                          declared_value='2026-10-23T20:00:00-04:00',
+                          declaration_basis='creator_declared_recording_start',
+                          evidence=[self.evidence], unresolved_reason='', qualification='',
+                          created_at=STAMP)
+        self.events = dict(schema='wall-clock-events/v1', **self.metadata, events=[self.event])
+
+    def write_receipt(self, relative, value=None):
+        path = self.root / relative
+        if value is not None:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            path.write_text(json.dumps(value) + '\n', encoding='utf-8')
+        data = path.read_bytes()
+        return dict(path=relative, size_bytes=len(data), sha256=hashlib.sha256(data).hexdigest())
+
+    def seal(self, previous=None):
+        members = 'ledgers/2026-W43-active/'
+        seal = dict(schema='wall-clock-ledger-seal/v1', **self.metadata,
+                    candidates=self.write_receipt(members + 'candidates.json', self.candidates),
+                    events=self.write_receipt(members + 'events.json', self.events),
+                    previous_seal_sha256=previous, created_at=STAMP)
+        return self.write_receipt(members + 'SEAL.json', seal)
+
+    def test_valid_minimal_week_passes(self):
+        self.assertEqual(ledger.receipt(self.root, 'evidence.txt'), self.evidence)
+        self.assertEqual(ledger.check_receipt(self.root, self.evidence), self.root / 'evidence.txt')
+        self.assertEqual(ledger.validate_candidates(self.candidates), self.candidates['candidates'])
+        self.assertEqual(ledger.validate_events(self.events), [self.event])
+        self.assertEqual(ledger.validate_seal(self.root, self.seal(), None),
+                         (self.candidates, self.events))
+        unresolved = copy.deepcopy(self.event)
+        unresolved.update(status='timing_unresolved', declared_value='', declaration_basis='',
+                          evidence=[], unresolved_reason='missing_declaration')
+        self.events['events'] = [unresolved]
+        self.assertEqual(ledger.validate_events(self.events), [unresolved])
+
+    def test_unsafe_or_mismatched_receipt_fails(self):
+        for path in ['', '.', '../evidence.txt', '/evidence.txt', './evidence.txt',
+                     'a/../evidence.txt', 'a//b.txt', 'a\\b.txt', 'C:evidence.txt',
+                     'evidence.txt/', 'clip.mp4', 'clip.MOV', 'image.png']:
+            with self.subTest(path=path), self.assertRaises(ValueError):
+                ledger.receipt(self.root, path)
+        for field, value in [('size_bytes', 0), ('size_bytes', True), ('size_bytes', 1),
+                             ('sha256', 'A' * 64), ('sha256', '0' * 64), ('sha256', None)]:
+            receipt = dict(self.evidence, **{field: value})
+            with self.subTest(field=field, value=value), self.assertRaises(ValueError):
+                ledger.check_receipt(self.root, receipt)
+        (self.root / 'link.txt').symlink_to(self.root / 'evidence.txt')
+        with self.assertRaises(ValueError):
+            ledger.receipt(self.root, 'link.txt')
+        (self.root / 'empty.txt').write_text('', encoding='utf-8')
+        with self.assertRaises(ValueError):
+            ledger.receipt(self.root, 'empty.txt')
+
+    def test_supported_claim_requires_text_evidence(self):
+        for evidence in [[], [dict(self.evidence, path='clip.mp4')],
+                         [dict(self.evidence, size_bytes=0)]]:
+            self.event['evidence'] = evidence
+            with self.subTest(evidence=evidence), self.assertRaises(ValueError):
+                ledger.validate_events(self.events)
+
+    def test_media_derived_basis_is_not_in_schema(self):
+        for basis in ['encoded_media', 'encoded_pts', 'playback_duration', 'frame_count', 'frame_rate']:
+            self.event['declaration_basis'] = basis
+            with self.subTest(basis=basis), self.assertRaises(ValueError):
+                ledger.validate_events(self.events)
+
+    def test_only_declared_text_bases_pass(self):
+        for basis in ['device_filename_interpreted_in_declared_timezone',
+                      'creator_declared_recording_start', 'contemporaneous_capture_log']:
+            self.event['declaration_basis'] = basis
+            self.assertEqual(ledger.validate_events(self.events), [self.event])
+
+    def test_wrong_schemas_claims_status_and_revision_fail(self):
+        for validator, packet in [(ledger.validate_candidates, self.candidates),
+                                  (ledger.validate_events, self.events)]:
+            for field, value in [('schema', 'wrong/v1'), ('source_revision', 'main'),
+                                 ('source_revision', 'a' * 39), ('cohort', 'combined'),
+                                 ('ingestion_week', '2026-W54')]:
+                changed = dict(packet, **{field: value})
+                with self.subTest(field=field), self.assertRaises(ValueError):
+                    validator(changed)
+        self.candidates['candidates'][0]['claim_type'] = 'recording_stop'
+        with self.assertRaises(ValueError):
+            ledger.validate_candidates(self.candidates)
+        for field, value in [('claim_type', 'recording_stop'), ('status', 'supported'),
+                             ('event_type', 'replacement'), ('frame_count', 100)]:
+            changed = dict(self.event, **{field: value})
+            with self.subTest(field=field), self.assertRaises(ValueError):
+                ledger.validate_events(dict(self.events, events=[changed]))
+
+    def test_duplicate_candidates_and_events_fail(self):
+        self.candidates['candidates'] *= 2
+        with self.assertRaises(ValueError):
+            ledger.validate_candidates(self.candidates)
+        self.events['events'] *= 2
+        with self.assertRaises(ValueError):
+            ledger.validate_events(self.events)
+
+    def test_literal_time_requires_explicit_offset(self):
+        for value in ['2026-10-23T20:00:00', '2026-10-23', '2026-02-30T20:00:00Z',
+                      '2026-10-23T20:00:00+99:00', '20261023T200000Z', '2026-10-23 20:00:00Z']:
+            self.event['declared_value'] = value
+            with self.subTest(value=value), self.assertRaises(ValueError):
+                ledger.validate_events(self.events)
+        self.event['declared_value'] = '2026-10-23T20:00:00Z'
+        self.assertEqual(ledger.validate_events(self.events), [self.event])
+
+    def test_unresolved_reasons_and_event_references(self):
+        self.event.update(status='timing_unresolved', declared_value='', declaration_basis='', evidence=[])
+        for reason in ['missing_declaration', 'conflicting_declarations', 'unverifiable_declaration']:
+            self.event['unresolved_reason'] = reason
+            self.assertEqual(ledger.validate_events(self.events), [self.event])
+        self.event['unresolved_reason'] = 'unknown'
+        with self.assertRaises(ValueError):
+            ledger.validate_events(self.events)
+        self.event['unresolved_reason'] = 'missing_declaration'
+        self.event['event_type'] = 'resolution'
+        with self.assertRaises(ValueError):
+            ledger.validate_events(self.events)
+        self.event['prior_event_id'] = 'prior:record-1'
+        self.assertEqual(ledger.validate_events(self.events), [self.event])
+
+    def test_seal_chain_and_member_tampering_fail(self):
+        previous = 'a' * 64
+        declared = self.seal(previous)
+        self.assertEqual(ledger.validate_seal(self.root, declared, previous),
+                         (self.candidates, self.events))
+        for prior in [None, 'b' * 64, 'not-a-digest']:
+            with self.subTest(prior=prior), self.assertRaises(ValueError):
+                ledger.validate_seal(self.root, declared, prior)
+        (self.root / 'ledgers/2026-W43-active/events.json').write_text('{}', encoding='utf-8')
+        with self.assertRaises(ValueError):
+            ledger.validate_seal(self.root, declared, previous)
+
+    def test_seal_binds_metadata_schema_and_evidence(self):
+        for mutation in ['schema', 'metadata', 'evidence']:
+            declared = self.seal()
+            seal_path = self.root / declared['path']
+            seal = json.loads(seal_path.read_text(encoding='utf-8'))
+            if mutation == 'schema':
+                seal['schema'] = 'wrong/v1'
+            elif mutation == 'metadata':
+                seal['ledger_id'] = 'another-ledger'
+            else:
+                (self.root / 'evidence.txt').write_text('Changed declaration.\n', encoding='utf-8')
+            declared = self.write_receipt(declared['path'], seal)
+            with self.subTest(mutation=mutation), self.assertRaises(ValueError):
+                ledger.validate_seal(self.root, declared, None)
+
+
+if __name__ == '__main__':
+    unittest.main()

tools/wall_clock_declarations.py

@@ -0,0 +1,234 @@
+"""Validate immutable, text-only recording-start declaration ledger packets.
+
+Receipt validation deliberately admits only named text formats and rejects
+symlinks before reading. No media path is probed, statted, opened, or hashed.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from datetime import date, datetime
+from pathlib import Path, PurePosixPath
+
+PREFIX = Path('Standard_Time_Lapses/Provenance/Wall_Clock_Declarations')
+SUPPORTED_BASES = frozenset({
+    'device_filename_interpreted_in_declared_timezone',
+    'creator_declared_recording_start',
+    'contemporaneous_capture_log',
+})
+UNRESOLVED_REASONS = frozenset({
+    'missing_declaration', 'conflicting_declarations', 'unverifiable_declaration',
+})
+METADATA_FIELDS = {'ledger_id', 'ingestion_week', 'source_revision', 'cohort'}
+TEXT_SUFFIXES = {'.json', '.csv', '.md', '.txt'}
+EVENT_FIELDS = {
+    'event_id', 'record_id', 'claim_type', 'status', 'event_type',
+    'prior_event_id', 'declared_value', 'declaration_basis', 'evidence',
+    'unresolved_reason', 'qualification', 'created_at',
+}
+
+
+def require(condition, message):
+    if not condition:
+        raise ValueError(message)
+
+
+def _fields(value, expected, description):
+    require(isinstance(value, dict) and set(value) == expected,
+            f'Unexpected or missing {description} fields')
+
+
+def _text(value, description, allow_empty=False):
+    require(isinstance(value, str) and (allow_empty or bool(value.strip())),
+            f'Invalid {description}')
+
+
+def _digest(value):
+    require(isinstance(value, str) and re.fullmatch(r'[0-9a-f]{64}', value),
+            'Invalid receipt SHA-256')
+
+
+def relative_path(value):
+    """Reject unsafe and non-text names before any filesystem operation."""
+    _text(value, 'receipt path')
+    path = PurePosixPath(value)
+    require(value != '.' and not path.is_absolute() and '..' not in path.parts
+            and '\\' not in value and ':' not in value
+            and not any(ord(character) < 32 for character in value), 'Unsafe receipt path')
+    require(path.as_posix() == value, 'Noncanonical receipt path')
+    require(path.suffix.lower() in TEXT_SUFFIXES or path.name == 'SHA256SUMS',
+            'Receipt must reference a text artifact')
+    return Path(value)
+
+
+def _validate_receipt(declared):
+    _fields(declared, {'path', 'size_bytes', 'sha256'}, 'receipt')
+    path = relative_path(declared['path'])
+    _digest(declared['sha256'])
+    require(type(declared['size_bytes']) is int and declared['size_bytes'] > 0,
+            'Invalid receipt size')
+    return path
+
+
+def receipt(root: Path, relative: str) -> dict[str, object]:
+    path = relative_path(relative)
+    target = Path(root)
+    # Never follow a text-named symlink into a media payload or out of root.
+    for part in path.parts:
+        target = target / part
+        require(not target.is_symlink(), 'Symlink receipt path is forbidden')
+    try:
+        data = target.read_bytes()
+        data.decode('utf-8-sig')
+    except (OSError, UnicodeError) as error:
+        raise ValueError(f'Cannot read UTF-8 text artifact: {relative}') from error
+    require(bool(data), 'Invalid receipt size')
+    return dict(path=relative, size_bytes=len(data), sha256=hashlib.sha256(data).hexdigest())
+
+
+def check_receipt(root: Path, declared: dict[str, object]) -> Path:
+    path = _validate_receipt(declared)
+    require(receipt(root, declared['path']) == declared,
+            f'Receipt mismatch: {declared["path"]}')
+    return Path(root) / path
+
+
+def _literal_time(value, description):
+    _text(value, description)
+    require(re.fullmatch(
+        r'\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})', value),
+        f'{description} requires an explicit-offset ISO-8601 literal')
+    try:
+        parsed = datetime.fromisoformat(value.replace('Z', '+00:00'))
+    except ValueError as error:
+        raise ValueError(f'Invalid {description}') from error
+    # datetime accepts oversized minute components by normalizing the offset.
+    require(value.endswith('Z') or (int(value[-5:-3]) <= 23 and int(value[-2:]) <= 59),
+            f'Invalid {description} offset')
+    require(parsed.utcoffset() is not None, f'Missing {description} offset')
+
+
+def _metadata(packet, schema, extra_fields):
+    _fields(packet, {'schema'} | METADATA_FIELDS | extra_fields, 'packet')
+    require(packet['schema'] == schema, 'Wrong wall-clock schema')
+    _text(packet['ledger_id'], 'ledger ID')
+    require(re.fullmatch(r'[A-Za-z0-9][A-Za-z0-9._-]*', packet['ledger_id']), 'Unsafe ledger ID')
+    revision = packet['source_revision']
+    require(isinstance(revision, str) and re.fullmatch(r'[0-9a-f]{40}', revision),
+            'Invalid source revision')
+    week = packet['ingestion_week']
+    require(isinstance(week, str) and re.fullmatch(r'\d{4}-W\d{2}', week), 'Invalid ingestion week')
+    try:
+        date.fromisocalendar(int(week[:4]), int(week[-2:]), 1)
+    except ValueError as error:
+        raise ValueError('Invalid ingestion week') from error
+    require(packet['cohort'] in ('active_ingest', 'historical_backfill'), 'Invalid cohort')
+
+
+def _receipts(value):
+    require(isinstance(value, list), 'Evidence receipts must be a list')
+    paths = set()
+    for declared in value:
+        _validate_receipt(declared)
+        require(declared['path'] not in paths, 'Duplicate evidence receipt')
+        paths.add(declared['path'])
+
+
+def _identity(item):
+    _text(item['record_id'], 'record ID')
+    require(item['claim_type'] == 'recording_start', 'Unsupported claim type')
+
+
+def validate_candidates(packet: dict[str, object]) -> list[dict[str, object]]:
+    _metadata(packet, 'wall-clock-candidates/v1', {'source_files', 'candidates'})
+    _receipts(packet['source_files'])
+    rows = packet['candidates']
+    require(isinstance(rows, list), 'Candidates must be a list')
+    seen = set()
+    for row in rows:
+        _fields(row, {'record_id', 'work_id', 'claim_type'}, 'candidate')
+        _identity(row)
+        _text(row['work_id'], 'work ID', allow_empty=True)
+        key = row['record_id'], row['claim_type']
+        require(key not in seen, 'Duplicate candidate key')
+        seen.add(key)
+    return rows
+
+
+def validate_events(packet: dict[str, object]) -> list[dict[str, object]]:
+    _metadata(packet, 'wall-clock-events/v1', {'events'})
+    rows = packet['events']
+    require(isinstance(rows, list), 'Events must be a list')
+    seen = set()
+    for row in rows:
+        _fields(row, EVENT_FIELDS, 'event')
+        _identity(row)
+        _text(row['event_id'], 'event ID')
+        require(row['event_id'] not in seen, 'Duplicate event ID')
+        seen.add(row['event_id'])
+        require(row['event_type'] in ('initial_classification', 'resolution', 'correction'),
+                'Invalid event type')
+        if row['event_type'] == 'initial_classification':
+            require(row['prior_event_id'] is None, 'Initial event cannot have a prior event')
+        else:
+            _text(row['prior_event_id'], 'prior event ID')
+            require(row['prior_event_id'] != row['event_id'], 'Self-referencing event')
+        _literal_time(row['created_at'], 'creation timestamp')
+        _text(row['qualification'], 'qualification', allow_empty=True)
+        _receipts(row['evidence'])
+        require(row['status'] in ('timing_supported', 'timing_unresolved'), 'Invalid timing status')
+        if row['status'] == 'timing_supported':
+            _literal_time(row['declared_value'], 'declared value')
+            require(isinstance(row['declaration_basis'], str)
+                    and row['declaration_basis'] in SUPPORTED_BASES, 'Unsupported declaration basis')
+            require(bool(row['evidence']), 'Supported claim requires text evidence')
+            require(row['unresolved_reason'] == '', 'Supported claim has unresolved reason')
+        else:
+            require(isinstance(row['unresolved_reason'], str)
+                    and row['unresolved_reason'] in UNRESOLVED_REASONS, 'Invalid unresolved reason')
+            require(row['declared_value'] == '' and row['declaration_basis'] == '',
+                    'Unresolved event cannot assert a supported declaration')
+    return rows
+
+
+def _json_packet(root, declared):
+    path = check_receipt(root, declared)
+    try:
+        return json.loads(path.read_text(encoding='utf-8-sig'))
+    except (OSError, UnicodeError, json.JSONDecodeError) as error:
+        raise ValueError(f'Invalid JSON packet: {declared["path"]}') from error
+
+
+def validate_seal(root: Path, declared_seal: dict[str, object],
+                  previous_sha256: str | None) -> tuple[dict[str, object], dict[str, object]]:
+    """Verify a registered seal and all text receipts before returning members.
+
+    The caller supplies the preceding registered seal's digest in registry order;
+    the first seal requires None. Event-history reduction is a separate layer.
+    """
+    if previous_sha256 is not None:
+        _digest(previous_sha256)
+    seal = _json_packet(root, declared_seal)
+    _metadata(seal, 'wall-clock-ledger-seal/v1',
+              {'candidates', 'events', 'previous_seal_sha256', 'created_at'})
+    _literal_time(seal['created_at'], 'seal creation timestamp')
+    require(seal['previous_seal_sha256'] == previous_sha256, 'Prior seal chain mismatch')
+    directory = relative_path(declared_seal['path']).parent
+    require(Path(declared_seal['path']).name == 'SEAL.json', 'Unexpected seal filename')
+    members = []
+    for name, validator in [('candidates', validate_candidates), ('events', validate_events)]:
+        declared = seal[name]
+        member_path = _validate_receipt(declared)
+        require(member_path == directory / f'{name}.json', 'Unexpected sealed member path')
+        packet = _json_packet(root, declared)
+        validator(packet)
+        require(all(packet[key] == seal[key] for key in METADATA_FIELDS), 'Sealed metadata mismatch')
+        members.append(packet)
+    candidates, events = members
+    for declared in candidates['source_files']:
+        check_receipt(root, declared)
+    for event in events['events']:
+        for declared in event['evidence']:
+            check_receipt(root, declared)
+    return candidates, events