Reference · verifier-standard 1.2.0 · VSTD-5 PROJECT SPECIFICATION; EVIDENCE-BOUND REFERENCE MECHANISM

Inspect the whole pipeline.

Terms used below: hash-based message authentication code (HMAC); International Organization for Standardization (ISO); JavaScript Object Notation (JSON); Secure Hash Algorithm 256-bit (SHA-256); and YAML Ain't Markup Language (YAML).

Every command, argument, top-level export, and listed dispatch edge below is read out of the installed package when this page is built, by scripts/build_reference.py, and the presentation tests fail closed when the committed page drifts — so it cannot describe behaviour the implementation no longer has.

This page states the declared public surface of one implementation. It does not establish that any individual claim checked by these commands is true, nor that an external implementation exists.

Pipeline map CLI reference API reference Wire and schemas

Pipeline

Command to implementation, without a gap.

Each entry point below is imported while this page is built. A rename, move, or deletion fails the build instead of publishing a stale map.

Command	What it does	Implementation entry points
`vstd demo`	Runs the four adversarial specimens in-process and reports whether each defensive outcome matched its declared invariant.	`verifier.runtime.demo:run_demo` `verifier.runtime.demo:demo_report`
`vstd plan`	Resolves a manifest's command and declared paths without executing anything.	`verifier.core.run_planning:load_manifest` `verifier.core.run_planning:describe_run_plan`
`vstd run`	Executes a trusted manifest without sandboxing, captures the observed execution, and writes a canonically digested receipt.	`verifier.core.run_planning:load_manifest` `verifier.core.run:capture_run` `verifier.core.receipt:compute_canonical_digest`
`vstd validate`	Dispatches on the receipt's serialized `schema_version` identifier and runs its implemented checks. Generic-run validation enforces its required structure and stable digest; other receipt kinds enforce their separately documented structure and evidence rules.	`verifier.core.run_validation:validate_run_receipt` `verifier.data.receipt:validate_data_receipt` `verifier.hardware.validation:validate_vstd3_receipt`
`vstd inspect`	Prints the claim coordinate, digest, and verdict surface of a stored receipt.	`verifier.core.run_inspection:inspect_run_receipt` `verifier.hardware.receipt:load_vstd3_receipt`
`vstd reproduce`	Replays only the mechanisms a stored receipt actually carries; physical hardware execution is refused rather than simulated.	`verifier.core.run_reproduction:reproduce_run_receipt` `verifier.data.receipt:reproduce_data_receipt`
`vstd impact`	Finds stored run receipts whose recorded ancestry reaches a revoked provenance artifact.	`verifier.core.run_impact:find_run_receipts_impacted_by_revocation`
`vstd data`	Traces, renders, or exports the provenance hypergraph carried by a VSTD-Graph receipt.	`verifier.data.models:ProvenanceHypergraph`
`vstd artifact`	Freezes exact regular-file bytes, adds or verifies finite self-closing seals, and creates observable copy-on-write thaw descendants.	`verifier.artifact_control:freeze_artifact` `verifier.artifact_control:seal_artifact` `verifier.artifact_control:verify_frozen_artifact` `verifier.artifact_control:thaw_artifact`
`vstd experiment`	Validates experimental workflow manifests or maps normalized GitHub snapshots without granting a VSTD verdict.	`verifier.runtime.experimental_workflow_cli:handle_experiment_command` `verifier.experimental_workflow.profile:load_manifest` `verifier.experimental_workflow.github:github_snapshot_to_events`
`vstd hardware / continuity / fleet / evidence / claims`	Evaluates VSTD-3 substrate-accountability receipts, their continuity and fleet evidence, and their declared claims.	`verifier.runtime.hardware_cli:handle_vstd3_command` `verifier.hardware.validation:validate_vstd3_receipt`

CLI

The `vstd` command reference.

Extracted from the live argument parser in verifier.runtime.public_cli. vstd is the canonical cross-platform command; verifier is retained as an alias only on platforms where it is unambiguous.

`vstd`

Subcommand group.

No arguments; this command only groups subcommands.

`vstd demo`

Run the side-effect-free VSTD adversarial flagship demonstration.

Argument	Kind	Meaning
`--scenario`	optional	Run all scenarios or one named scenario. (one of: all, wrong-artifact, honest-unknown, inflated-tier, poisoned-ancestor) [default: all]
`--json`	optional
`--emit-specimens`	optional	Write deterministic JSON specimens and observations to DIR.

`vstd run`

Execute a trusted manifest without sandboxing and capture a VSTD receipt.

Argument	Kind	Meaning
`manifest`	positional	JSON or YAML run manifest.
`--output`	optional	Receipt output directory.
`--receipt-id`	optional	Override the manifest claim id.

`vstd plan`

Show a manifest's declared command and paths without executing it.

Argument	Kind	Meaning
`manifest`	positional	JSON or YAML run manifest.
`--json`	optional

`vstd validate`

Run implemented receipt checks; Graph candidate validation is not conformance.

Argument	Kind	Meaning
`receipt`	positional	Receipt directory or receipt.json.
`--json`	optional
`--key`	optional

