# Fixture engagement SE1 — the reproduction package

Fixture: every provider, listing, identifier, address, date and hash here is invented. The structure is the deliverable, not the values. No real key material.

This directory is the reproduction package of the SE1 sample case (fixture:engagement-se1:case): the signed case (case.json, four generations — one per state, every source extract embedded as bytes with its sha256, each generation carrying its Finding contract with the contract's sha256 digest — the contract binds each finding to the commission version that authorizes its question, and every conclusion, limitation, typed action, binding, state, reason and reading value in the delivered contract is PRODUCED by the shipped evaluator from the delivered extracts under the one-evaluated-result law: the input's authored conclusion bytes are read only to be compared with the produced ones and a mismatch refuses, and the embedded contract copy under artifacts["finding-contract"] is accepted only when it equals the contract the evaluator produced in the same run), the case record (case-record.json), the permitted inputs (permitted-inputs.json — the case's own readings: role, source, observed time, the sha256 of the extract bytes), the exact law versions (law-versions.json — every rule version the contract cites), the executable rule files byte-equal the repository modules (under lib/ and docs/, including the ONE Finding-contract module — a READER of the evaluated result — and the action-contract module that names every decision's precondition), the approved commission specification delivered as its public form with its approval (commission/ — commission/SE1-COMMISSION-SPEC-v2.json, the ratified canon bytes sha256 288c7b85c6bda003730779a0264eb6962a8ce13d95287002a5d7b7524db45ce2 (version 2 — the jurisdiction and temporal_scope the founder approved 2026-10-29; supersedes version 1, whose ratified bytes sha256 73284d360fc4deca0c5ee054d33a81c13b9b072c7cfd26280efc934ec2b6e936 are kept root-side) held root-side in docs/canon, with the three founder-name sites in the public vocabulary — PUBLIC-NAMES-0, no exemptions — and every other byte identical; commission/approval-receipt.json, the approval naming the ratified bytes by their sha256, the approval instant and the ratification's msg id; commission/change-history.json, versions 1 and 2 with the specification's own change-control law verbatim, version 1 superseded by version 2 from the v2 approval; and oracle-receipts/, the binding oracle's receipts — its identity, its positive run and its red run, each red naming its refusal code and the sha256 of the exact tampered input it consumed, the positive run naming the case.json and law-versions bytes it ran over; the commissioned-question set the verifier holds the delivery to: exactly these four questions, each answered exactly once, an omission, duplicate, substitution or unexpected addition refuses, and the DERIVE phase holds the delivery to its commission's approval — a package without the approval receipt, the change history or the oracle's receipts refuses naming the missing file, and a receipt that does not bind to the ratified specification sha or the authenticated case bytes refuses too), plus the fixtures registry that pins this engagement's generation addresses, the signed inventory (inventory.json), the signature (fixture-signing.json), the manifest (SHA256SUMS), this README, and the repository's current observation runner delivered as bytes (observation-extract-runner-v5.mjs).

## Verify offline — network off

1. From inside this directory:

   node observation-extract-runner-v5.mjs --case-dir . --trust-config ../trust/fixture-trust.json --case fixture:engagement-se1:case --generation <id>

   Expected: exit 0. ARGS, KEY, INVENTORY, CARRIED, SIGNATURE, LOAD and DERIVE print PASS; RELIANCE prints NOT EVALUATED without --at (an evaluation the runner did not perform never prints PASS). CARRIED is the pre-sign leg (CARRIED-PRESENT-1): every artifact this cover names as carried resolves inside the package bytes and the signed manifest, and a named-but-absent artifact refuses the package before signing. The authenticated launcher — an external verifier whose own digest is published outside this package — runs this same command for you after it has verified the signature, the signed inventory and every file's sha256 against the external trust configuration, before any package-supplied code executes (see Trust prerequisite below and the Technical page, which prints the launcher command and the launcher's published digest). V, C and S re-derive: the runner re-executes the shipped evaluate over the embedded extracts and the delivered serialize bytes and digests are byte-equal. PARITY compares the delivered contract with the re-executed evaluated result on predicate, question, rule, state, reason, the subject identifier, every reading value, every evidence digest (cross-surface), the conclusion, the conclusion's bounds, the limitation and the typed action — the PASS line names only the comparisons that ran. CARRIERS re-renders every delivered carrier from the evaluated result with the shipped serializer — the packaged text (carrying both compared values, the bounded conclusion as its Supports line, the limitation, the action and completion criterion, the reliance clock in human words, and the pinned generation by its exact public address), the brief payload (the canonical Finding bytes and digest) and the export payload (the case-record entry) — and refuses on any byte difference, naming the carrier. U is REFUSED BY NAME at DERIVE — reproduction unavailable — no search record: the delivered NPPES extract carries a registry record but no search record (query, result set, completeness), so the registry-listing reproduction is refused by name and the identifier comparison is never executed on a bare record; its finding travels in the signed case as the Finding contract with its own finding bytes and digest, whose conclusion, limitation and typed action are the evaluator's own produced refusal. One QUESTION outcome line prints per commissioned question, in the specification's own order — three read EVALUATED with their state, and SE1-Q-REGISTRY reads REFUSED — no search record: a bounded refusal is an accounted answer, never a failure, and a PASS never follows a refusal on the same question line. With --json the runner prints the machine summary — package integrity, issuer eligibility, contract completeness, per-question evaluated|refused, currentness — as its last line; on any refusal under --json the SAME five-field object prints with the failing field `refused:<PHASE>` and every other field `not-evaluated`, and the process exits non-zero (an ARGS refusal exits 2 with every field `not-evaluated` — no field was measured; the phase rides stderr).

