docs(conformance): address code-review findings on the interop hardening

Follow-up to the IETF-audit hardening pass, fixing 8 review findings:

- Page copy no longer claims counts "cannot silently drift" absolutely: the
  reconciliation test runs in cross-sdk-tests.yml, which triggers on the vector
  corpus / spec (not site/** or scripts/**), so the copy now states what is
  actually enforced (a corpus edit that outdates a number turns CI red). Test
  header comment records the same trigger-scope caveat.
- Retract the "independent implementations" overclaim in the two docs the page
  links to (README.md, cross-sdk-tests/README.md); state the real property
  (separate, no-shared-code, single author; serialisation-drift detector, not
  spec-ambiguity detector).
- ADR-0015: the dated 2026-05-12 snapshot's "Phase B ... deferred" line now
  forward-points to the update where Phase B checkpoint anchoring landed, so it
  no longer contradicts the header.
- Reconciliation test: scope the matrix regex to the "## Results matrix"
  section and the prose regexes to the honesty callout, so an unrelated table
  or stray figure elsewhere on the page can't be misread; surface count.py's
  stderr on failure; load count.py output + page once and share across
  subtests (was exec'd/read twice).
- Remove the unpinned "2-3 pinned receipt/chain vectors per spec version" prose
  figure, pointing to the (pinned) matrix instead.
- Pin the verifier-side checkpoint reference to "ADR-0008 §3 out-of-band check
  over ADR-0015 Phase B checkpoints" (was bare "ADR-0008 follow-through").

Author: ojongerius

README.md

@@ -49,7 +49,7 @@
 
 ## Conformance
 
-Anyone can implement the protocol — so interoperability is the property that matters. The three SDKs (Go, Python, TypeScript) are independent implementations that **verify one another's receipts**: every conformance vector is signed once with a shared Ed25519 keypair, and each SDK re-verifies the signatures, canonical JSON, and hashes the other two produced — across a positive corpus, a MUST-reject corpus, and four pinned spec versions. This cross-language verification is enforced in CI.
+Anyone can implement the protocol — so interoperability is the property that matters. The three SDKs (Go, Python, TypeScript) are separate, no-shared-code implementations that **verify one another's receipts**: every conformance vector is signed once with a shared Ed25519 keypair, and each SDK re-verifies the signatures, canonical JSON, and hashes the other two produced — across a positive corpus, a MUST-reject corpus, and four pinned spec versions. This cross-language verification is enforced in CI (it catches serialisation drift between the languages, not spec-interpretation ambiguity — the SDKs share one author).
 
 The **[Conformance page](https://agentreceipts.ai/conformance/)** is the citeable summary: the interop claim, a results matrix with per-set vector counts, permanent links to every frozen vector set, and how to reproduce the checks. The shared corpus lives in [`cross-sdk-tests/`](cross-sdk-tests/).
 

cross-sdk-tests/README.md

@@ -1,6 +1,6 @@
 # Cross-SDK Tests
 
-Three independent implementations of the Agent Receipt Protocol — the Go, Python, and TypeScript SDKs — verify one another's receipts. The vectors in this directory are the shared corpus that makes that claim checkable: each is signed once with a single shared Ed25519 keypair, and every SDK re-verifies the signatures, canonical JSON (RFC 8785), and receipt hashes the other two produced. Verification runs in both directions, over a **positive corpus** every implementation must accept and a **MUST-reject corpus** every implementation must refuse, across four pinned spec versions (v0.2.0–v0.5.0).
+Three separate implementations of the Agent Receipt Protocol — the Go, Python, and TypeScript SDKs, one per language with no shared code — verify one another's receipts. The vectors in this directory are the shared corpus that makes that claim checkable: each is signed once with a single shared Ed25519 keypair, and every SDK re-verifies the signatures, canonical JSON (RFC 8785), and receipt hashes the other two produced. Verification runs in both directions, over a **positive corpus** every implementation must accept and a **MUST-reject corpus** every implementation must refuse, across four pinned spec versions (v0.2.0–v0.5.0). This catches cross-language serialisation drift; because the SDKs share a single author, it does not catch a spec-interpretation ambiguity encoded identically into all three (see the [Conformance page](https://agentreceipts.ai/conformance/) for the full statement of what this does and does not prove).
 
 For the published, citeable summary of this suite — the interop claim, the results matrix with per-set vector counts, and CI-enforcement status — see the [Conformance page](https://agentreceipts.ai/conformance/).
 

cross-sdk-tests/conformance_page_test.go

@@ -10,8 +10,8 @@ package crosssdk_test
 // is the generator — it reads the frozen vector files and emits the counts.
 // Nothing, though, forced the page's numbers to equal count.py's output: the
 // table cells and the prose figures were hand-typed, so a change to a vector
-// file (or a typo in the page) could silently desync the two. On a page that is
-// cited to a standards body as evidence, a stale number is worse than none.
+// file could silently desync the two. On a page that is cited to a standards
+// body as evidence, a stale number is worse than none.
 //
 // This test closes that gap. It runs count.py, parses the page, and asserts:
 //   - every on-page vector set from count.py appears as a matrix row with the
@@ -21,11 +21,16 @@ package crosssdk_test
 //     total and the MUST-reject case count) match count.py.
 //
 // It lives here, in cross-sdk-tests/, because cross-sdk-tests.yml re-runs on
-// every change to the vector corpora (cross-sdk-tests/** and spec/**) — exactly
-// the changes that move these counts. count.py is invoked as the single source
-// of truth rather than re-deriving counts here, so the two cannot drift.
+// every change to the vector corpora (cross-sdk-tests/** and spec/**) — the
+// changes that actually move these counts. That path filter does NOT cover
+// site/** or scripts/**, so a page-only edit (or a count.py-only edit) that is
+// not accompanied by a corpus change is outside this gate's CI trigger;
+// widening the trigger to those paths is a separate workflow change. count.py
+// is invoked as the single source of truth rather than re-deriving counts here,
+// so the two cannot drift.
 
 import (
+	"bytes"
 	"encoding/json"
 	"os"
 	"os/exec"
@@ -51,19 +56,32 @@ type countPayload struct {
 	Total int        `json:"total"`
 }
 
-// runCountScript executes count.py --format json and returns the parsed payload.
-// If python3 is not on PATH (e.g. a bare local `go test` without Python), the
-// test is skipped rather than failed — CI runners have python3, so the gate
-// still fires where it matters.
-func runCountScript(t *testing.T) countPayload {
+// reconcileInputs bundles the once-loaded count.py output and page text so the
+// subtests share a single python3 invocation and a single page read.
+type reconcileInputs struct {
+	payload countPayload
+	counts  map[string]int // set name -> count, for O(1) lookup
+	page    string
+}
+
+// loadReconcileInputs runs count.py --format json and reads the page. If python3
+// is not on PATH (e.g. a bare local `go test` without Python), the test is
+// skipped rather than failed — CI runners have python3, so the gate still fires
+// where it matters.
+func loadReconcileInputs(t *testing.T) reconcileInputs {
 	t.Helper()
 	python, err := exec.LookPath("python3")
 	if err != nil {
 		t.Skipf("python3 not available, skipping conformance-page reconciliation: %v", err)
 	}
-	out, err := exec.Command(python, countScriptPath, "--format", "json").Output()
+	cmd := exec.Command(python, countScriptPath, "--format", "json")
+	var stderr bytes.Buffer
+	cmd.Stderr = &stderr
+	out, err := cmd.Output()
 	if err != nil {
-		t.Fatalf("run count.py: %v", err)
+		// count.py prints "error: could not count vectors: <detail>" to stderr;
+		// surface it so a broken vector file is diagnosable from the CI log.
+		t.Fatalf("run count.py: %v\nstderr: %s", err, strings.TrimSpace(stderr.String()))
 	}
 	var payload countPayload
 	if err := json.Unmarshal(out, &payload); err != nil {
@@ -72,19 +90,58 @@ func runCountScript(t *testing.T) countPayload {
 	if len(payload.Sets) == 0 {
 		t.Fatal("count.py returned no vector sets")
 	}
-	return payload
+	counts := make(map[string]int, len(payload.Sets))
+	for _, s := range payload.Sets {
+		counts[s.Name] = s.Count
+	}
+	pageBytes, err := os.ReadFile(conformancePage)
+	if err != nil {
+		t.Fatalf("read conformance page: %v", err)
+	}
+	return reconcileInputs{payload: payload, counts: counts, page: string(pageBytes)}
+}
+
+// section returns the slice of the page between the first line starting with
+// startPrefix (exclusive) and the next line starting with endPrefix (exclusive).
+// Scoping the regex scans to the intended block means an unrelated table or a
+// stray prose figure elsewhere on the page cannot be misread as a matrix row or
+// as a pinned count.
+func section(t *testing.T, page, startPrefix, endPrefix string) string {
+	t.Helper()
+	lines := strings.Split(page, "\n")
+	start := -1
+	for i, line := range lines {
+		if strings.HasPrefix(line, startPrefix) {
+			start = i + 1
+			break
+		}
+	}
+	if start == -1 {
+		t.Fatalf("section start %q not found on the page", startPrefix)
+	}
+	end := len(lines)
+	for i := start; i < len(lines); i++ {
+		if strings.HasPrefix(lines[i], endPrefix) {
+			end = i
+			break
+		}
+	}
+	if end <= start {
+		t.Fatalf("section %q..%q is empty", startPrefix, endPrefix)
+	}
+	return strings.Join(lines[start:end], "\n")
 }
 
 // matrixRow matches a results-matrix data row: a table row whose first cell is a
 // markdown link, e.g. `| [canonicalization](https://…) | … | 44 |`. The link
 // text is the vector-set name; the final numeric cell is the count.
 var matrixRowRe = regexp.MustCompile(`^\|\s*\[([^\]]+)\]\([^)]*\)\s*\|.*\|\s*([0-9]+)\s*\|\s*$`)
 
-// parsePageMatrix extracts {name: count} for every results-matrix row on the page.
-func parsePageMatrix(t *testing.T, page string) map[string]int {
+// parseMatrix extracts {name: count} for every matrix row in the given section.
+func parseMatrix(t *testing.T, src string) map[string]int {
 	t.Helper()
 	rows := map[string]int{}
-	for _, line := range strings.Split(page, "\n") {
+	for _, line := range strings.Split(src, "\n") {
 		m := matrixRowRe.FindStringSubmatch(line)
 		if m == nil {
 			continue
@@ -99,97 +156,81 @@ func parsePageMatrix(t *testing.T, page string) map[string]int {
 		rows[m[1]] = n
 	}
 	if len(rows) == 0 {
-		t.Fatal("no matrix rows parsed from the conformance page")
+		t.Fatal("no matrix rows parsed from the results-matrix section")
 	}
 	return rows
 }
 
-func TestConformancePageMatrixReconciles(t *testing.T) {
-	payload := runCountScript(t)
-	pageBytes, err := os.ReadFile(conformancePage)
-	if err != nil {
-		t.Fatalf("read conformance page: %v", err)
-	}
-	page := string(pageBytes)
-	pageRows := parsePageMatrix(t, page)
-
-	// Every on-page set from count.py must appear with the exact computed count.
-	expected := map[string]int{}
-	for _, s := range payload.Sets {
-		if !s.OnPage {
-			// Off-page sets (reference fixtures) must NOT appear as matrix rows.
-			if _, present := pageRows[s.Name]; present {
-				t.Errorf("set %q is on_page=False in count.py but appears in the page matrix", s.Name)
-			}
-			continue
-		}
-		expected[s.Name] = s.Count
-		got, present := pageRows[s.Name]
-		if !present {
-			t.Errorf("count.py set %q is missing from the page matrix", s.Name)
-			continue
-		}
-		if got != s.Count {
-			t.Errorf("count mismatch for %q: page=%d, count.py=%d", s.Name, got, s.Count)
-		}
-	}
-	// No matrix row may exist that count.py does not account for.
-	for name := range pageRows {
-		if _, ok := expected[name]; !ok {
-			t.Errorf("page matrix row %q has no corresponding on-page set in count.py", name)
-		}
-	}
-}
-
-// setCount returns the count.py count for a named set.
-func setCount(t *testing.T, payload countPayload, name string) int {
-	t.Helper()
-	for _, s := range payload.Sets {
-		if s.Name == name {
-			return s.Count
-		}
-	}
-	t.Fatalf("count.py has no set named %q", name)
-	return 0
-}
-
 var (
 	proseCanonRe     = regexp.MustCompile(`(\d+) canonicalization/receipt-hash vectors`)
 	proseMalformedRe = regexp.MustCompile(`(\d+)-case MUST-reject corpus`)
 )
 
-// TestConformancePageProseFiguresReconcile pins the two exact numeric claims in
-// the honesty callout to count.py, so the prose cannot drift from the matrix
-// either.
-func TestConformancePageProseFiguresReconcile(t *testing.T) {
-	payload := runCountScript(t)
-	pageBytes, err := os.ReadFile(conformancePage)
-	if err != nil {
-		t.Fatalf("read conformance page: %v", err)
-	}
-	page := string(pageBytes)
-
-	checks := []struct {
-		label   string
-		re      *regexp.Regexp
-		setName string
-	}{
-		{"canonicalization total", proseCanonRe, "canonicalization"},
-		{"MUST-reject case count", proseMalformedRe, "malformed (MUST-reject)"},
-	}
-	for _, c := range checks {
-		m := c.re.FindStringSubmatch(page)
-		if m == nil {
-			t.Errorf("%s: prose figure not found on the page (pattern %q)", c.label, c.re)
-			continue
+func TestConformancePageReconciles(t *testing.T) {
+	in := loadReconcileInputs(t)
+
+	// The published matrix lives under "## Results matrix" and ends at the
+	// "Each linked vector set…" sentence right after the table.
+	t.Run("matrix", func(t *testing.T) {
+		matrixSrc := section(t, in.page, "## Results matrix", "Each linked vector set")
+		pageRows := parseMatrix(t, matrixSrc)
+
+		expected := map[string]int{}
+		for _, s := range in.payload.Sets {
+			if !s.OnPage {
+				// Off-page sets (reference fixtures) must NOT appear as matrix rows.
+				if _, present := pageRows[s.Name]; present {
+					t.Errorf("set %q is on_page=False in count.py but appears in the page matrix", s.Name)
+				}
+				continue
+			}
+			expected[s.Name] = s.Count
+			got, present := pageRows[s.Name]
+			if !present {
+				t.Errorf("count.py set %q is missing from the page matrix", s.Name)
+				continue
+			}
+			if got != s.Count {
+				t.Errorf("count mismatch for %q: page=%d, count.py=%d", s.Name, got, s.Count)
+			}
 		}
-		got, err := strconv.Atoi(m[1])
-		if err != nil {
-			t.Fatalf("%s: non-numeric prose figure %q", c.label, m[1])
+		// No matrix row may exist that count.py does not account for.
+		for name := range pageRows {
+			if _, ok := expected[name]; !ok {
+				t.Errorf("page matrix row %q has no corresponding on-page set in count.py", name)
+			}
 		}
-		want := setCount(t, payload, c.setName)
-		if got != want {
-			t.Errorf("%s: prose says %d, count.py says %d", c.label, got, want)
+	})
+
+	// The two exact numeric claims in the honesty callout are pinned to count.py
+	// too, scoped to that Aside so an earlier figure elsewhere cannot shadow them.
+	t.Run("prose", func(t *testing.T) {
+		callout := section(t, in.page, `<Aside type="caution" title="Honest coverage`, "</Aside>")
+		checks := []struct {
+			label   string
+			re      *regexp.Regexp
+			setName string
+		}{
+			{"canonicalization total", proseCanonRe, "canonicalization"},
+			{"MUST-reject case count", proseMalformedRe, "malformed (MUST-reject)"},
 		}
-	}
+		for _, c := range checks {
+			m := c.re.FindStringSubmatch(callout)
+			if m == nil {
+				t.Errorf("%s: prose figure not found in the honesty callout (pattern %q)", c.label, c.re)
+				continue
+			}
+			got, err := strconv.Atoi(m[1])
+			if err != nil {
+				t.Fatalf("%s: non-numeric prose figure %q", c.label, m[1])
+			}
+			want, ok := in.counts[c.setName]
+			if !ok {
+				t.Fatalf("count.py has no set named %q", c.setName)
+			}
+			if got != want {
+				t.Errorf("%s: prose says %d, count.py says %d", c.label, got, want)
+			}
+		}
+	})
 }

daemon/internal/verifycli/anchor.go

@@ -18,7 +18,8 @@ type anchorResult struct {
 }
 
 // verifyAgainstAnchor checks the receipt chain HEAD against the out-of-band
-// signed checkpoints in the anchor at anchorPath (ADR-0008 follow-through).
+// signed checkpoints in the anchor at anchorPath (the ADR-0008 §3 out-of-band
+// check over ADR-0015 Phase B checkpoints).
 //
 // It performs, in order:
 //   - read the anchor log and retrieve the latest verified checkpoint for

docs/adr/0015-key-rotation-byok-anchoring.md

@@ -138,7 +138,7 @@ What has **not** landed and is in scope for Phase A:
 - `Rotate()` currently returns `ErrNotImplemented`. No rotation event schema, no `key_rotated` synthetic receipt emission path, no verifier-side rotation traversal.
 - The external anchor write contract for rotation events. Until the anchor sink exists, **the post-compromise integrity guarantee is not honoured** and any rotation work that lands before it is partial.
 
-Phase B (checkpoint anchoring) and Phase C (HSM/KMS adapters) are explicitly deferred and not on a schedule.
+Phase B (checkpoint anchoring) and Phase C (HSM/KMS adapters) are explicitly deferred and not on a schedule *at this snapshot* — see the updates below, where Phase B checkpoint anchoring has since landed end-to-end. Phase C remains deferred.
 
 ### Update (2026-06-10): rotation verification and offline rotation landed
 

site/src/content/docs/conformance.mdx

@@ -23,7 +23,7 @@ The three SDKs share no code: each is a separate implementation of the same spec
 
 ## Results matrix
 
-Each row is a frozen vector set. The **Go / Py / TS** columns mark which implementations consume and verify that set in their test suites. Vector counts are generated from the committed JSON by [`scripts/conformance_matrix/count.py`](https://github.com/agent-receipts/obsigna/blob/main/scripts/conformance_matrix/count.py), and a CI [reconciliation test](https://github.com/agent-receipts/obsigna/blob/main/cross-sdk-tests/conformance_page_test.go) asserts every count in this table equals that script's output — so a number here cannot silently drift from the corpus.
+Each row is a frozen vector set. The **Go / Py / TS** columns mark which implementations consume and verify that set in their test suites. Vector counts are generated from the committed JSON by [`scripts/conformance_matrix/count.py`](https://github.com/agent-receipts/obsigna/blob/main/scripts/conformance_matrix/count.py), and a CI [reconciliation test](https://github.com/agent-receipts/obsigna/blob/main/cross-sdk-tests/conformance_page_test.go) asserts every count in this table — and the figures in the callout below — equal that script's output. It re-runs whenever the vector corpus or the spec changes, so a corpus edit that outdates a number here turns the check red before merge.
 
 | Vector set | Purpose | Go | Py | TS | Spec version(s) | Vectors |
 | --- | --- | :-: | :-: | :-: | --- | ---: |
@@ -40,7 +40,7 @@ Each row is a frozen vector set. The **Go / Py / TS** columns mark which impleme
 Each linked vector set above is pinned to an immutable commit, so a citation stays valid as the corpus grows.
 
 <Aside type="caution" title="Honest coverage — these are seed-level counts">
-The counts are the real sizes of the frozen corpora today, not a coverage claim. They are seed-level and growing: 44 canonicalization/receipt-hash vectors, a 7-case MUST-reject corpus, and 2–3 pinned receipt/chain vectors per spec version. They are **not** exhaustive — they pin the shapes that mattered enough to freeze, and the corpus is extended as the specification evolves. Separately, the `did:key` resolution vectors ([`spec/test-vectors/did-key/`](https://github.com/agent-receipts/obsigna/tree/main/spec/test-vectors/did-key)) fix the `did:key` v0.7 wire shape (ADR-0007) as reference fixtures, but **no SDK implements `did:key` resolution yet**, so no suite consumes them. Rather than show an all-dashes row, that set is out-of-scope-for-now and omitted from the matrix above; wiring it into a cross-language suite is tracked in [#956](https://github.com/agent-receipts/obsigna/issues/956).
+The counts are the real sizes of the frozen corpora today, not a coverage claim. They are seed-level and growing: 44 canonicalization/receipt-hash vectors, a 7-case MUST-reject corpus, and the per-version receipt/chain counts shown in the matrix above. They are **not** exhaustive — they pin the shapes that mattered enough to freeze, and the corpus is extended as the specification evolves. Separately, the `did:key` resolution vectors ([`spec/test-vectors/did-key/`](https://github.com/agent-receipts/obsigna/tree/main/spec/test-vectors/did-key)) fix the `did:key` v0.7 wire shape (ADR-0007) as reference fixtures, but **no SDK implements `did:key` resolution yet**, so no suite consumes them. Rather than show an all-dashes row, that set is out-of-scope-for-now and omitted from the matrix above; wiring it into a cross-language suite is tracked in [#956](https://github.com/agent-receipts/obsigna/issues/956).
 </Aside>
 
 ## CI enforcement