`vstd inspect`

Inspect a generic-run or VSTD-Graph receipt; validate and report VSTD-3.

Argument	Kind	Meaning
`receipt`	positional	Receipt directory or receipt.json.
`--json`	optional
`--key`	optional

`vstd reproduce`

Replay the mechanisms available in a stored receipt.

Argument	Kind	Meaning
`receipt`	positional	Receipt directory or receipt.json.
`--json`	optional
`--rerun`	optional	Generic-run receipts only: execute the recorded command again.

`vstd impact`

Find run receipts affected by a provenance-artifact revocation.

Argument	Kind	Meaning
`dataset_receipt`	positional
`artifact_id`	positional
`--search-root`	optional	[default: receipts]

`vstd data`

Inspect a stored VSTD-Graph hypergraph.

No arguments; this command only groups subcommands.

`vstd data trace`

Subcommand group.

Argument	Kind	Meaning
`artifact_id`	positional
`--receipt`	optional
`--direction`	optional	(one of: ancestors, descendants, blast_radius) [default: ancestors]

`vstd data graph`

Subcommand group.

Argument	Kind	Meaning
`receipt`	positional

`vstd data export`

Subcommand group.

Argument	Kind	Meaning
`receipt`	positional

`vstd artifact`

Freeze exact artifact bytes, add or verify a seal, or thaw a descendant.

No arguments; this command only groups subcommands.

`vstd artifact freeze`

Copy exact ordinary file or directory bytes into a new guarded bundle; symbolic-link sources are refused.

Argument	Kind	Meaning
`source`	positional
`bundle`	positional
`--media-type`	optional	[default: application/octet-stream]
`--parent`	optional
`--context`	optional
`--json`	optional

`vstd artifact seal`

Add a readable finite self-closing Ed25519 seal.

Argument	Kind	Meaning
`bundle`	positional
`--private-key`	optional
`--json`	optional

`vstd artifact verify`

Recompute exact bytes, guards, seals, and optional external anchors.

Argument	Kind	Meaning
`bundle`	positional
`--expected-artifact-id`	optional
`--expected-key-id`	optional
`--freeze-only`	optional	Accept a clean freeze without claiming seal-backed identity.
`--json`	optional

`vstd artifact thaw`

Copy a clean sealed parent into a new, lexically absent mutable descendant.

Argument	Kind	Meaning
`bundle`	positional
`destination`	positional
`--expected-artifact-id`	optional
`--expected-key-id`	optional
`--json`	optional

`vstd artifact status`

Compare a descendant with recorded sidecar metadata, or verify current equality against a supplied sealed parent.

Argument	Kind	Meaning
`artifact`	positional
`--record`	optional
`--parent-bundle`	optional	Actual frozen parent bundle required to establish THAWED_CLEAN or THAWED_DIRTY.
`--expected-artifact-id`	optional
`--expected-key-id`	optional
`--json`	optional

`vstd experiment`

Validate or adapt experimental, non-normative workflow records.

No arguments; this command only groups subcommands.

`vstd experiment validate`

Validate a profile manifest without granting a VSTD verdict.

Argument	Kind	Meaning
`manifest`	positional	Experimental workflow manifest JSON.
`--repo-root`	optional	Repository root used to verify every repo: artifact locator.
`--json`	optional

`vstd experiment github-events`

Map a strict normalized GitHub snapshot to verdict-neutral events.

Argument	Kind	Meaning
`snapshot`	positional	Normalized GitHub snapshot JSON.
`--json`	optional

`vstd hardware`

Discover or emulate accelerator evidence.

No arguments; this command only groups subcommands.

`vstd hardware list`

List accelerator profiles.

Argument	Kind	Meaning
`--vendor`	optional
`--json`	optional	Emit stable machine-readable JSON.

`vstd hardware inspect`

Inspect one accelerator profile.

Argument	Kind	Meaning
`profile_id`	positional
`--json`	optional	Emit stable machine-readable JSON.

`vstd hardware discover`

Run a vendor or generic adapter.

Argument	Kind	Meaning
`--adapter`	optional	(one of: generic, nvidia, amd, intel)
`--fixture`	optional
`--output`	optional	Write the normalized adapter result JSON.
`--json`	optional	Emit stable machine-readable JSON.

`vstd hardware emulate`

Run the deterministic virtual firmware contract probe.

Argument	Kind	Meaning
`--output`	optional
`--created-at`	optional	Final ISO-8601 receipt timestamp.
`--device-id`	optional	[default: vstd3-virtual-0]
`--firmware-version`	optional	[default: 1.0.0]
`--key-id`	optional	[default: vstd3-virtual-device-key]
`--key-hex`	optional	Test-only emulator HMAC key in hex.
`--json`	optional	Emit stable machine-readable JSON.

`vstd hardware attest`

Run an explicitly virtual attestation probe; no commodity claim is made.

