OpenChainGraph · Standards crosswalk Read against VCP v1.2.0, GA tagged 8 October 2026 JST

Side by side with VCP

The VeritasChain Protocol records what an algorithmic trading system decided and executed, in an append-only, hash-chained, externally anchored log. Our receipts record what a computation did, in a deterministic, browser-verifiable artifact chain. This page reads the two formats against the same questions: what does a record bind, how is completeness proven, who can verify it without trusting the producer, and where does each format stop. It was written for a live correspondence with a practitioner on the VCP side, and for anyone comparing record formats for audit or regulatory work.

Everything about VCP here is read from their published specification v1.2.0, document dated 6 July 2026, GA tagged 8 October 2026 JST (fix merged 9 October) at commit b23acb266f88 of github.com/veritaschain/vcp-spec — the pinned commit is the GA tag itself — retrieved 15 October 2026. Everything about our side is live on this site today. No connector, bridge, or implementation exists between the two formats, and nothing on this page claims otherwise. Part three pins both sides to exact revisions and classifies every field of one artifact per side into three classes: hash-preimage, metadata, and externally trusted. Part four turns the correspondence's 25 October review into the page's review basis: a per-row evidence table, a fourth check for declared-set completeness, and a negative battery with verdicts written down in advance.

Presenter mode shows one step per screen. Arrow keys move, A toggles autoplay, Esc exits.
Part one · The two record formats

What each format binds and how

VCP separates integrity into three named layers. Our receipts bind one canonical hash per run and hang verification off determinism. The table in step 3 puts the two side by side row by row.

1
Step 1 · The other format

What VCP asks a producer to keep

VCP is published by the VeritasChain Standards Organization in Tokyo as the financial-domain profile of their Verifiable AI Provenance framework. The v1.2 document is dated 6 July 2026; VSO's release history records the v1.2.0 GA merge on 8 October 2026 JST, with a fix on 9 October (step 8 carries both dates). A producer records its trading events in an append-only log; the spec's own scope line says the log verifies integrity and attribution of recorded events and does not certify the correctness or safety of the underlying AI or trading decisions. That boundary is written by VSO themselves, and it rhymes with the boundary our own artifacts declare.

Layer 3 · external verifiability Ed25519 signature · dual-format timestamp · external anchor REQUIRED Layer 2 · collection integrity RFC 6962 Merkle tree · root · audit path, per anchored batch Layer 1 · event integrity EventHash, SHA-256 of the canonical event · PrevHash optional since v1.1 anchor intervals by tier Platinum · HFT PTPv2 clock, 10 min anchor Gold · prop / institutional NTP clock, 1 hour anchor Silver · retail / MT4-5 best-effort clock, 24 h anchor targets: Bitcoin, OpenTimestamps, RFC 3161 since v1.1 the external anchor is REQUIRED at every tier; the Merkle batch plus anchor replaced the mandatory hash chain

Anchoring is where VCP is strictest: every tier must anchor externally, on a clock budget that tightens from Silver's 24 hours to Platinum's 10 minutes. Acceptable targets include Bitcoin, OpenTimestamps, and RFC 3161 timestamp authorities. The spec sets expectations per tier plainly: Silver, in VSO's own words on their site, provides transparency rather than regulatory-grade evidence.

Prompt at this stepread their spec
Fetch VCP-Specification-v1_2_en.md from github.com/veritaschain/vcp-spec and summarize the three integrity layers, one sentence per layer, quoting the REQUIRED components exactly.
Layer 1: EventHash (SHA-256 of canonical event), PrevHash optional. Layer 2: RFC 6962 Merkle tree, root, audit path. Layer 3: Ed25519 signature, dual-format timestamp, external anchor.
2
Step 2 · The home format

What our receipts keep

An OpenChainGraph receipt binds one computation. Its execution hash is a SHA-256 over the canonical JSON of exactly the declared inputs and the output payload, produced through the shared hash library; the kernel that computed the output is pinned by its own digest. Workflows chain receipts by carrying each parent hash forward, and the public ledger stores the artifacts content-addressed so the hash is the address.

the preimage { policy_parameters, output_payload } canonicalised per RFC 8785 (JCS) kernel pinned by digest beside them SHA-256 execution_hash carried into the next run as parent hash a composite hash anchors a whole workflow stored content-addressed: the hash is the address verification is recompute: same inputs and same pinned kernel rebuild the identical hash on any machine

The full anatomy, including a synthetic run you can reproduce from its published witness, is the subject of our companion page Four hashes and a witness. The short version for this crosswalk: our format proves a computation by reconstruction rather than by attestation, keeps private figures out of the record as salted commitments, and publishes receipts to a ledger any browser can verify without a server.