2. The trust configuration lives OUTSIDE this package — published by the site under /verify/fixture/trust/ — and is the ONE source of the signing key's SPKI DER sha256 (the pin): no pin value is typed in this package's own bytes, and the pin printed on the Technical page next to the command derives from the same source. The record is never its own trust root: the launcher and the runner decide trust on the external trust configuration (or the pin you checked), never a claimed fingerprint string.

3. SHA256SUMS is an index, not a reproduction: it covers this directory's own files except itself and the two signed control files — a manifest cannot carry its own digest, and the signed inventory and the signature are bound by the Ed25519 signature, never by the sums. The package's integrity root is the SIGNED inventory: every delivered file at every depth is listed in inventory.json and signed in fixture-signing.json, and the runner refuses any byte that differs.

## Trust prerequisite

Check the launcher's sha256 against the published value first — the Technical page prints the launcher command beside the launcher's published digest, and the external trust configuration published by the site carries it too; the launcher re-checks its own digest at boot and refuses a replacement. The supported consumer is obtained independently of this package: a trusted installation of your own (the Node.js you already run) plus the authenticated launcher, whose own digest is published outside the package and which verifies this package's detached signature, the signed inventory and every file's sha256 against the external trust configuration BEFORE any package-supplied code executes — then it runs the package's own runner, which re-verifies everything in turn. Running the launcher requires Node.js on the recipient’s machine; a verification path that needs no Node.js is not provided yet.

## What the verification establishes — the trust statement

One trust statement in three parts — what anyone can check independently, what this service attests, and what remains reliance on others.

- **Independently checkable:** the signature over the signed inventory · every delivered file's sha256 · the re-derivation of the C, S and V generations · the refusal of the U generation.
- **Attested by this service:** the capture time of each observation · the source locator of each observation · that each capture was complete.
- **Relied on from others:** the board's own published accuracy · the NPPES registry's own accuracy · the approved rule interpretation · the commission's authorization · the clock.

Act on the verified bytes without accepting any unsupported assertion from this service: a signature proves the signer and the bytes, never the truth or the original capture. This package never claims you can act here "without trusting us" — that absolute phrase is refused in this service's own copy (the same statement renders on the Technical page, from the same source module).

## What this establishes