Argument	Kind	Meaning
`--virtual`	optional
`--output`	optional
`--created-at`	optional
`--device-id`	optional	[default: vstd3-virtual-0]
`--firmware-version`	optional	[default: 1.0.0]
`--key-id`	optional	[default: vstd3-virtual-device-key]
`--key-hex`	optional
`--json`	optional	Emit stable machine-readable JSON.

`vstd hardware capabilities`

Evaluate incremental VSTD 3 conformance profiles.

Argument	Kind	Meaning
`receipt`	positional
`--json`	optional	Emit stable machine-readable JSON.
`--key`	optional	Test-only HMAC verification key; repeat for multiple key ids.

`vstd hardware verify`

Verify a VSTD 3 receipt and all recorded passing claims.

Argument	Kind	Meaning
`receipt`	positional
`--json`	optional	Emit stable machine-readable JSON.
`--key`	optional	Test-only HMAC verification key; repeat for multiple key ids.

`vstd continuity`

Verify authenticated event continuity.

No arguments; this command only groups subcommands.

`vstd continuity verify`

Subcommand group.

Argument	Kind	Meaning
`receipt`	positional
`--json`	optional	Emit stable machine-readable JSON.
`--key`	optional	Test-only HMAC verification key; repeat for multiple key ids.

`vstd fleet`

Verify a declared enrolled fleet boundary.

No arguments; this command only groups subcommands.

`vstd fleet verify`

Subcommand group.

Argument	Kind	Meaning
`receipt`	positional
`--json`	optional	Emit stable machine-readable JSON.

`vstd evidence`

Inspect VSTD 3 evidence strength.

No arguments; this command only groups subcommands.

`vstd evidence inspect`

Subcommand group.

Argument	Kind	Meaning
`receipt`	positional
`--json`	optional	Emit stable machine-readable JSON.
`--key`	optional	Test-only HMAC verification key; repeat for multiple key ids.

`vstd claims`

Evaluate or explain VSTD 3 claims.

No arguments; this command only groups subcommands.

`vstd claims evaluate`

Subcommand group.

Argument	Kind	Meaning
`receipt`	positional
`--json`	optional	Emit stable machine-readable JSON.
`--key`	optional	Test-only HMAC verification key; repeat for multiple key ids.

`vstd claims explain`

Subcommand group.

Argument	Kind	Meaning
`kind`	positional	(one of: DEVICE_IDENTITY, FIRMWARE_INTEGRITY, EXECUTION_OBSERVED, EXECUTION_ATTESTATION, EXECUTION_ACCOUNTING, ACCOUNTING_CONTINUITY, COMPLETE_MEDIATION, FLEET_COMPLETENESS, PHYSICAL_WORLD_COMPLETENESS)
`--json`	optional	Emit stable machine-readable JSON.

API

Top-level Python exports.

The names in verifier.__all__, with their live signatures and declared docstrings, are the supported runtime surface under the Python API stability policy. Subpackage imports are internal unless a published policy names them.

`ArtifactControlError` class

ArtifactControlError

Raised when an artifact-control action cannot fail closed.

Defined in verifier.artifact_control

`ArtifactVerification` class

ArtifactVerification(state: 'str', artifact_id: 'str | None', content_id: 'str | None', freeze_id: 'str | None', freeze_valid: 'bool', guard_valid: 'bool', valid_seal_ids: 'tuple[str, ...]', key_ids: 'tuple[str, ...]', external_anchor: 'str', errors: 'tuple[str, ...]', warnings: 'tuple[str, ...]') -> None

Result of independently recomputing a frozen artifact and its seals.

Defined in verifier.artifact_control

Method	Summary
`to_dict(self) -> 'dict[str, Any]'`

`AssuranceLedger` class

AssuranceLedger(graph: 'ProvenanceHypergraph') -> 'None'

Append-only current-state overlay for an immutable provenance graph.

Defined in verifier.data.assurance

