prov: tamper-evident hash chain — V-L1-B1 + V-L2-N1 + V-L2-C1..C4 + V-L2-L1..L2 (#33)

Step 2 of the bottom-up plan. Brings the Provenance octad concern up to
the claim made in the README: tampering with any audit-relevant field
in a logged entry breaks `verify()`.

V-L1-B1 — docs/theory/provenance-threat-model.adoc:
  Four-adversary model (R / SW / SR / SR+CK), per-adversary protection
  matrix, the field-coverage and canonical-encoding requirements that
  bind V-L2-C1 + V-L2-C2, the append-serialisation requirement that
  binds V-L2-L1 + V-L2-L2, anchor/notary future work, open questions
  (None vs Some(""), chain_id). Each Step 2 issue cites a section.

V-L2-N1 — deduplicate ProvenanceRecord vs ProvenanceEntry:
  Delete src/tier1/provenance.rs::ProvenanceRecord (orphan duplicate
  of abi::ProvenanceEntry with its own compute_hash that risked
  drifting). tier1/provenance.rs now re-exports the canonical type;
  the file is the future home of V-L1-C1's write-path helpers
  (sqlite3_update_hook → append_provenance). TOPOLOGY.md updated.

V-L2-C1 — full-field, domain-separated hash:
  compute_hash signature changes from (4 strs) to (5 strs + DateTime +
  2 Options). New preimage = domain tag b"verisim-prov-v1\0" ||
  length-prefixed (previous_hash, entity_id, operation, actor) ||
  canonical timestamp (V-L2-C2) || length-prefixed (before_snapshot,
  transformation). All seven fields participate. PROV_DOMAIN_TAG
  versioning is reserved for a future SHA-256→? migration.
  verify(), genesis(), chain() all pass the full field set.

V-L2-C2 — canonical timestamp:
  Replace timestamp.to_rfc3339() (multiple valid forms per instant)
  with i64_le(timestamp()) || u32_le(timestamp_subsec_nanos()), 12
  bytes total. Round-trip unit test asserts two construction paths
  that yield the same instant produce the same hash.

V-L2-C3 — positive tamper-detection tests:
  Eight new unit tests in abi::tests covering each hash-covered
  field (entity_id, actor, before_snapshot, transformation,
  operation, previous_hash, timestamp) plus the canonical-encoding
  property test plus a 4-entry chain mutation-matrix that asserts
  every field mutation on every entry breaks verify(). 9 new test
  cases (26 → 35 lib tests).

V-L2-C4 — flip the wontfix test:
  tests/integration_test.rs::test_provenance_chain_integrity_multi_step
  previously codified the bug ("Actor is not part of hash — tamper to
  actor alone is invisible"). Replaced with assertions that
  tampering with actor and with before_snapshot both break verify().

V-L2-L1 — chain_head table + write-path serialisation spec:
  codegen/overlay.rs emits a new verisimdb_provenance_chain_head
  (entity_id PK, head_hash, updated_at) alongside the provenance log.
  The write-path lock (SELECT … FOR UPDATE / BEGIN IMMEDIATE on the
  head row, INSERT into log, UPDATE head, COMMIT) is specified in
  the threat-model doc and the table-generator docstring. The
  library function that performs the transaction is V-L1-C1's job;
  V-L2-L1 only lands the schema.

V-L2-L2 — UNIQUE INDEX makes forks unrepresentable:
  CREATE UNIQUE INDEX IF NOT EXISTS ux_provenance_chain ON
  verisimdb_provenance_log(entity_id, previous_hash). Genesis rows
  all carry previous_hash='' so the same constraint enforces exactly
  one genesis per entity. Two new DDL tests assert presence of both
  the UNIQUE INDEX and the chain_head table.

Verified locally:
- cargo fmt --all -- --check clean
- cargo clippy --all-targets -- -D warnings clean
- cargo test reports 35 + 9 = 44 tests, 0 failed

Closes #25, #26, #27, #28, #29, #30, #31, #32

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

Author: hyperpolymath

docs/architecture/TOPOLOGY.md

@@ -12,7 +12,7 @@ verisimiser/
 │   ├── src/manifest/         — TOML manifest parsing (verisimiser.toml)
 │   ├── src/tier1/            — Tier 1 piggyback data types
 │   │   ├── drift.rs          — DriftReport, DriftCategory (8 categories)
-│   │   ├── provenance.rs     — ProvenanceRecord, SHA-256 hash chain
+│   │   ├── provenance.rs     — re-exports abi::ProvenanceEntry; future write-path helpers (V-L1-C1)
 │   │   └── temporal.rs       — TemporalVersion, point-in-time snapshots
 │   ├── src/tier2/            — Tier 2 overlay stubs (graph, vector, tensor, semantic, document, spatial)
 │   ├── src/intercept/        — Per-backend interception strategies

docs/theory/provenance-threat-model.adoc

@@ -0,0 +1,202 @@
+// SPDX-License-Identifier: PMPL-1.0-or-later
+// Copyright (c) 2026 Jonathan D.A. Jewell (hyperpolymath) <j.d.a.jewell@open.ac.uk>
+= Provenance threat model
+:toc: left
+:toclevels: 3
+:icons: font
+
+This document fixes what the Provenance concern's hash chain proves and
+what it doesn't. It binds the design choices made in V-L2-C1, V-L2-C2,
+V-L2-L1, V-L2-L2, and the ADR-0004 follow-up.
+
+Resolves: https://github.com/hyperpolymath/verisimiser/issues/25[V-L1-B1].
+
+== Scope
+
+In scope:: the `Provenance` octad concern as implemented by
+`ProvenanceEntry` in `src/abi/mod.rs` plus the sidecar table
+`verisimdb_provenance_log` plus (post V-L2-L1) the `chain_head` table.
+
+Out of scope:: denial-of-service against the sidecar; side-channels
+(timing, cache); tampering of the target database itself
+(verisimiser only sees what its interceptors intercept); retroactive
+provenance for pre-existing rows (the genesis entry for an entity
+attests its existence at the moment verisimiser started observing it,
+not before); cryptographic compromise of SHA-256.
+
+== Adversaries
+
+Four adversaries cover the relevant capability axes. Each is a
+*lattice point*; real attackers combine capabilities.
+
+[cols="1,3"]
+|===
+| Tag | Capability
+
+| **R**  | Read-only — can read both the target database and the
+sidecar. No write to either. Models: a forensic auditor;
+a leaked replica; a debugging copy on a laptop.
+
+| **SW** | Sidecar-Write — can append new rows to
+`verisimdb_provenance_log` and `verisimdb_temporal_versions` but
+**cannot delete or rewrite existing rows**. Models: a sidecar
+configured append-only (filesystem-level WORM, S3 Object Lock,
+SQLite + revoked-DELETE/UPDATE permissions); also models a buggy
+verisimiser daemon that double-writes.
+
+| **SR** | Sidecar-Rewrite — can rewrite or delete arbitrary rows
+in the sidecar. Models: root on the sidecar host; compromised
+application credential with full sidecar privileges; a backup
+operator restoring an older sidecar snapshot.
+
+| **CK** | Clock-skew — can write entries (via SW or SR) with
+timestamps that lie. Models: a system clock that drifts; an
+adversary who controls the clock source; coordinated backdating.
+|===
+
+== Per-adversary protection matrix
+
+For each adversary, what the chain proves about each field:
+**P** = protected (tampering detected),
+**N** = not protected,
+**C** = conditionally protected (see note).
+
+[cols="2,1,1,1,1"]
+|===
+| Field | R | SW | SR | SR+CK
+
+| Genesis existence / order        | P | P | N    | N
+| `previous_hash` of any entry     | P | P | C-1  | C-1
+| `entity_id` of any entry         | P | P | C-1  | C-1
+| `operation` of any entry         | P | P | C-1  | C-1
+| `actor` of any entry             | P | P | C-1  | C-1
+| `timestamp` of any entry         | P | P | C-1  | N (CK falsifies)
+| `before_snapshot` of any entry   | P | P | C-1  | C-1
+| `transformation` of any entry    | P | P | C-1  | C-1
+| Absence of an entry              | C-2 | C-2 | N    | N
+| Total ordering across entities   | N | N | N    | N
+|===
+
+**C-1** — under SR (or SR+CK), the adversary can rewrite an
+arbitrary suffix of the chain (recomputing hashes as they go). What's
+preserved against SR is **only the prefix up to the most-recent
+externally attested hash** (e.g. a hash periodically signed by an
+out-of-band notary, anchored to an append-only log, or published to
+a transparency service). Without an external anchor, the chain
+proves *nothing* against SR.
+
+**C-2** — absence is provable only if every legitimate append goes
+through verisimiser. Direct writes to the target database that
+bypass interception are invisible to the chain; the chain cannot
+attest to what it never saw.
+
+== Field coverage requirement
+
+A direct consequence of C-1 / C-2 and the per-adversary matrix:
+
+[NOTE]
+====
+Every field that an auditor will rely on for forensic purposes
+**must** participate in the hash. `actor`, `before_snapshot`, and
+`transformation` are all such fields — they are the audit. If they
+are not in the preimage, the chain protects them against R and SW
+only by *coincidence* (because the row itself was hash-keyed in the
+DB), not by design.
+
+This document therefore *requires* V-L2-C1: the preimage must cover
+`previous_hash`, `entity_id`, `operation`, `actor`, `timestamp`,
+`before_snapshot`, `transformation`. Any future field added to
+`ProvenanceEntry` must either be added to the preimage or
+explicitly recorded here with a justification for its omission.
+====
+
+== Canonical encoding requirement
+
+A direct consequence of "the hash protects the field" being a
+*function*, not a relation:
+
+[NOTE]
+====
+Two distinct preimages must produce distinct hashes (collision
+resistance is SHA-256's job). Two *equal* preimages must produce
+equal hashes (canonicalisation is our job). The encoding must:
+
+. Domain-separate verisimiser provenance hashes from any other
+hash the system computes (`b"verisim-prov-v1\0"`).
+. Length-prefix variable-length fields so concatenation is
+unambiguous.
+. Use a canonical timestamp encoding (V-L2-C2:
+  `i64_le(secs) || u32_le(nanos)`), not a string representation that
+  admits multiple valid forms for the same instant.
+====
+
+== Append serialisation requirement
+
+A direct consequence of "previous_hash chains entries linearly":
+
+[NOTE]
+====
+Two writers cannot independently chain from the same `previous_hash`
+without forking the chain. Verisimiser must serialise appends
+per-entity. V-L2-L1 specifies the write-path lock; V-L2-L2 specifies
+the database UNIQUE constraint that makes forks structurally
+impossible even if the lock is bypassed.
+
+The chain is *per-entity-serial* but *cross-entity-parallel*.
+A global serial order across entities is *not* a requirement
+(see "Total ordering" in the matrix above).
+====
+
+== Anchor / notary (future)
+
+Protection against SR requires an *external anchor* that the
+adversary cannot rewrite. Options, none of which this document
+mandates yet:
+
+. **Periodic notarisation** — every N minutes, sign the latest
+chain_head with a key not held on the sidecar host, and publish
+the signature to an out-of-band log.
+. **Transparency log** — submit each `chain_head` update to an
+external append-only log (Sigstore-style).
+. **Replication to immutable storage** — write each new entry to
+S3 Object Lock (or equivalent) as a defence in depth.
+
+The threat model leaves the choice for ADR-0005 once a deployment
+context exists.
+
+== Out-of-band assumptions
+
+. The sidecar host's clock is monotonic and within bounded skew of
+real time. Without this, all timestamps are advisory (see CK in the
+matrix).
+. Verisimiser's process integrity is assumed — a verisimiser binary
+that has been swapped for a malicious one can produce a hash-chain
+that verifies against itself but attests to nothing real. Binary
+provenance is a separate concern (out of scope here).
+. SHA-256 is collision-resistant in the cryptographic sense for the
+lifetime of the audit window.
+
+== Open questions
+
+. Should `Option<String>` fields (`before_snapshot`, `transformation`)
+encode `None` vs `Some("")` distinctly? The current proposal collapses
+them (both encode as `u64_le(0)` length). Document explicitly that
+the chain treats "no snapshot" and "empty snapshot" identically; if a
+future use case requires distinguishing them, a single sentinel byte
+(`0x00` for None, `0x01` for Some) prefixed inside the length-prefixed
+slot resolves it.
+. Should the chain include an explicit `chain_id` covering all of an
+entity's entries (in addition to chaining via `previous_hash`)? Cheap
+defence in depth against entity_id confusion; defer to ADR-0004.
+
+== Cross-references
+
+* V-L2-C1 — implements the field coverage + domain separation
+* V-L2-C2 — implements canonical timestamp encoding
+* V-L2-C3 — positive tamper-detection tests
+* V-L2-C4 — removes the wontfix test that codified the C-1 gap
+* V-L2-L1 — per-entity write-path serialisation
+* V-L2-L2 — UNIQUE INDEX(entity_id, previous_hash) defence in depth
+* V-L2-N1 — deduplicates the type used here (ProvenanceEntry vs
+  ProvenanceRecord)
+* ADR-0004 (future) — records the binding choices made here