Publication observations only, for the invented engagement. The commission's question, the subject and the observation schedule travel in the case record; the full validated finding objects travel in the signed case. Completing the service never resolves a finding.

## Limits

The case record is the ONE generator's own serialization (the sample-case export module of the public repository): the case id, one entry per finding with its immutable generation, every evidence reference the case pins, the method versions, and the observation schedule. The signed case's four generations derive from the ONE evaluated result: V, C and S are the contract's executable rules re-run over the retained extracts (LICENCE-STATUS-COMPARE@v1, LICENCE-EXPIRY-COMPARE@v1 for C, and RELIANCE-WINDOW@v1 for S), each delivered conclusion and typed action produced by the evaluator from the evaluated state, readings, binding and missing precondition; the typed action's due date is not established by any evaluated reading and is not authored — the case record's own follow-up plan carries its schedule. U cites REGISTRY-SEARCH-COMPLETE@v1 — the bound NPI from the buyer card and a search record (the query, its result set and a completeness marker) — but the delivered extracts carry no search record, so its reproduction is refused by name and registry absence is never established; the contract layer carries the finding with the evaluator's produced refusal conclusion. A proposition with no rule is never reproduced as a different proposition. The retained-reading question (S) and the directory-vs-board expiry question (C) share the licence-expiry field and are DIFFERENT commissioned questions — each delivered exactly once under its own question id, linked as related questions in each contract's history byte, never as versions of one another. The portable text is the serializer's contract path (R-BQ): every operative line — limits, owner, completion criterion, binding, generation and the history line — derives from the contract by field path, one input shape for the screen copy, the workspace export and this packaged text; a required path absent refuses serialization naming the path, and "not recorded" appears only where the contract records absence.

## Action permission — the normative context/action table

Action permission derives from the evaluated result alone. The permitted list is rendered from the boundary twin v1's own decision rows over the stored chain the evaluator derives from the admitted readings and the evaluated question, and every action below is the twin's own decision text, verbatim, in the context the executable preconditions name. This table is the normative statement of those preconditions; the shipped action-contract module names each one and the twin bytes this package delivers carry each decision's own text, so a recipient can check every row against the delivery.

| Decision | The twin's permitted action (verbatim) | The context that renders it (the executable preconditions) |
|---|---|---|
| D1 | Accept a finding as VERIFIED | gated over the contract: the Finding contract is supplied under artifacts["finding-contract"]; the finding state is VERIFIED; the admitted readings agree (the contract's own rule executed on its readings) |
| D2 | Treat a finding as UNVERIFIABLE | the twin's own state precondition: missing_precondition_named (the named missing precondition) |
| D3 | Treat a finding as CONTESTED | the twin's own state preconditions: comparability_verdict, subject_binding, readings_disagree |
| D4 | Treat a finding as STALE | gated over the contract: the Finding contract is supplied; the reliance period is past (established from the contract's readings and the reliance window) |
| D5 | Issue or accept a correction instruction | gated over the contract: the Finding contract is supplied; an established discrepancy with a justified field, correction target and authority |
| D6 | Request clarification (next admissible step) | the twin's own state precondition: missing_precondition_named |
| D7 | Challenge a finding | the twin's own state precondition: challenge_route_pre_addressed |
| D8 | Rely on the offline download | the twin's own state preconditions: signed_inventory_named, every_file_byte_verified, omission_tamper_vector_refused |
| D10 | Treat an address as published by the registry on its observation date | the twin's own state precondition: observation_date_carried |
| D11 | Commission a follow-up observation | the twin's own state precondition: obligation_cell_outcome_recorded |
| D12 | Treat the service as complete | the twin's own state precondition: obligation_matrix_complete |

An embedded contract copy under artifacts["finding-contract"] is accepted only when it equals the operative evaluated contract — the contract this evaluator produced in the same run over the same admitted readings and the evaluated question — before any use; a differing copy permits nothing: correction is unavailable while the copy disagrees, the refusal names the first differing path, and no permission is ever inferred from a separately authored field that merely claims a discrepancy.