Method	Summary
`admissibility_blocking_conflicts(self) -> 'tuple[ConflictRecord, ...]'`	Return conflicts whose effect still blocks a clean TRUST route.
`compose_guilt(self, ancestor_id: 'str', descendant_id: 'str', obligation: 'ObligationCoordinate', proposition: 'BoundProposition', *, localization_event_digest: 'str', responsibility_component_digest: 'str', applicability_component_digest: 'str', violation_component_digest: 'str', session: 'VerificationSession', recorded_at: 'str') -> 'DiagnosticAttribution'`	Compose technical GUILT from three exact, separately earned components.
`current_status(self, artifact_id: 'str') -> 'ArtifactStatus'`
`current_transformation_status(self, transformation_id: 'str') -> 'str'`	Return a transformation's additive current status projection.
`current_trust_events(self) -> 'tuple[AssuranceEvent, ...]'`	Return recursively current edge-local TRUST records.
`diagnose(self, kind: 'DiagnosticKind', ancestor_id: 'str', descendant_id: 'str', proposition: 'Optional[BoundProposition]', *, session: 'VerificationSession', recorded_at: 'str') -> 'DiagnosticAttribution'`	Compute BLAME, or fail closed for legacy opaque GUILT calls.
`establish_guilt_components(self, ancestor_id: 'str', descendant_id: 'str', obligation: 'ObligationCoordinate', responsibility_proposition: 'BoundProposition', applicability_proposition: 'BoundProposition', violation_proposition: 'BoundProposition', *, localization_event_digest: 'str', session: 'VerificationSession', recorded_at: 'str') -> 'tuple[AssuranceEvent, AssuranceEvent, AssuranceEvent]'`	Run one compound mechanism and retain three separately bound results.
`establish_obligation_applicability(self, artifact_id: 'str', obligation: 'ObligationCoordinate', proposition: 'BoundProposition', *, session: 'VerificationSession', recorded_at: 'str') -> 'AssuranceEvent'`	Evaluate whether one exact obligation applies to one exact artifact.
`establish_obligation_violation(self, ancestor_id: 'str', descendant_id: 'str', obligation: 'ObligationCoordinate', proposition: 'BoundProposition', *, localization_event_digest: 'str', applicability_component_digest: 'str', session: 'VerificationSession', recorded_at: 'str') -> 'AssuranceEvent'`	Evaluate violation after exact applicability and deviation localization.
`establish_responsibility(self, ancestor_id: 'str', descendant_id: 'str', proposition: 'BoundProposition', *, localization_event_digest: 'str', session: 'VerificationSession', recorded_at: 'str') -> 'AssuranceEvent'`	Evaluate one separately bound material-contribution component.
`events(self) -> 'tuple[AssuranceEvent, ...]'`
`impacted_descendants(self, artifact_id: 'str') -> 'tuple[str, ...]'`	Return the deduplicated recorded forward impact set, not a verdict.
`localize_cause(self, ancestor_id: 'str', descendant_id: 'str', proposition: 'BoundProposition', *, rust_event_digest: 'str', session: 'VerificationSession', recorded_at: 'str') -> 'AssuranceEvent'`	Bind one ancestor to one exact passing descendant-deviation event.
`materialize_current_graph(self) -> 'ProvenanceHypergraph'`	Create a derived current view; never mutate the historical graph.
`project_challenges(self, challenges: 'ChallengeLedger', *, recorded_at: 'str') -> 'tuple[AssuranceEvent, ...]'`	Project challenge state into an additive current Graph overlay.
`record_conflict(self, conflict: 'ConflictRecord', proposition: 'BoundProposition', *, session: 'VerificationSession', recorded_at: 'str') -> 'AssuranceEvent'`	Add mechanism-established current conflict evidence without rewriting Graph.
`record_rot(self, artifact_id: 'str', resulting_status: 'ArtifactStatus', proposition: 'BoundProposition', *, session: 'VerificationSession', recorded_at: 'str') -> 'AssuranceEvent'`
`record_rust(self, descendant_id: 'str', deviation: 'BoundProposition', *, session: 'VerificationSession', recorded_at: 'str') -> 'AssuranceEvent'`
`record_status_projection(self, artifact_id: 'str', proposition: 'BoundProposition', *, session: 'VerificationSession', recorded_at: 'str') -> 'AssuranceEvent'`	Record a mechanism-checked current-status projection additively.
`record_trust(self, target_id: 'str', source_ids: 'Iterable[str]', proposition: 'BoundProposition', *, transformation_id: 'str', prerequisite_trust_event_digests: 'Iterable[str]' = (), session: 'VerificationSession', recorded_at: 'str') -> 'AssuranceEvent'`
`resolutions(self) -> 'tuple[ConflictResolution, ...]'`
`resolve_conflict(self, conflict_id: 'str', selected_value: 'str', proposition: 'BoundProposition', *, session: 'VerificationSession', recorded_at: 'str') -> 'ConflictResolution'`	Adjudicate one value without equating selection with admissibility.
`rust_concentration(self) -> 'tuple[StructuralConcentration, ...]'`
`to_dict(self) -> 'dict[str, Any]'`
`unresolved_conflicts(self) -> 'tuple[ConflictRecord, ...]'`
`verify_hash_chain(self) -> 'bool'`

`BoundProposition` class

BoundProposition(subject_id: 'str', predicate: 'str', expected: 'Any', mechanism_id: 'str', mechanism_digest: 'str', evidence_refs: 'tuple[str, ...]', trust_roots: 'tuple[str, ...]', bounds: 'EvidenceBounds', parameters: 'Mapping[str, str]' = <factory>) -> None

Exact proposition, evidence, mechanism, trust-root, and bound binding.

Defined in verifier.core.evidence

Method	Summary
`digest(self) -> 'str'`
`to_dict(self) -> 'dict[str, Any]'`

`DecisionCertificate` class

DecisionCertificate(header: 'CertificateHeader', formula: 'tuple[tuple[int, ...], ...]', grounding: 'Grounding', decision: 'DecisionBlock', hints: 'dict[str, Any]' = <factory>) -> None

Canonical grounded decision certificate (GDC) blocks for the bounded checker.

Defined in verifier.core.certificate

Method	Summary
`digest(self) -> 'str'`
`to_dict(self) -> 'dict[str, Any]'`
`without_hints(self) -> "'DecisionCertificate'"`	Hint-stripped form.