Prompt at this stepsee it live
Open the record-provenance walkthrough on this site and report the four hashes of its specimen run, then recompute the step 1 hash from the published witness.
Four hashes: cd1503d3…, 0ca6da06…, composite 36c64bd6…, commitment sha256:ee204261…; all four recompute bit for bit.
3
Step 3 · The crosswalk

The crosswalk table

Nine concerns cover what an audit-grade record format has to decide. The left column is VCP v1.2 with the section that decides it; the right column is the OpenChainGraph receipt as it ships today. Where the two agree, the row says so; where one of them does less, the row says that instead.

ConcernVCP v1.2.0 (GA tagged 2026-10-08 JST)OpenChainGraph receipt
per-event integrityEventHash: SHA-256 over the canonical event (Layer 1, §6)execution_hash: SHA-256 over JCS-canonical {policy_parameters, output_payload} (SPEC §4)
chain linkagePrevHash optional since v1.1; Merkle batching preferredparent_hashes required on chained workflows; composite hash anchors a whole run
completenessMerkle tree + root + audit path per anchored batch (Layer 2, §6); inclusion rather than completeness (steps 10, 13)determinism: identical inputs rebuild identical hashes anywhere; completeness is the declared-set comparison of step 13; recompute alone does not provide it
producer signatureEd25519 REQUIRED at every tier (PQC algorithms experimental)signature envelope ships empty on standard runs; §27.12 countersigning covers two-party runs
external anchoringREQUIRED, all tiers: 10 min (Platinum) to 24 h (Silver), targets incl. Bitcoin, OpenTimestamps, RFC 3161not attached to standard runs; Sigsum lineage checkpoint published (leaf 72845 at writing) and an anchor endpoint serves other workflow families
actor linkingVCP-XREF dual logging: trader-side and broker-side streams cross-referenced (§5.6)work-mandate binding records which policy governed a run; countersigned receipts for the two-party case
erasureERASURE event + crypto-shredding: destroy the DEK, accept the §17a-4 reproducibility tension (Annex §3)§25 salted commitments: private figures never enter the record at all, so there is nothing to shred
verification surfacesupervision-node PoC, Explorer GUI live, Explorer API planned with no datebrowser verification, public content-addressed ledger, live MCP endpoint, hash-swept receipts
declared boundary“does not certify the correctness or safety of the underlying AI or trading decisions” (their site)“proves the computation over the declared inputs, never the real-world inputs themselves” (each artifact's rationale)

Both formats state their limits in their own voice, and the two limits are the same limit: a record binds the computation it witnessed, and the truth of the declarations feeding it lives somewhere else. A reader comparing the two formats for procurement or audit work can carry that single sentence across every row above.

Prompt at this stepcheck a row yourself
Read section 6 of the VCP v1.2 specification and section 4 of the OpenChainGraph SPEC, then write the completeness row of this crosswalk in your own words with both citations.
Neither mechanism establishes completeness. VCP's tree places provided leaves in the anchored batch; OCG's recompute validates held receipts. What should have been there is decided by a declared expected set and compared separately (steps 10 and 13).
VCP v1.2 §2, §5.6, §6, Annex §3, §5OpenChainGraph SPEC.md §4, §25, §27.12as of 15 October 2026row aligned 2026-11-05
Part two · Differences, common ground, and the unbuilt bridges

Beyond the table

Three differences survive the table because they are philosophy rather than mechanism. After them: the primitives both formats already share, and the connectors that do not exist yet, described without pretending otherwise.

4
Step 4 · Philosophy

Three differences that matter

Most of the table is mechanism, where either format could adopt the other's answer. Three rows are philosophy, and those are the ones a standards discussion should settle first.

vcp: chain optional Merkle batch plus anchor replaces per-event links ocg: chain is the core parent hashes make the workflow one verifiable object vcp: erasure by key destruction crypto-shredding; the 17a-4 tension is stated in-annex ocg: never held at all private figures enter only as salted commitments vcp: anchor on a tier clock 10 min to 24 h, external authority REQUIRED ocg: no authority on the run the record says so itself; lineage published beside it none of these is a defect on either side; each is a defensible answer to the same question

The erasure row deserves one extra sentence. VCP's annex is candid that destroying the decryption key satisfies an erasure obligation only in some jurisdictions, and that it sits badly with reproducibility-style retention rules such as SEC Rule 17a-4. Our format's answer, holding private figures outside the record from the first byte, sidesteps that tension and pays for it elsewhere: a commitment without the witness is a claim nobody can bind to real figures. Which answer fits depends on what the auditor is allowed to ask for.

Prompt at this stepcompare the GDPR answers
Read Annex 3 of the VCP v1.2 specification and OCG Standard section 25, then state which GDPR pressure each answers and what each gives up.
VCP shreds what it stored (the record stays, the plaintext becomes unrecoverable); OCG never stored the figures (the record holds only a salted commitment). VCP keeps full audit richness and accepts non-recoverability; OCG keeps verifiability and accepts that only the witness-holder can bind commitment to figure.
VCP v1.2 Annex §3, §6.0.2OCG Standard §25, SPEC §27.12EDPB Guidelines 01/2025, cited in their annex
5
Step 5 · Common ground

The primitives both formats already share

A crosswalk is easier when the floors are the same. Both formats default to Ed25519, hash with SHA-256, and use Merkle trees over batches of hashes where their designs call for them (VCP per anchored batch, step 1; OCG in the estate's Sigsum lineage checkpoint, step 3), cite the IETF SCITT architecture, and treat external anchoring as the escape hatch from trusting the producer. Those shared floors are why a field-level mapping is possible at all.

vcp v1.2 cites Ed25519 (default) SHA-256 EventHash RFC 6962 Merkle trees draft-ietf-scitt-architecture Bitcoin / OTS / RFC 3161 anchors ocg receipts use Ed25519 (signing guide + verdicts) SHA-256 execution hashes lineage tiles (Checkpoint format) SCITT-mappable receipt fields Sigsum checkpoint + anchor endpoint Ed25519 SHA-256 Merkle both cite draft-ietf-scitt-architecture; the VCP profile draft for it is authored by the practitioner this page was written for

The SCITT row is the one to watch. VCP v1.2 defines normative opt-in alignment fields targeting COSE Receipts, and the profile Internet-Draft for VCP on SCITT is an individual submission by Kamimura, the practitioner this correspondence is with. Our receipts were built with the same mapping in mind. Neither side has implemented the handshake; the vocabulary for it exists on paper on both sides of the table.

Prompt at this stepread the profile draft
Fetch draft-kamimura-scitt-vcp from the IETF datatracker and list which COSE Receipt fields a VCP event populates, then say which of those an OCG execution_hash receipt could populate without new cryptography.
The payload-binding and transparency-tree fields map directly; both formats already commit SHA-256 digests over canonical bytes, so no new primitive is needed on our side.
draft-kamimura-scitt-vcpVCP v1.2 §5 references pageour Ed25519 guide
6
Step 6 · The part to verify

No connector exists yet

Everything above is a reading of two published specifications. It is not an integration, and neither side claims one. A code search across all 27 public repositories in the veritaschain GitHub organisation returns zero hits for Model Context Protocol, zero for OpenChainGraph, and zero for AINumbers, measured on 15 October 2026. VSO's own correction wave states that zero external implementations of VAP exist. Our estate contains no VCP bytes either. A reader should trust this page as a mapping on paper, and as nothing more.

searched 15 October 2026 github code search, org: veritaschain Model Context Protocol ..... 0 hits OpenChainGraph ............. 0 hits AINumbers .................. 0 hits their own disclosure agrees zero external implementations of VAP (their October 2026 correction wave, on their site) our estate holds no VCP bytes either producer shimunbuilt receipts as VCP events, both run on Workers verification crosswalkunbuilt their Merkle proofs beside our verifier anchoring reciprocityunbuilt OTS / RFC 3161 for them, Sigsum for us

The three sketches are one-sentence descriptions of work that would be small on both sides, listed because a reader comparing formats always asks what a bridge would take. None of them is announced, planned, or in progress by either organisation, and this page deliberately does not date them into existence.

Prompt at this stepverify the search
Search GitHub code in the veritaschain organisation for Model Context Protocol, for OpenChainGraph, and for AINumbers, and report all three counts with the date you ran them.
Zero, zero, zero on 15 October 2026, matching this page; rerun it yourself, the counts move if the world does.
GitHub code search, org: veritaschainveritaschain.org corrections text, read 15 October 2026
7
Step 7 · Sources and staleness

Check every source yourself

Every claim about VCP on this page is checkable against two pinned sources: their specification file at commit b23acb266f88 in the vcp-spec repository, and their public site as it read on 15 October 2026. Every claim about our side is checkable against the live estate: the specimen run, its witness, the ledger, and the verifier are all public. A mapping page earns trust the same way a receipt does, by naming exactly what it read.

  1. Read VCP v1.2 section 6 for the three layers, then rebuild the crosswalk's integrity rows from the section text.
  2. Read Annex §3 for ERASURE and Annex §5 for the SCITT alignment fields, and decide which GDPR answer fits your auditor.
  3. Re-run the three GitHub searches from step 6; if the counts have moved, something has been built and this page is behind the world.
  4. Recompute the companion page's specimen hash from its witness to see our side's reproducibility claim working end to end.

Three events would make this page stale, and each is easy to spot: a VCP v1.3 or a VAP draft beyond Draft 3 changes the left column; a deployed Explorer API changes the verification row; a connector repository appearing in either organisation changes the boundary row from step 6. The page is a dated observation, written to stay true as a record of what the two formats said on 15 October 2026.

Prompt at this stepfreshness check
Check for a VCP v1.3, a VAP draft newer than 3, and a live Explorer API deployment, then say whether this crosswalk is still current as of today.
As of 15 October 2026: v1.2 GA is current, VAP sits at Draft 3, and the Explorer API remains planned with no date.
vcp-spec commit b23acb266f88, 9 October 2026VCP developer resourcesthe companion walkthrough
Part three · Revisions, preimage classes, and the first test

The pinned map

A mapping becomes checkable when both sides are pinned to exact revisions and every field is placed in one of three classes: inside the hash preimage, recorded metadata outside it, or a claim that needs an external trust source. This part does that for one artifact per side, then proposes the first joint test.

8
Step 8 · The pins

The pinned revisions

Nothing below works against a moving target, so both sides are pinned to exact revisions before any field is classified. The OCG side pins its specification, its specimen run, and the kernel digests that produced it. The VCP side pins the v1.2 specification file by commit, the framework draft it profiles, and the SCITT profile Internet-Draft the correspondence keeps circling.

ocg pins SPEC v0.4 envelope schema, main 15 Oct 2026 specimen: cd1503d3… 0ca6da06… 36c64bd6… commitment ee204261… + published witness kernels 1fa3932e… / 4d536197… witness: 3 figures + 256-bit salt, reproducible vcp pins VCP-Specification-v1_2_en.md (doc 2026-07-06) GA tag v1.2.0 at this commit, 8 Oct JST VAP framework at Draft 3 draft-kamimura-scitt-vcp-03, 2026-07-21 retrieved 15 October 2026, both sides four checks, kept separate: C1 hash consistency · C2 replay of the pinned producer · C3 real-world binding (out of scope for both) · C4 declared-set completeness

The four-check line at the bottom is the rule the rest of this part follows. C1 asks whether a recorded hash matches its recorded preimage. C2 asks whether re-running the pinned producer reproduces it. C3 asks whether the declared inputs match the world, and both formats decline to answer that in writing. C4, added per the recipient's 25 October review, asks whether the captured record covers a declared expected set fixed from a source independent of the record itself (step 13). Every field in steps 9 and 10 sits in exactly one of three classes: preimage (C1 reads it), metadata (C1 ignores it), or external trust (no check on this page covers it).

Integrity review, 24 October 2026. VSO's own review notice, published at veritaschain.org, reports that VCP v1.2 §6.2.1 requires RFC 6962 construction "but the published builder and proof examples have known inconsistencies," that "root-only signatures do not bind attached batch metadata; exact nanosecond serialization also needs review," and that "full VAP conformance has not been established." The notice changes nothing in the paper mapping above and everything in its implementation status: a normative requirement is not a verified property of every implementation. It is the reason the VCP rows in step 12 stay UNRUN. Source pinned at vcp-v1.2-integrity-alignment (vap-spec @ 9fa5fbc6).

Prompt at this stepverify the pins
Fetch both pinned revisions and confirm they resolve: the OCG envelope schema on PostOakLabs/ainumbers at main, and VCP-Specification-v1_2_en.md at commit b23acb266f88 on veritaschain/vcp-spec. Report both commit dates.
Both resolve; the VCP spec commit is dated 2026-10-09, retrieved 15 October 2026.
OCG main @ 0c201846 at stagingvcp-spec @ b23acb266f88draft-kamimura-scitt-vcp-03VSO integrity review 2026-10-24
9
Step 9 · Three classes

The preimage map

The two formats hash different bytes. VCP concatenates the canonicalized header and payload and hashes the string, with the algorithm selectable per deployment. OCG hashes a single canonicalized two-member object, with SHA-256 fixed. Both cite RFC 8785 for canonicalization, so the difference is structural, not accidental: the same two JSON fragments produce different hashes under the two rules, and neither hash verifies the other's bytes.

vcp event preimage canonical(header) + canonical(payload) concatenated as a string, then hashed SHA256 | SHA3_256 | BLAKE3 (selectable) header is INSIDE the preimage ocg receipt preimage { policy_parameters, output_payload } one canonical two-member object (RFC 8785 JCS) SHA-256, fixed by SPEC section 4 identity fields and timestamps OUTSIDE two different hashes same primitive family, different preimages: neither hash verifies the other format's bytes
OCG field (specimen artifact)ClassNote
policy_parameters (normalized)PREIMAGEnull members removed; all decision inputs fold in here
policy_parameters.member_figures_commitmentPREIMAGEthe commitment is bound; plaintext figures and salt exist nowhere in the artifact
output_payloadPREIMAGEthe complete stage-by-stage output
generated_atMETADATAproducer clock; truth depends on that clock, stated unverified
chain { parent_hashes, depth }METADATAlinkage; in composites the child receipts also sit inside output_payload, so linkage is hash-bound there
tool_id / tool_version / mandate_type / @context / buildType / compute_modeMETADATAidentity and transport
compliance_flagsMETADATAverdict vocabulary, hash-excluded by design
audit_signature (+ §18 compute_proof when present)METADATAempty envelope on the specimen; proofs, when attached, are hash-excluded by design
kernel source ↔ kernel_digestEXTERNAL TRUSTdigest re-hashable against the public repo; C2 replay eliminates the trust
operator execution (server runs)EXTERNAL TRUSTeliminated by idempotent re-run or zero-egress browser execution
ledger.ainumbers.coEXTERNAL TRUSTavailability only; integrity is local recompute-and-match
§27.12 countersigner keys (two-party runs)EXTERNAL TRUSTabsent on the specimen (envelope empty)
§25 witness holderEXTERNAL TRUSTonly the witness-holder can bind commitment to real figures
VCP field (one event)ClassNote
Header (EventID, EventType, Timestamp, ProducerID, SchemaVersion)PREIMAGEcanonicalized and concatenated into the EventHash
Payload (domain content)PREIMAGEcanonicalized and concatenated
PrevHash (when chain mode is used)PREIMAGEoptional since v1.1; "0"*64 sentinel otherwise
Merkle root + audit path (Layer 2)METADATA per eventcovers a batch of EventHashes; inclusion proven at anchor time
Ed25519 signature over the root (Layer 3)EXTERNAL TRUSTproducer key authenticity; REQUIRED, signs the batch not the event
dual-format timestamp (Layer 3)EXTERNAL TRUSTtier clock: PTPv2, NTP, or best-effort
anchor receipt (Layer 3)EXTERNAL TRUSTBitcoin / OpenTimestamps / RFC 3161 authority, per tier SLA
SCITT alignment fields (opt-in)EXTERNAL TRUSTCOSE Receipts toward a transparency service
VCP-XREF blockPREIMAGE (as declared)cross-reference and reconciliation status live in the hashed structure

Read the two tables together and the asymmetry is structural. VCP puts the clock, the producer identity, and the anchor inside its trust perimeter by design, because a trading record must say when and who under regulatory scrutiny. OCG puts the computation inside its preimage and leaves time, identity, and anchoring as declared metadata, because a computation receipt must stay reproducible without any of them. A field is never trusted in one format because its twin is trusted in the other.

Prompt at this steprun the structural test
Take a toy JSON header and payload, compute the VCP-style hash (concatenate the two RFC 8785 canonical parts and SHA-256 the string) and the OCG-style hash (RFC 8785 of the two-member object), and report both digests.
Two different digests from the same two fragments, on both hash libraries. The maps agree: same family, different preimages.
VCP v1.2 §6.1.1-6.1.3, §6.3OCG SPEC §4, §12, §25, §27.12classification as of 15 October 2026
10
Step 10 · Names are not guarantees

Where similar names diverge

The two vocabularies overlap enough to invite false equivalences: both formats speak of event hashes, Merkle trees, signatures, anchors, timestamps, and commitments. Each row below takes one shared word and states why the two guarantees behind it differ. This is the table to read before treating any single field as interchangeable.

Shared wordWhy the guarantees differ
EventHash ↔ execution_hashVCP concatenates two canonicalized parts with a selectable algorithm and includes the header; OCG hashes one two-member JCS object with SHA-256 fixed and excludes identity fields. Same family, different preimages.
Merkle completenessNeither mechanism establishes completeness. VCP: an RFC 6962 audit path places a provided leaf in the anchored batch; which events were expected is declared outside the log. OCG: recompute validates held receipts; which steps were expected is the chain definition. Completeness is the declared-set comparison of step 13, run separately on both sides.
signatureVCP: the producer signs every Merkle root, REQUIRED. OCG: the envelope ships empty on standard runs; §27.12 countersigning is scoped to two-party runs.
anchorVCP: external authority on a tier clock, REQUIRED. OCG: no authority attached to standard runs; the Sigsum lineage checkpoint is published beside the estate, not per run.
timestampVCP: dual-format with tier-synced clock SLAs down to PTPv2. OCG: a single operator-asserted field outside the preimage.
commitmentVCP ERASURE: destroy the key over stored plaintext. OCG §25: salted hash over figures that were never stored. Opposite answers to the same GDPR pressure.

The practical rule the correspondence settled on: read the two tables together only at the concern level, never at the field-name level. A shared word is an invitation to compare the underlying guarantees, and the comparison usually ends in a deliberate difference rather than a gap.

Prompt at this stepstress one row
Take the completeness row and state what a VCP Merkle audit path proves that OCG recompute does not, and what OCG recompute proves that a Merkle audit path does not.
Neither the audit path nor recompute establishes completeness. The audit path places provided leaves in the anchored batch; recompute validates the receipts you hold. What should have been there is a different question with its own check: declared set versus captured set, step 13 on both sides. Each mechanism is blind to it by construction.
VCP v1.2 §6, Annex §3, §5OCG SPEC §4, §25, §27.12as of 15 October 2026
11
Step 11 · The proposal

The first side-by-side test

The correspondence settled on a concrete opening move: one artifact each, three-class tables filled from each side's own pinned text, and the replay check executed rather than assumed. Five steps, all doable on paper and in a terminal, none requiring the other side's permission.

  1. Each side pins one artifact: our CCP specimen from the companion page, and a Platinum-tier sample event from the nasdaq-rta conformance dataset.
  2. Each side fills the three-class table for its own artifact from its own pinned text, without borrowing the other's field names.
  3. C1 and C2 are kept separate per the recipient's 25 October review: we recompute the specimen's hash from its own recorded bytes (C1, offline), then replay it from the published witness through the pinned kernel (C2); the VCP event hash is recomputed from its header and payload per §6.1.1 (C1; the sample carries no producer process to replay).
  4. The two tables are read together at the concern level only, with any shared word checked against the non-equivalence table from step 10.
  5. C3 is written down as out of scope for both, in each side's own words, so the boundary travels with the mapping.

Steps 1 and 2 are complete on our side: the tables in step 9 are that classification, filled from the pinned texts and reproducible from this page. Steps 3 through 5 are joint by nature. Dated 25 October: C1 and C2 are executed and named separately; the VCP half is C1-only until producer-process disclosure exists. If the test surfaces a row where the two formats genuinely can be bridged, that row becomes the first connector worth building, and the three sketches in step 6 stop being sketches.

Prompt at this stepexecute our half
Recompute the OCG specimen's step 1 execution hash from the published witness and the pinned kernel, and report it beside the recorded cd1503d3… value.
Identical, bit for bit: C2 done on our side. The VCP half needs one sample event from the conformance dataset.
vcp-nasdaq-rta-reference conformance datasetthe specimen walkthroughproposed 15 October 2026
Part four · Evidence, completeness, and the negative battery

The review basis

The recipient's 25 October review of part three is adopted here point by point, and it improves the page: the mapping stays provisional until he can rerun it, C1 and C2 are named separately, completeness gets its own check, and every mapping row now carries an evidence record with statuses a rerun can confirm or contradict.

12
Step 12 · The evidence schema

What every row must record

A mapping row is only as good as the evidence behind it, so each row of this crosswalk now records four things: the exact artifact path and bytes it pins, the mechanism that binds them, the external trust the binding still assumes, and an observed test result. A hash-bound field can still carry an unverified real-world claim; those properties stay in separate columns, never merged into one "verified" verdict.

RowArtifact path / bytes (exact pin)Binding mechanismExternal trust assumptionObserved result
EventHash ↔ execution_hashOCG: specimen step 1, pinned cd1503d3fb854f71…73f98f5c; bytes rebuildable from the public kernel + published witness (export art-529-artifact.json). VCP: no sample event pinned yet.OCG §4: SHA-256 over JCS of the two-member object. VCP §6.1.1: SHA-256 over canonicalize_json(header) + canonicalize_json(payload).SHA-256 + RFC 8785; for OCG C2 additionally that the public kernel source matches its pinned digest.OCG C1 PASS (2026-10-25: recompute over recorded bytes matches the pinned hash). OCG C2 PASS (2026-10-14 and again 2026-10-25: three now variants, identical hash; the clock is provably outside the preimage). VCP C1 UNRUN. VCP C2 OUT OF SCOPE for the sample.
Merkle completenessOCG: composite receipt 36c64bd689b19b1c…b95d95608 (export ledger-receipt.json, decoded from the self-contained ledger URL). VCP: anchored batch from the conformance dataset, not yet pinned.OCG: children embedded in the composite preimage (linkage is hash-bound). VCP: RFC 6962 tree over batch EventHashes + audit path (implementation status: the 24 October notice, step 8).OCG: none beyond the artifact (C1 runs offline; ledger availability only). VCP: anchor authority per tier SLA.OCG linkage PASS (2026-10-25: chain.parent_hashes = [cd1503d3…, 0ca6da06…], embedded step hash matches the standalone artifact). VCP inclusion UNRUN.
signatureOCG: same composite; audit_signature present and empty. VCP: producer Ed25519 key.OCG: none on standard runs (§27.12 countersigning is two-party only). VCP: producer signs every Merkle root (Layer 3 REQUIRED).OCG: nothing to trust (empty by design). VCP: key belongs to the declared producer (VC-Certified audit).OCG N/A BY DESIGN (observed: signatures: [] on the pinned composite). VCP UNRUN; the 24 October notice also reports root-only signatures leave attached batch metadata unbound (step 8).
anchorOCG: same composite; no anchor field. VCP: anchor receipt (Bitcoin / OpenTimestamps / RFC 3161) per tier interval.OCG: none, content addressing replaces external anchoring. VCP: external authority on a tier clock, REQUIRED.OCG: none. VCP: the anchoring authority.OCG ABSENT BY DESIGN (the 2026-10-14 export states this as a real gap vs VCP). VCP UNRUN.
timestampOCG: generated_at 2026-10-07T18:07:38.316Z, operator-asserted. VCP: dual-format, tier-synced.OCG: none, outside the preimage. VCP: tier clock SLA (PTPv2 / NTP / best-effort).OCG: the operator clock. VCP: the time infrastructure.OCG DEMONSTRATED UNVERIFIED (2026-10-25 probe N1b: moving the clock leaves the hash unchanged: the silence is the boundary the preimage map draws). VCP UNRUN.
commitmentOCG: member_figures_commitment sha256:ee2042618d9ac086…445686224 + witness (3 figures + 256-bit salt, published). VCP: ERASURE key-destruction events.OCG §25: salted hash over figures never stored. VCP: destroy the key over stored plaintext.OCG: the witness holder. VCP: ERASURE key ceremony.OCG PASS (2026-10-14, reconfirmed 2026-10-25: rebuild from witness reproduces the commitment and the full artifact hash). VCP UNRUN.

Statuses mean: PASS: executed by us, date given, reproducible from the pinned inputs. UNRUN: no execution yet; the row is paper-derived from pinned text. N/A by design / absent by design: the format's own text places the guarantee elsewhere. OUT OF SCOPE: agreed exclusion, recorded rather than silently dropped. The recipient's rerun turns UNRUN into his own PASS or a contradiction; both outcomes are progress, which is the point of the table. The same rule that keeps hash-bound and world-verified in separate columns keeps this whole page provisional until the rerun lands. The recipient's review of this page is textual feedback, not independent reproduction or endorsement: UNRUN cells stay UNRUN and provisional stays provisional until a rerun changes them, and nothing here treats his reading as validation.

correspondence review 25 October 2026OCG SPEC §4, §25VCP v1.2 §6.1.1, §6verify.mjs + negative-probe.mjs, run 2026-10-25
13
Step 13 · C4

The fourth check

A Merkle inclusion proof places a provided leaf in the anchored tree; it says nothing about whether every expected event was captured. C4, declared-set completeness, fixes the expected set from a source independent of the captured record, then compares. Neither C1, nor C2, nor a Merkle inclusion proof implies it.

declared set (chain definition) art-529-…waterfall-recompute art-530-default-fund-cover2-sizing fixed outside the captured record exactly 2 steps expected captured: composite receipt art-529 … present (embedded) art-530 … present (embedded) linkage hash-bound in the preimage verdict: COMPLETE, 2 of 2 captured: standalone artifact art-529 … present (C1-valid) art-530 … MISSING bytes verify; set does not verdict: INCOMPLETE, 1 of 2 a valid record can be an incomplete record: completeness is a separate axis
SideExpected set (independent source)Captured setResult
OCGthe chain definition: chain-ccp-default-waterfall declares exactly two steps, art-529 → art-530child receipts embedded in the composite's output_payload, each with tool_id + execution_hash, hash-bound via the composite preimageCOMPLETE: 2 of 2 expected steps captured (2026-10-25)
OCG (the instructive negative)same declared two-step setthe standalone step-1 artifact (art-529-artifact.json): perfectly C1-valid, its bytes verifyINCOMPLETE: 1 of 2 against the declared set, with C1 still passing
VCPdeclared expected event list from outside the log (reconciliation source, upstream manifest, the dual-logged stream's other side)events whose inclusion is proven in the anchored batchUNRUN until a sample batch is pinned

A batch root with an audit path proves where the provided leaves sit; the expected-set comparison is what notices an event that never made it into any batch. The standalone artifact is the recipient's point generalized to our own format: completeness is a separate axis from validity, and only the fourth check reads it. The comparison is scoped to the declared set: it notices a captured record that falls short of what was declared, and it cannot establish that the declaration itself includes every real-world event; that gap stays with C3 and with each format's own declared-boundary line (the last row of the step 3 table).

Prompt at this steprun the fourth check
Read the chain definition and count its declared steps; then decode the composite receipt and count the child receipts embedded in its output_payload. Report declared, captured, and the comparison verdict.
Declared 2, captured 2 against the composite: COMPLETE. Against the standalone artifact, captured 1: INCOMPLETE, while its own hash still verifies.
correspondence review 25 October 2026OCG SPEC §4VCP v1.2 §6negative-probe.mjs probe N2, run 2026-10-25
14
Step 14 · Falsifiable boundaries

The negative battery

Changed bytes, a missing expected record, an absent anchor proof. The expected verdicts below were written down before running, so the boundaries are falsifiable: if a probe lands anywhere other than its expected cell, the mapping is wrong. All three classes are executed or stated on the OCG side; the VCP-side cells stay UNRUN until a sample is pinned.

ProbeWhat is doneExpected verdict (written first)Observed 2026-10-25
N1a: changed bytes (preimage)Flip one value inside the preimage: output_payload.residual_minor_units 0 → 1; recompute execution_hash against the pinned reference cd1503d3….MISMATCH: a one-minor-unit change must not survive.MISMATCH as expected (e3c0c15a48f32f31…).
N1b: changed bytes (metadata)Set generated_at to 2030-01-01; recompute.UNCHANGED: the clock is outside the preimage; the silence here is the boundary the preimage map draws, by design.UNCHANGED as expected.
N2: missing expected recordCompare the declared two-step chain against (a) the composite's captured children and (b) the standalone step-1 artifact.(a) COMPLETE. (b) INCOMPLETE, 1 of 2, with C1 still passing on the standalone bytes.Both as expected (2/2; 1 of 2).
N3: absent anchor proofStrip or withhold the Layer-3 anchor receipt on a VCP record. On OCG: nothing to strip.VCP: Layer-3 verification fails; the record degrades to C1 (+ C2 where possible) with the timestamp falling back to operator-asserted. OCG: absent by design; the verifier's guarantee set is unchanged, as the anchor row of step 10 already states.OCG stated (absent by design, observed on the pinned composite). VCP UNRUN, needing a real anchored batch from the conformance dataset.

One scope note the battery makes visible, in the correspondence's own words: C1 detects tampering only against a pinned reference hash. On our side the references are the ledger content address, the composite's parent_hashes, and the published witness; a standalone artifact with no external pin could be replaced wholesale by a self-consistent fake. The binding is only as strong as the pinning of the binding itself: hash-bound is not world-verified, one level up.

What promotes a row: a mapping row graduates from "mapping on paper" to connector candidate only when, for both sides, its evidence row shows an observed PASS (not UNRUN) under the four columns, and its negative probes fail exactly where the table predicts. Until then the step 6 statement stands unchanged: no connector exists, and nothing on the page claims otherwise.

Prompt at this stepreproduce the battery
Run negative-probe.mjs against the pinned specimen and report each verdict beside the expected column. Any cell that lands off its expectation falsifies the mapping row it tests.
All four probes landed on their expected cells: C1 MATCH; N1a MISMATCH; N1b UNCHANGED; N2 COMPLETE 2/2 and INCOMPLETE 1-of-2. The boundaries held.
correspondence review 25 October 2026OCG SPEC §4, §25VCP v1.2 §6.1.1, §6negative-probe.mjs, first run 2026-10-25
🔒 All inputs are processed locally in your browser. No data is transmitted. Do not enter real personal data — use synthetic or anonymised inputs only.