`EvidenceBindingError` class

EvidenceBindingError

An evidence binding is malformed or cannot be resolved exactly.

Defined in verifier.core.evidence

`EvidenceBounds` class

EvidenceBounds(max_evidence_items: 'int', max_evidence_bytes: 'int') -> None

Resource ceilings enforced before invoking a domain mechanism.

Defined in verifier.core.evidence

Method	Summary
`to_dict(self) -> 'dict[str, int]'`

`EvidenceStore` class

EvidenceStore() -> 'None'

In-memory content-addressed evidence store with collision/fork refusal.

Defined in verifier.core.evidence

Method	Summary
`add(self, payload: 'bytes') -> 'str'`
`export_base64(self, references: 'Sequence[str]') -> 'dict[str, str]'`	Export exact evidence bytes for portable, offline mechanism replay.
`import_base64(self, payloads: 'Mapping[str, str]') -> 'None'`	Import a portable bundle and refuse every reference/byte mismatch.
`resolve(self, reference: 'str') -> 'bytes'`

`MechanismDecision` class

MechanismDecision(outcome: 'MechanismOutcome', details: 'str', observations: 'Mapping[str, Any]' = <factory>) -> None

One bounded mechanism result plus its exact observations.

Defined in verifier.core.evidence

`MechanismOutcome` enum

Enumeration of the exported result values.

Defined in verifier.core.evidence

Members: PASS, FAIL, UNKNOWN

`ObligationCoordinate` class

ObligationCoordinate(obligation_id: 'str' = '', content_digest: 'str' = '', scope: 'Mapping[str, str]' = <factory>, assumptions: 'tuple[str, ...]' = (), exclusions: 'tuple[str, ...]' = ()) -> None

Exact technical obligation and the declared scope in which it applies.

Defined in verifier.data.assurance

Method	Summary
`digest(self) -> 'str'`
`to_dict(self) -> 'dict[str, Any]'`

`ProvenanceHypergraph` class

ProvenanceHypergraph() -> 'None'

N-ary Hypergraph structure for dataset, training, and artifact lineage.

Defined in verifier.data.models

Method	Summary
`add_artifact(self, artifact: 'ArtifactNode') -> 'str'`
`add_conflict(self, conflict: 'ConflictRecord') -> 'str'`
`add_contributor(self, contributor: 'ContributorSpec') -> 'str'`
`add_rights(self, rights: 'RightsSpec') -> 'str'`
`add_transformation(self, transform: 'TransformationHyperedge') -> 'str'`
`ancestors(self, artifact_ids: 'Iterable[str]') -> 'set[str]'`	Backward reachability closure across transformation hyperedges.
`blast_radius(self, revoked_artifact_id: 'str') -> 'list[str]'`	Compute the forward blast radius of affected downstream artifacts when one node is revoked.
`compute_completeness(self) -> 'CompletenessMetrics'`
`descendants(self, artifact_ids: 'Iterable[str]') -> 'set[str]'`	Forward reachability closure across transformation hyperedges.
`has_conflict(self, subject_id: 'str') -> 'bool'`
`incoming_hyperedges(self, artifact_id: 'str') -> 'list[TransformationHyperedge]'`	Hyperedges that produce artifact_id as an output.
`outgoing_hyperedges(self, artifact_id: 'str') -> 'list[TransformationHyperedge]'`	Hyperedges that consume artifact_id as an input.
`root_sources(self) -> 'set[str]'`	Artifacts with zero incoming hyperedges (genesis roots).
`to_dict(self) -> 'dict[str, Any]'`
`validate_structure(self, *, allow_legacy_identifier_overlap: 'bool' = False) -> 'list[str]'`	Return deterministic errors for the implemented graph surface.
`verify_acyclicity(self, artifact_ids: 'Optional[Iterable[str]]' = None) -> 'bool'`	Check whether all or a selected artifact-induced subgraph contains cycles.

`ReproducibilityLevel` enum

Monotone reproduction-fidelity states; class name retained for compatibility.

Defined in verifier.core.reproducibility

Members: BITWISE_IDENTICAL, CONTENT_IDENTICAL, EVIDENCE_EQUIVALENT, RESULT_EQUIVALENT, SEMANTIC_REPRODUCTION

`VerificationGeometry` class

VerificationGeometry(geometry_id: 'str', primary_subject_id: 'str', subjects: 'list[Subject]', loci: 'list[Locus]', facets: 'list[Facet]', coordinates: 'list[Coordinate]', surface: 'VerificationSurface', seams: 'list[Seam]' = <factory>, mechanisms: 'list[VerificationMechanism]' = <factory>, judgments: 'list[CoordinateJudgment]' = <factory>, horizons: 'list[Horizon]' = <factory>, residuals: 'list[Residual]' = <factory>, valences: 'list[VerificationValence]' = <factory>, reconstructions: 'list[ReconstructionAttempt]' = <factory>, verification_layers: 'list[VerificationLayer]' = <factory>, novelties: 'list[Novelty]' = <factory>, secondary_subject_id: 'Optional[str]' = None, focus_coordinate_ids: 'tuple[str, ...]' = (), meta_focus_coordinate_ids: 'tuple[str, ...]' = (), schema_version: 'str' = 'VSTD-2') -> None

A finite verification geometry and its higher-order audit surface.

Defined in verifier.core.geometry

Method	Summary
`assess_closure(self) -> 'ClosureAssessment'`	Assess declared closure and higher-order self-closure separately.
`canonical_digest(self) -> 'str'`
`to_dict(self) -> 'dict[str, Any]'`
`validate(self) -> 'list[str]'`	Return structural and epistemic errors; an empty list means valid.

`VerificationSession` class

VerificationSession(evidence: 'EvidenceStore') -> 'None'

Resolve evidence and rerun only explicitly registered mechanisms.

Defined in verifier.core.evidence

Method	Summary
`evaluate(self, binding: 'BoundProposition') -> 'EvaluatedProposition'`
`evaluate_compound(self, bindings: 'Sequence[BoundProposition]') -> 'tuple[EvaluatedProposition, ...]'`	Run one compound mechanism invocation over separately bound propositions.
`register(self, mechanism: 'VerificationMechanism') -> 'None'`

`VerificationVerdict` enum

Outcome vocabulary returned by the VSTD-1 claim-mechanics checker.

Defined in verifier.core.checker

Members: VERIFIED, FALSIFIED, INDETERMINATE, UNSUPPORTED

`VstdReceipt` class

VstdReceipt(schema_version: 'str', receipt_kind: 'str', receipt_id: 'str', claim: 'ClaimSpec', evidence: 'EvidencePayload', target_result: 'dict[str, Any]', independent_audit: 'IndependentAuditReport', provenance: 'ProvenanceRecord', reproducibility: 'dict[str, Any]', canonical_digest: 'str' = '', execution_metadata: 'Optional[ExecutionMetadata]' = None) -> None

Mutable in-memory model of a canonically digested VSTD-1 claim receipt.

Defined in verifier.core.receipt

Method	Summary
`compute_and_set_digest(self) -> 'str'`
`get_stable_payload(self) -> 'dict[str, Any]'`	Extract only deterministic, location-independent fields for canonical hashing.
`save_to_directory(self, out_dir: 'Path') -> 'Path'`
`to_dict(self) -> 'dict[str, Any]'`
`verify_digest_integrity(self) -> 'bool'`

`WitnessBundle` class

WitnessBundle(claim_id: 'str', declarant_id: 'str', claim_binding_digest: 'str', witnesses: 'tuple[WitnessIdentity, ...]', independence: 'tuple[IndependenceAssertion, ...]', corroborations: 'tuple[CorroborationRecord, ...]') -> None

Claim-bound identities, ordered separation assertions, and corroborations.

Defined in verifier.core.witness

Method	Summary
`to_dict(self) -> 'dict[str, Any]'`

`assess_witness_corroboration` function

assess_witness_corroboration(entry: 'EvidenceBoundDepthResult', bundle: 'WitnessBundle', *, session: 'VerificationSession') -> 'WitnessCorroborationResult'

Recheck VSTD-5 entry, separation evidence, and corroboration evidence.

Defined in verifier.core.witness

`build_evidence_bound_graph_level_record` function

build_evidence_bound_graph_level_record(result: 'EvidenceBoundGraphLevelResult', *, graph: 'ProvenanceHypergraph', members: 'Sequence[str]', binding: 'ClaimBinding', object_evidence: 'Mapping[str, BoundProposition]', edge_evidence: 'Mapping[str, BoundProposition]', session: 'VerificationSession') -> 'dict[str, Any]'

Serialize exact Graph rating bindings and bytes for offline replay.

Defined in verifier.data.graph_level

`build_evidence_bound_vstd4_receipt` function

build_evidence_bound_vstd4_receipt(result: 'EvidenceBoundDepthResult', *, receipt_id: 'str', claim_id: 'str', binding: 'ClaimBinding', prerequisite_evidence: 'Mapping[int, BoundProposition]', rung_evidence: 'Mapping[str, BoundProposition]', session: 'VerificationSession', status: 'str' = 'VALID') -> 'dict[str, object]'

Serialize every input needed to rerun an evidence-bound VSTD-4 result.

Defined in verifier.core.depth

`build_vstd5_receipt` function

build_vstd5_receipt(entry: 'EvidenceBoundDepthResult', bundle: 'WitnessBundle', result: 'WitnessCorroborationResult', *, receipt_id: 'str', session: 'VerificationSession') -> 'dict[str, Any]'

Serialize a replayable VSTD-5 receipt without treating names as trust.

Defined in verifier.core.witness

`capture_run` function

capture_run(manifest: 'Mapping[str, Any]', manifest_dir: 'Path', receipt_id: 'Optional[str]' = None) -> 'GenericRunReceipt'

Execute the manifest-declared command and capture a computational run receipt.

Defined in verifier.core.run

`certificate_from_canonical_bytes` function

certificate_from_canonical_bytes(data: 'bytes') -> 'DecisionCertificate'

Decode only the canonical JSON representation used in commitment digests.

Defined in verifier.core.certificate

`claim_binding_from_dict` function

claim_binding_from_dict(data: 'Mapping[str, object]') -> 'ClaimBinding'

Reconstruct the exact VSTD-4 claim binding carried by a receipt.

Defined in verifier.core.depth

`compute_canonical_digest` function

compute_canonical_digest(stable_payload: 'Mapping[str, Any]') -> 'str'

Compute SHA-256 digest of canonicalized stable payload.

Defined in verifier.core.receipt

`establish_graph_level` function

establish_graph_level(graph: 'ProvenanceHypergraph', *, collection_id: 'str', members: 'Sequence[str]', object_evidence: 'Mapping[str, BoundProposition]', edge_evidence: 'Mapping[str, BoundProposition]', session: 'VerificationSession', binding: 'ClaimBinding') -> 'EvidenceBoundGraphLevelResult'

Rerun rating mechanisms before computing a conforming Graph profile.

Defined in verifier.data.graph_level

`establish_vstd4` function

establish_vstd4(rung_evidence: 'Mapping[str, BoundProposition]', *, prerequisite_evidence: 'Mapping[int, BoundProposition]', session: 'VerificationSession', claim_id: 'str', binding: 'ClaimBinding') -> 'EvidenceBoundDepthResult'

Rerun evidence mechanisms and establish VSTD-4 only if all pass.

Defined in verifier.core.depth

`freeze_artifact` function

freeze_artifact(source: 'str | Path', bundle: 'str | Path', *, media_type: 'str' = 'application/octet-stream', parent_bundles: 'Iterable[str | Path]' = (), context_bundles: 'Iterable[str | Path]' = ()) -> 'dict[str, Any]'

Preserve exact bytes in a new guarded bundle without creating a seal.

Defined in verifier.artifact_control

`graph_collection_binding_digest` function

graph_collection_binding_digest(graph: 'ProvenanceHypergraph', *, collection_id: 'str', members: 'Sequence[str]', binding: 'ClaimBinding') -> 'str'

Bind ratings to one Graph, member set, collection, and claim coordinate.

Defined in verifier.data.graph_level

`recheck_assurance_log` function

recheck_assurance_log(payload: 'Mapping[str, Any]', *, mechanisms: 'Iterable[VerificationMechanism]') -> 'AssuranceLedger'

Rebuild and replay a portable assurance log from its embedded bytes.

Defined in verifier.data.assurance

`recheck_evidence_bound_graph_level_record` function

recheck_evidence_bound_graph_level_record(graph: 'ProvenanceHypergraph', record: 'Mapping[str, Any]', *, mechanisms: 'Sequence[VerificationMechanism]') -> 'EvidenceBoundGraphLevelResult'

Rebuild the evidence store, rerun rating mechanisms, and compare result.

Defined in verifier.data.graph_level

`recheck_evidence_bound_vstd4_receipt` function

recheck_evidence_bound_vstd4_receipt(receipt: 'Mapping[str, object]', *, mechanisms: 'Sequence[VerificationMechanism]') -> 'EvidenceBoundDepthResult'

Reconstruct evidence bytes and rerun an evidence-bound VSTD-4 receipt.

Defined in verifier.core.depth

`recheck_vstd5_receipt` function

recheck_vstd5_receipt(entry: 'EvidenceBoundDepthResult', receipt: 'Mapping[str, Any]', *, mechanisms: 'tuple[VerificationMechanism, ...]') -> 'WitnessCorroborationResult'

Import exact bytes, rerun all witness mechanisms, and compare the result.

Defined in verifier.core.witness

`require_vstd5_entry` function

require_vstd5_entry(result: 'DepthResult | EvidenceBoundDepthResult') -> 'EvidenceBoundDepthResult'

Reject the current unbound candidate result at the VSTD-5 boundary.

Defined in verifier.core.depth

`seal_artifact` function

seal_artifact(bundle: 'str | Path', private_key: 'str | Path') -> 'dict[str, Any]'

Add one deterministic, readable, self-closing Ed25519 seal.

Defined in verifier.artifact_control

`thaw_artifact` function

thaw_artifact(bundle: 'str | Path', destination: 'str | Path', *, expected_artifact_id: 'str | None' = None, expected_key_id: 'str | None' = None) -> 'dict[str, Any]'

Create a mutable descendant from a cleanly sealed frozen artifact.

Defined in verifier.artifact_control

`thawed_artifact_status` function

thawed_artifact_status(artifact: 'str | Path', thaw_record: 'str | Path | None' = None, *, parent_bundle: 'str | Path | None' = None, expected_artifact_id: 'str | None' = None, expected_key_id: 'str | None' = None) -> 'dict[str, Any]'

Assess current descendant equality without authenticating the historical copy.

Defined in verifier.artifact_control

`validate_run_receipt` function

validate_run_receipt(receipt_path_or_dir: 'Path') -> 'int'

Validate one generic-run receipt's required fields and stable canonical digest.

Defined in verifier.core.run_validation

`verify_frozen_artifact` function

verify_frozen_artifact(bundle: 'str | Path', *, expected_artifact_id: 'str | None' = None, expected_key_id: 'str | None' = None, require_seal: 'bool' = True) -> 'ArtifactVerification'

Recompute preserved bytes, write guards, closure, and optional external anchors.

Defined in verifier.artifact_control

`vstd4_depth` function

vstd4_depth(evidence: 'Mapping[str, str]', *, claim_id: 'str', binding: 'ClaimBinding') -> 'DepthResult'

Compute a structural candidate depth from caller-supplied references.

Defined in verifier.core.depth

Wire

Canonical schemas and identifiers.

Receipt schemas are served from this site at their canonical $id routes, and their serialized `schema_version` identifiers are listed in the standard.

Wire identifiers Schema sources Quickstart Claim limits

Inspect the whole pipeline.

Command to implementation, without a gap.

The vstd command reference.

vstd

vstd demo

vstd run

vstd plan

vstd validate

vstd inspect

vstd reproduce

vstd impact

vstd data

vstd data trace

vstd data graph

vstd data export

vstd artifact

vstd artifact freeze

vstd artifact seal

vstd artifact verify

vstd artifact thaw

vstd artifact status

vstd experiment

vstd experiment validate

vstd experiment github-events

vstd hardware

vstd hardware list

vstd hardware inspect

vstd hardware discover

vstd hardware emulate

vstd hardware attest

vstd hardware capabilities

vstd hardware verify

vstd continuity

vstd continuity verify

vstd fleet

vstd fleet verify

vstd evidence

vstd evidence inspect

vstd claims

vstd claims evaluate

vstd claims explain

Top-level Python exports.

ArtifactControlError class

ArtifactVerification class

AssuranceLedger class

BoundProposition class

DecisionCertificate class

EvidenceBindingError class

EvidenceBounds class

EvidenceStore class

MechanismDecision class

MechanismOutcome enum

ObligationCoordinate class

ProvenanceHypergraph class

ReproducibilityLevel enum

VerificationGeometry class

VerificationSession class

VerificationVerdict enum

VstdReceipt class

WitnessBundle class

assess_witness_corroboration function

build_evidence_bound_graph_level_record function

build_evidence_bound_vstd4_receipt function

build_vstd5_receipt function

capture_run function

certificate_from_canonical_bytes function

claim_binding_from_dict function

compute_canonical_digest function

establish_graph_level function

establish_vstd4 function

freeze_artifact function

graph_collection_binding_digest function

recheck_assurance_log function

recheck_evidence_bound_graph_level_record function

recheck_evidence_bound_vstd4_receipt function

recheck_vstd5_receipt function

require_vstd5_entry function

seal_artifact function

thaw_artifact function

thawed_artifact_status function

The `vstd` command reference.

`vstd`

`vstd demo`

`vstd run`

`vstd plan`

`vstd validate`

`vstd inspect`

`vstd reproduce`

`vstd impact`

`vstd data`

`vstd data trace`

`vstd data graph`

`vstd data export`

`vstd artifact`

`vstd artifact freeze`

`vstd artifact seal`

`vstd artifact verify`

`vstd artifact thaw`

`vstd artifact status`

`vstd experiment`

`vstd experiment validate`

`vstd experiment github-events`

`vstd hardware`

`vstd hardware list`

`vstd hardware inspect`

`vstd hardware discover`

`vstd hardware emulate`

`vstd hardware attest`

`vstd hardware capabilities`

`vstd hardware verify`

`vstd continuity`

`vstd continuity verify`

`vstd fleet`

`vstd fleet verify`

`vstd evidence`

`vstd evidence inspect`

`vstd claims`

`vstd claims evaluate`

`vstd claims explain`

`ArtifactControlError` class

`ArtifactVerification` class

`AssuranceLedger` class

`BoundProposition` class

`DecisionCertificate` class

`EvidenceBindingError` class

`EvidenceBounds` class

`EvidenceStore` class

`MechanismDecision` class

`MechanismOutcome` enum

`ObligationCoordinate` class

`ProvenanceHypergraph` class

`ReproducibilityLevel` enum

`VerificationGeometry` class

`VerificationSession` class

`VerificationVerdict` enum

`VstdReceipt` class

`WitnessBundle` class

`assess_witness_corroboration` function

`build_evidence_bound_graph_level_record` function

`build_evidence_bound_vstd4_receipt` function

`build_vstd5_receipt` function

`capture_run` function

`certificate_from_canonical_bytes` function

`claim_binding_from_dict` function

`compute_canonical_digest` function

`establish_graph_level` function

`establish_vstd4` function

`freeze_artifact` function

`graph_collection_binding_digest` function

`recheck_assurance_log` function

`recheck_evidence_bound_graph_level_record` function

`recheck_evidence_bound_vstd4_receipt` function

`recheck_vstd5_receipt` function

`require_vstd5_entry` function

`seal_artifact` function

`thaw_artifact` function

`thawed_artifact_status` function

`validate_run_receipt` function

`verify_frozen_artifact` function

`vstd4_depth` function