4,464 bytes · SHA-256 a5fa03769a4aafd3ab40813e9a36cceef4a0dd251214630aa6e7e093ff077726

SCIENTIFIC SIMULATIONS UNDER DISASTER MANAGEMENT
Public developer annex — Deployment Supplement 2026-10-11, revision 1
By Dr. Julio C. Spinelli

PURPOSE
This is an implementation specification and offline document-check package.
It is not a production adapter, installer, scientific solver, live readiness
verifier or power-control program. It contains no historical host evidence
archives. No service, host, device, reset budget or scientific run is changed.

START HERE
1. Read docs/DEPLOYMENT_SUPPLEMENT.txt.
2. Use science_simulation_first_deployment_prompt_20261011.txt as one initial
   prompt with the new scientific brief and current authoritative source/data
   files. It embeds the interface, schemas, fixtures, checks and test matrix.
3. For implementation, use docs/PRODUCTION_INTERFACE.md and the exact schemas.
   References to schemas/ and examples/ resolve inside this annex.
4. Complete COMMISSIONING_MATRIX.csv with actual implementation evidence.
   Every commissioning row currently says NOT_PERFORMED_FUTURE_IMPLEMENTATION.

PROTOCOL COMPATIBILITY
SCI-DR/1.0.0 production-v1 remains a design contract to implement. The source
schemas are reproduced unchanged. The new supplement adds deployment/testing
obligations, not new wire fields. N541's historical N541_CONTROL_RESULT_V1 and
the prior article's iboot-sample-v1 are separate interfaces. They are not drop-in
substitutes. Numerical evidence formats and validators remain model-specific
implementation work; a reference digest does not supply those semantics.

REPRODUCE DOCUMENT CHECKS
Use an isolated Linux development directory with Python 3.12+ and venv/pip.
Dependency installation needs an approved package source/network connection.
After installation, document checks need no network. These exact pins describe
the article's check environment, not requirements for a future numerical solver.
From the extracted annex directory, run this complete child-shell block:

bash <<'BASH'
(
    set -eu
    python3 -m venv check_env
    check_env/bin/python -m pip install --requirement requirements-checks.txt
    check_env/bin/python -B tools/document_checks.py
)
check_status=$?
printf 'DOCUMENT_CHECK_STATUS=%s\n' "$check_status"
printf '%s\n' 'RETURNED_TO_INTERACTIVE_SHELL=YES'
BASH

Expected time: dependency installation commonly takes 1–3 minutes but depends
on the package source; the checks themselves took less than one second in the
authoring environment. Check the printed status, not the shell-return marker.
The Python child exits with its result; the interactive SSH shell remains open.

VERIFICATION SCOPE
VALIDATION_REPORT.json records the actual 29 unittest methods (including
fixture subcases), 13 valid synthetic schema shapes, 8 supplied invalid cases,
three full Draft 2020-12 schema checks, canonical evidence vectors, and selected
freshness/binding negatives. These are document-level checks. They do not
authenticate evidence, inspect cgroups or execute a recovery lifecycle. The
tools' selected_ready_bindings function intentionally is NOT a live gate.

All production examples are synthetic and refer to no real artifacts or trust
authority. Passing shape validation does not make them acceptable live evidence.

INTEGRITY AND PROVENANCE
SOURCE_PROVENANCE.json records the exact source assets copied from the supplied
September kit. SHA256SUMS identifies final annex files; it excludes itself.
The outer ZIP.sha256 identifies the exact ZIP. Checksums identify bytes, not an
independently authorized signer. No old private baseline archives are included.
The source kit's 98 manifest entries were checked while preparing the article.

To check extracted files (requires sha256sum), run:

bash <<'BASH'
sha256sum -c SHA256SUMS
manifest_status=$?
printf 'ANNEX_MANIFEST_STATUS=%s\n' "$manifest_status"
printf '%s\n' 'RETURNED_TO_INTERACTIVE_SHELL=YES'
BASH

FIGURES
Seven original SVG engineering diagrams are provided in figures/. They are
illustrations, not screenshots, photographs, measured timelines or actual
process captures. The standalone HTML article embeds every diagram and both
downloads, requiring no remote rendering assets.

HISTORICAL LIMITS
The supplied October reports established first verified N541 FIT progress and
reported repair/commissioning results. They did not establish a real reboot,
physical power-loss recovery, completed bulk SCORE/aggregation, generic SCI-DR
production conformance, or a final physics/engineering conclusion.

46,753 bytes · SHA-256 a48e8ba46c8b1c48038cd55fe9e5cccac07eaddfd1986e3710c61b5c4a0ea511

A calculation can survive a power interruption and still lose its scientific identity. It can restart with different libraries, count an unfinished file as a result, or repeat work that was already accepted. A recovery system needs more than a running process: it needs a defensible answer to what was computed, what was committed, and what may safely happen next.
The earlier application note, [
Linux unattended crash recovery for off-site server management using iBoot-G2+
][prior], describes the host recovery system. This companion specifies the scientific application that such a system must supervise. Its scope is the boundary between numerical computation, durable evidence, and recovery authority. The hardware installation and its commissioning remain covered by the earlier note. [1]
The practical objective is a successful first production deployment. Achieving that objective means finding implementation errors during development and a bounded rehearsal on the actual target, before admitting a long calculation. An initial prompt can specify this work completely; it cannot replace missing equations, unavailable source files, or measurements that have never been made.
The acceptance standard
A release is ready when the installed system has demonstrated the complete lifecycle on an isolated scientific case: compute, commit, drain, validate, resume, change phase, finish, verify completion, reconcile installation, and remain correctly integrated with recovery. A passing unit-test suite is one part of that evidence.
This article contains the operational requirements, illustrated failure boundaries, a commissioning matrix, and a single-file implementation prompt. Its embedded developer annex supplies the exact production wire schemas and reproducible document-level checks. These materials specify a production implementation; they are not a live installer or a claim that a generic adapter has already been commissioned.
1. What the N541 commissioning sequence taught
On 11 October 2026, the N541 commissioning reports recorded 73 FIT tiles and 19 exact numerical comparisons. Yet the deployment could not finish. A post-commissioning boot resolver needed temporary files inside a filesystem namespace that did not provide a usable writable location. The numerical gate had succeeded; another branch of the installed application had not been exercised soon enough.
An earlier acceptance check had rejected a remaining process as a worker. The supplied target diagnostic showed a Python 3.14 forkserver launch template beginning with
import sys;
. The implementation recognized a narrower command prefix. A real multiprocessing helper therefore exposed a compatibility assumption that the local tests had missed. The original process was no longer present when the later diagnostic ran; the subsequent repair report recorded a successful actual-pool probe and compatibility installation. [P1, P3]
After the repairs, the reports recorded preserved baseline bytes, preserved FIT tiles, released recovery holds, and three active recovery timers. Production initially remained paused. An explicit start produced an acknowledgement while startup validation was still underway. A later status recorded 137 accepted FIT tiles, a delta of 64, current execution identity, and
integrity: PASS
. That later observation established new production work. The acknowledgement did not. [P1, P3]
Evidence from the supplied record
What it establishes
What remains outside that evidence
73 FIT tiles preserved; original baseline unchanged
The reported repairs retained the commissioning data
Completion of the full FIT or SCORE population
19 comparisons reported exact
The selected replay panel agreed with its accepted baseline
Equality across every possible work item or correctness of the physical theory
Actual helper-pool probe passed
The installed compatibility check handled the tested pool
Every future CPython release or process topology
Boot resolver and finalization reported complete
The repaired commissioned branch ran successfully
A physical power-loss recovery test
137 accepted FIT tiles, including 64 new tiles
Production advanced after the explicit start
Final scientific results or engineering feasibility
The September SCI-DR developer kit already distinguished its design contract from its offline reference. It contained 68 normative requirements and a proposed production protocol. It did not supply a production implementation of that protocol. The subsequent engineering lesson is therefore specific: requirements must be tied to executable checks of the
whole installed path
, including branches reached only after commissioning. [P2]
2. Declare the support envelope before writing the installer
The baseline developed here is one scientific workload, on one Linux host using systemd, with a supported local persistent filesystem and contained CPU worker processes. The numerical algorithm may be a field solver, parameter sweep, imaging computation, or another deterministic or explicitly reproducible calculation. The recovery architecture is reusable; its scientific validation remains model specific.
Distributed execution, network filesystems, GPU-resident state, external writers, and multiple independently scheduled workloads sharing a power domain require additional contracts. For several workloads, host readiness must cover the entire registered set under one generation and one action barrier. A newly added workload invalidates an earlier readiness observation. A single application's READY response cannot establish that the whole host is safe to restart.
State the failure model explicitly:
Process failure:
a worker, executor, validator, installer, or observer can stop at any instruction.
Abrupt host loss:
neither a shutdown hook nor a final checkpoint is assumed to run.
Storage failure:
writes, synchronization, metadata operations, and reads can fail; storage that loses acknowledged writes is a separate physical risk to test and document.
Environment change:
interpreter, kernel, libraries, configuration, or effective services can differ at restart or change while a run is active.
Recovery concurrency:
queued jobs, boot hooks, maintenance requests, or incident handlers can race.
Missing evidence:
inaccessible files, stale observations, and unknown action outcomes remain unknown.
The contract protects validated committed work under its stated storage assumptions. Uncommitted computation may be lost and repeated. Catastrophic storage loss still requires a separately tested backup and restore strategy; a checkpoint protocol is not a backup.
3. Give each component one clear authority
The numerical worker should have the permissions needed to calculate and stage results. It should not control the power device, request unrestricted privileged commands, rewrite accepted registrations, or replenish reset allowances. A protected observer verifies scientific evidence and operating-system facts. The recovery manager combines that evidence with its own incident policy and budgets. A separate actuator carries out an authorized host or device action.
Component
Owns
Must establish independently
Scientific model
Equations, task meaning, payload validation, reduction rules
Numerical correctness against appropriate controls
Executor and commit writer
Bounded work admission, candidate output, deterministic task identity
That each admitted task is accounted for once
Lifecycle adapter
Durable scientific intent, prepare/resume transactions
That requests belong to the registered run and current generation
Protected observer
Source verification, process identity, accepted catalog, readiness evidence
Actual OS state and the referenced scientific artifacts
Recovery manager
Incident decisions, action reservations, policy
Current readiness and separate authority for the proposed action
Actuator
Exact approved host/device operation
A valid, current dispatch from its authorized manager
“Independent” has two meanings here.
Operational independence
means that the worker cannot rewrite the observer, accepted evidence, or administrative trust records.
Numerical independence
means an independently derived calculation or benchmark. Recomputing with the same kernel in a fresh process establishes a continuity check; it does not create an independent derivation of that kernel.
A checksum identifies bytes. It does not establish who authorized them. The deployment requires an independently accepted release digest or signature and protected registration. A package must not approve itself by calculating a manifest of whatever happens to be installed.
A concrete directory and ownership model
The following layout is a design example, to be generated from the new run manifest. These are not discovered paths on a reader's server.
Location pattern
Owner and purpose
/opt/science/releases/<release-id>/
Administrative owner; immutable model, controller, observer and dependency closure
/etc/science/registrations/<registration-id>/
Protected configuration and accepted registration generations
/var/lib/science-authority/<run-id>/
Protected intent, acceptance records, seals, environment approvals and transaction receipts
/srv/science/<run-id>/candidates/
Scientific UID; incomplete or unaccepted output
/srv/science/<run-id>/objects/
Immutable accepted objects under a documented publication/ownership policy
/run/science/<run-id>/
Volatile locks and IPC; never the only copy of accepted state
If payloads remain workload-writable, a protected catalog can detect subsequent changes but cannot prevent them. Prefer an immutable accepted store or an explicit ownership handoff. In either case, acceptance must validate stable opened bytes, and later readers must verify those bytes against the protected catalog. Checking a pathname and then reopening it without protection leaves a replacement race.
Audit file type, full ancestry, ownership, write permissions, link policy, size, and before/after identity. Account for the actual runtime dependency tree, including numerical shared libraries. Fix only reviewed metadata defects; a broad recursive permission change can damage unrelated services.
4. Freeze the science as precisely as the software
Before production, write a scientific contract and a machine-readable run manifest. A filename such as “N541” is not a sufficient scientific identity. Grid size alone omits physical spacing, boundaries, normalization, and the algorithm that interprets the data.
Contract element
Required content
Scientific question
What is being tested; possible pass, qualified, inconclusive and falsifying outcomes
Model
Governing equations, units, sign/index conventions, assumptions and input provenance
Discretization
Domain, coordinates, actual spacing per axis, boundaries, stencil/order, halos, cores, crops and masks
Work plan
Exact task-key enumeration; phases, dependencies, eligible populations and expected counts
Numerical policy
Dtype, byte order, seed/RNG policy, aggregation order, rounding policy and parallel reduction rules
Validation
Analytic/manufactured cases, nontrivial controls, comparison formula, frozen tolerance or bitwise equality
Phase transitions
Which accepted prerequisite artifacts bind each later phase; when fits become immutable
Completion
Exact expected task set, final consolidation, independent validation and terminal artifact
Limits
What this calculation cannot establish about the model or practical engineering feasibility
Separate three identities: the scientific model and inputs; the operational release; and the accepted execution environment. A packaging repair can change operational identity while preserving the original science. A changed stencil or fitting rule is a scientific change even if the filename stays the same. It requires a new run or an explicitly reviewed scientific migration.
A model adapter with a small, explicit boundary
The reusable lifecycle core should depend on a stage-specific interface with the following responsibilities. These are implementation contracts, not supplied executable functions:
plan(contract) -> exact, reproducible task catalog and phase dependencies
compute(task, frozen_inputs, accepted_phase_binding) -> candidate payload
validate(task, payload, contract) -> structured scientific verdict
reduce(ordered_accepted_tasks, contract) -> phase/final artifact
select_panel(eligible_catalog, frozen_selection_policy) -> recorded task IDs
compare(original_payload, fresh_payload, frozen_rule) -> evidence
verify_completion(contract, catalog, final_artifacts) -> evidence
The core owns single-executor admission, durable transactions, time bounds, lifecycle requests, and evidence publication. The model owns the meaning of a task and a valid answer. New models must not be built by copying scattered stage-specific names through old recovery scripts.
The work catalog must be reproducible without materializing millions of tasks in RAM. For random or adaptive science, freeze how randomness and adaptation are represented, how decisions become durable, and what constitutes an equivalent restart. Reusing a seed is insufficient if task scheduling changes the order in which a shared random stream is consumed.
5. Define exactly when a result becomes accepted
A worker finishing a calculation is not a commit. A complete file is not necessarily an accepted result. A result becomes accepted only when its validated payload and the authoritative acceptance record have both reached their specified durable publication points.
For a local file-based store, use this ordering or a reviewed database/journal protocol that provides equivalent guarantees:
Compute into a unique candidate on the destination filesystem. Bind run, phase, deterministic task key, parameters, inputs, prerequisite phase digest, numerical format and environment epoch.
Finish the payload and metadata; validate the candidate. Flush userspace buffers and synchronize the file. Treat any error as failure to commit.
Publish an immutable object with
no-clobber
semantics. Synchronize the affected directory and any newly created directory ancestry required by the storage protocol.
Publish an immutable acceptance segment that identifies the validated objects and links to the preceding accepted segment. Synchronize that segment and its directory.
Update a protected mutable head only after the referenced segment is durable. Synchronize the new head and its containing directory. Define exactly how a crash between segment and head publication is reconciled.
Advance an accepted counter only from this authoritative state. Keep attempt counts and candidate counts separate.
Linux documents that synchronizing a file does not itself synchronize the directory entry containing it. Atomic namespace publication and persistence are different properties. Python's
os.replace
can overwrite an existing destination; it may suit a controlled mutable head, but it is not, by itself, immutable no-clobber publication. [4, 5]
Specify one reconciliation policy for a durable segment beyond the current head: either the segment is already authoritative and the head catches up after full verification, or it remains unaccepted until a new logged transaction adopts it. Every reader must use the same policy. Never select the largest sequence number from filenames without authenticating its chain, task set, and lineage.
Interruption point
Required restart behavior
During candidate write
Treat as unaccepted; retain/quarantine or discard under the frozen policy
After complete candidate, before durable publication
Validate before any adoption; no accepted-counter credit
After durable object, before acceptance segment
Treat as an orphan; adopt only through the recorded same-run validation rule
After segment publication, before head update
Reconcile the verified chain using the one declared policy
After accepted commit
Recover the same key and digest exactly once
Missing or altered accepted payload
Create a specific integrity block; preserve evidence
Completion artifact exists, writers still active
Completion/readiness remains unverified
Do not silently regenerate a corrupt accepted result. That erases the distinction between a failed continuity guarantee and an ordinary uncommitted retry. Identical retried task keys deduplicate; an incompatible digest for an accepted key is a conflict to investigate.
Scale changes the implementation
A run with millions of records needs a scalable catalog, sharded objects or bounded segments, and explicit inode and metadata estimates. Full integrity checks belong at defined startup, gate, and completion boundaries, with measured deadlines and progress reporting. Frequent status queries should use protected incremental observations, not scan the entire dataset.
Aggregate in a frozen task order, independent of worker completion order. Where floating-point summation is order dependent, specify the reduction tree or ordered algorithm. Test serial/parallel, dense/tiled, and interrupted/uninterrupted results against the same rule.
6. Treat a numerical environment as an accepted epoch
An environment fingerprint should include the interpreter and executable identity, kernel, numerical packages, loaded numerical libraries, threading settings, relevant CPU assumptions, scientific code/configuration, and runtime features that can affect results. Run small representative operations before fingerprinting so lazily loaded BLAS/LAPACK or OpenMP libraries are visible.
Record the boot identity separately. A new boot invalidates process observations even when software hashes are unchanged. A changed environment requires a new gate; it must not be accepted by rewriting the expected fingerprint.
The continuity gate runs with production dispatch fenced and calculation writers quiescent. It recomputes a frozen selection of accepted tasks in a genuinely fresh interpreter, validates their numerical payloads, compares them with the original accepted records, and records the evidence. Cached answers must not masquerade as fresh computation. Verify the environment before and after replay; a change during the gate invalidates its result.
The N541 example used a FIT baseline of 64 uniformly selected tiles plus nine wall controls. Later checks used ten frozen random canaries from those 64 plus the nine controls. Those 19 comparisons were a fixed panel, not a fresh random draw from all production output. This is an example of one acceptance policy, not a universal sample-size prescription. [P1]
For a future run, declare whether each gate uses fixed canaries, a new reproducible sample from a frozen eligible population, or both. Record the population digest, algorithm, seed and selected IDs before comparison. Preserve that selection when retrying a failed gate. Resampling until a mismatch disappears invalidates the test.
A small sample cannot prove universal equivalence. For a uniformly drawn sample of size
n
without replacement from
N
eligible records containing
k
affected records, the probability of missing all affected records is
C(N−k,n) / C(N,n)
, when that draw model applies. Fixed canaries provide repeatable coverage, not repeated independent sampling. Difficult, nonzero controls protect against agreement on trivial regions; they do not eliminate every blind spot.
A tolerance must be scientifically justified and frozen before discrepancies are observed. If exact payload agreement is required, compare the canonical scientific bytes, excluding irrelevant timestamps or PIDs. Do not widen a tolerance, refit frozen coefficients, or reorder reductions to make an upgrade pass.
Every numerical phase needs its own evidence
FIT continuity does not prove SCORE continuity. Exercise all kernels on a small isolated case before release. A production SCORE baseline may be accepted only after the actual frozen FIT prerequisite exists and is bound into that SCORE identity. Test interruption immediately before and after this transition.
Prevent mixed-environment output by using immutable runtime releases where practicable, coordinating upgrades with the run, and fencing admission when drift is detected. A periodic fingerprint check alone leaves a detection interval. Record that bound and how candidates computed during an ambiguous interval are withheld from acceptance. The historical 300-second observation interval is not automatically appropriate for another workload.
7. Test the service that will actually run
An interactive shell is a different execution environment from a protected systemd service. Test the exact UID/GID, interpreter, working directory, imports, writable roots, IPC, process pool, and final confinement. Repeat these checks for the observer, acceptance service, installer and commissioned boot resolver, not only the executor.
Dependencies and privilege transitions
Resolve and pin the dependencies of
every
entry point before sealing the release. Include fingerprinting and reporting packages as well as the numerical libraries. A missing
threadpoolctl
import can break commissioning even when the solver imports successfully. Check real representative numerical calls, not imports alone.
When a requirements file crosses a user boundary, use a private regular file with tested ownership and read access. Do not assume a different UID can reopen
/dev/stdin
. Authenticate privileged staging in the foreground, then submit sustained work to an appropriately protected service. Submission must survive SSH disconnect and expiration of the interactive sudo timestamp. Passwords belong in the terminal's authentication flow, not command arguments or logs.
Process roles, including Python helpers
Python documents that 3.14 changed the default to forkserver on supported POSIX platforms; spawn or forkserver can also create a resource tracker. These are relevant compatibility changes, not reasons to broadly exempt Python processes from identity checks. [2]
Select and test a multiprocessing context explicitly. Recognize supported helper roles using the installed interpreter's verified implementation, a narrow argument grammar, UID, executable, parent relationships, cgroup membership, and bounded role counts. Never accept every
python -c
process because its text contains “multiprocessing.” Exercise a real pool, worker completion, pool drain, surviving helpers, unexpected children and duplicates.
Authenticate active executions using the current boot, service invocation, PID,
/proc
start ticks, UID/GID, executable identity, approved arguments, and recursive containment. Recheck around observation. A PID alone can be reused. An empty or unreadable process listing must not become proof of quiescence. Check pending service jobs as well as current processes.
For a
numerical acceptance barrier
, a specifically authenticated non-writing helper may be allowed if the acceptance contract permits it and admission is fenced. For
host readiness
, require the registered science writers and pending jobs to be absent, the durable seal to validate, and the full readiness policy to pass. These are different barriers.
Writable temporary space inside confinement
The N541 repair retained filesystem protection and provided the resolver with private temporary space. The systemd documentation explicitly describes writable
/tmp
and
/var/tmp
when
PrivateTmp
is enabled alongside strict filesystem protection. [3]
# Design fragment, not an installable unit.
[Service]
ProtectSystem=strict
PrivateTmp=yes
NoNewPrivileges=yes
This fragment does not supply the service's persistent write permissions or complete security policy. The generated unit must name its permitted state/output roots, ensure they exist with correct ownership, and test actual temporary-file allocation, IPC, locks, result publication, child commands and cleanup under the loaded configuration. A blanket relaxation of protection is not an equivalent repair.
Fingerprint and verify effective units, including drop-ins, loaded commands, environment policy, identity, writable roots, resource controls and pending daemon reload. A base-unit checksum cannot detect an unreviewed override. Query properties by unit type: service process properties are not applicable to timers. Distinguish absent, empty, zero and malformed values.
Stop policy and scheduling
Bound admitted and queued work; do not enqueue the entire simulation. A maintenance request first records intent and fences admissions. Workers finish only already admitted work according to a measured drain policy. The service's signal, stop-timeout and forced-kill behavior must match that policy. Test how signals reach descendants and helper processes in the chosen containment arrangement.
A controller observation deadline is not permission to kill a worker. A drain deadline can expire with a visible blocked or pending state. If a separate force-stop policy is authorized, record it as such, account for uncommitted work, and do not label it graceful readiness. A globally unbounded stop can also obstruct host shutdown; choose the host policy explicitly and test it.
Keep automatic retries bounded, with classified failures, backoff, and treatment of systemd start-rate limits. A healthy retry must preserve desired RUN and accepted history. Integrity failures and persistent configuration defects need visible containment, not repeated restarts.
8. Make intent survive the crash
The boot resolver must recover a durable decision, not infer intent from whether a process is currently alive. Installation starts paused. An authorized production start records RUN. Planned maintenance records PAUSE before draining and retains that pause across boot unless its exact accepted transaction specifies otherwise.
State at interruption
Boot/restart decision
New or uncommissioned deployment
Remain paused; finish/reconcile commissioning
Explicit maintenance PAUSE
Retain pause; require the authorized continuation for that transaction
Accepted RUN, unexpected boot
Reconcile commits, verify sources and environment, then resume missing work under the accepted boot policy
Unfinished install or mutation
Reconcile its durable transaction before starting another
Known integrity block
Preserve evidence and block dispatch pending the scoped repair decision
Unknown/malformed desired state
Refuse favorable inference; report the unreadable or inconsistent authority
Independently verified completion
Remain complete; do not schedule another run
The controller must distinguish operational retry, maintenance, validation, integrity block, completion pending validation, and terminal verified completion. A completion marker by itself is insufficient. Verify the exact task set, phase bindings, final aggregate, prescribed numerical checks, immutable manifest and writer quiescence.
Order boot reconciliation before consumers that might dispatch science or recovery. Avoid dependency cycles, synchronous waits on a service from its own pre-start verifier, and holding a lock while waiting for a child that requires it. Exercise the commissioned boot branch in an isolated target test even if no real host reboot is authorized.
Local-input computation should be able to reconcile without the Internet or router. If a network dependency is essential, report a distinct bounded wait and retry policy.
network-online.target
concerns startup synchronization; it is not proof of continuing connectivity. [6]
9. Use one exact interface, not a family of similar status strings
This supplement retains the
SCI-DR/1.0.0 / production-v1
design interface. Its request, response and registration schemas are embedded in the annex without changing their bytes. The N541 installation used a different, custom status schema. Its successful operation does not establish conformance to this generic protocol. The earlier iBoot article's sample adapter is another separate interface.
Do not interchange these profiles or convert an offline response to production evidence by changing
simulation_only
. A new implementation must implement and test the chosen profile end to end, and explicitly adapt every consumer.
Command
Meaning of success
What success does not mean
capabilities
Accepted protocol, limits and registration were observed
The response can establish its own trust root
status
A valid bounded observation was returned
Science is healthy merely because exit code is zero
prepare
Durable drain/seal transaction accepted or advanced
Writers have necessarily exited
ready
The exact seal and current quiescence were independently observed
Host or outlet action is authorized
resume
Durable start request accepted
New work or recovery has been verified
verify-completion
Exact completion proof and quiescence validated
The next stage is authorized
Transport and strict parsing
Invoke the registered absolute executable directly, with no positional arguments and one UTF-8 JSON request on stdin. Close stdin. Stdout must contain exactly one JSON object and one terminal LF; diagnostics go to bounded stderr. Do not run a shell assembled from request values. Requests select identities, never arbitrary paths, units or executables.
Use the smaller registered bound or 1,048,576 bytes for each request/response, a maximum nesting depth of 32, and no more than 8,192 stderr bytes. Supervision must bound reads and elapsed time before decoding. Reject duplicate keys at every depth, invalid UTF-8, unknown fields, wrong types, nonfinite values, extra output, truncation, and boolean counters. Validate with a Draft 2020-12 implementation plus the semantic/evidence checks; a schema is not an authenticity verifier. [7]
Actual process exit and JSON exit
Verdict
Operational meaning
0
PASS
Command-specific observation or acceptance succeeded
20
REFUSED
Known unmet precondition or policy
21
STALE
Expired evidence or invalid freshness/clock basis
22
INTEGRITY_BLOCKED
Known source, identity or scientific mismatch
23
CONFLICT
Generation, transaction, replay or lock conflict
64
INVALID_REQUEST
Unsupported or malformed request
74
IO_UNKNOWN
Required evidence, transport or durable outcome unavailable
The two exit values must agree. A timeout, signal, oversized stream or partial response is unknown at the consumer boundary. An unreadable artifact is not a demonstrated hash mismatch; a demonstrated mismatch is not a transient read failure. Preserve that distinction when deciding whether to retry.
Identity, freshness and replay
Operational requests bind the registration ID/generation/digest, scientific identity, request ID, random 128-bit nonce, command, current boot and declared clock. Mutations also bind their transaction and expected lifecycle generation. Registration generation and lifecycle generation are different counters.
Nanosecond fields ending in
_mono_ns
use canonical unsigned decimal strings of up to 19 digits. Parse them as exact integers. Do not pass them through floating-point values or compare them lexicographically. This avoids a 53-bit precision boundary around 104 days. Clock comparisons require the same boot and clock domain; UTC is chronology, not authority.
For an operational success, require
issued ≤ started ≤ finished ≤ consumed < deadline
. READY additionally requires
finished ≤ consumed < valid_until ≤ deadline
. Bind all comparisons to the outstanding request and independently accepted registration. A fresh random nonce is useful for correspondence; it is not an authentication credential.
Under the lifecycle lock, a mutation checks its expected generation, records durable intent before effects, increments generation when state advances, and publishes an immutable receipt. Identical valid replay observes the existing transaction. Reusing an identity with different bytes conflicts. Expired replay cannot mint renewed readiness or dispatch a second action; obtain a fresh observation and reconcile the original outcome.
Canonical evidence and numerical bytes
Control/evidence artifacts use SCI-DR-CJSON/1: UTF-8 JSON with ASCII escapes, keys sorted by decoded Unicode code points, compact separators, integer-only numbers, already-NFC strings, and one terminal LF included in the digest. Reject negative-zero numeric encodings, floats, unpaired surrogates and duplicate keys. The exact escaping rules and full producer-role table are included in the embedded production-interface document.
Numerical arrays use a separately specified binary/scientific format with shape, dtype, endian order, units and digest. Do not normalize a floating-point payload into vaguely formatted JSON text. Evidence references identify kind, exact byte count, canonicalization, hash and accepted producer release. A reference has no authority until those actual bytes and the producer's trust binding verify.
Proving progress and readiness
Positive progress requires two comparable accepted observations within one run, boot, invocation, process identity, phase and batch; a positive difference in accepted work; stable evidence; and valid freshness/gap limits. Starting a new invocation requires a new comparison baseline. A phase change requires its transition proof, not subtraction of unrelated counters.
For long tasks, expose scientifically meaningful milestones or a registered pending interval. CPU use, fresh log timestamps, and heartbeat messages are useful diagnostics but do not establish accepted numerical progress. Verified completion is a separate success condition when no positive delta is expected.
Immediately before governed host action, the manager must recheck sources, registration, transaction/generation, seal, recursive writers, pending jobs, applicable holds and incident/budget authority under the action barrier. The barrier must also prevent a concurrent resume or registration switch. A still-unexpired READY message cannot substitute for this final check.
10. Integrate the entire recovery chain
Replacing a service name is not a migration. The historical deployment had several readers of science state: health checks, preparation/resume wrappers, incident evidence and handoff, warm-reboot/postboot paths, a heartbeat-loss guardian, and quick/full reset-allowance renewal checks. All affected consumers must resolve the same accepted registration and interpret the same evidence.
Consumer class
Migration obligation
Science service and lifecycle wrappers
New identity, output namespace, source closure, intent and numerical gates
Manager and health observers
Exact profile, phase-aware progress/completion and explicit unknown states
Incident coordinator and handoff
Transaction/generation/boot binding and preserved uncertain actions
Warm-reboot and postboot paths
Fresh readiness before dispatch; new-execution proof afterward
Heartbeat-loss guardian
Correct workload selection, bounded preparation and explicit unresolved state
Allowance renewal observers
Same registration and accepted recovery dependencies; unchanged budget history
Install/activation/source verifiers
Exact code, dependencies, unit drop-ins and approved registration generation
Keep scientific PAUSE, manager HOLD, reset inhibition, migration fence, incident ledger and reset allowance separate. Every hold must identify its owner, reason, scope and transaction. A finalizer may release only its own hold after proving the required condition. It must preserve an operator's hold.
A new run is not a new reset allowance. Preserve spent attempts, unresolved action intents, incident lineage, cooldown anchors and delivery receipts through upgrades and rollback. A missing or corrupt budget file cannot be interpreted as an unused allowance.
The September kit documented an existing 60-minute availability override requiring an explicit migration decision. A successor must retain it with an accepted exception, revise it, or remove it through the authorized recovery-policy change. It must not claim that every inherited path refuses action on unknown scientific state when the inherited code does otherwise. [P2]
The hardware watchdog can still act when the host is locked up or unavailable. Host-side refusal logic cannot prevent an independent timer or utility outage. That is why the scientific commit protocol must tolerate abrupt loss even when orderly preparation is normally required.
11. Make installation an interruptible transaction
Run one bounded, read-only target inventory before staging. Collect independent prerequisite failures together: versions, imports, numerical library calls, permissions, filesystem/inodes, resource limits, service/timer properties, effective unit configuration, containment and recovery-consumer compatibility. Do not make the operator discover predictable prerequisites one repair package at a time.
Generate names, paths, counts and bindings from one validated manifest. Stage a new immutable release in its own directory and preserve the working deployment. Never mix extraction of revised bytes into a previously sealed directory.
The installer must record an explicit phase after each durable step. At minimum, distinguish staging, preflight, bootstrap, baseline verification, activation, finalization pending, complete-paused, and subsequent production proof. Its resumable state machine must handle interruption after registration activation and before timer restoration or hold release.
The word
COMMITTED
is too ambiguous to be a final verdict when post-activation work remains. Final installation success requires the commissioned boot resolver, all required source/consumer checks, the prescribed recovery timer states, correct hold ownership, and production still paused. A later explicit start and observed new commits establish production operation.
Rollback is a new forward-recorded event. It can restore a compatible code/registration release, but it cannot erase accepted science or rewind spent recovery history. If compatibility or an action outcome cannot be established, retain containment and report the exact unresolved condition.
The small complete rehearsal
Use a separate run identity and output namespace for an isolated case that passes through
every numerical phase and actual installed verifier
. It must exercise the same entry points, dependency family, worker start method, confinement, durability implementation and recovery interface as production. A toy calculation can test transport; it cannot substitute for exercising the real model kernels.
The rehearsal must include both the uncommissioned bootstrap branch and the commissioned restart/boot-resolver branch. It must reach genuine verified completion and demonstrate that completion prevents rescheduling. It must also demonstrate a start followed by two comparable current-execution observations with new accepted work. Scale-sensitive bounds then need representative measurements; a tiny case alone cannot validate million-record startup cost.
12. Commission against observable outcomes
The following gates are obligations for the future implementation. They are not claims that this article has performed them on a server. The embedded CSV gives stable gate IDs, failure injections, expected outcomes and evidence requirements.
Gate
Exercise
Required outcome
G01 Scientific definition
Analytic/manufactured controls; dense/tiled; serial/parallel
Frozen scientific criteria met, including difficult nonempty regions
G02 Dependency closure
Exact service UID/interpreter; every entry-point import and real numerical call
All dependencies available and identified before sealing
G03 Permissions
Protected ancestors, runtime libraries, wrong ownership/link/type
Legitimate files pass; unsafe or changed sources refuse
G04 Service confinement
Tempfiles, IPC, locks, writes and child commands in final units
Required operations work without broadening unrelated privileges
G05 Actual pool
Real workers/helpers; late/foreign/duplicate child; PID reuse
Correct role classification; live calculation writer blocks acceptance
G06 Commit boundaries
Kill child processes at each publication boundary
Accepted prefix/set preserved; orphans reconciled; no double credit
G07 Corruption
Alter accepted bytes, duplicate keys/tasks, stale prerequisite binding
Durable specific integrity refusal; evidence preserved
G08 Numerical epoch
Fresh replay, deliberate mismatch, environment change during replay
Stable valid epoch accepted; mismatch blocks without resampling
G09 Maintenance
Partial queue, long task, prepare timeout, late writer
Admissions stop; timeout is not READY; seal only after verified drain
G10 Intent and boot
Planned pause versus unexpected boot with accepted RUN
Pause retained; RUN resumes only through reconciliation and validation
G11 Protocol
Malformed/foreign/stale/replayed requests; exit disagreement
Rejected at the correct parser, semantic or evidence layer
G12 Progress
Same count, wrong phase, stale invocation, real new commits
Only the defined comparable accepted advancement passes
G13 Completion
Tiny case through all phases; crash during final verification
Exact completion and quiescence; no automatic restart after completion
G14 Installer interruption
Stop after each durable phase, including activation
One coherent registration or explicit containment; safe continuation
G15 Recovery integration
Every active consumer, stale pin, pending job, external hold
Consistent identity; conflicting authority refused
G16 History preservation
Reinstall, migration, rollback and uncertain dispatch
Spent/pending lineage preserved; no new allowance created
G17 Resource pressure
Full bytes/inodes, slow commits, memory/CPU constraints
Evidence retained; bounded retry/stop; other host services protected
G18 Submission independence
SSH loss and expired sudo timestamp after submission
Commissioning continues under its service identity; status remains accessible
G19 Installed lifecycle
Bootstrap → commissioned resolver → finalization → paused → start
Exact final configuration and verified new work
G20 Physical recovery
Separately authorized real reboot and abrupt power test
Separate observed results; skipped tests remain NOT PERFORMED
Record test class, exact release digest, target identity, expected and actual outcome, artifacts, elapsed time and limitations. A simulated new boot, a real OS reboot and a physical power cut are three different experiments. Success in one cannot be reported as success in the others.
If no production-equivalent host or authorization is available, deliver a clearly bounded candidate plus the target commissioning procedure. That limitation changes the release claim. It does not justify skipping a check and marking it passed.
13. Give the operator evidence, timing and an actionable failure
A report should answer: Which run and release? Which boot and invocation? Which phase and accepted work? Is scientific integrity established? Is recovery capable of acting? What was requested, what actually happened, and what is the next permitted step?
Do not discard the failing child's reason behind a generic
REVIEW_REPORT
. Preserve a bounded exception chain, failing operation, safe pathname, child exit code, and allowed stdout/stderr. Collect partial evidence when a diagnostic step fails. Exclude credentials and environment dumps; do not search
.env
contents without the owner's explicit permission.
Report submission, execution, scientific progress, readiness and completion as separate facts. In the historical N541 schema,
autorestart_armed
and
replay_gate_passed
were phase-dependent stop/readiness predicates; they could be false during healthy FIT computation. A new operator-facing report should separately explain durable boot policy, current recovery capability, current seal readiness and actual test coverage. Those explanations do not authorize unversioned changes to the exact wire schema.
Estimate foreground submission, commissioning, startup validation and the full calculation separately. A whole-run estimate includes remaining phases, ordered aggregation, independent verification and export. Measure with real durability writes, final confinement and the intended worker/thread configuration. Include bytes, inodes, temporary space and uncertainty. Do not reuse a predecessor's calendar estimate as a guaranteed duration.
For pasted SSH procedures, keep the operation in a child shell and print the real status afterward. The following is a harmless shell-behavior example; it installs nothing:
bash <<'BASH'
python3 - <<'PY'
print("EXAMPLE_REPORT=NO_SERVER_ACTION_REQUESTED")
PY
report_status=$?
printf 'REPORT_COMMAND_STATUS=%s\n' "$report_status"
printf '%s\n' 'RETURNED_TO_INTERACTIVE_SHELL=YES'
BASH
The shell-return marker means the interactive session remains available. Only the operation's actual status and evidence determine success.
14. The single-prompt development handoff
The downloadable TXT is one self-contained implementation prompt. It contains the engineering contract, the post-incident supplement, exact production-interface semantics, embedded schemas and synthetic protocol examples. It does not require the original conversation or the private historical archives.
The implementer supplies the scientific brief and current authoritative code/input files. The prompt requires a focused request for missing material facts; it forbids invented equations, paths, numerical thresholds and test results. It then directs the assistant or engineering team through a clean release, isolated target rehearsal, production-paused installation, and evidence of new accepted work.
Embedded downloads · usable offline
Take the complete specification into the next project
The TXT includes the exact interface assets inside the prompt. The ZIP provides those assets as separate files, the test matrix, source provenance, and offline document checks. Neither contains a server installer or historical private evidence archives.
The complete prompt includes exact interface assets below.
Required delivery from the future implementation
One coherent versioned package must include the scientific definition, pinned dependencies, preflight, executor/store, lifecycle controller, protected observer, final units, all consumer adaptations, transactional installer, commissioning and operator tools, tests, exact test-scope report, member manifest, ZIP and its matching SHA-256 sidecar.
Compute checksums from final bytes and verify the created archive after packaging. Supply actual transfer/launch/status commands with filenames that match those bytes. Installation must default to production paused. Do not announce successful production from a submitted transient unit, a zero-exit status command, an intermediate activation receipt, or a model-only test suite.
The most useful first prompt is one that makes these conditions unavoidable. The most useful final report is the evidence that they were met.

28,020 bytes · SHA-256 af75cce8c819260b135e86a4b91e03ea997db5a490ad4c8e001db1df1981ab2e

# SCI-DR/1.0.0 production-v1 — exact proposed wire contract

**Status: design contract; no production adapter is supplied or installed.** The separate executable sandbox uses `schemas/request.schema.json`, `schemas/response.schema.json` and `simulation_only=true`. Production uses the schemas named below and `simulation_only=false`. Changing that flag on sandbox output is invalid: it does not implement independent observation, scientific validation, protected registration or production orchestration.

| Artifact | Role |
|---|---|
| `schemas/production-request.schema.json` | Exact six request variants; all objects reject unknown fields |
| `schemas/production-response.schema.json` | Exact six success payloads and six nonzero error variants |
| `schemas/registration.schema.json` | Independently accepted registration, execution identity, scientific identity, limits and source closure |
| `examples/production-valid-*.json` | Synthetic schema-valid shapes; placeholder digests do not refer to real evidence |
| `examples/production-invalid-*.json` | Deliberately invalid examples; the example index distinguishes schema rejection from semantic rejection |

These production schemas are normative together with the semantic checks below. Structural schema acceptance alone is never conformance, health, readiness or actuation permission. Files with `production-` names are design examples, not current server observations.

## 1. Invocation, transport and limits

The accepted registration specifies one absolute adapter executable, UID/GID, fixed working directory, exact allowlisted environment and service/writer roots. Invoke that executable directly with **no positional arguments**, send one request object to stdin, then close stdin. Do not invoke a shell, source login files or `.env`, inherit arbitrary Python import paths, interpolate request values, or let a request select filesystem roots, units or privilege rules. Requests carry identifiers, not executable command strings.

Both streams are UTF-8. Stdout contains exactly one JSON object followed by one LF and no banners or additional JSON. Stderr is optional bounded human diagnostics, at most 8,192 bytes, with no credentials, private environment values or uncontrolled exception dumps. Consumers must validate the actual process exit code as well as `exit_code` in the JSON. A timeout, process signal, absent response, extra stdout, truncation, invalid UTF-8 or stream-size overflow is `IO_UNKNOWN` at the consumer boundary, even if a partial output contains PASS. The consumer must not fabricate a valid adapter receipt for a failed transport.

Before decoding, enforce the smaller of the accepted registration's request/response byte limit and 1,048,576 bytes. Registration permits smaller bounds; the selected release must prove that every mandatory response and refusal fits its configured bounds. Decoder requirements are duplicate-key rejection at every nesting level, no NaN/infinity, no booleans treated as integers, no extra fields, finite nesting and exact schema validation. Maximum JSON nesting depth is 32. The schemas' bounded collections/string lengths still apply.

| Command | Maximum observer duration from registration |
|---|---|
| `capabilities`, `status` | `limits.status_timeout_seconds` |
| `prepare` | `limits.prepare_observation_timeout_seconds` |
| `ready` | `limits.ready_timeout_seconds` |
| `resume` | `limits.resume_observation_timeout_seconds` |
| `verify-completion` | `limits.ready_timeout_seconds` |

The deadline includes lock acquisition, whose separate maximum is `limits.lock_timeout_seconds`; the shorter remaining limit wins. The supervisor enforces elapsed-time bounds independently of the child. Operational request `deadline_mono_ns` must be after `issued_mono_ns`, no later than issuance plus the registered command duration, and still in the future when processed. A requester may choose a shorter deadline, never a longer one.

Drain and numerical validation may continue under durable intent beyond a single observation request, bounded respectively by `drain_deadline_seconds` and `validation_deadline_seconds`. A command timeout does not authorize worker termination, restart, host reboot or heartbeat withdrawal. `prepare`/`resume` return bounded acceptance/progress receipts instead of blocking for the entire scientific task. The asynchronous implementation and event journal remain production work to implement.

## 2. Version, identity and number encoding

`api_version` is exactly `SCI-DR/1.0.0`; `profile_id` is exactly `production-v1`. Capability discovery is read-only and selects no looser version. This release advertises only this exact protocol/profile and six commands. An unsupported version/profile returns `INVALID_REQUEST` with the appropriate reason if a safe bounded response is possible. No minor-version assumption, optional unknown field or fallback to sandbox is allowed. Schema changes require a new explicitly advertised/accepted version, consumer tests and migration review.

Identifiers are 1–96 ASCII characters beginning alphanumerically and containing only letters, digits, `_`, `.`, `:`, or `-`; unit identifiers have their stricter service-name schema. SHA-256 values are exactly 64 lowercase hexadecimal characters. Boot IDs, service invocation IDs and request nonces are exactly 32 lowercase hexadecimal characters without hyphens. Nonces must be generated from a cryptographically suitable 128-bit source by the trusted requester; `request_id` supplies the durable human/audit identity. Neither value is authentication by itself.

**Every field ending in `_mono_ns` is a canonical unsigned decimal string**, not a JSON number: `"0"` or a nonzero first digit followed by at most 18 digits. Convert it with exact integer arithmetic before comparison; never compare lexicographically or through an IEEE-754 float. This supports long host uptimes without the approximately 104-day limit of a 53-bit nanosecond counter. Counts use JSON integers bounded by the schemas; implementations must preserve them exactly. No numeric exponent, leading plus or fractional number is allowed for these timestamp strings. No token may contain trailing LF/control characters; patterns use an absolute-end assertion.

`timing.boot_id` and `observation.boot_id` identify the **current host boot**. `clock_domain` is either `CLOCK_MONOTONIC` or `CLOCK_BOOTTIME`, exactly matching the protected registration. A consumer may not subtract across boot IDs or clock domains. A same-host trusted requester obtains issuance and consumption timestamps from that clock. UTC is report metadata only: validate that it is a real UTC calendar timestamp, but do not use it for cooldown, freshness, ordering or timeout decisions. An NTP correction cannot extend a ready receipt.

The operational `identity` is the complete tuple `stage_id`, `run_id`, `code_sha256`, `parameters_sha256`, `inputs_sha256`. Every field must equal the accepted registration and the validated scientific run. The registration reference contains `registration_id`, its independently accepted `generation` (at least 1), and `sha256` of the exact canonical registration. Adapter lifecycle `state.generation` is a separate monotonically advancing counter; changing one generation cannot satisfy a precondition on the other.

## 3. Exact requests

Every request contains `api_version`, `profile_id`, `request_id`, `nonce` and `command`. All fields listed for each variant are required; `null` is allowed only where the schema explicitly allows it. Every operational request additionally contains `registration`, `identity` and `timing`.

| Command | Additional exact fields | Semantics |
|---|---|---|
| `capabilities` | None | Discover the single accepted registration selected by this protected executable; no caller-supplied registration or filesystem path |
| `status` | `previous_response_sha256` (digest or null) | Null requests a baseline observation; a digest requests comparison with the trusted supervisor's retained earlier status response |
| `prepare` | `transaction`, `reason`, `authorization_sha256` | `transaction` is `{transaction_id, expected_state_generation}`; reason is `planned-maintenance`, `recovery` or `stage-transition`; authorization references an independently accepted scientific-lifecycle request |
| `ready` | `transaction`, `seal_sha256` | Re-observe the identified maintenance transaction and current state generation, checking that exact seal |
| `resume` | `transaction`, `seal_sha256`, `authorization_sha256` | Reconcile the same sealed transaction and request legitimate validated startup; authorization is scoped to that lifecycle action |
| `verify-completion` | `expected_state_generation`, `completion_manifest_sha256` | Validate the exact completion manifest and current state, independently of a success marker |

The supervisor resolves previous responses and authorization records only in its protected stores. It must not interpret a supplied digest as authority to read an arbitrary path or accept an untrusted file. A mutation authorization binds the entire registration/run, transaction, exact command, expected generation, nonce and boot policy. It grants no controller-reset, reboot, outlet or reset-budget authority.

Compare-and-swap generation checks occur under the lifecycle transaction lock. A mutation that changes durable state increments the generation, records the request's canonical digest and publishes an immutable receipt. Asynchronous lifecycle changes also advance generation. A repeated identical mutation received before its deadline may return its recorded outcome without reissuing the operation; a changed canonical request under the same request identity is `CONFLICT`. Fresh transport observations must still use current boot/source evidence. An expired replay cannot renew authority: obtain a new `status` request, reconcile the original transaction, and issue any subsequent authorized request with a new request ID/nonce and the actual current generation.

`ready` and `verify-completion` have generation preconditions but do not advance scientific/lifecycle generation. They cannot clear maintenance, change worker state or issue actuation. Read-only commands may produce bounded observation artifacts in the protected evidence store; they may not modify scientific output, control state, budgets or device state.

## 4. Success envelope and source verification

Every success response contains exactly:

`api_version`, `profile_id`, `simulation_only`, `request_id`, `nonce`, `registration`, `identity`, `provenance`, `observation`, `transaction_id`, `verdict`, `exit_code`, `command`, `data`.

`simulation_only=false`, `verdict=PASS` and `exit_code=0` identify a production-profile operation response. They do not prove that production exists or that science is healthy. In particular, status PASS means a valid current observation was returned; its lifecycle/validation/progress may still be unsuitable for a recovery gate.

`registration`, `identity`, request ID, nonce and command must exactly match the outstanding request and protected registration, except that capability discovery returns the one independently selected active registration. The top-level `transaction_id` is the requested ID for prepare/ready/resume and null for other commands. All nested transaction IDs and generation references must agree. The response's source hashes must match the independently approved release set before its scientific statements are consumed.

`provenance` contains exactly the registered `adapter_release_sha256`, a `registration_acceptance` artifact reference, and a `source_verification` artifact reference. `observation` contains current boot, registered clock, bounded `started_mono_ns`/`finished_mono_ns`, report UTC, and the independent observer's release digest. The observer must be a separately accepted consumer in the registration, running from protected source bytes with access to the registered process boundary. The workload must not be able to replace the observer, its approval records, evidence store or root of trust.

For an operational success, require:

1. The same boot, clock domain and registered generation at request, observation and response consumption.
2. `issued <= started <= finished <= consumed < deadline`, using the same exact clock. A discontinuity/refused clock read produces no valid success.
3. Stable registration/source identities across the observation, validated by the supervisor independently of the adapter's assertions.
4. The adapter's actual executable/source closure, effective execution identity and selected service boundary match registration. A reply claiming a hash cannot substitute for reading/verifying the trusted executable and imports.
5. Evidence references resolve to the exact accepted producer and exact canonical bytes. Reject missing, changed, unknown-format or foreign-generation artifacts.

Capability discovery has no requester timing object. Its caller must apply the registered status timeout, verify current boot/clock and source identities before and after execution, and validate the returned registration against independent trust. The discovery result cannot bootstrap trust in its own registration.

## 5. Artifact references and canonical bytes

Each evidence reference is an exact object containing `kind`, `sha256`, `bytes`, `canonicalization`, `producer_role`, `producer_release_sha256`. `canonicalization` is exactly `SCI-DR-CJSON/1`; `bytes` is 1–67,108,864 and must equal the opened artifact size. The lower registered evidence-store/format bound also applies. No paths or network URLs are accepted in a reference.

`SCI-DR-CJSON/1` is UTF-8 JSON encoded with ASCII escapes, keys sorted by Unicode code-point order, no insignificant whitespace, compact comma/colon separators, lowercase hexadecimal JSON escapes, exact decimal integers, JSON `true`/`false`/`null`, and **one terminal LF included in the hash**. Reject duplicate keys, floats, negative zero encodings, nonfinite numbers, invalid Unicode scalars and non-NFC strings before canonical encoding. Scientific floating-point arrays use their declared numerical/binary format and hashes in the canonical manifest; they are not reformatted as JSON floats for hashing. A verifier recomputes canonical bytes and requires byte equality before checking SHA-256.

String encoding is exact: encode quotation mark as `\"` and backslash as `\\`; use the short escapes `\b`, `\t`, `\n`, `\f`, `\r` for backspace, tab, LF, form feed and CR. Encode every other U+0000–U+001F character as lowercase `\u00xx`. Emit U+0020–U+007E directly except quotation mark/backslash; `/` is never escaped. Encode U+007F as `\u007f`, non-ASCII BMP scalars as lowercase `\uxxxx`, and supplementary scalars as their lowercase UTF-16 surrogate-pair escapes. Reject unpaired surrogates. Keys and string values must already be NFC; do not silently normalize them. Sort the decoded NFC keys by Unicode code-point order before escaping them.

Evidence is a separate immutable artifact, not an arbitrary `data` object or a self-referential hash of the response containing it. A producer first creates the bounded observation/receipt, then the response references it. A retained previous response is itself canonicalized and hashed by the trusted supervisor after strict validation; this is the `previous_response_sha256` input.

| Artifact kind | Permitted declared producer | Required independent interpretation |
|---|---|---|
| `registration-acceptance` | Release approver | Protected administrative acceptance binds registration hash and release set |
| `source-verification` | Independent observer | Full accepted source closure, ownership and active generation checked |
| `state-receipt`, `maintenance-intent`, `start-request` | Adapter | Durable transaction, generation and scoped request identity checked against state |
| `scientific-seal` | Workload or adapter | Independent observer verifies exact output catalog, durable maintenance and writer barrier |
| `recursive-cgroup-observation`, `writer-observation`, `ready-observation` | Independent observer | Actual current recursive process/writer/job observations, not workload statements |
| `accepted-catalog`, `completion-manifest` | Workload, adapter or independent observer | Exact task membership, hashes and scientific format interpreted by accepted validator |
| `numerical-validation`, `phase-transition`, `completion-validation`, `resumption-proof` | Independent observer | Validated stage-specific numerical/transition/completion semantics |

The schema constrains declared roles but a role string is not authentication. An administrative approval must be resolved through external protected trust; source/cgroup/ready evidence must be resolved through the accepted observer identity. A workload-generated artifact cannot promote itself by setting `producer_role`.

Stage-specific evidence formats, units, numerical validation and trusted producer identities are part of the separately approved validation profile and source closure. The wire contract fixes reference shape and interpretation; it does not manufacture numerical validity from an artifact digest. An implementation lacking a known validator for any required evidence kind must refuse production acceptance.

## 6. Exact success payloads

Every `data` object is closed by its command variant in the response schema. There is no unconstrained payload slot.

| Command | Required payload and interpretation |
|---|---|
| `capabilities` | Exact supported version/profile/command arrays, read-only commands, accepted registration status, complete registered `limits`, `power_authority=none`, `budget_authority=none`, `numerical_validation_claimed=false`. Limits must equal protected registration, not values chosen by the adapter |
| `status` | Lifecycle, state receipt/generation, current active/inactive execution binding, validated scientific identity, validation result/profile/receipt, catalog, progress comparison, quiescence, maintenance transaction or null, completion proof or null, resumption result/proof. Use the separate predicates below |
| `prepare` | `DRAINING` or `SEALED`, full transaction receipt, resulting state receipt/generation, `dispatch_stopped=true`, pending count, seal or null, quiescence, drain deadline. SEALED requires a real seal, zero pending work and full quiescence; DRAINING requires null seal and grants no ready claim |
| `ready` | `READY_OBSERVED`, same transaction, state receipt, exact requested seal, numerical validation, catalog, independently proved quiescence, new ready-observation artifact, `valid_until_mono_ns`, `power_authorization=false` |
| `resume` | `START_REQUESTED`, transaction and resulting state receipts, durable start-request artifact, new execution binding if known (otherwise null), `recovery_proven=false`, `required_followup=status-or-verify-completion`. Accepted startup is never verified recovery |
| `verify-completion` | `COMPLETE_VERIFIED`, matching state receipt, validated scientific identity, exact completion proof including required/accepted counts and independent quiescence, `power_authorization=false` |

### Execution and quiescence

Active execution contains exact service unit, invocation ID, positive PID, UID/GID and process start ticks. The boot is supplied by the common observation; together these fields resist PID reuse. Inactive execution has PID zero, null process start ticks and a retained invocation or null if none exists. Inactive does not itself mean completed or safe.

Quiescence reports `QUIESCENT`, `BUSY` or `UNKNOWN`; recursive-cgroup and writer evidence references; writer count, pending-job count and observation stability. UNKNOWN must not become zero counts by default. Ready and completion success require both independent observations, zero writers, zero pending jobs and stable observation. Recursive containment includes descendants and every registered writer; an empty parent PID list is insufficient. A workload's current process count cannot certify independent observer behavior.

### Status comparison and numerical validity

Status has a scientifically validated identity even when full numerical/output validation is pending. `validation.result` separates `NOT_STARTED`, `PENDING`, `PASS`, `INTEGRITY_BLOCKED` and `UNKNOWN`. PASS requires a non-null numerical-validation artifact with exactly the registered validation-profile digest; other values never satisfy a validated-science gate. Lifecycle, service and progress may not contradict the validated artifacts.

`progress` always supplies phase/batch/unit or null, accepted/total counts, earlier response digest or null, classification, delta or null, window bounds, identity stability, registered-age/gap result and phase-transition proof or null. Its accepted count must equal the current accepted catalog and the declared phase accounting, and cannot exceed a known total.

| Classification | Mandatory semantic constraints |
|---|---|
| `BASELINE_ONLY` | Previous response, delta and window start are null; no progress claim |
| `VERIFIED_POSITIVE_DELTA` | Previous accepted response exists; same registration/run/boot/clock/service invocation/PID/UID/GID/start ticks/phase/batch; active execution; stable identities; strictly ordered window; positive exact count difference; no lost previously accepted commits; registered age/gap pass |
| `NO_POSITIVE_DELTA` | Same verified comparison basis; delta is zero; cannot pass positive-progress gate |
| `VALIDATED_PHASE_TRANSITION` | Prior response and independent phase-transition artifact present; approved phase ordering/task membership/counter relation; do not subtract unrelated phase counters |
| `LONG_TASK_PENDING` | Registered long-task interval/milestone policy applies; no invented accepted work; no positive-progress or recovery claim solely from liveness |
| `NOT_APPLICABLE` | Documented completed/sealed/starting/validating state; comparison not used as progress evidence |

Missing/expired comparison evidence, foreign identity, reversed clocks or counters inconsistent with accepted commits produce a nonzero refusal/stale/integrity response as appropriate; they are not a successful comparison. `window_end_mono_ns` is bounded by the enclosing finished observation. Retained prior response provenance and timestamps must be reverified before comparison.

`resumption.result` is `NOT_REQUESTED`, `AWAITING_PROOF`, `VERIFIED_PROGRESS` or `VERIFIED_COMPLETION`. NOT_REQUESTED has null transaction/prior identities/proof. AWAITING_PROOF carries the relevant transaction and no claimed proof. VERIFIED_PROGRESS requires an independent resumption artifact plus the positive comparison described above after the start request, bound to the new execution; VERIFIED_COMPLETION requires complete validation and quiescence. Prior boot/invocation identify the predecessor when known, never an invented value. A same-boot resumed process must still have its newly demonstrated execution identity.

### Completion and uncached readiness

Completion proof includes exact manifest, completion-validation and accepted-catalog references, required and accepted counts, and quiescence. Counts must equal one another and the authorized complete task set; zero is only valid for an independently approved zero-work completion. A completed receipt while writers are active cannot pass `verify-completion`.

Ready success is a fresh observation for the outstanding nonce, not a cached prepare/seal result. Its generation must equal the request precondition and still be current. The requested seal digest must equal the returned seal and current durable transaction. Require `finished <= consumed < valid_until <= request.deadline`; the implementation may use an earlier expiration. A reused request/nonce cannot mint a fresh ready observation or extend expiration. Ready evidence from a previous boot, changed invocation/writer set, expired request, different registration, different transaction or state-generation change is rejected.

Immediately before any governed actuation, the separate authorized supervisor must recheck current sources/registration, transaction/generation, seal, recursive workers/jobs, applicable holds/inhibits and incident/budget authority under the action barrier. An unexpired ready reply cannot substitute for this final observation. All replies explicitly grant no power authority; none changes reset allowances.

## 7. Exact error payload and exit codes

A nonzero response contains the same protocol/profile/`simulation_only=false` identifiers; nullable request ID, nonce, registration, identity, provenance, observation and transaction ID; a known command or `invalid`; exact verdict/exit code; and `error`. It has no `data` member. Null means unavailable/unverified, not agreement with a requested value. If a malformed field cannot be safely bound, return null rather than reflecting arbitrary bytes. Duplicate-key ambiguity must not select one of the duplicates.

`error` contains exactly `reason_code`, one-line bounded `message`, `current_state_generation` or null, `retry`, `mutation_state`, and `receipt` or null. `reason_code` is one of the explicit enum values in the schema. `retry` is `NO_AUTOMATIC_RETRY`, `FRESH_OBSERVATION` or `SAME_MUTATION_IDENTITY`; the last never permits changing a request's identity or generation. `mutation_state` is `NONE`, `UNCHANGED`, `INTENT_DURABLE`, `STATE_ADVANCED` or `OUTCOME_UNKNOWN`. Report durable intent/uncertain outcome honestly; failure is not proof that nothing happened.

| Actual exit and JSON exit | Verdict | Meaning |
|---|---|---|
| 0 | `PASS` | Command-specific successful response; not universal health/authority |
| 20 | `REFUSED` | Known unmet precondition or policy; e.g. not sealed, writers/jobs remain, validation pending or prepare deadline |
| 21 | `STALE` | Evidence/request expired, changed boot or unusable observation freshness/clock basis |
| 22 | `INTEGRITY_BLOCKED` | Known scientific/source/identity verification failure; requires review |
| 23 | `CONFLICT` | Generation, transaction, replay identity or concurrent lock conflict |
| 64 | `INVALID_REQUEST` | Unsupported version/profile or malformed/duplicate/oversized/schema-invalid request |
| 74 | `IO_UNKNOWN` | Required evidence/transport/storage/observer outcome unavailable or durability uncertain |

An unreadable object is IO_UNKNOWN, not a proved integrity mismatch. A known hash or scientific-validation mismatch is INTEGRITY_BLOCKED. `SOURCE_MISMATCH`, `IDENTITY_MISMATCH` and `INTEGRITY_FAILURE` cannot be retried into permission by replacing expected values. An expired ready request must obtain a fresh observation with a fresh request identity. A mutation with uncertain outcome must first be reconciled through the durable transaction and current status; repeat dispatch is prohibited while the outcome remains unknown.

## 8. Required verification beyond schemas

A production implementation must test the strict parser, absolute-end token handling, byte/depth limits, response/actual-exit agreement, every field equality, artifact canonicalization/digest/producer checks, generation locking, nonce replay, timestamp ordering and real calendar parsing. Tests must include >104-day nanosecond values, boot change, mixed clock domains, changed source/registration, cached ready proof, one late descendant writer, pending systemd start, stale prior status, false positive delta, unvalidated completion and resume overclaim.

The supplied schema-valid samples deliberately use synthetic repeated-hex digests, and are **not semantically trusted evidence**. The invalid index includes structurally valid messages that must fail semantic checking: foreign nonce, foreign boot, expired readiness and clock-domain mismatch. Local schema-checker results demonstrate only the supported structural subset, not these production semantics, numerical validity, privilege separation or hardware behavior.

302,107 bytes · SHA-256 8ef04050a49a4fbaff3e500bbe2eaf9b4105f75b6343461f8dddce9cdfdf9de4

The entire prompt is displayed once in Appendix B. Its exact bytes are also embedded in the download below.

10,788 bytes · SHA-256 b3a276b1cb05d323fbce961bf69921e9058185e032b89286e72c527509c33ec8

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "urn:sci-dr:1.0.0:production-request",
  "title": "Proposed SCI-DR/1.0.0 production-v1 request; no production implementation supplied",
  "$defs": {
    "identity": {
      "type": "object",
      "properties": {
        "stage_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "run_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "code_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        },
        "parameters_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        },
        "inputs_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        }
      },
      "required": [
        "stage_id",
        "run_id",
        "code_sha256",
        "parameters_sha256",
        "inputs_sha256"
      ],
      "additionalProperties": false
    },
    "registration": {
      "type": "object",
      "properties": {
        "registration_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "generation": {
          "type": "integer",
          "minimum": 1,
          "maximum": 2147483647
        },
        "sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        }
      },
      "required": [
        "registration_id",
        "generation",
        "sha256"
      ],
      "additionalProperties": false
    },
    "timing": {
      "type": "object",
      "properties": {
        "boot_id": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "clock_domain": {
          "enum": [
            "CLOCK_MONOTONIC",
            "CLOCK_BOOTTIME"
          ]
        },
        "issued_mono_ns": {
          "type": "string",
          "pattern": "^(0|[1-9][0-9]{0,18})(?![\\s\\S])",
          "maxLength": 19
        },
        "deadline_mono_ns": {
          "type": "string",
          "pattern": "^(0|[1-9][0-9]{0,18})(?![\\s\\S])",
          "maxLength": 19
        }
      },
      "required": [
        "boot_id",
        "clock_domain",
        "issued_mono_ns",
        "deadline_mono_ns"
      ],
      "additionalProperties": false
    },
    "transaction": {
      "type": "object",
      "properties": {
        "transaction_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "expected_state_generation": {
          "type": "integer",
          "minimum": 0,
          "maximum": 2147483647
        }
      },
      "required": [
        "transaction_id",
        "expected_state_generation"
      ],
      "additionalProperties": false
    }
  },
  "oneOf": [
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "command": {
          "const": "capabilities"
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "request_id",
        "nonce",
        "command"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "registration": {
          "$ref": "#/$defs/registration"
        },
        "identity": {
          "$ref": "#/$defs/identity"
        },
        "timing": {
          "$ref": "#/$defs/timing"
        },
        "command": {
          "const": "status"
        },
        "previous_response_sha256": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "request_id",
        "nonce",
        "registration",
        "identity",
        "timing",
        "command",
        "previous_response_sha256"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "registration": {
          "$ref": "#/$defs/registration"
        },
        "identity": {
          "$ref": "#/$defs/identity"
        },
        "timing": {
          "$ref": "#/$defs/timing"
        },
        "command": {
          "const": "prepare"
        },
        "transaction": {
          "$ref": "#/$defs/transaction"
        },
        "reason": {
          "enum": [
            "planned-maintenance",
            "recovery",
            "stage-transition"
          ]
        },
        "authorization_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "request_id",
        "nonce",
        "registration",
        "identity",
        "timing",
        "command",
        "transaction",
        "reason",
        "authorization_sha256"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "registration": {
          "$ref": "#/$defs/registration"
        },
        "identity": {
          "$ref": "#/$defs/identity"
        },
        "timing": {
          "$ref": "#/$defs/timing"
        },
        "command": {
          "const": "ready"
        },
        "transaction": {
          "$ref": "#/$defs/transaction"
        },
        "seal_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "request_id",
        "nonce",
        "registration",
        "identity",
        "timing",
        "command",
        "transaction",
        "seal_sha256"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "registration": {
          "$ref": "#/$defs/registration"
        },
        "identity": {
          "$ref": "#/$defs/identity"
        },
        "timing": {
          "$ref": "#/$defs/timing"
        },
        "command": {
          "const": "resume"
        },
        "transaction": {
          "$ref": "#/$defs/transaction"
        },
        "seal_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        },
        "authorization_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "request_id",
        "nonce",
        "registration",
        "identity",
        "timing",
        "command",
        "transaction",
        "seal_sha256",
        "authorization_sha256"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "registration": {
          "$ref": "#/$defs/registration"
        },
        "identity": {
          "$ref": "#/$defs/identity"
        },
        "timing": {
          "$ref": "#/$defs/timing"
        },
        "command": {
          "const": "verify-completion"
        },
        "expected_state_generation": {
          "type": "integer",
          "minimum": 0,
          "maximum": 2147483647
        },
        "completion_manifest_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "request_id",
        "nonce",
        "registration",
        "identity",
        "timing",
        "command",
        "expected_state_generation",
        "completion_manifest_sha256"
      ],
      "additionalProperties": false
    }
  ]
}

107,807 bytes · SHA-256 fc114fc79f0c42f9b51df07231042da2f6f37fc3b3874c7266551fa98357e5bc

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "urn:sci-dr:1.0.0:production-response",
  "title": "Proposed SCI-DR/1.0.0 production-v1 response; assertions require independent verification",
  "$defs": {
    "identity": {
      "type": "object",
      "properties": {
        "stage_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "run_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "code_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        },
        "parameters_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        },
        "inputs_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        }
      },
      "required": [
        "stage_id",
        "run_id",
        "code_sha256",
        "parameters_sha256",
        "inputs_sha256"
      ],
      "additionalProperties": false
    },
    "registration": {
      "type": "object",
      "properties": {
        "registration_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "generation": {
          "type": "integer",
          "minimum": 1,
          "maximum": 2147483647
        },
        "sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        }
      },
      "required": [
        "registration_id",
        "generation",
        "sha256"
      ],
      "additionalProperties": false
    },
    "observation": {
      "type": "object",
      "properties": {
        "boot_id": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "clock_domain": {
          "enum": [
            "CLOCK_MONOTONIC",
            "CLOCK_BOOTTIME"
          ]
        },
        "started_mono_ns": {
          "type": "string",
          "pattern": "^(0|[1-9][0-9]{0,18})(?![\\s\\S])",
          "maxLength": 19
        },
        "finished_mono_ns": {
          "type": "string",
          "pattern": "^(0|[1-9][0-9]{0,18})(?![\\s\\S])",
          "maxLength": 19
        },
        "observed_utc": {
          "type": "string",
          "pattern": "^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(\\.[0-9]{1,9})?Z(?![\\s\\S])",
          "maxLength": 30
        },
        "observer_release_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        }
      },
      "required": [
        "boot_id",
        "clock_domain",
        "started_mono_ns",
        "finished_mono_ns",
        "observed_utc",
        "observer_release_sha256"
      ],
      "additionalProperties": false
    },
    "provenance": {
      "type": "object",
      "properties": {
        "adapter_release_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        },
        "registration_acceptance": {
          "type": "object",
          "properties": {
            "kind": {
              "const": "registration-acceptance"
            },
            "sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            },
            "bytes": {
              "type": "integer",
              "minimum": 1,
              "maximum": 67108864
            },
            "canonicalization": {
              "const": "SCI-DR-CJSON/1"
            },
            "producer_role": {
              "enum": [
                "release-approver"
              ]
            },
            "producer_release_sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            }
          },
          "required": [
            "kind",
            "sha256",
            "bytes",
            "canonicalization",
            "producer_role",
            "producer_release_sha256"
          ],
          "additionalProperties": false
        },
        "source_verification": {
          "type": "object",
          "properties": {
            "kind": {
              "const": "source-verification"
            },
            "sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            },
            "bytes": {
              "type": "integer",
              "minimum": 1,
              "maximum": 67108864
            },
            "canonicalization": {
              "const": "SCI-DR-CJSON/1"
            },
            "producer_role": {
              "enum": [
                "independent-observer"
              ]
            },
            "producer_release_sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            }
          },
          "required": [
            "kind",
            "sha256",
            "bytes",
            "canonicalization",
            "producer_role",
            "producer_release_sha256"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "adapter_release_sha256",
        "registration_acceptance",
        "source_verification"
      ],
      "additionalProperties": false
    },
    "execution": {
      "oneOf": [
        {
          "type": "object",
          "properties": {
            "state": {
              "const": "active"
            },
            "service_unit": {
              "type": "string",
              "pattern": "^[A-Za-z0-9_.@:-]+\\.service(?![\\s\\S])",
              "maxLength": 128
            },
            "invocation_id": {
              "type": "string",
              "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
              "maxLength": 32
            },
            "pid": {
              "type": "integer",
              "minimum": 1,
              "maximum": 2147483647
            },
            "uid": {
              "type": "integer",
              "minimum": 0,
              "maximum": 2147483647
            },
            "gid": {
              "type": "integer",
              "minimum": 0,
              "maximum": 2147483647
            },
            "process_start_ticks": {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            }
          },
          "required": [
            "state",
            "service_unit",
            "invocation_id",
            "pid",
            "uid",
            "gid",
            "process_start_ticks"
          ],
          "additionalProperties": false
        },
        {
          "type": "object",
          "properties": {
            "state": {
              "const": "inactive"
            },
            "service_unit": {
              "type": "string",
              "pattern": "^[A-Za-z0-9_.@:-]+\\.service(?![\\s\\S])",
              "maxLength": 128
            },
            "invocation_id": {
              "anyOf": [
                {
                  "type": "string",
                  "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
                  "maxLength": 32
                },
                {
                  "type": "null"
                }
              ]
            },
            "pid": {
              "const": 0
            },
            "uid": {
              "type": "integer",
              "minimum": 0,
              "maximum": 2147483647
            },
            "gid": {
              "type": "integer",
              "minimum": 0,
              "maximum": 2147483647
            },
            "process_start_ticks": {
              "const": null
            }
          },
          "required": [
            "state",
            "service_unit",
            "invocation_id",
            "pid",
            "uid",
            "gid",
            "process_start_ticks"
          ],
          "additionalProperties": false
        }
      ]
    },
    "quiescence": {
      "type": "object",
      "properties": {
        "verdict": {
          "enum": [
            "QUIESCENT",
            "BUSY",
            "UNKNOWN"
          ]
        },
        "recursive_cgroup": {
          "anyOf": [
            {
              "type": "object",
              "properties": {
                "kind": {
                  "const": "recursive-cgroup-observation"
                },
                "sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                },
                "bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 67108864
                },
                "canonicalization": {
                  "const": "SCI-DR-CJSON/1"
                },
                "producer_role": {
                  "enum": [
                    "independent-observer"
                  ]
                },
                "producer_release_sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                }
              },
              "required": [
                "kind",
                "sha256",
                "bytes",
                "canonicalization",
                "producer_role",
                "producer_release_sha256"
              ],
              "additionalProperties": false
            },
            {
              "type": "null"
            }
          ]
        },
        "writers": {
          "anyOf": [
            {
              "type": "object",
              "properties": {
                "kind": {
                  "const": "writer-observation"
                },
                "sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                },
                "bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 67108864
                },
                "canonicalization": {
                  "const": "SCI-DR-CJSON/1"
                },
                "producer_role": {
                  "enum": [
                    "independent-observer"
                  ]
                },
                "producer_release_sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                }
              },
              "required": [
                "kind",
                "sha256",
                "bytes",
                "canonicalization",
                "producer_role",
                "producer_release_sha256"
              ],
              "additionalProperties": false
            },
            {
              "type": "null"
            }
          ]
        },
        "writer_count": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "pending_jobs": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "observation_stable": {
          "type": "boolean"
        }
      },
      "required": [
        "verdict",
        "recursive_cgroup",
        "writers",
        "writer_count",
        "pending_jobs",
        "observation_stable"
      ],
      "additionalProperties": false
    },
    "quiet": {
      "type": "object",
      "properties": {
        "verdict": {
          "const": "QUIESCENT"
        },
        "recursive_cgroup": {
          "type": "object",
          "properties": {
            "kind": {
              "const": "recursive-cgroup-observation"
            },
            "sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            },
            "bytes": {
              "type": "integer",
              "minimum": 1,
              "maximum": 67108864
            },
            "canonicalization": {
              "const": "SCI-DR-CJSON/1"
            },
            "producer_role": {
              "enum": [
                "independent-observer"
              ]
            },
            "producer_release_sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            }
          },
          "required": [
            "kind",
            "sha256",
            "bytes",
            "canonicalization",
            "producer_role",
            "producer_release_sha256"
          ],
          "additionalProperties": false
        },
        "writers": {
          "type": "object",
          "properties": {
            "kind": {
              "const": "writer-observation"
            },
            "sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            },
            "bytes": {
              "type": "integer",
              "minimum": 1,
              "maximum": 67108864
            },
            "canonicalization": {
              "const": "SCI-DR-CJSON/1"
            },
            "producer_role": {
              "enum": [
                "independent-observer"
              ]
            },
            "producer_release_sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            }
          },
          "required": [
            "kind",
            "sha256",
            "bytes",
            "canonicalization",
            "producer_role",
            "producer_release_sha256"
          ],
          "additionalProperties": false
        },
        "writer_count": {
          "const": 0
        },
        "pending_jobs": {
          "const": 0
        },
        "observation_stable": {
          "const": true
        }
      },
      "required": [
        "verdict",
        "recursive_cgroup",
        "writers",
        "writer_count",
        "pending_jobs",
        "observation_stable"
      ],
      "additionalProperties": false
    },
    "state": {
      "type": "object",
      "properties": {
        "generation": {
          "type": "integer",
          "minimum": 0,
          "maximum": 2147483647
        },
        "state_receipt": {
          "type": "object",
          "properties": {
            "kind": {
              "const": "state-receipt"
            },
            "sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            },
            "bytes": {
              "type": "integer",
              "minimum": 1,
              "maximum": 67108864
            },
            "canonicalization": {
              "const": "SCI-DR-CJSON/1"
            },
            "producer_role": {
              "enum": [
                "adapter"
              ]
            },
            "producer_release_sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            }
          },
          "required": [
            "kind",
            "sha256",
            "bytes",
            "canonicalization",
            "producer_role",
            "producer_release_sha256"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "generation",
        "state_receipt"
      ],
      "additionalProperties": false
    },
    "validation": {
      "type": "object",
      "properties": {
        "result": {
          "enum": [
            "NOT_STARTED",
            "PENDING",
            "PASS",
            "INTEGRITY_BLOCKED",
            "UNKNOWN"
          ]
        },
        "profile_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        },
        "receipt": {
          "anyOf": [
            {
              "type": "object",
              "properties": {
                "kind": {
                  "const": "numerical-validation"
                },
                "sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                },
                "bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 67108864
                },
                "canonicalization": {
                  "const": "SCI-DR-CJSON/1"
                },
                "producer_role": {
                  "enum": [
                    "independent-observer"
                  ]
                },
                "producer_release_sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                }
              },
              "required": [
                "kind",
                "sha256",
                "bytes",
                "canonicalization",
                "producer_role",
                "producer_release_sha256"
              ],
              "additionalProperties": false
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "result",
        "profile_sha256",
        "receipt"
      ],
      "additionalProperties": false
    },
    "progress": {
      "type": "object",
      "properties": {
        "phase_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "batch_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "work_unit": {
          "anyOf": [
            {
              "type": "string",
              "minLength": 1,
              "maxLength": 512
            },
            {
              "type": "null"
            }
          ]
        },
        "accepted": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "total": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "previous_response_sha256": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            },
            {
              "type": "null"
            }
          ]
        },
        "classification": {
          "enum": [
            "BASELINE_ONLY",
            "VERIFIED_POSITIVE_DELTA",
            "NO_POSITIVE_DELTA",
            "VALIDATED_PHASE_TRANSITION",
            "LONG_TASK_PENDING",
            "NOT_APPLICABLE"
          ]
        },
        "delta": {
          "anyOf": [
            {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            {
              "type": "null"
            }
          ]
        },
        "window_start_mono_ns": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^(0|[1-9][0-9]{0,18})(?![\\s\\S])",
              "maxLength": 19
            },
            {
              "type": "null"
            }
          ]
        },
        "window_end_mono_ns": {
          "type": "string",
          "pattern": "^(0|[1-9][0-9]{0,18})(?![\\s\\S])",
          "maxLength": 19
        },
        "identity_stable": {
          "type": "boolean"
        },
        "within_registered_age_and_gap": {
          "type": "boolean"
        },
        "phase_transition": {
          "anyOf": [
            {
              "type": "object",
              "properties": {
                "kind": {
                  "const": "phase-transition"
                },
                "sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                },
                "bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 67108864
                },
                "canonicalization": {
                  "const": "SCI-DR-CJSON/1"
                },
                "producer_role": {
                  "enum": [
                    "independent-observer"
                  ]
                },
                "producer_release_sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                }
              },
              "required": [
                "kind",
                "sha256",
                "bytes",
                "canonicalization",
                "producer_role",
                "producer_release_sha256"
              ],
              "additionalProperties": false
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "phase_id",
        "batch_id",
        "work_unit",
        "accepted",
        "total",
        "previous_response_sha256",
        "classification",
        "delta",
        "window_start_mono_ns",
        "window_end_mono_ns",
        "identity_stable",
        "within_registered_age_and_gap",
        "phase_transition"
      ],
      "additionalProperties": false
    },
    "resumption": {
      "type": "object",
      "properties": {
        "result": {
          "enum": [
            "NOT_REQUESTED",
            "AWAITING_PROOF",
            "VERIFIED_PROGRESS",
            "VERIFIED_COMPLETION"
          ]
        },
        "transaction_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "prior_boot_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
              "maxLength": 32
            },
            {
              "type": "null"
            }
          ]
        },
        "prior_invocation_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
              "maxLength": 32
            },
            {
              "type": "null"
            }
          ]
        },
        "proof": {
          "anyOf": [
            {
              "type": "object",
              "properties": {
                "kind": {
                  "const": "resumption-proof"
                },
                "sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                },
                "bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 67108864
                },
                "canonicalization": {
                  "const": "SCI-DR-CJSON/1"
                },
                "producer_role": {
                  "enum": [
                    "independent-observer"
                  ]
                },
                "producer_release_sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                }
              },
              "required": [
                "kind",
                "sha256",
                "bytes",
                "canonicalization",
                "producer_role",
                "producer_release_sha256"
              ],
              "additionalProperties": false
            },
            {
              "type": "null"
            }
          ]
        }
      },
      "required": [
        "result",
        "transaction_id",
        "prior_boot_id",
        "prior_invocation_id",
        "proof"
      ],
      "additionalProperties": false
    },
    "completion": {
      "type": "object",
      "properties": {
        "manifest": {
          "type": "object",
          "properties": {
            "kind": {
              "const": "completion-manifest"
            },
            "sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            },
            "bytes": {
              "type": "integer",
              "minimum": 1,
              "maximum": 67108864
            },
            "canonicalization": {
              "const": "SCI-DR-CJSON/1"
            },
            "producer_role": {
              "enum": [
                "workload",
                "adapter",
                "independent-observer"
              ]
            },
            "producer_release_sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            }
          },
          "required": [
            "kind",
            "sha256",
            "bytes",
            "canonicalization",
            "producer_role",
            "producer_release_sha256"
          ],
          "additionalProperties": false
        },
        "validation": {
          "type": "object",
          "properties": {
            "kind": {
              "const": "completion-validation"
            },
            "sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            },
            "bytes": {
              "type": "integer",
              "minimum": 1,
              "maximum": 67108864
            },
            "canonicalization": {
              "const": "SCI-DR-CJSON/1"
            },
            "producer_role": {
              "enum": [
                "independent-observer"
              ]
            },
            "producer_release_sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            }
          },
          "required": [
            "kind",
            "sha256",
            "bytes",
            "canonicalization",
            "producer_role",
            "producer_release_sha256"
          ],
          "additionalProperties": false
        },
        "accepted_catalog": {
          "type": "object",
          "properties": {
            "kind": {
              "const": "accepted-catalog"
            },
            "sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            },
            "bytes": {
              "type": "integer",
              "minimum": 1,
              "maximum": 67108864
            },
            "canonicalization": {
              "const": "SCI-DR-CJSON/1"
            },
            "producer_role": {
              "enum": [
                "workload",
                "adapter",
                "independent-observer"
              ]
            },
            "producer_release_sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            }
          },
          "required": [
            "kind",
            "sha256",
            "bytes",
            "canonicalization",
            "producer_role",
            "producer_release_sha256"
          ],
          "additionalProperties": false
        },
        "required_count": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "accepted_count": {
          "type": "integer",
          "minimum": 0,
          "maximum": 9007199254740991
        },
        "quiescence": {
          "type": "object",
          "properties": {
            "verdict": {
              "const": "QUIESCENT"
            },
            "recursive_cgroup": {
              "type": "object",
              "properties": {
                "kind": {
                  "const": "recursive-cgroup-observation"
                },
                "sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                },
                "bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 67108864
                },
                "canonicalization": {
                  "const": "SCI-DR-CJSON/1"
                },
                "producer_role": {
                  "enum": [
                    "independent-observer"
                  ]
                },
                "producer_release_sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                }
              },
              "required": [
                "kind",
                "sha256",
                "bytes",
                "canonicalization",
                "producer_role",
                "producer_release_sha256"
              ],
              "additionalProperties": false
            },
            "writers": {
              "type": "object",
              "properties": {
                "kind": {
                  "const": "writer-observation"
                },
                "sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                },
                "bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 67108864
                },
                "canonicalization": {
                  "const": "SCI-DR-CJSON/1"
                },
                "producer_role": {
                  "enum": [
                    "independent-observer"
                  ]
                },
                "producer_release_sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                }
              },
              "required": [
                "kind",
                "sha256",
                "bytes",
                "canonicalization",
                "producer_role",
                "producer_release_sha256"
              ],
              "additionalProperties": false
            },
            "writer_count": {
              "const": 0
            },
            "pending_jobs": {
              "const": 0
            },
            "observation_stable": {
              "const": true
            }
          },
          "required": [
            "verdict",
            "recursive_cgroup",
            "writers",
            "writer_count",
            "pending_jobs",
            "observation_stable"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "manifest",
        "validation",
        "accepted_catalog",
        "required_count",
        "accepted_count",
        "quiescence"
      ],
      "additionalProperties": false
    },
    "transaction_receipt": {
      "type": "object",
      "properties": {
        "transaction_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "expected_state_generation": {
          "type": "integer",
          "minimum": 0,
          "maximum": 2147483647
        },
        "result_state_generation": {
          "type": "integer",
          "minimum": 0,
          "maximum": 2147483647
        },
        "intent": {
          "type": "object",
          "properties": {
            "kind": {
              "const": "maintenance-intent"
            },
            "sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            },
            "bytes": {
              "type": "integer",
              "minimum": 1,
              "maximum": 67108864
            },
            "canonicalization": {
              "const": "SCI-DR-CJSON/1"
            },
            "producer_role": {
              "enum": [
                "adapter"
              ]
            },
            "producer_release_sha256": {
              "type": "string",
              "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
              "maxLength": 64
            }
          },
          "required": [
            "kind",
            "sha256",
            "bytes",
            "canonicalization",
            "producer_role",
            "producer_release_sha256"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "transaction_id",
        "expected_state_generation",
        "result_state_generation",
        "intent"
      ],
      "additionalProperties": false
    },
    "artifact": {
      "type": "object",
      "properties": {
        "kind": {
          "enum": [
            "registration-acceptance",
            "source-verification",
            "state-receipt",
            "maintenance-intent",
            "scientific-seal",
            "recursive-cgroup-observation",
            "writer-observation",
            "accepted-catalog",
            "numerical-validation",
            "phase-transition",
            "ready-observation",
            "start-request",
            "resumption-proof",
            "completion-manifest",
            "completion-validation",
            "observation-response"
          ]
        },
        "sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        },
        "bytes": {
          "type": "integer",
          "minimum": 1,
          "maximum": 67108864
        },
        "canonicalization": {
          "const": "SCI-DR-CJSON/1"
        },
        "producer_role": {
          "enum": [
            "release-approver",
            "workload",
            "adapter",
            "independent-observer",
            "recovery-supervisor"
          ]
        },
        "producer_release_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        }
      },
      "required": [
        "kind",
        "sha256",
        "bytes",
        "canonicalization",
        "producer_role",
        "producer_release_sha256"
      ],
      "additionalProperties": false
    }
  },
  "oneOf": [
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "registration": {
          "$ref": "#/$defs/registration"
        },
        "identity": {
          "$ref": "#/$defs/identity"
        },
        "provenance": {
          "$ref": "#/$defs/provenance"
        },
        "observation": {
          "$ref": "#/$defs/observation"
        },
        "transaction_id": {
          "const": null
        },
        "verdict": {
          "const": "PASS"
        },
        "exit_code": {
          "const": 0
        },
        "command": {
          "const": "capabilities"
        },
        "data": {
          "type": "object",
          "properties": {
            "supported_versions": {
              "const": [
                "SCI-DR/1.0.0"
              ]
            },
            "supported_profiles": {
              "const": [
                "production-v1"
              ]
            },
            "commands": {
              "const": [
                "capabilities",
                "status",
                "prepare",
                "ready",
                "resume",
                "verify-completion"
              ]
            },
            "read_only_commands": {
              "const": [
                "capabilities",
                "status",
                "ready",
                "verify-completion"
              ]
            },
            "limits": {
              "type": "object",
              "properties": {
                "clock_domain": {
                  "enum": [
                    "CLOCK_MONOTONIC",
                    "CLOCK_BOOTTIME"
                  ]
                },
                "status_timeout_seconds": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 3600
                },
                "ready_timeout_seconds": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 86400
                },
                "prepare_observation_timeout_seconds": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 3600
                },
                "resume_observation_timeout_seconds": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 3600
                },
                "drain_deadline_seconds": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 604800
                },
                "validation_deadline_seconds": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 604800
                },
                "lock_timeout_seconds": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 60
                },
                "request_max_bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 1048576
                },
                "response_max_bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 1048576
                }
              },
              "required": [
                "clock_domain",
                "status_timeout_seconds",
                "ready_timeout_seconds",
                "prepare_observation_timeout_seconds",
                "resume_observation_timeout_seconds",
                "drain_deadline_seconds",
                "validation_deadline_seconds",
                "lock_timeout_seconds",
                "request_max_bytes",
                "response_max_bytes"
              ],
              "additionalProperties": false
            },
            "registration_status": {
              "const": "accepted"
            },
            "power_authority": {
              "const": "none"
            },
            "budget_authority": {
              "const": "none"
            },
            "numerical_validation_claimed": {
              "const": false
            }
          },
          "required": [
            "supported_versions",
            "supported_profiles",
            "commands",
            "read_only_commands",
            "limits",
            "registration_status",
            "power_authority",
            "budget_authority",
            "numerical_validation_claimed"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "command",
        "data"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "registration": {
          "$ref": "#/$defs/registration"
        },
        "identity": {
          "$ref": "#/$defs/identity"
        },
        "provenance": {
          "$ref": "#/$defs/provenance"
        },
        "observation": {
          "$ref": "#/$defs/observation"
        },
        "transaction_id": {
          "const": null
        },
        "verdict": {
          "const": "PASS"
        },
        "exit_code": {
          "const": 0
        },
        "command": {
          "const": "status"
        },
        "data": {
          "type": "object",
          "properties": {
            "lifecycle": {
              "enum": [
                "starting",
                "validating",
                "running",
                "draining",
                "sealed",
                "resuming",
                "completed",
                "failed",
                "integrity_blocked",
                "unknown"
              ]
            },
            "state": {
              "$ref": "#/$defs/state"
            },
            "execution": {
              "$ref": "#/$defs/execution"
            },
            "scientific_identity_validated": {
              "const": true
            },
            "validation": {
              "$ref": "#/$defs/validation"
            },
            "catalog": {
              "type": "object",
              "properties": {
                "accepted_count": {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 9007199254740991
                },
                "catalog": {
                  "type": "object",
                  "properties": {
                    "kind": {
                      "const": "accepted-catalog"
                    },
                    "sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    },
                    "bytes": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 67108864
                    },
                    "canonicalization": {
                      "const": "SCI-DR-CJSON/1"
                    },
                    "producer_role": {
                      "enum": [
                        "workload",
                        "adapter",
                        "independent-observer"
                      ]
                    },
                    "producer_release_sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    }
                  },
                  "required": [
                    "kind",
                    "sha256",
                    "bytes",
                    "canonicalization",
                    "producer_role",
                    "producer_release_sha256"
                  ],
                  "additionalProperties": false
                }
              },
              "required": [
                "accepted_count",
                "catalog"
              ],
              "additionalProperties": false
            },
            "progress": {
              "$ref": "#/$defs/progress"
            },
            "quiescence": {
              "$ref": "#/$defs/quiescence"
            },
            "maintenance_transaction_id": {
              "anyOf": [
                {
                  "type": "string",
                  "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
                  "maxLength": 96
                },
                {
                  "type": "null"
                }
              ]
            },
            "completion": {
              "anyOf": [
                {
                  "$ref": "#/$defs/completion"
                },
                {
                  "type": "null"
                }
              ]
            },
            "resumption": {
              "$ref": "#/$defs/resumption"
            }
          },
          "required": [
            "lifecycle",
            "state",
            "execution",
            "scientific_identity_validated",
            "validation",
            "catalog",
            "progress",
            "quiescence",
            "maintenance_transaction_id",
            "completion",
            "resumption"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "command",
        "data"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "registration": {
          "$ref": "#/$defs/registration"
        },
        "identity": {
          "$ref": "#/$defs/identity"
        },
        "provenance": {
          "$ref": "#/$defs/provenance"
        },
        "observation": {
          "$ref": "#/$defs/observation"
        },
        "transaction_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "verdict": {
          "const": "PASS"
        },
        "exit_code": {
          "const": 0
        },
        "command": {
          "const": "prepare"
        },
        "data": {
          "type": "object",
          "properties": {
            "result": {
              "enum": [
                "DRAINING",
                "SEALED"
              ]
            },
            "transaction": {
              "$ref": "#/$defs/transaction_receipt"
            },
            "state": {
              "$ref": "#/$defs/state"
            },
            "dispatch_stopped": {
              "const": true
            },
            "pending_work_count": {
              "type": "integer",
              "minimum": 0,
              "maximum": 9007199254740991
            },
            "seal": {
              "anyOf": [
                {
                  "type": "object",
                  "properties": {
                    "kind": {
                      "const": "scientific-seal"
                    },
                    "sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    },
                    "bytes": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 67108864
                    },
                    "canonicalization": {
                      "const": "SCI-DR-CJSON/1"
                    },
                    "producer_role": {
                      "enum": [
                        "workload",
                        "adapter"
                      ]
                    },
                    "producer_release_sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    }
                  },
                  "required": [
                    "kind",
                    "sha256",
                    "bytes",
                    "canonicalization",
                    "producer_role",
                    "producer_release_sha256"
                  ],
                  "additionalProperties": false
                },
                {
                  "type": "null"
                }
              ]
            },
            "quiescence": {
              "$ref": "#/$defs/quiescence"
            },
            "drain_deadline_mono_ns": {
              "type": "string",
              "pattern": "^(0|[1-9][0-9]{0,18})(?![\\s\\S])",
              "maxLength": 19
            }
          },
          "required": [
            "result",
            "transaction",
            "state",
            "dispatch_stopped",
            "pending_work_count",
            "seal",
            "quiescence",
            "drain_deadline_mono_ns"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "command",
        "data"
      ],
      "additionalProperties": false,
      "allOf": [
        {
          "if": {
            "properties": {
              "data": {
                "properties": {
                  "result": {
                    "const": "SEALED"
                  }
                }
              }
            }
          },
          "then": {
            "properties": {
              "data": {
                "properties": {
                  "seal": {
                    "type": "object",
                    "properties": {
                      "kind": {
                        "const": "scientific-seal"
                      },
                      "sha256": {
                        "type": "string",
                        "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                        "maxLength": 64
                      },
                      "bytes": {
                        "type": "integer",
                        "minimum": 1,
                        "maximum": 67108864
                      },
                      "canonicalization": {
                        "const": "SCI-DR-CJSON/1"
                      },
                      "producer_role": {
                        "enum": [
                          "workload",
                          "adapter"
                        ]
                      },
                      "producer_release_sha256": {
                        "type": "string",
                        "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                        "maxLength": 64
                      }
                    },
                    "required": [
                      "kind",
                      "sha256",
                      "bytes",
                      "canonicalization",
                      "producer_role",
                      "producer_release_sha256"
                    ],
                    "additionalProperties": false
                  },
                  "quiescence": {
                    "$ref": "#/$defs/quiet"
                  },
                  "pending_work_count": {
                    "const": 0
                  }
                }
              }
            }
          }
        },
        {
          "if": {
            "properties": {
              "data": {
                "properties": {
                  "result": {
                    "const": "DRAINING"
                  }
                }
              }
            }
          },
          "then": {
            "properties": {
              "data": {
                "properties": {
                  "seal": {
                    "const": null
                  }
                }
              }
            }
          }
        }
      ]
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "registration": {
          "$ref": "#/$defs/registration"
        },
        "identity": {
          "$ref": "#/$defs/identity"
        },
        "provenance": {
          "$ref": "#/$defs/provenance"
        },
        "observation": {
          "$ref": "#/$defs/observation"
        },
        "transaction_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "verdict": {
          "const": "PASS"
        },
        "exit_code": {
          "const": 0
        },
        "command": {
          "const": "ready"
        },
        "data": {
          "type": "object",
          "properties": {
            "result": {
              "const": "READY_OBSERVED"
            },
            "transaction_id": {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            "state": {
              "$ref": "#/$defs/state"
            },
            "seal": {
              "type": "object",
              "properties": {
                "kind": {
                  "const": "scientific-seal"
                },
                "sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                },
                "bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 67108864
                },
                "canonicalization": {
                  "const": "SCI-DR-CJSON/1"
                },
                "producer_role": {
                  "enum": [
                    "workload",
                    "adapter"
                  ]
                },
                "producer_release_sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                }
              },
              "required": [
                "kind",
                "sha256",
                "bytes",
                "canonicalization",
                "producer_role",
                "producer_release_sha256"
              ],
              "additionalProperties": false
            },
            "validation": {
              "type": "object",
              "properties": {
                "kind": {
                  "const": "numerical-validation"
                },
                "sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                },
                "bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 67108864
                },
                "canonicalization": {
                  "const": "SCI-DR-CJSON/1"
                },
                "producer_role": {
                  "enum": [
                    "independent-observer"
                  ]
                },
                "producer_release_sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                }
              },
              "required": [
                "kind",
                "sha256",
                "bytes",
                "canonicalization",
                "producer_role",
                "producer_release_sha256"
              ],
              "additionalProperties": false
            },
            "catalog": {
              "type": "object",
              "properties": {
                "accepted_count": {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 9007199254740991
                },
                "catalog": {
                  "type": "object",
                  "properties": {
                    "kind": {
                      "const": "accepted-catalog"
                    },
                    "sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    },
                    "bytes": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 67108864
                    },
                    "canonicalization": {
                      "const": "SCI-DR-CJSON/1"
                    },
                    "producer_role": {
                      "enum": [
                        "workload",
                        "adapter",
                        "independent-observer"
                      ]
                    },
                    "producer_release_sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    }
                  },
                  "required": [
                    "kind",
                    "sha256",
                    "bytes",
                    "canonicalization",
                    "producer_role",
                    "producer_release_sha256"
                  ],
                  "additionalProperties": false
                }
              },
              "required": [
                "accepted_count",
                "catalog"
              ],
              "additionalProperties": false
            },
            "quiescence": {
              "$ref": "#/$defs/quiet"
            },
            "ready_observation": {
              "type": "object",
              "properties": {
                "kind": {
                  "const": "ready-observation"
                },
                "sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                },
                "bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 67108864
                },
                "canonicalization": {
                  "const": "SCI-DR-CJSON/1"
                },
                "producer_role": {
                  "enum": [
                    "independent-observer"
                  ]
                },
                "producer_release_sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                }
              },
              "required": [
                "kind",
                "sha256",
                "bytes",
                "canonicalization",
                "producer_role",
                "producer_release_sha256"
              ],
              "additionalProperties": false
            },
            "valid_until_mono_ns": {
              "type": "string",
              "pattern": "^(0|[1-9][0-9]{0,18})(?![\\s\\S])",
              "maxLength": 19
            },
            "power_authorization": {
              "const": false
            }
          },
          "required": [
            "result",
            "transaction_id",
            "state",
            "seal",
            "validation",
            "catalog",
            "quiescence",
            "ready_observation",
            "valid_until_mono_ns",
            "power_authorization"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "command",
        "data"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "registration": {
          "$ref": "#/$defs/registration"
        },
        "identity": {
          "$ref": "#/$defs/identity"
        },
        "provenance": {
          "$ref": "#/$defs/provenance"
        },
        "observation": {
          "$ref": "#/$defs/observation"
        },
        "transaction_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "verdict": {
          "const": "PASS"
        },
        "exit_code": {
          "const": 0
        },
        "command": {
          "const": "resume"
        },
        "data": {
          "type": "object",
          "properties": {
            "result": {
              "const": "START_REQUESTED"
            },
            "transaction": {
              "$ref": "#/$defs/transaction_receipt"
            },
            "state": {
              "$ref": "#/$defs/state"
            },
            "start_request": {
              "type": "object",
              "properties": {
                "kind": {
                  "const": "start-request"
                },
                "sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                },
                "bytes": {
                  "type": "integer",
                  "minimum": 1,
                  "maximum": 67108864
                },
                "canonicalization": {
                  "const": "SCI-DR-CJSON/1"
                },
                "producer_role": {
                  "enum": [
                    "adapter"
                  ]
                },
                "producer_release_sha256": {
                  "type": "string",
                  "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                  "maxLength": 64
                }
              },
              "required": [
                "kind",
                "sha256",
                "bytes",
                "canonicalization",
                "producer_role",
                "producer_release_sha256"
              ],
              "additionalProperties": false
            },
            "execution": {
              "anyOf": [
                {
                  "$ref": "#/$defs/execution"
                },
                {
                  "type": "null"
                }
              ]
            },
            "recovery_proven": {
              "const": false
            },
            "required_followup": {
              "const": "status-or-verify-completion"
            }
          },
          "required": [
            "result",
            "transaction",
            "state",
            "start_request",
            "execution",
            "recovery_proven",
            "required_followup"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "command",
        "data"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "type": "string",
          "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
          "maxLength": 96
        },
        "nonce": {
          "type": "string",
          "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
          "maxLength": 32
        },
        "registration": {
          "$ref": "#/$defs/registration"
        },
        "identity": {
          "$ref": "#/$defs/identity"
        },
        "provenance": {
          "$ref": "#/$defs/provenance"
        },
        "observation": {
          "$ref": "#/$defs/observation"
        },
        "transaction_id": {
          "const": null
        },
        "verdict": {
          "const": "PASS"
        },
        "exit_code": {
          "const": 0
        },
        "command": {
          "const": "verify-completion"
        },
        "data": {
          "type": "object",
          "properties": {
            "result": {
              "const": "COMPLETE_VERIFIED"
            },
            "state": {
              "$ref": "#/$defs/state"
            },
            "scientific_identity_validated": {
              "const": true
            },
            "completion": {
              "$ref": "#/$defs/completion"
            },
            "power_authorization": {
              "const": false
            }
          },
          "required": [
            "result",
            "state",
            "scientific_identity_validated",
            "completion",
            "power_authorization"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "command",
        "data"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "nonce": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
              "maxLength": 32
            },
            {
              "type": "null"
            }
          ]
        },
        "command": {
          "enum": [
            "capabilities",
            "status",
            "prepare",
            "ready",
            "resume",
            "verify-completion",
            "invalid"
          ]
        },
        "registration": {
          "anyOf": [
            {
              "$ref": "#/$defs/registration"
            },
            {
              "type": "null"
            }
          ]
        },
        "identity": {
          "anyOf": [
            {
              "$ref": "#/$defs/identity"
            },
            {
              "type": "null"
            }
          ]
        },
        "provenance": {
          "anyOf": [
            {
              "$ref": "#/$defs/provenance"
            },
            {
              "type": "null"
            }
          ]
        },
        "observation": {
          "anyOf": [
            {
              "$ref": "#/$defs/observation"
            },
            {
              "type": "null"
            }
          ]
        },
        "transaction_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "verdict": {
          "const": "REFUSED"
        },
        "exit_code": {
          "const": 20
        },
        "error": {
          "type": "object",
          "properties": {
            "reason_code": {
              "enum": [
                "UNSUPPORTED_VERSION",
                "UNSUPPORTED_PROFILE",
                "MALFORMED_JSON",
                "DUPLICATE_KEY",
                "SCHEMA_VIOLATION",
                "SIZE_LIMIT",
                "REGISTRATION_NOT_ACCEPTED",
                "REGISTRATION_MISMATCH",
                "SOURCE_MISMATCH",
                "IDENTITY_MISMATCH",
                "AUTHORIZATION_MISSING",
                "AUTHORIZATION_INVALID",
                "INTEGRITY_FAILURE",
                "EVIDENCE_STALE",
                "EVIDENCE_UNREADABLE",
                "CLOCK_DOMAIN_MISMATCH",
                "BOOT_CHANGED",
                "REQUEST_EXPIRED",
                "GENERATION_MISMATCH",
                "REQUEST_REPLAY_CONFLICT",
                "TRANSACTION_CONFLICT",
                "LOCK_BUSY",
                "NOT_SEALED",
                "WRITERS_PRESENT",
                "PENDING_JOBS",
                "NOT_COMPLETE",
                "PREPARE_DEADLINE",
                "VALIDATION_PENDING",
                "OBSERVER_FAILURE",
                "DURABILITY_UNCERTAIN",
                "IO_FAILURE"
              ]
            },
            "message": {
              "type": "string",
              "minLength": 1,
              "maxLength": 512,
              "pattern": "^[^\\u0000\\r\\n]*(?![\\s\\S])"
            },
            "current_state_generation": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 2147483647
                },
                {
                  "type": "null"
                }
              ]
            },
            "retry": {
              "enum": [
                "NO_AUTOMATIC_RETRY",
                "FRESH_OBSERVATION",
                "SAME_MUTATION_IDENTITY"
              ]
            },
            "mutation_state": {
              "enum": [
                "NONE",
                "UNCHANGED",
                "INTENT_DURABLE",
                "STATE_ADVANCED",
                "OUTCOME_UNKNOWN"
              ]
            },
            "receipt": {
              "anyOf": [
                {
                  "type": "object",
                  "properties": {
                    "kind": {
                      "const": "state-receipt"
                    },
                    "sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    },
                    "bytes": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 67108864
                    },
                    "canonicalization": {
                      "const": "SCI-DR-CJSON/1"
                    },
                    "producer_role": {
                      "enum": [
                        "adapter"
                      ]
                    },
                    "producer_release_sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    }
                  },
                  "required": [
                    "kind",
                    "sha256",
                    "bytes",
                    "canonicalization",
                    "producer_role",
                    "producer_release_sha256"
                  ],
                  "additionalProperties": false
                },
                {
                  "type": "null"
                }
              ]
            }
          },
          "required": [
            "reason_code",
            "message",
            "current_state_generation",
            "retry",
            "mutation_state",
            "receipt"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "command",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "error"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "nonce": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
              "maxLength": 32
            },
            {
              "type": "null"
            }
          ]
        },
        "command": {
          "enum": [
            "capabilities",
            "status",
            "prepare",
            "ready",
            "resume",
            "verify-completion",
            "invalid"
          ]
        },
        "registration": {
          "anyOf": [
            {
              "$ref": "#/$defs/registration"
            },
            {
              "type": "null"
            }
          ]
        },
        "identity": {
          "anyOf": [
            {
              "$ref": "#/$defs/identity"
            },
            {
              "type": "null"
            }
          ]
        },
        "provenance": {
          "anyOf": [
            {
              "$ref": "#/$defs/provenance"
            },
            {
              "type": "null"
            }
          ]
        },
        "observation": {
          "anyOf": [
            {
              "$ref": "#/$defs/observation"
            },
            {
              "type": "null"
            }
          ]
        },
        "transaction_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "verdict": {
          "const": "STALE"
        },
        "exit_code": {
          "const": 21
        },
        "error": {
          "type": "object",
          "properties": {
            "reason_code": {
              "enum": [
                "UNSUPPORTED_VERSION",
                "UNSUPPORTED_PROFILE",
                "MALFORMED_JSON",
                "DUPLICATE_KEY",
                "SCHEMA_VIOLATION",
                "SIZE_LIMIT",
                "REGISTRATION_NOT_ACCEPTED",
                "REGISTRATION_MISMATCH",
                "SOURCE_MISMATCH",
                "IDENTITY_MISMATCH",
                "AUTHORIZATION_MISSING",
                "AUTHORIZATION_INVALID",
                "INTEGRITY_FAILURE",
                "EVIDENCE_STALE",
                "EVIDENCE_UNREADABLE",
                "CLOCK_DOMAIN_MISMATCH",
                "BOOT_CHANGED",
                "REQUEST_EXPIRED",
                "GENERATION_MISMATCH",
                "REQUEST_REPLAY_CONFLICT",
                "TRANSACTION_CONFLICT",
                "LOCK_BUSY",
                "NOT_SEALED",
                "WRITERS_PRESENT",
                "PENDING_JOBS",
                "NOT_COMPLETE",
                "PREPARE_DEADLINE",
                "VALIDATION_PENDING",
                "OBSERVER_FAILURE",
                "DURABILITY_UNCERTAIN",
                "IO_FAILURE"
              ]
            },
            "message": {
              "type": "string",
              "minLength": 1,
              "maxLength": 512,
              "pattern": "^[^\\u0000\\r\\n]*(?![\\s\\S])"
            },
            "current_state_generation": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 2147483647
                },
                {
                  "type": "null"
                }
              ]
            },
            "retry": {
              "enum": [
                "NO_AUTOMATIC_RETRY",
                "FRESH_OBSERVATION",
                "SAME_MUTATION_IDENTITY"
              ]
            },
            "mutation_state": {
              "enum": [
                "NONE",
                "UNCHANGED",
                "INTENT_DURABLE",
                "STATE_ADVANCED",
                "OUTCOME_UNKNOWN"
              ]
            },
            "receipt": {
              "anyOf": [
                {
                  "type": "object",
                  "properties": {
                    "kind": {
                      "const": "state-receipt"
                    },
                    "sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    },
                    "bytes": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 67108864
                    },
                    "canonicalization": {
                      "const": "SCI-DR-CJSON/1"
                    },
                    "producer_role": {
                      "enum": [
                        "adapter"
                      ]
                    },
                    "producer_release_sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    }
                  },
                  "required": [
                    "kind",
                    "sha256",
                    "bytes",
                    "canonicalization",
                    "producer_role",
                    "producer_release_sha256"
                  ],
                  "additionalProperties": false
                },
                {
                  "type": "null"
                }
              ]
            }
          },
          "required": [
            "reason_code",
            "message",
            "current_state_generation",
            "retry",
            "mutation_state",
            "receipt"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "command",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "error"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "nonce": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
              "maxLength": 32
            },
            {
              "type": "null"
            }
          ]
        },
        "command": {
          "enum": [
            "capabilities",
            "status",
            "prepare",
            "ready",
            "resume",
            "verify-completion",
            "invalid"
          ]
        },
        "registration": {
          "anyOf": [
            {
              "$ref": "#/$defs/registration"
            },
            {
              "type": "null"
            }
          ]
        },
        "identity": {
          "anyOf": [
            {
              "$ref": "#/$defs/identity"
            },
            {
              "type": "null"
            }
          ]
        },
        "provenance": {
          "anyOf": [
            {
              "$ref": "#/$defs/provenance"
            },
            {
              "type": "null"
            }
          ]
        },
        "observation": {
          "anyOf": [
            {
              "$ref": "#/$defs/observation"
            },
            {
              "type": "null"
            }
          ]
        },
        "transaction_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "verdict": {
          "const": "INTEGRITY_BLOCKED"
        },
        "exit_code": {
          "const": 22
        },
        "error": {
          "type": "object",
          "properties": {
            "reason_code": {
              "enum": [
                "UNSUPPORTED_VERSION",
                "UNSUPPORTED_PROFILE",
                "MALFORMED_JSON",
                "DUPLICATE_KEY",
                "SCHEMA_VIOLATION",
                "SIZE_LIMIT",
                "REGISTRATION_NOT_ACCEPTED",
                "REGISTRATION_MISMATCH",
                "SOURCE_MISMATCH",
                "IDENTITY_MISMATCH",
                "AUTHORIZATION_MISSING",
                "AUTHORIZATION_INVALID",
                "INTEGRITY_FAILURE",
                "EVIDENCE_STALE",
                "EVIDENCE_UNREADABLE",
                "CLOCK_DOMAIN_MISMATCH",
                "BOOT_CHANGED",
                "REQUEST_EXPIRED",
                "GENERATION_MISMATCH",
                "REQUEST_REPLAY_CONFLICT",
                "TRANSACTION_CONFLICT",
                "LOCK_BUSY",
                "NOT_SEALED",
                "WRITERS_PRESENT",
                "PENDING_JOBS",
                "NOT_COMPLETE",
                "PREPARE_DEADLINE",
                "VALIDATION_PENDING",
                "OBSERVER_FAILURE",
                "DURABILITY_UNCERTAIN",
                "IO_FAILURE"
              ]
            },
            "message": {
              "type": "string",
              "minLength": 1,
              "maxLength": 512,
              "pattern": "^[^\\u0000\\r\\n]*(?![\\s\\S])"
            },
            "current_state_generation": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 2147483647
                },
                {
                  "type": "null"
                }
              ]
            },
            "retry": {
              "enum": [
                "NO_AUTOMATIC_RETRY",
                "FRESH_OBSERVATION",
                "SAME_MUTATION_IDENTITY"
              ]
            },
            "mutation_state": {
              "enum": [
                "NONE",
                "UNCHANGED",
                "INTENT_DURABLE",
                "STATE_ADVANCED",
                "OUTCOME_UNKNOWN"
              ]
            },
            "receipt": {
              "anyOf": [
                {
                  "type": "object",
                  "properties": {
                    "kind": {
                      "const": "state-receipt"
                    },
                    "sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    },
                    "bytes": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 67108864
                    },
                    "canonicalization": {
                      "const": "SCI-DR-CJSON/1"
                    },
                    "producer_role": {
                      "enum": [
                        "adapter"
                      ]
                    },
                    "producer_release_sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    }
                  },
                  "required": [
                    "kind",
                    "sha256",
                    "bytes",
                    "canonicalization",
                    "producer_role",
                    "producer_release_sha256"
                  ],
                  "additionalProperties": false
                },
                {
                  "type": "null"
                }
              ]
            }
          },
          "required": [
            "reason_code",
            "message",
            "current_state_generation",
            "retry",
            "mutation_state",
            "receipt"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "command",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "error"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "nonce": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
              "maxLength": 32
            },
            {
              "type": "null"
            }
          ]
        },
        "command": {
          "enum": [
            "capabilities",
            "status",
            "prepare",
            "ready",
            "resume",
            "verify-completion",
            "invalid"
          ]
        },
        "registration": {
          "anyOf": [
            {
              "$ref": "#/$defs/registration"
            },
            {
              "type": "null"
            }
          ]
        },
        "identity": {
          "anyOf": [
            {
              "$ref": "#/$defs/identity"
            },
            {
              "type": "null"
            }
          ]
        },
        "provenance": {
          "anyOf": [
            {
              "$ref": "#/$defs/provenance"
            },
            {
              "type": "null"
            }
          ]
        },
        "observation": {
          "anyOf": [
            {
              "$ref": "#/$defs/observation"
            },
            {
              "type": "null"
            }
          ]
        },
        "transaction_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "verdict": {
          "const": "CONFLICT"
        },
        "exit_code": {
          "const": 23
        },
        "error": {
          "type": "object",
          "properties": {
            "reason_code": {
              "enum": [
                "UNSUPPORTED_VERSION",
                "UNSUPPORTED_PROFILE",
                "MALFORMED_JSON",
                "DUPLICATE_KEY",
                "SCHEMA_VIOLATION",
                "SIZE_LIMIT",
                "REGISTRATION_NOT_ACCEPTED",
                "REGISTRATION_MISMATCH",
                "SOURCE_MISMATCH",
                "IDENTITY_MISMATCH",
                "AUTHORIZATION_MISSING",
                "AUTHORIZATION_INVALID",
                "INTEGRITY_FAILURE",
                "EVIDENCE_STALE",
                "EVIDENCE_UNREADABLE",
                "CLOCK_DOMAIN_MISMATCH",
                "BOOT_CHANGED",
                "REQUEST_EXPIRED",
                "GENERATION_MISMATCH",
                "REQUEST_REPLAY_CONFLICT",
                "TRANSACTION_CONFLICT",
                "LOCK_BUSY",
                "NOT_SEALED",
                "WRITERS_PRESENT",
                "PENDING_JOBS",
                "NOT_COMPLETE",
                "PREPARE_DEADLINE",
                "VALIDATION_PENDING",
                "OBSERVER_FAILURE",
                "DURABILITY_UNCERTAIN",
                "IO_FAILURE"
              ]
            },
            "message": {
              "type": "string",
              "minLength": 1,
              "maxLength": 512,
              "pattern": "^[^\\u0000\\r\\n]*(?![\\s\\S])"
            },
            "current_state_generation": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 2147483647
                },
                {
                  "type": "null"
                }
              ]
            },
            "retry": {
              "enum": [
                "NO_AUTOMATIC_RETRY",
                "FRESH_OBSERVATION",
                "SAME_MUTATION_IDENTITY"
              ]
            },
            "mutation_state": {
              "enum": [
                "NONE",
                "UNCHANGED",
                "INTENT_DURABLE",
                "STATE_ADVANCED",
                "OUTCOME_UNKNOWN"
              ]
            },
            "receipt": {
              "anyOf": [
                {
                  "type": "object",
                  "properties": {
                    "kind": {
                      "const": "state-receipt"
                    },
                    "sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    },
                    "bytes": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 67108864
                    },
                    "canonicalization": {
                      "const": "SCI-DR-CJSON/1"
                    },
                    "producer_role": {
                      "enum": [
                        "adapter"
                      ]
                    },
                    "producer_release_sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    }
                  },
                  "required": [
                    "kind",
                    "sha256",
                    "bytes",
                    "canonicalization",
                    "producer_role",
                    "producer_release_sha256"
                  ],
                  "additionalProperties": false
                },
                {
                  "type": "null"
                }
              ]
            }
          },
          "required": [
            "reason_code",
            "message",
            "current_state_generation",
            "retry",
            "mutation_state",
            "receipt"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "command",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "error"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "nonce": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
              "maxLength": 32
            },
            {
              "type": "null"
            }
          ]
        },
        "command": {
          "enum": [
            "capabilities",
            "status",
            "prepare",
            "ready",
            "resume",
            "verify-completion",
            "invalid"
          ]
        },
        "registration": {
          "anyOf": [
            {
              "$ref": "#/$defs/registration"
            },
            {
              "type": "null"
            }
          ]
        },
        "identity": {
          "anyOf": [
            {
              "$ref": "#/$defs/identity"
            },
            {
              "type": "null"
            }
          ]
        },
        "provenance": {
          "anyOf": [
            {
              "$ref": "#/$defs/provenance"
            },
            {
              "type": "null"
            }
          ]
        },
        "observation": {
          "anyOf": [
            {
              "$ref": "#/$defs/observation"
            },
            {
              "type": "null"
            }
          ]
        },
        "transaction_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "verdict": {
          "const": "INVALID_REQUEST"
        },
        "exit_code": {
          "const": 64
        },
        "error": {
          "type": "object",
          "properties": {
            "reason_code": {
              "enum": [
                "UNSUPPORTED_VERSION",
                "UNSUPPORTED_PROFILE",
                "MALFORMED_JSON",
                "DUPLICATE_KEY",
                "SCHEMA_VIOLATION",
                "SIZE_LIMIT",
                "REGISTRATION_NOT_ACCEPTED",
                "REGISTRATION_MISMATCH",
                "SOURCE_MISMATCH",
                "IDENTITY_MISMATCH",
                "AUTHORIZATION_MISSING",
                "AUTHORIZATION_INVALID",
                "INTEGRITY_FAILURE",
                "EVIDENCE_STALE",
                "EVIDENCE_UNREADABLE",
                "CLOCK_DOMAIN_MISMATCH",
                "BOOT_CHANGED",
                "REQUEST_EXPIRED",
                "GENERATION_MISMATCH",
                "REQUEST_REPLAY_CONFLICT",
                "TRANSACTION_CONFLICT",
                "LOCK_BUSY",
                "NOT_SEALED",
                "WRITERS_PRESENT",
                "PENDING_JOBS",
                "NOT_COMPLETE",
                "PREPARE_DEADLINE",
                "VALIDATION_PENDING",
                "OBSERVER_FAILURE",
                "DURABILITY_UNCERTAIN",
                "IO_FAILURE"
              ]
            },
            "message": {
              "type": "string",
              "minLength": 1,
              "maxLength": 512,
              "pattern": "^[^\\u0000\\r\\n]*(?![\\s\\S])"
            },
            "current_state_generation": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 2147483647
                },
                {
                  "type": "null"
                }
              ]
            },
            "retry": {
              "enum": [
                "NO_AUTOMATIC_RETRY",
                "FRESH_OBSERVATION",
                "SAME_MUTATION_IDENTITY"
              ]
            },
            "mutation_state": {
              "enum": [
                "NONE",
                "UNCHANGED",
                "INTENT_DURABLE",
                "STATE_ADVANCED",
                "OUTCOME_UNKNOWN"
              ]
            },
            "receipt": {
              "anyOf": [
                {
                  "type": "object",
                  "properties": {
                    "kind": {
                      "const": "state-receipt"
                    },
                    "sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    },
                    "bytes": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 67108864
                    },
                    "canonicalization": {
                      "const": "SCI-DR-CJSON/1"
                    },
                    "producer_role": {
                      "enum": [
                        "adapter"
                      ]
                    },
                    "producer_release_sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    }
                  },
                  "required": [
                    "kind",
                    "sha256",
                    "bytes",
                    "canonicalization",
                    "producer_role",
                    "producer_release_sha256"
                  ],
                  "additionalProperties": false
                },
                {
                  "type": "null"
                }
              ]
            }
          },
          "required": [
            "reason_code",
            "message",
            "current_state_generation",
            "retry",
            "mutation_state",
            "receipt"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "command",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "error"
      ],
      "additionalProperties": false
    },
    {
      "type": "object",
      "properties": {
        "api_version": {
          "const": "SCI-DR/1.0.0"
        },
        "profile_id": {
          "const": "production-v1"
        },
        "simulation_only": {
          "const": false
        },
        "request_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "nonce": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[a-f0-9]{32}(?![\\s\\S])",
              "maxLength": 32
            },
            {
              "type": "null"
            }
          ]
        },
        "command": {
          "enum": [
            "capabilities",
            "status",
            "prepare",
            "ready",
            "resume",
            "verify-completion",
            "invalid"
          ]
        },
        "registration": {
          "anyOf": [
            {
              "$ref": "#/$defs/registration"
            },
            {
              "type": "null"
            }
          ]
        },
        "identity": {
          "anyOf": [
            {
              "$ref": "#/$defs/identity"
            },
            {
              "type": "null"
            }
          ]
        },
        "provenance": {
          "anyOf": [
            {
              "$ref": "#/$defs/provenance"
            },
            {
              "type": "null"
            }
          ]
        },
        "observation": {
          "anyOf": [
            {
              "$ref": "#/$defs/observation"
            },
            {
              "type": "null"
            }
          ]
        },
        "transaction_id": {
          "anyOf": [
            {
              "type": "string",
              "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
              "maxLength": 96
            },
            {
              "type": "null"
            }
          ]
        },
        "verdict": {
          "const": "IO_UNKNOWN"
        },
        "exit_code": {
          "const": 74
        },
        "error": {
          "type": "object",
          "properties": {
            "reason_code": {
              "enum": [
                "UNSUPPORTED_VERSION",
                "UNSUPPORTED_PROFILE",
                "MALFORMED_JSON",
                "DUPLICATE_KEY",
                "SCHEMA_VIOLATION",
                "SIZE_LIMIT",
                "REGISTRATION_NOT_ACCEPTED",
                "REGISTRATION_MISMATCH",
                "SOURCE_MISMATCH",
                "IDENTITY_MISMATCH",
                "AUTHORIZATION_MISSING",
                "AUTHORIZATION_INVALID",
                "INTEGRITY_FAILURE",
                "EVIDENCE_STALE",
                "EVIDENCE_UNREADABLE",
                "CLOCK_DOMAIN_MISMATCH",
                "BOOT_CHANGED",
                "REQUEST_EXPIRED",
                "GENERATION_MISMATCH",
                "REQUEST_REPLAY_CONFLICT",
                "TRANSACTION_CONFLICT",
                "LOCK_BUSY",
                "NOT_SEALED",
                "WRITERS_PRESENT",
                "PENDING_JOBS",
                "NOT_COMPLETE",
                "PREPARE_DEADLINE",
                "VALIDATION_PENDING",
                "OBSERVER_FAILURE",
                "DURABILITY_UNCERTAIN",
                "IO_FAILURE"
              ]
            },
            "message": {
              "type": "string",
              "minLength": 1,
              "maxLength": 512,
              "pattern": "^[^\\u0000\\r\\n]*(?![\\s\\S])"
            },
            "current_state_generation": {
              "anyOf": [
                {
                  "type": "integer",
                  "minimum": 0,
                  "maximum": 2147483647
                },
                {
                  "type": "null"
                }
              ]
            },
            "retry": {
              "enum": [
                "NO_AUTOMATIC_RETRY",
                "FRESH_OBSERVATION",
                "SAME_MUTATION_IDENTITY"
              ]
            },
            "mutation_state": {
              "enum": [
                "NONE",
                "UNCHANGED",
                "INTENT_DURABLE",
                "STATE_ADVANCED",
                "OUTCOME_UNKNOWN"
              ]
            },
            "receipt": {
              "anyOf": [
                {
                  "type": "object",
                  "properties": {
                    "kind": {
                      "const": "state-receipt"
                    },
                    "sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    },
                    "bytes": {
                      "type": "integer",
                      "minimum": 1,
                      "maximum": 67108864
                    },
                    "canonicalization": {
                      "const": "SCI-DR-CJSON/1"
                    },
                    "producer_role": {
                      "enum": [
                        "adapter"
                      ]
                    },
                    "producer_release_sha256": {
                      "type": "string",
                      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
                      "maxLength": 64
                    }
                  },
                  "required": [
                    "kind",
                    "sha256",
                    "bytes",
                    "canonicalization",
                    "producer_role",
                    "producer_release_sha256"
                  ],
                  "additionalProperties": false
                },
                {
                  "type": "null"
                }
              ]
            }
          },
          "required": [
            "reason_code",
            "message",
            "current_state_generation",
            "retry",
            "mutation_state",
            "receipt"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "api_version",
        "profile_id",
        "simulation_only",
        "request_id",
        "nonce",
        "command",
        "registration",
        "identity",
        "provenance",
        "observation",
        "transaction_id",
        "verdict",
        "exit_code",
        "error"
      ],
      "additionalProperties": false
    }
  ]
}

12,320 bytes · SHA-256 80198dbc97800b5f535eaa5655e432cf87fdc813e14829935c0dcdaa1252f9cf

{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "urn:sci-dr:1.0.0:registration",
  "type": "object",
  "properties": {
    "schema": {
      "const": "SCI-DR-REGISTRATION/1.0.0"
    },
    "deployment_status": {
      "enum": [
        "design-example",
        "candidate",
        "accepted"
      ]
    },
    "registration_id": {
      "type": "string",
      "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
      "maxLength": 96
    },
    "generation": {
      "type": "integer",
      "minimum": 1,
      "maximum": 2147483647
    },
    "api_version": {
      "const": "SCI-DR/1.0.0"
    },
    "profile_id": {
      "type": "string",
      "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
      "maxLength": 96
    },
    "approval_record_sha256": {
      "type": "string",
      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
      "maxLength": 64
    },
    "stage_id": {
      "type": "string",
      "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
      "maxLength": 96
    },
    "run_id": {
      "type": "string",
      "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
      "maxLength": 96
    },
    "code_sha256": {
      "type": "string",
      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
      "maxLength": 64
    },
    "parameters_sha256": {
      "type": "string",
      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
      "maxLength": 64
    },
    "inputs_sha256": {
      "type": "string",
      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
      "maxLength": 64
    },
    "output_schema": {
      "type": "string",
      "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
      "maxLength": 96
    },
    "validation_profile_sha256": {
      "type": "string",
      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
      "maxLength": 64
    },
    "adapter_release_sha256": {
      "type": "string",
      "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
      "maxLength": 64
    },
    "platform": {
      "type": "object",
      "properties": {
        "distribution": {
          "type": "string",
          "minLength": 1,
          "maxLength": 512
        },
        "systemd_version": {
          "type": "string",
          "minLength": 1,
          "maxLength": 512
        },
        "python_version": {
          "type": "string",
          "minLength": 1,
          "maxLength": 512
        },
        "kernel_version": {
          "type": "string",
          "minLength": 1,
          "maxLength": 512
        },
        "cgroup_mode": {
          "const": "v2-domain"
        },
        "filesystem_profile_sha256": {
          "type": "string",
          "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
          "maxLength": 64
        },
        "failure_model": {
          "type": "array",
          "items": {
            "type": "string",
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
            "maxLength": 96
          },
          "minItems": 1,
          "maxItems": 256,
          "uniqueItems": true
        }
      },
      "required": [
        "distribution",
        "systemd_version",
        "python_version",
        "kernel_version",
        "cgroup_mode",
        "filesystem_profile_sha256",
        "failure_model"
      ],
      "additionalProperties": false
    },
    "execution": {
      "type": "object",
      "properties": {
        "uid": {
          "type": "integer",
          "minimum": 0,
          "maximum": 2147483647
        },
        "gid": {
          "type": "integer",
          "minimum": 0,
          "maximum": 2147483647
        },
        "service_unit": {
          "type": "string",
          "pattern": "^[A-Za-z0-9_.@:-]+\\.service(?![\\s\\S])",
          "maxLength": 128
        },
        "adapter_absolute_path": {
          "type": "string",
          "pattern": "^/[^\\u0000\\r\\n]+(?![\\s\\S])",
          "maxLength": 1024
        },
        "working_directory": {
          "type": "string",
          "pattern": "^/[^\\u0000\\r\\n]*(?![\\s\\S])",
          "maxLength": 1024
        },
        "cgroup_relative_path": {
          "type": "string",
          "minLength": 1,
          "maxLength": 512
        },
        "output_root": {
          "type": "string",
          "pattern": "^/[^\\u0000\\r\\n]+(?![\\s\\S])",
          "maxLength": 1024
        },
        "state_root": {
          "type": "string",
          "pattern": "^/[^\\u0000\\r\\n]+(?![\\s\\S])",
          "maxLength": 1024
        },
        "writer_units": {
          "type": "array",
          "items": {
            "type": "string",
            "pattern": "^[A-Za-z0-9_.@:-]+\\.service(?![\\s\\S])",
            "maxLength": 128
          },
          "minItems": 1,
          "maxItems": 256,
          "uniqueItems": true
        },
        "environment": {
          "type": "object",
          "properties": {
            "LANG": {
              "const": "C.UTF-8"
            },
            "LC_ALL": {
              "const": "C.UTF-8"
            },
            "PYTHONNOUSERSITE": {
              "const": "1"
            },
            "PYTHONDONTWRITEBYTECODE": {
              "const": "1"
            },
            "PATH": {
              "const": "/usr/sbin:/usr/bin:/sbin:/bin"
            }
          },
          "required": [
            "LANG",
            "LC_ALL",
            "PYTHONNOUSERSITE",
            "PYTHONDONTWRITEBYTECODE",
            "PATH"
          ],
          "additionalProperties": false
        }
      },
      "required": [
        "uid",
        "gid",
        "service_unit",
        "adapter_absolute_path",
        "working_directory",
        "cgroup_relative_path",
        "output_root",
        "state_root",
        "writer_units",
        "environment"
      ],
      "additionalProperties": false
    },
    "phase_profiles": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "phase_id": {
            "type": "string",
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
            "maxLength": 96
          },
          "batch_id": {
            "type": "string",
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
            "maxLength": 96
          },
          "work_unit": {
            "type": "string",
            "minLength": 1,
            "maxLength": 512
          },
          "expected_total": {
            "type": "integer",
            "minimum": 1,
            "maximum": 9007199254740991
          },
          "progress_age_limit_seconds": {
            "type": "integer",
            "minimum": 1,
            "maximum": 86400
          },
          "progress_gap_limit_seconds": {
            "type": "integer",
            "minimum": 1,
            "maximum": 86400
          },
          "max_task_seconds": {
            "type": "integer",
            "minimum": 1,
            "maximum": 604800
          },
          "internal_milestone_policy": {
            "type": "string",
            "minLength": 1,
            "maxLength": 2048
          }
        },
        "required": [
          "phase_id",
          "batch_id",
          "work_unit",
          "expected_total",
          "progress_age_limit_seconds",
          "progress_gap_limit_seconds",
          "max_task_seconds",
          "internal_milestone_policy"
        ],
        "additionalProperties": false
      },
      "minItems": 1,
      "maxItems": 256,
      "uniqueItems": true
    },
    "limits": {
      "type": "object",
      "properties": {
        "clock_domain": {
          "enum": [
            "CLOCK_MONOTONIC",
            "CLOCK_BOOTTIME"
          ]
        },
        "status_timeout_seconds": {
          "type": "integer",
          "minimum": 1,
          "maximum": 3600
        },
        "ready_timeout_seconds": {
          "type": "integer",
          "minimum": 1,
          "maximum": 86400
        },
        "prepare_observation_timeout_seconds": {
          "type": "integer",
          "minimum": 1,
          "maximum": 3600
        },
        "resume_observation_timeout_seconds": {
          "type": "integer",
          "minimum": 1,
          "maximum": 3600
        },
        "drain_deadline_seconds": {
          "type": "integer",
          "minimum": 1,
          "maximum": 604800
        },
        "validation_deadline_seconds": {
          "type": "integer",
          "minimum": 1,
          "maximum": 604800
        },
        "lock_timeout_seconds": {
          "type": "integer",
          "minimum": 1,
          "maximum": 60
        },
        "request_max_bytes": {
          "type": "integer",
          "minimum": 1,
          "maximum": 1048576
        },
        "response_max_bytes": {
          "type": "integer",
          "minimum": 1,
          "maximum": 1048576
        }
      },
      "required": [
        "clock_domain",
        "status_timeout_seconds",
        "ready_timeout_seconds",
        "prepare_observation_timeout_seconds",
        "resume_observation_timeout_seconds",
        "drain_deadline_seconds",
        "validation_deadline_seconds",
        "lock_timeout_seconds",
        "request_max_bytes",
        "response_max_bytes"
      ],
      "additionalProperties": false
    },
    "policies": {
      "type": "object",
      "properties": {
        "boot_maintenance": {
          "enum": [
            "remain-paused",
            "resume-only-for-matching-recovery-transaction"
          ]
        },
        "unknown_integrity_action": {
          "const": "refuse"
        },
        "force_kill_authorized": {
          "const": false
        },
        "concurrency": {
          "const": "single-workload"
        },
        "power_authority": {
          "const": "none-in-adapter"
        },
        "budget_access": {
          "const": "none-in-adapter"
        },
        "availability_override": {
          "const": "disabled-unless-separate-reviewed-policy"
        }
      },
      "required": [
        "boot_maintenance",
        "unknown_integrity_action",
        "force_kill_authorized",
        "concurrency",
        "power_authority",
        "budget_access",
        "availability_override"
      ],
      "additionalProperties": false
    },
    "source_closure": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "archive": {
            "type": "string",
            "minLength": 1,
            "maxLength": 512
          },
          "member": {
            "type": "string",
            "minLength": 1,
            "maxLength": 1024
          },
          "sha256": {
            "type": "string",
            "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
            "maxLength": 64
          }
        },
        "required": [
          "archive",
          "member",
          "sha256"
        ],
        "additionalProperties": false
      },
      "minItems": 1,
      "maxItems": 2048,
      "uniqueItems": true
    },
    "consumers": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
            "maxLength": 96
          },
          "release_sha256": {
            "type": "string",
            "pattern": "^[a-f0-9]{64}(?![\\s\\S])",
            "maxLength": 64
          },
          "protocol": {
            "type": "string",
            "pattern": "^[A-Za-z0-9][A-Za-z0-9_.:-]{0,95}(?![\\s\\S])",
            "maxLength": 96
          }
        },
        "required": [
          "name",
          "release_sha256",
          "protocol"
        ],
        "additionalProperties": false
      },
      "minItems": 1,
      "maxItems": 256,
      "uniqueItems": true
    }
  },
  "required": [
    "schema",
    "deployment_status",
    "registration_id",
    "generation",
    "api_version",
    "profile_id",
    "approval_record_sha256",
    "stage_id",
    "run_id",
    "code_sha256",
    "parameters_sha256",
    "inputs_sha256",
    "output_schema",
    "validation_profile_sha256",
    "adapter_release_sha256",
    "platform",
    "execution",
    "phase_profiles",
    "limits",
    "policies",
    "source_closure",
    "consumers"
  ],
  "additionalProperties": false
}

1,760 bytes · SHA-256 a0f5c21d7d953cd502a53104772ecc51cd85c1b5e2690d6409a426932f222848

{
  "synthetic": true,
  "implementation_status": "proposed-production-wire-contract-only",
  "digest_values": "synthetic placeholders; no artifacts or authority exist",
  "valid_files": "production-valid-*.json: schema-valid shapes, not live evidence",
  "invalid_cases": [
    {
      "filename": "production-invalid-unknown-field-request.json",
      "rejection_layer": "schema",
      "reason": "Unknown request member is forbidden."
    },
    {
      "filename": "production-invalid-missing-generation-request.json",
      "rejection_layer": "schema",
      "reason": "Mutation generation precondition is required."
    },
    {
      "filename": "production-invalid-nonquiescent-ready-response.json",
      "rejection_layer": "schema",
      "reason": "READY success requires zero writers."
    },
    {
      "filename": "production-invalid-resume-overclaim-response.json",
      "rejection_layer": "schema",
      "reason": "A start request cannot claim recovery proof."
    },
    {
      "filename": "production-invalid-foreign-nonce-response.json",
      "rejection_layer": "semantic",
      "reason": "Response nonce differs from outstanding ready request."
    },
    {
      "filename": "production-invalid-foreign-boot-response.json",
      "rejection_layer": "semantic",
      "reason": "Readiness response belongs to another boot."
    },
    {
      "filename": "production-invalid-expired-ready-response.json",
      "rejection_layer": "semantic",
      "reason": "Readiness expiration precedes completed observation/current consumption."
    },
    {
      "filename": "production-invalid-clock-domain-request.json",
      "rejection_layer": "semantic",
      "reason": "Selected example registration requires CLOCK_BOOTTIME."
    }
  ]
}

936 bytes · SHA-256 a5c75c562b6205f66b69caf9bd0e49de44e7039f828f913174bcaf9a4685ae47

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "timing": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_MONOTONIC",
    "issued_mono_ns": "100000000000",
    "deadline_mono_ns": "130000000000"
  },
  "command": "status",
  "previous_response_sha256": null
}

4,993 bytes · SHA-256 ab0116c335fa9fb9d48939edf8dc63847f1a49acc7bf1005055f77b1dc3e3ed6

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": "synthetic-maintenance-001",
  "verdict": "PASS",
  "exit_code": 0,
  "command": "ready",
  "data": {
    "result": "READY_OBSERVED",
    "transaction_id": "synthetic-maintenance-001",
    "state": {
      "generation": 12,
      "state_receipt": {
        "kind": "state-receipt",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "seal": {
      "kind": "scientific-seal",
      "sha256": "6666666666666666666666666666666666666666666666666666666666666666",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "adapter",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "validation": {
      "kind": "numerical-validation",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "catalog": {
      "accepted_count": 42,
      "catalog": {
        "kind": "accepted-catalog",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "quiescence": {
      "verdict": "QUIESCENT",
      "recursive_cgroup": {
        "kind": "recursive-cgroup-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writers": {
        "kind": "writer-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writer_count": 0,
      "pending_jobs": 0,
      "observation_stable": true
    },
    "ready_observation": {
      "kind": "ready-observation",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "valid_until_mono_ns": "100000000000",
    "power_authorization": false
  }
}

4,993 bytes · SHA-256 d1840f914a98e129bd3d07f7c13d75b0171e570738df62bcce5c75e950af8d90

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "dddddddddddddddddddddddddddddddd",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": "synthetic-maintenance-001",
  "verdict": "PASS",
  "exit_code": 0,
  "command": "ready",
  "data": {
    "result": "READY_OBSERVED",
    "transaction_id": "synthetic-maintenance-001",
    "state": {
      "generation": 12,
      "state_receipt": {
        "kind": "state-receipt",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "seal": {
      "kind": "scientific-seal",
      "sha256": "6666666666666666666666666666666666666666666666666666666666666666",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "adapter",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "validation": {
      "kind": "numerical-validation",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "catalog": {
      "accepted_count": 42,
      "catalog": {
        "kind": "accepted-catalog",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "quiescence": {
      "verdict": "QUIESCENT",
      "recursive_cgroup": {
        "kind": "recursive-cgroup-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writers": {
        "kind": "writer-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writer_count": 0,
      "pending_jobs": 0,
      "observation_stable": true
    },
    "ready_observation": {
      "kind": "ready-observation",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "valid_until_mono_ns": "130000000000",
    "power_authorization": false
  }
}

4,993 bytes · SHA-256 a342f6282d2599ebf879a30c08443d03f95c7fd3379a468a5c7ffe057c7b24af

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "ffffffffffffffffffffffffffffffff",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": "synthetic-maintenance-001",
  "verdict": "PASS",
  "exit_code": 0,
  "command": "ready",
  "data": {
    "result": "READY_OBSERVED",
    "transaction_id": "synthetic-maintenance-001",
    "state": {
      "generation": 12,
      "state_receipt": {
        "kind": "state-receipt",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "seal": {
      "kind": "scientific-seal",
      "sha256": "6666666666666666666666666666666666666666666666666666666666666666",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "adapter",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "validation": {
      "kind": "numerical-validation",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "catalog": {
      "accepted_count": 42,
      "catalog": {
        "kind": "accepted-catalog",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "quiescence": {
      "verdict": "QUIESCENT",
      "recursive_cgroup": {
        "kind": "recursive-cgroup-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writers": {
        "kind": "writer-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writer_count": 0,
      "pending_jobs": 0,
      "observation_stable": true
    },
    "ready_observation": {
      "kind": "ready-observation",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "valid_until_mono_ns": "130000000000",
    "power_authorization": false
  }
}

1,103 bytes · SHA-256 92addcb5462bb51eb3149ecf4b1cf97fffc8adba156a82e9d0ad01741a079b03

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "timing": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "issued_mono_ns": "100000000000",
    "deadline_mono_ns": "130000000000"
  },
  "command": "prepare",
  "transaction": {
    "transaction_id": "synthetic-maintenance-001"
  },
  "reason": "planned-maintenance",
  "authorization_sha256": "5555555555555555555555555555555555555555555555555555555555555555"
}

4,993 bytes · SHA-256 44906e74b28d92112518a843877f58de78c4fece3ca4c1dad1badfe294075a31

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": "synthetic-maintenance-001",
  "verdict": "PASS",
  "exit_code": 0,
  "command": "ready",
  "data": {
    "result": "READY_OBSERVED",
    "transaction_id": "synthetic-maintenance-001",
    "state": {
      "generation": 12,
      "state_receipt": {
        "kind": "state-receipt",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "seal": {
      "kind": "scientific-seal",
      "sha256": "6666666666666666666666666666666666666666666666666666666666666666",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "adapter",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "validation": {
      "kind": "numerical-validation",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "catalog": {
      "accepted_count": 42,
      "catalog": {
        "kind": "accepted-catalog",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "quiescence": {
      "verdict": "QUIESCENT",
      "recursive_cgroup": {
        "kind": "recursive-cgroup-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writers": {
        "kind": "writer-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writer_count": 1,
      "pending_jobs": 0,
      "observation_stable": true
    },
    "ready_observation": {
      "kind": "ready-observation",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "valid_until_mono_ns": "130000000000",
    "power_authorization": false
  }
}

3,446 bytes · SHA-256 1a4c9069755f9c085a9e8f8440d94284794f21e8d7c9a44ffdef44800d5f5ace

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": "synthetic-maintenance-001",
  "verdict": "PASS",
  "exit_code": 0,
  "command": "resume",
  "data": {
    "result": "START_REQUESTED",
    "transaction": {
      "transaction_id": "synthetic-maintenance-001",
      "expected_state_generation": 12,
      "result_state_generation": 13,
      "intent": {
        "kind": "maintenance-intent",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "state": {
      "generation": 13,
      "state_receipt": {
        "kind": "state-receipt",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "start_request": {
      "kind": "start-request",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "adapter",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "execution": null,
    "recovery_proven": true,
    "required_followup": "status-or-verify-completion"
  }
}

1,133 bytes · SHA-256 56bfb21d33f19f9112e82ae558c8a2947b598c477bd4259baf8aedf72e14a3c0

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "timing": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "issued_mono_ns": "100000000000",
    "deadline_mono_ns": "130000000000"
  },
  "command": "ready",
  "transaction": {
    "transaction_id": "synthetic-maintenance-001",
    "expected_state_generation": 12
  },
  "seal_sha256": "6666666666666666666666666666666666666666666666666666666666666666",
  "unregistered_root": "/tmp/example"
}

182 bytes · SHA-256 b4fe40ade9b6390899851b814bddc8003eae612883ecc56bd7ffc83facb9c9cd

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "command": "capabilities"
}

2,949 bytes · SHA-256 6e0f17848f29f903b8844dad814a857d3cb7766e4c267b06a7dc098ecdcf269d

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": null,
  "verdict": "PASS",
  "exit_code": 0,
  "command": "capabilities",
  "data": {
    "supported_versions": [
      "SCI-DR/1.0.0"
    ],
    "supported_profiles": [
      "production-v1"
    ],
    "commands": [
      "capabilities",
      "status",
      "prepare",
      "ready",
      "resume",
      "verify-completion"
    ],
    "read_only_commands": [
      "capabilities",
      "status",
      "ready",
      "verify-completion"
    ],
    "limits": {
      "clock_domain": "CLOCK_BOOTTIME",
      "status_timeout_seconds": 30,
      "ready_timeout_seconds": 120,
      "prepare_observation_timeout_seconds": 30,
      "resume_observation_timeout_seconds": 30,
      "drain_deadline_seconds": 3600,
      "validation_deadline_seconds": 7200,
      "lock_timeout_seconds": 5,
      "request_max_bytes": 65536,
      "response_max_bytes": 262144
    },
    "registration_status": "accepted",
    "power_authority": "none",
    "budget_authority": "none",
    "numerical_validation_claimed": false
  }
}

2,294 bytes · SHA-256 2e6521e90a2552a13ebd25d87d178259671016b9a1714a104bc7998b33236b0e

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "command": "ready",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": "synthetic-maintenance-001",
  "verdict": "STALE",
  "exit_code": 21,
  "error": {
    "reason_code": "REQUEST_EXPIRED",
    "message": "Synthetic example: readiness request expired; collect a new observation.",
    "current_state_generation": 12,
    "retry": "FRESH_OBSERVATION",
    "mutation_state": "NONE",
    "receipt": null
  }
}

1,140 bytes · SHA-256 fe5187273d16bfa75570d33b5b5aaa7de8d97954fc7c3149d512d3a003acc7d2

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "timing": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "issued_mono_ns": "100000000000",
    "deadline_mono_ns": "130000000000"
  },
  "command": "prepare",
  "transaction": {
    "transaction_id": "synthetic-maintenance-001",
    "expected_state_generation": 12
  },
  "reason": "planned-maintenance",
  "authorization_sha256": "5555555555555555555555555555555555555555555555555555555555555555"
}

4,010 bytes · SHA-256 1e30f3609c1e264a8c34a4338f6c87dad36e62cb50d22fb1ba597acdd1798aa8

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": "synthetic-maintenance-001",
  "verdict": "PASS",
  "exit_code": 0,
  "command": "prepare",
  "data": {
    "result": "DRAINING",
    "transaction": {
      "transaction_id": "synthetic-maintenance-001",
      "expected_state_generation": 12,
      "result_state_generation": 13,
      "intent": {
        "kind": "maintenance-intent",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "state": {
      "generation": 13,
      "state_receipt": {
        "kind": "state-receipt",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "dispatch_stopped": true,
    "pending_work_count": 3,
    "seal": null,
    "quiescence": {
      "verdict": "BUSY",
      "recursive_cgroup": {
        "kind": "recursive-cgroup-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writers": {
        "kind": "writer-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writer_count": 1,
      "pending_jobs": 0,
      "observation_stable": true
    },
    "drain_deadline_mono_ns": "3701000000000"
  }
}

1,094 bytes · SHA-256 614cb8e209654100e2b4bc5d2f15d95017701cc18cf03eca2735f51b9565e70e

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "timing": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "issued_mono_ns": "100000000000",
    "deadline_mono_ns": "130000000000"
  },
  "command": "ready",
  "transaction": {
    "transaction_id": "synthetic-maintenance-001",
    "expected_state_generation": 12
  },
  "seal_sha256": "6666666666666666666666666666666666666666666666666666666666666666"
}

4,993 bytes · SHA-256 3d76d3c92a5e97980a157488e12ebedaa23824c523826c343650158c2cef4829

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": "synthetic-maintenance-001",
  "verdict": "PASS",
  "exit_code": 0,
  "command": "ready",
  "data": {
    "result": "READY_OBSERVED",
    "transaction_id": "synthetic-maintenance-001",
    "state": {
      "generation": 12,
      "state_receipt": {
        "kind": "state-receipt",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "seal": {
      "kind": "scientific-seal",
      "sha256": "6666666666666666666666666666666666666666666666666666666666666666",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "adapter",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "validation": {
      "kind": "numerical-validation",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "catalog": {
      "accepted_count": 42,
      "catalog": {
        "kind": "accepted-catalog",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "quiescence": {
      "verdict": "QUIESCENT",
      "recursive_cgroup": {
        "kind": "recursive-cgroup-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writers": {
        "kind": "writer-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writer_count": 0,
      "pending_jobs": 0,
      "observation_stable": true
    },
    "ready_observation": {
      "kind": "ready-observation",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "valid_until_mono_ns": "130000000000",
    "power_authorization": false
  }
}

1,189 bytes · SHA-256 50acd6305958cbc03305d353bcd12c5aecdad98b2778496f6dd213fe757505d5

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "timing": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "issued_mono_ns": "100000000000",
    "deadline_mono_ns": "130000000000"
  },
  "command": "resume",
  "transaction": {
    "transaction_id": "synthetic-maintenance-001",
    "expected_state_generation": 12
  },
  "seal_sha256": "6666666666666666666666666666666666666666666666666666666666666666",
  "authorization_sha256": "5555555555555555555555555555555555555555555555555555555555555555"
}

3,447 bytes · SHA-256 fc84dba9e99667185185994d618df6ed59b2d49797ce114f3d0cfff6d8c2972d

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": "synthetic-maintenance-001",
  "verdict": "PASS",
  "exit_code": 0,
  "command": "resume",
  "data": {
    "result": "START_REQUESTED",
    "transaction": {
      "transaction_id": "synthetic-maintenance-001",
      "expected_state_generation": 12,
      "result_state_generation": 13,
      "intent": {
        "kind": "maintenance-intent",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "state": {
      "generation": 13,
      "state_receipt": {
        "kind": "state-receipt",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "start_request": {
      "kind": "start-request",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "adapter",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "execution": null,
    "recovery_proven": false,
    "required_followup": "status-or-verify-completion"
  }
}

935 bytes · SHA-256 0e6d19264f7d83e5b59562e9d9645474ec0b8785c4cd7ae793b5410078b27a94

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "timing": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "issued_mono_ns": "100000000000",
    "deadline_mono_ns": "130000000000"
  },
  "command": "status",
  "previous_response_sha256": null
}

5,279 bytes · SHA-256 ed36140af6006b5028073096b216f6175ae8ba0f91b660ca1ae71a04183c13e7

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": null,
  "verdict": "PASS",
  "exit_code": 0,
  "command": "status",
  "data": {
    "lifecycle": "running",
    "state": {
      "generation": 12,
      "state_receipt": {
        "kind": "state-receipt",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "execution": {
      "state": "active",
      "service_unit": "synthetic-stage10d.service",
      "invocation_id": "cccccccccccccccccccccccccccccccc",
      "pid": 1234,
      "uid": 1000,
      "gid": 1000,
      "process_start_ticks": 555
    },
    "scientific_identity_validated": true,
    "validation": {
      "result": "PASS",
      "profile_sha256": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
      "receipt": {
        "kind": "numerical-validation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "catalog": {
      "accepted_count": 42,
      "catalog": {
        "kind": "accepted-catalog",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "progress": {
      "phase_id": "integration",
      "batch_id": "batch-1",
      "work_unit": "accepted-work-unit",
      "accepted": 42,
      "total": 100,
      "previous_response_sha256": null,
      "classification": "BASELINE_ONLY",
      "delta": null,
      "window_start_mono_ns": null,
      "window_end_mono_ns": "102000000000",
      "identity_stable": true,
      "within_registered_age_and_gap": true,
      "phase_transition": null
    },
    "quiescence": {
      "verdict": "BUSY",
      "recursive_cgroup": {
        "kind": "recursive-cgroup-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writers": {
        "kind": "writer-observation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "writer_count": 1,
      "pending_jobs": 0,
      "observation_stable": true
    },
    "maintenance_transaction_id": null,
    "completion": null,
    "resumption": {
      "result": "NOT_REQUESTED",
      "transaction_id": null,
      "prior_boot_id": null,
      "prior_invocation_id": null,
      "proof": null
    }
  }
}

1,045 bytes · SHA-256 74bb866ba4e5f31ee0bb9ec4786d907b0e637bc357b1f2a0b7be753a1185fcd2

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "timing": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "issued_mono_ns": "100000000000",
    "deadline_mono_ns": "130000000000"
  },
  "command": "verify-completion",
  "expected_state_generation": 12,
  "completion_manifest_sha256": "7777777777777777777777777777777777777777777777777777777777777777"
}

4,707 bytes · SHA-256 035bf6979e87afd9f30756877a84097b5f3d0a73a5b10a0cef5c7d45197163e8

{
  "api_version": "SCI-DR/1.0.0",
  "profile_id": "production-v1",
  "simulation_only": false,
  "request_id": "synthetic-request",
  "nonce": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
  "registration": {
    "registration_id": "synthetic-registration",
    "generation": 7,
    "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
  },
  "identity": {
    "stage_id": "synthetic-stage10d",
    "run_id": "synthetic-run-001",
    "code_sha256": "1111111111111111111111111111111111111111111111111111111111111111",
    "parameters_sha256": "2222222222222222222222222222222222222222222222222222222222222222",
    "inputs_sha256": "3333333333333333333333333333333333333333333333333333333333333333"
  },
  "provenance": {
    "adapter_release_sha256": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
    "registration_acceptance": {
      "kind": "registration-acceptance",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "release-approver",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    },
    "source_verification": {
      "kind": "source-verification",
      "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
      "bytes": 1024,
      "canonicalization": "SCI-DR-CJSON/1",
      "producer_role": "independent-observer",
      "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
    }
  },
  "observation": {
    "boot_id": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
    "clock_domain": "CLOCK_BOOTTIME",
    "started_mono_ns": "101000000000",
    "finished_mono_ns": "102000000000",
    "observed_utc": "2026-09-20T10:00:02Z",
    "observer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
  },
  "transaction_id": null,
  "verdict": "PASS",
  "exit_code": 0,
  "command": "verify-completion",
  "data": {
    "result": "COMPLETE_VERIFIED",
    "state": {
      "generation": 12,
      "state_receipt": {
        "kind": "state-receipt",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "adapter",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      }
    },
    "scientific_identity_validated": true,
    "completion": {
      "manifest": {
        "kind": "completion-manifest",
        "sha256": "7777777777777777777777777777777777777777777777777777777777777777",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "validation": {
        "kind": "completion-validation",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "accepted_catalog": {
        "kind": "accepted-catalog",
        "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
        "bytes": 1024,
        "canonicalization": "SCI-DR-CJSON/1",
        "producer_role": "independent-observer",
        "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
      },
      "required_count": 42,
      "accepted_count": 42,
      "quiescence": {
        "verdict": "QUIESCENT",
        "recursive_cgroup": {
          "kind": "recursive-cgroup-observation",
          "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
          "bytes": 1024,
          "canonicalization": "SCI-DR-CJSON/1",
          "producer_role": "independent-observer",
          "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
        },
        "writers": {
          "kind": "writer-observation",
          "sha256": "8888888888888888888888888888888888888888888888888888888888888888",
          "bytes": 1024,
          "canonicalization": "SCI-DR-CJSON/1",
          "producer_role": "independent-observer",
          "producer_release_sha256": "9999999999999999999999999999999999999999999999999999999999999999"
        },
        "writer_count": 0,
        "pending_jobs": 0,
        "observation_stable": true
      }
    },
    "power_authorization": false
  }
}

133 bytes · SHA-256 be071ad18ad2a30f892f6ad9f34766053b48b5bccda3c3baf3165d3e520c69f0

jsonschema==4.25.1
attrs==26.1.0
jsonschema-specifications==2025.9.1
referencing==0.37.0
rpds-py==2026.9.1
typing_extensions==4.16.0

10,028 bytes · SHA-256 306fa171c7a15748308cd10f5d0f090edfb1a6f31cbb52f6dd4faa13dc31fa7d

"""Validate supplied design assets offline; never validates a live deployment.

Requires jsonschema (requirements-checks.txt). No services, sudo, networking,
controller actions, or mutations to scientific data are performed.
"""
import copy
import hashlib
import json
import platform
import sys
import unittest
from pathlib import Path

from jsonschema import Draft202012Validator, FormatChecker
from evidence_format import canonical_bytes, decode_object, decode_wire_response, verify_canonical

ROOT = Path(__file__).resolve().parents[1]


def read_json(relative):
    return decode_object((ROOT / relative).read_bytes())


def selected_ready_bindings(request, response, consumed, actual_exit=0,
                            registered_clock="CLOCK_BOOTTIME"):
    """Selected offline semantic negatives only. NEVER a live readiness gate.

    This deliberately lacks source/producer authentication, OS observation,
    registration-store trust, seal/catalog/numerical verification and actuation.
    """
    for field in ("api_version", "profile_id", "request_id", "nonce", "command", "registration", "identity"):
        if response[field] != request[field]:
            raise ValueError("binding:" + field)
    if response["exit_code"] != actual_exit or actual_exit != 0:
        raise ValueError("exit agreement")
    timing, observation = request["timing"], response["observation"]
    if timing["clock_domain"] != registered_clock:
        raise ValueError("registered clock mismatch")
    for field in ("boot_id", "clock_domain"):
        if timing[field] != observation[field]:
            raise ValueError("clock binding:" + field)
    issued = int(timing["issued_mono_ns"])
    started = int(observation["started_mono_ns"])
    finished = int(observation["finished_mono_ns"])
    deadline = int(timing["deadline_mono_ns"])
    valid_until = int(response["data"]["valid_until_mono_ns"])
    if not issued <= started <= finished <= consumed < valid_until <= deadline:
        raise ValueError("freshness")
    if response["transaction_id"] != request["transaction"]["transaction_id"]:
        raise ValueError("transaction binding")


class EvidenceEncodingTests(unittest.TestCase):
    def test_literal_canonical_vector(self):
        value = {"z": True, "a": "\u00e9/\n\x7f", "n": 9007199254740993}
        expected = b'{"a":"\\u00e9/\\n\\u007f","n":9007199254740993,"z":true}\n'
        self.assertEqual(canonical_bytes(value), expected)
        self.assertEqual(verify_canonical(expected), value)

    def test_astral_scalar_vector(self):
        self.assertEqual(canonical_bytes({"a": "\U0001f52c"}), b'{"a":"\\ud83d\\udd2c"}\n')

    def test_decoded_codepoint_sort(self):
        self.assertEqual(canonical_bytes({"\U00010000": 1, "\ue000": 2}),
                         b'{"\\ue000":2,"\\ud800\\udc00":1}\n')

    def test_control_escape_vector(self):
        self.assertEqual(canonical_bytes({"x": '\b\t\n\f\r"\\\x01'}),
                         b'{"x":"\\b\\t\\n\\f\\r\\\"\\\\\\u0001"}\n')

    def test_nested_duplicate_rejected(self):
        with self.assertRaises(ValueError): decode_object(b'{"a":{"b":1,"b":2}}')

    def test_float_rejected(self):
        with self.assertRaises(ValueError): decode_object(b'{"x":1.0}')

    def test_negative_zero_rejected(self):
        with self.assertRaises(ValueError): decode_object(b'{"x":-0}')

    def test_nonfinite_rejected(self):
        with self.assertRaises(ValueError): decode_object(b'{"x":NaN}')

    def test_invalid_utf8_rejected(self):
        with self.assertRaises(ValueError): decode_object(b'{"x":"\xff"}')

    def test_unpaired_surrogate_rejected(self):
        with self.assertRaises(ValueError): decode_object(b'{"x":"\\ud800"}')

    def test_non_nfc_rejected(self):
        with self.assertRaises(ValueError): decode_object(b'{"x":"e\\u0301"}')

    def test_whitespace_not_canonical(self):
        with self.assertRaises(ValueError): verify_canonical(b'{"x": 1}\n')

    def test_evidence_lf_is_hashed(self):
        with self.assertRaises(ValueError): verify_canonical(b'{"x":1}')
        self.assertNotEqual(hashlib.sha256(b'{"x":1}').digest(), hashlib.sha256(b'{"x":1}\n').digest())

    def test_byte_limit(self):
        with self.assertRaises(ValueError): decode_object(b'{"x":1}', limit=5)

    def test_nesting_bound_before_decode(self):
        with self.assertRaises(ValueError): decode_object(b'{"x":' + b'['*32 + b'0' + b']'*32 + b'}')

    def test_brackets_in_string_are_not_depth(self):
        self.assertEqual(decode_object(b'{"x":"[[["}', maximum_depth=1), {"x":"[[["})

    def test_extra_stdout_rejected(self):
        with self.assertRaises(ValueError): decode_wire_response(b'{"x":1}\n{"y":2}\n')

    def test_double_terminal_lf_rejected(self):
        with self.assertRaises(ValueError): decode_wire_response(b'{"x":1}\n\n')


class SchemaAndBindingTests(unittest.TestCase):
    @classmethod
    def setUpClass(cls):
        cls.validators = {}
        for key in ("production-request", "production-response", "registration"):
            schema = read_json("schemas/" + key + ".schema.json")
            Draft202012Validator.check_schema(schema)
            cls.validators[key] = Draft202012Validator(schema, format_checker=FormatChecker())

    def test_all_valid_synthetic_shapes(self):
        for path in sorted((ROOT / "examples").glob("production-valid-*.json")):
            key = "production-request" if path.name.endswith("request.json") else "production-response"
            with self.subTest(path=path.name):
                self.validators[key].validate(decode_object(path.read_bytes()))

    def test_invalid_cases_rejected_at_declared_layer(self):
        for case in read_json("examples/production-example-index.json")["invalid_cases"]:
            data = read_json("examples/" + case["filename"])
            key = "production-request" if case["filename"].endswith("request.json") else "production-response"
            errors = list(self.validators[key].iter_errors(data))
            with self.subTest(path=case["filename"]):
                self.assertEqual(bool(errors), case["rejection_layer"] == "schema")

    def test_boolean_registration_generation_rejected(self):
        q=read_json("examples/production-valid-ready-request.json")
        q["registration"]["generation"]=True
        self.assertTrue(list(self.validators["production-request"].iter_errors(q)))

    def test_long_uptime_string_accepted_structurally(self):
        q=read_json("examples/production-valid-ready-request.json")
        q["timing"]["issued_mono_ns"]="10000000000000000"
        q["timing"]["deadline_mono_ns"]="10000030000000000"
        self.validators["production-request"].validate(q)

    def test_timestamp_number_rejected(self):
        q=read_json("examples/production-valid-ready-request.json")
        q["timing"]["issued_mono_ns"]=10000000000000000
        self.assertTrue(list(self.validators["production-request"].iter_errors(q)))

    def test_identifier_trailing_lf_rejected(self):
        q=read_json("examples/production-valid-ready-request.json")
        q["nonce"] += "\n"
        self.assertTrue(list(self.validators["production-request"].iter_errors(q)))

    def test_selected_valid_ready_bindings(self):
        q=read_json("examples/production-valid-ready-request.json")
        r=read_json("examples/production-valid-ready-response.json")
        selected_ready_bindings(q,r,103000000000)

    def test_selected_semantic_response_negatives(self):
        q=read_json("examples/production-valid-ready-request.json")
        for kind in ("foreign-nonce", "foreign-boot", "expired-ready"):
            r=read_json("examples/production-invalid-"+kind+"-response.json")
            with self.subTest(kind=kind), self.assertRaises(ValueError):
                selected_ready_bindings(q,r,103000000000)

    def test_registered_clock_mismatch(self):
        invalid=read_json("examples/production-invalid-clock-domain-request.json")
        q=read_json("examples/production-valid-ready-request.json")
        r=read_json("examples/production-valid-ready-response.json")
        q["timing"]["clock_domain"]=invalid["timing"]["clock_domain"]
        r["observation"]["clock_domain"]=invalid["timing"]["clock_domain"]
        # Matching request/response clocks must still match accepted registration.
        with self.assertRaisesRegex(ValueError,"registered clock mismatch"):
            selected_ready_bindings(q,r,103000000000)

    def test_exit_disagreement(self):
        q=read_json("examples/production-valid-ready-request.json")
        r=read_json("examples/production-valid-ready-response.json")
        with self.assertRaises(ValueError): selected_ready_bindings(q,r,103000000000,actual_exit=20)

    def test_late_consumption(self):
        q=read_json("examples/production-valid-ready-request.json")
        r=read_json("examples/production-valid-ready-response.json")
        with self.assertRaises(ValueError): selected_ready_bindings(q,r,130000000000)


if __name__ == "__main__":
    suite=unittest.defaultTestLoader.loadTestsFromModule(sys.modules[__name__])
    result=unittest.TextTestRunner(verbosity=2).run(suite)
    report={"scope":"OFFLINE_DOCUMENT_ASSETS_ONLY", "python":platform.python_version(),
        "tests_run":result.testsRun,"failures":len(result.failures),"errors":len(result.errors),
        "passed":result.wasSuccessful(),
        "valid_synthetic_fixtures":len(list((ROOT/'examples').glob('production-valid-*.json'))),
        "production_adapter_implemented":False,"live_server_tested":False,
        "physical_power_loss_tested":False,
        "limitations":["Schema shape is not evidence authenticity.",
          "Selected binding tests omit OS, source, producer, scientific and action authority.",
          "Subtest fixtures are counted separately from unittest methods."]}
    print(json.dumps(report,indent=2))
    # This is a child Python CLI, never sourced into the user's SSH shell.
    raise SystemExit(0 if result.wasSuccessful() else 1)

3,466 bytes · SHA-256 243b4413ba578e4b67524eb3cccf12f7bd95c0ddc036b0a94208d03832359323

"""Offline SCI-DR-CJSON/1 encoding aid. No OS, filesystem-trust or action authority.

Implements the document's integer-only evidence format. Scientific arrays need
their separately declared format. This module is not a production observer.
"""
import json
import unicodedata


def _pairs(items):
    result = {}
    for key, value in items:
        if key in result:
            raise ValueError("duplicate JSON key")
        result[key] = value
    return result


def _integer(token):
    if token == "-0":
        raise ValueError("negative zero")
    return int(token)


def _forbidden_number(token):
    raise ValueError("non-integer or nonfinite number")


def _check(value):
    if isinstance(value, str):
        if any(0xD800 <= ord(c) <= 0xDFFF for c in value):
            raise ValueError("unpaired surrogate")
        if unicodedata.normalize("NFC", value) != value:
            raise ValueError("non-NFC string")
    elif type(value) is dict:
        for key, child in value.items():
            if type(key) is not str:
                raise ValueError("non-string object key")
            _check(key)
            _check(child)
    elif type(value) is list:
        for child in value:
            _check(child)
    elif value is None or type(value) in (bool, int):
        pass
    else:
        raise ValueError("unsupported evidence value")


def _bounded_depth(text, maximum):
    depth = 0
    quoted = False
    escaped = False
    for char in text:
        if quoted:
            if escaped:
                escaped = False
            elif char == "\\":
                escaped = True
            elif char == '"':
                quoted = False
        elif char == '"':
            quoted = True
        elif char in "[{":
            depth += 1
            if depth > maximum:
                raise ValueError("nesting limit exceeded")
        elif char in "]}":
            depth -= 1
    # JSON decoder checks unbalanced syntax and incomplete strings.


def decode_object(raw, limit=1_048_576, maximum_depth=32):
    if type(raw) is not bytes or len(raw) > limit:
        raise ValueError("byte type or limit")
    text = raw.decode("utf-8", errors="strict")
    _bounded_depth(text, maximum_depth)
    value = json.loads(text, object_pairs_hook=_pairs, parse_int=_integer,
                       parse_float=_forbidden_number,
                       parse_constant=_forbidden_number)
    if type(value) is not dict:
        raise ValueError("top-level object required")
    _check(value)
    return value


def canonical_bytes(value):
    if type(value) is not dict:
        raise ValueError("top-level object required")
    _check(value)
    result = (json.dumps(value, ensure_ascii=True, sort_keys=True,
                         separators=(",", ":"), allow_nan=False) + "\n").encode("ascii")
    _bounded_depth(result.decode("ascii"), 32)
    return result


def verify_canonical(raw, limit=67_108_864):
    value = decode_object(raw, limit=limit)
    if raw != canonical_bytes(value):
        raise ValueError("noncanonical bytes")
    return value


def decode_wire_response(raw, limit=1_048_576):
    # Transport already has a separately enforced read deadline and byte cap.
    # Check exactly one terminal LF; no banners or extra JSON are allowed.
    if not raw.endswith(b"\n") or raw[:-1].endswith((b" ", b"\t", b"\r", b"\n")):
        raise ValueError("exact terminal LF required")
    return decode_object(raw, limit=limit)

5,427 bytes · SHA-256 8d29e87772773a45a19311304de9ac45acf2da31d6cd7a90a202b2ce4082d48a

gate,subject,exercise,required_outcome,required_evidence,related_base_requirements,execution_status
G01,Scientific definition,"Analytic/manufactured, dense/tiled, serial/parallel, difficult controls",Frozen numerical criteria hold,"Model derivation, golden data, comparison outputs",SC-DAT-001;SC-TST-001,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G02,Dependency closure,Fresh service UID/interpreter; all entry-point imports and numerical calls,No undeclared dependency; initialized library bindings recorded,"Target import/call report, lock file and environment fingerprint",SC-API-003;SC-MIG-001,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G03,Permissions,Wrong ancestor/owner/link/type; stable opened-file checks,Reject unsafe source paths without changing approved digests,Before/after metadata and negative outcomes,SC-ARC-004;SC-MIG-003,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G04,Final confinement,"Tempfiles, IPC, locks, writes, subprocesses in every actual unit",All required paths work; forbidden paths remain forbidden,"Loaded units/drop-ins, actual sandbox probe logs",SC-BOOT-005;SC-MIG-007,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G05,Actual pool,"Real helper/worker exits; late, foreign, duplicate processes; PID reuse",Correct roles; live worker and unreadable containment block gate,Recursive cgroup snapshots and runtime pool report,SC-ARC-005;SC-PRE-007,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G06,Commit boundaries,"Interrupt before/after each durable payload, segment and head step",Valid accepted set recovered once; orphan rule respected,Before/after task/digest catalogs and interruption index,SC-DAT-004;SC-DAT-006,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G07,Corruption,"Changed accepted payload, duplicates, stale phase binding",Specific integrity block; no silent rewrite or lost history,Affected object hashes and persistent refusal evidence,SC-DAT-003;SC-DAT-006,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G08,Numerical epochs,"Fresh replay, known mismatch, environment drift during gate",Stable epoch accepted; mismatch blocks without resampling,"Original panel IDs, before/after fingerprint and comparisons",SC-BOOT-001;SC-DAT-001,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G09,Maintenance,"Bounded queue, long task, timeout, late writer",Stop admissions; timeout never equals READY; sealed only when verified,"Intent, admission/drain timeline, recursive writer and seal proof",SC-LIF-002;SC-PRE-006,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G10,Intent and boot,PAUSE reboot; unexpected boot with accepted RUN; malformed intent,Retain planned pause; reconcile and validate authorized RUN; unknown blocks,"Boot IDs, intent and phase receipts; specify simulated or real",SC-BOOT-002;SC-BOOT-006,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G11,Protocol,"Foreign nonce/boot/domain, stale time, generation replay, malformed streams",Correct layer refuses; no authority from structural validity,Raw bounded requests/responses and actual child exit,SC-API-001;SC-API-002;SC-LIF-003,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G12,Progress,"Static count, stale invocation, phase change, real new commits",Only valid same-execution accepted delta or validated transition passes,Two bound observations and catalog lineage,SC-PRG-002;SC-PRG-004,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G13,Completion,All real kernels; stop mid-verification; completion marker with live writer,"Exact task set, final artifacts and quiescence; complete does not restart",Independent completion receipt and restart refusal,SC-LIF-001;SC-TST-002,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G14,Install interruption,Stop after every durable step including activation before finalization,One coherent generation or explicit containment; resumable finalizer,Transaction log; effective config; owned hold/timer states,SC-MIG-004;SC-MIG-006,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G15,All recovery consumers,"Every active consumer, stale pins, queued jobs, operator hold",Same registration throughout; conflicting authority refused,"Consumer matrix, installed validator outcomes and source graph",SC-MIG-002;SC-MIG-007,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G16,History,"Reinstall, migration, rollback, lost dispatch result",No budget refund; spent/uncertain lineage and cooldowns survive,Before/after ledger prefixes and reconciliation receipt,SC-AUT-002;SC-AUT-003;SC-AUT-005,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G17,Resource pressure,"Bytes/inodes exhausted, slow durable writes, memory/CPU pressure",Preserve evidence; bounded retry/stop; respect other services,"Resource measurements, limits and pressure-test records",SC-SCP-001;SC-LIF-004,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G18,Submission independence,Disconnect SSH; expire sudo timestamp after durable submission,Background operation continues; protected status remains available,Service identity plus final/submitted phase reports,SC-API-003;SC-LIF-002,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G19,Full installed lifecycle,"Bootstrap, commissioned resolver, finalizer, paused result, explicit start",Final recovery configuration restored; observed new accepted work,End-to-end isolated real-model commissioning dossier,SC-TST-001;SC-MIG-007;SC-BOOT-003,NOT_PERFORMED_FUTURE_IMPLEMENTATION
G20,Physical tests,Separately authorized real reboot and power removal on specified hardware,Record each actual result or NOT_PERFORMED; no simulation substitution,"External/live evidence, scope and recovery outcome",SC-TST-003;SC-SCP-001,NOT_PERFORMED_FUTURE_IMPLEMENTATION

4,544 bytes · SHA-256 991b305292bab7db48b2ece9295dc24d7391c3e6de30073d5424184ef1066c02

8d29e87772773a45a19311304de9ac45acf2da31d6cd7a90a202b2ce4082d48a  COMMISSIONING_MATRIX.csv
a5fa03769a4aafd3ab40813e9a36cceef4a0dd251214630aa6e7e093ff077726  README.txt
795e95c693782e051d9890d74a6ba1c78f1f1332d92f0d5ab5ff3d3f08e23f70  SOURCE_PROVENANCE.json
37c822fa78fb1245cd305f02848939059d15f0bd1ba94fa5e52f2ae102a06ff9  VALIDATION_REPORT.json
a48e8ba46c8b1c48038cd55fe9e5cccac07eaddfd1986e3710c61b5c4a0ea511  docs/DEPLOYMENT_SUPPLEMENT.txt
af75cce8c819260b135e86a4b91e03ea997db5a490ad4c8e001db1df1981ab2e  docs/PRODUCTION_INTERFACE.md
a0f5c21d7d953cd502a53104772ecc51cd85c1b5e2690d6409a426932f222848  examples/production-example-index.json
a5c75c562b6205f66b69caf9bd0e49de44e7039f828f913174bcaf9a4685ae47  examples/production-invalid-clock-domain-request.json
ab0116c335fa9fb9d48939edf8dc63847f1a49acc7bf1005055f77b1dc3e3ed6  examples/production-invalid-expired-ready-response.json
d1840f914a98e129bd3d07f7c13d75b0171e570738df62bcce5c75e950af8d90  examples/production-invalid-foreign-boot-response.json
a342f6282d2599ebf879a30c08443d03f95c7fd3379a468a5c7ffe057c7b24af  examples/production-invalid-foreign-nonce-response.json
92addcb5462bb51eb3149ecf4b1cf97fffc8adba156a82e9d0ad01741a079b03  examples/production-invalid-missing-generation-request.json
44906e74b28d92112518a843877f58de78c4fece3ca4c1dad1badfe294075a31  examples/production-invalid-nonquiescent-ready-response.json
1a4c9069755f9c085a9e8f8440d94284794f21e8d7c9a44ffdef44800d5f5ace  examples/production-invalid-resume-overclaim-response.json
56bfb21d33f19f9112e82ae558c8a2947b598c477bd4259baf8aedf72e14a3c0  examples/production-invalid-unknown-field-request.json
b4fe40ade9b6390899851b814bddc8003eae612883ecc56bd7ffc83facb9c9cd  examples/production-valid-capabilities-request.json
6e0f17848f29f903b8844dad814a857d3cb7766e4c267b06a7dc098ecdcf269d  examples/production-valid-capabilities-response.json
2e6521e90a2552a13ebd25d87d178259671016b9a1714a104bc7998b33236b0e  examples/production-valid-error-response.json
fe5187273d16bfa75570d33b5b5aaa7de8d97954fc7c3149d512d3a003acc7d2  examples/production-valid-prepare-request.json
1e30f3609c1e264a8c34a4338f6c87dad36e62cb50d22fb1ba597acdd1798aa8  examples/production-valid-prepare-response.json
614cb8e209654100e2b4bc5d2f15d95017701cc18cf03eca2735f51b9565e70e  examples/production-valid-ready-request.json
3d76d3c92a5e97980a157488e12ebedaa23824c523826c343650158c2cef4829  examples/production-valid-ready-response.json
50acd6305958cbc03305d353bcd12c5aecdad98b2778496f6dd213fe757505d5  examples/production-valid-resume-request.json
fc84dba9e99667185185994d618df6ed59b2d49797ce114f3d0cfff6d8c2972d  examples/production-valid-resume-response.json
0e6d19264f7d83e5b59562e9d9645474ec0b8785c4cd7ae793b5410078b27a94  examples/production-valid-status-request.json
ed36140af6006b5028073096b216f6175ae8ba0f91b660ca1ae71a04183c13e7  examples/production-valid-status-response.json
74bb866ba4e5f31ee0bb9ec4786d907b0e637bc357b1f2a0b7be753a1185fcd2  examples/production-valid-verify-completion-request.json
035bf6979e87afd9f30756877a84097b5f3d0a73a5b10a0cef5c7d45197163e8  examples/production-valid-verify-completion-response.json
a978f28c5a1e14c29304f8535e2c2ed5cdf23b05dc26a591b5b0c53cf1f7f886  figures/architecture.svg
906b3c4d800329d9bd6099d406c019d387b1998dd523a24a830cbc8d3a7be9d1  figures/commit.svg
20e2d431323e70a067a15b6843c30e7768f4a509ba3070bc038ff496d67e1e1a  figures/epochs.svg
a6af8e733af7d8eaaeadb2037b8286d8997b1f148defb29f87c6c784625b9eae  figures/installation.svg
6cfa1e005ef104db3247aa84a86fa847997f52443c3491c227ea00196f1c3349  figures/lifecycle.svg
1908275f63615dad7601bbd06857cb7d5fd7ec3b2e88ad08eb4b87ccace6fb0d  figures/processes.svg
a45f8cd8e889f9223e4ddcfde94ab517a47b8ed8a84e628f2174b65e9e303d94  figures/release-gap.svg
be071ad18ad2a30f892f6ad9f34766053b48b5bccda3c3baf3165d3e520c69f0  requirements-checks.txt
b3a276b1cb05d323fbce961bf69921e9058185e032b89286e72c527509c33ec8  schemas/production-request.schema.json
fc114fc79f0c42f9b51df07231042da2f6f37fc3b3874c7266551fa98357e5bc  schemas/production-response.schema.json
80198dbc97800b5f535eaa5655e432cf87fdc813e14829935c0dcdaa1252f9cf  schemas/registration.schema.json
8ef04050a49a4fbaff3e500bbe2eaf9b4105f75b6343461f8dddce9cdfdf9de4  science_simulation_first_deployment_prompt_20261011.txt
487ffda516fa2d6ba609769029313517fbe7f528fde0a26b5b84330fa139c196  tests/document-check-results.txt
306fa171c7a15748308cd10f5d0f090edfb1a6f31cbb52f6dd4faa13dc31fa7d  tools/document_checks.py
243b4413ba578e4b67524eb3cccf12f7bd95c0ddc036b0a94208d03832359323  tools/evidence_format.py

7,288 bytes · SHA-256 795e95c693782e051d9890d74a6ba1c78f1f1332d92f0d5ab5ff3d3f08e23f70

{
  "schema": "ARTICLE_SOURCE_PROVENANCE_V1",
  "copied_assets": [
    {
      "path": "schemas/production-request.schema.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 10788,
      "sha256": "b3a276b1cb05d323fbce961bf69921e9058185e032b89286e72c527509c33ec8",
      "modified": false
    },
    {
      "path": "schemas/production-response.schema.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 107807,
      "sha256": "fc114fc79f0c42f9b51df07231042da2f6f37fc3b3874c7266551fa98357e5bc",
      "modified": false
    },
    {
      "path": "schemas/registration.schema.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 12320,
      "sha256": "80198dbc97800b5f535eaa5655e432cf87fdc813e14829935c0dcdaa1252f9cf",
      "modified": false
    },
    {
      "path": "docs/PRODUCTION_INTERFACE.md",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 28020,
      "sha256": "af75cce8c819260b135e86a4b91e03ea997db5a490ad4c8e001db1df1981ab2e",
      "modified": false
    },
    {
      "path": "examples/production-example-index.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 1760,
      "sha256": "a0f5c21d7d953cd502a53104772ecc51cd85c1b5e2690d6409a426932f222848",
      "modified": false
    },
    {
      "path": "examples/production-invalid-clock-domain-request.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 936,
      "sha256": "a5c75c562b6205f66b69caf9bd0e49de44e7039f828f913174bcaf9a4685ae47",
      "modified": false
    },
    {
      "path": "examples/production-invalid-expired-ready-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 4993,
      "sha256": "ab0116c335fa9fb9d48939edf8dc63847f1a49acc7bf1005055f77b1dc3e3ed6",
      "modified": false
    },
    {
      "path": "examples/production-invalid-foreign-boot-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 4993,
      "sha256": "d1840f914a98e129bd3d07f7c13d75b0171e570738df62bcce5c75e950af8d90",
      "modified": false
    },
    {
      "path": "examples/production-invalid-foreign-nonce-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 4993,
      "sha256": "a342f6282d2599ebf879a30c08443d03f95c7fd3379a468a5c7ffe057c7b24af",
      "modified": false
    },
    {
      "path": "examples/production-invalid-missing-generation-request.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 1103,
      "sha256": "92addcb5462bb51eb3149ecf4b1cf97fffc8adba156a82e9d0ad01741a079b03",
      "modified": false
    },
    {
      "path": "examples/production-invalid-nonquiescent-ready-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 4993,
      "sha256": "44906e74b28d92112518a843877f58de78c4fece3ca4c1dad1badfe294075a31",
      "modified": false
    },
    {
      "path": "examples/production-invalid-resume-overclaim-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 3446,
      "sha256": "1a4c9069755f9c085a9e8f8440d94284794f21e8d7c9a44ffdef44800d5f5ace",
      "modified": false
    },
    {
      "path": "examples/production-invalid-unknown-field-request.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 1133,
      "sha256": "56bfb21d33f19f9112e82ae558c8a2947b598c477bd4259baf8aedf72e14a3c0",
      "modified": false
    },
    {
      "path": "examples/production-valid-capabilities-request.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 182,
      "sha256": "b4fe40ade9b6390899851b814bddc8003eae612883ecc56bd7ffc83facb9c9cd",
      "modified": false
    },
    {
      "path": "examples/production-valid-capabilities-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 2949,
      "sha256": "6e0f17848f29f903b8844dad814a857d3cb7766e4c267b06a7dc098ecdcf269d",
      "modified": false
    },
    {
      "path": "examples/production-valid-error-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 2294,
      "sha256": "2e6521e90a2552a13ebd25d87d178259671016b9a1714a104bc7998b33236b0e",
      "modified": false
    },
    {
      "path": "examples/production-valid-prepare-request.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 1140,
      "sha256": "fe5187273d16bfa75570d33b5b5aaa7de8d97954fc7c3149d512d3a003acc7d2",
      "modified": false
    },
    {
      "path": "examples/production-valid-prepare-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 4010,
      "sha256": "1e30f3609c1e264a8c34a4338f6c87dad36e62cb50d22fb1ba597acdd1798aa8",
      "modified": false
    },
    {
      "path": "examples/production-valid-ready-request.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 1094,
      "sha256": "614cb8e209654100e2b4bc5d2f15d95017701cc18cf03eca2735f51b9565e70e",
      "modified": false
    },
    {
      "path": "examples/production-valid-ready-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 4993,
      "sha256": "3d76d3c92a5e97980a157488e12ebedaa23824c523826c343650158c2cef4829",
      "modified": false
    },
    {
      "path": "examples/production-valid-resume-request.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 1189,
      "sha256": "50acd6305958cbc03305d353bcd12c5aecdad98b2778496f6dd213fe757505d5",
      "modified": false
    },
    {
      "path": "examples/production-valid-resume-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 3447,
      "sha256": "fc84dba9e99667185185994d618df6ed59b2d49797ce114f3d0cfff6d8c2972d",
      "modified": false
    },
    {
      "path": "examples/production-valid-status-request.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 935,
      "sha256": "0e6d19264f7d83e5b59562e9d9645474ec0b8785c4cd7ae793b5410078b27a94",
      "modified": false
    },
    {
      "path": "examples/production-valid-status-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 5279,
      "sha256": "ed36140af6006b5028073096b216f6175ae8ba0f91b660ca1ae71a04183c13e7",
      "modified": false
    },
    {
      "path": "examples/production-valid-verify-completion-request.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 1045,
      "sha256": "74bb866ba4e5f31ee0bb9ec4786d907b0e637bc357b1f2a0b7be753a1185fcd2",
      "modified": false
    },
    {
      "path": "examples/production-valid-verify-completion-response.json",
      "source": "SCI-DR/1.0.0 2026-09-20 supplied kit",
      "bytes": 4707,
      "sha256": "035bf6979e87afd9f30756877a84097b5f3d0a73a5b10a0cef5c7d45197163e8",
      "modified": false
    }
  ],
  "original_kit_zip_sha256": "7d22328085c3fa53eaca6a5e175e8e9f67d46e9eab652fc7869d11c60c9ae794",
  "original_specification_sha256": "21716508fd90fdaea6d1fedd8fd4302a662c441bf99569f4775159111aaa741f",
  "post_incident_prompt_sha256": "509afcf5098a3b35a57bce2f81656f70bbcdeb2f296af84939d616a907a8f8d5",
  "historical_private_archives_included": false
}

3,780 bytes · SHA-256 37c822fa78fb1245cd305f02848939059d15f0bd1ba94fa5e52f2ae102a06ff9

{
  "scope": "OFFLINE_DOCUMENT_ASSETS_ONLY",
  "python": "3.12.14",
  "tests_run": 29,
  "failures": 0,
  "errors": 0,
  "passed": true,
  "valid_synthetic_fixtures": 13,
  "production_adapter_implemented": false,
  "live_server_tested": false,
  "physical_power_loss_tested": false,
  "limitations": [
    "Schema shape is not evidence authenticity.",
    "Selected binding tests omit OS, source, producer, scientific and action authority.",
    "Subtest fixtures are counted separately from unittest methods."
  ],
  "edition": "2026-10-11 revision 1",
  "schema_validator": "jsonschema 4.25.1 Draft202012Validator",
  "schemas_checked": 3,
  "supplied_invalid_cases": 8,
  "original_kit_manifest_entries_checked": 98,
  "commissioning_gates_performed": 0,
  "executed_utc": "2026-10-11T17:21:45.499712+00:00",
  "test_methods": [
    "test_astral_scalar_vector (__main__.EvidenceEncodingTests.test_astral_scalar_vector)",
    "test_brackets_in_string_are_not_depth (__main__.EvidenceEncodingTests.test_brackets_in_string_are_not_depth)",
    "test_byte_limit (__main__.EvidenceEncodingTests.test_byte_limit)",
    "test_control_escape_vector (__main__.EvidenceEncodingTests.test_control_escape_vector)",
    "test_decoded_codepoint_sort (__main__.EvidenceEncodingTests.test_decoded_codepoint_sort)",
    "test_double_terminal_lf_rejected (__main__.EvidenceEncodingTests.test_double_terminal_lf_rejected)",
    "test_evidence_lf_is_hashed (__main__.EvidenceEncodingTests.test_evidence_lf_is_hashed)",
    "test_extra_stdout_rejected (__main__.EvidenceEncodingTests.test_extra_stdout_rejected)",
    "test_float_rejected (__main__.EvidenceEncodingTests.test_float_rejected)",
    "test_invalid_utf8_rejected (__main__.EvidenceEncodingTests.test_invalid_utf8_rejected)",
    "test_literal_canonical_vector (__main__.EvidenceEncodingTests.test_literal_canonical_vector)",
    "test_negative_zero_rejected (__main__.EvidenceEncodingTests.test_negative_zero_rejected)",
    "test_nested_duplicate_rejected (__main__.EvidenceEncodingTests.test_nested_duplicate_rejected)",
    "test_nesting_bound_before_decode (__main__.EvidenceEncodingTests.test_nesting_bound_before_decode)",
    "test_non_nfc_rejected (__main__.EvidenceEncodingTests.test_non_nfc_rejected)",
    "test_nonfinite_rejected (__main__.EvidenceEncodingTests.test_nonfinite_rejected)",
    "test_unpaired_surrogate_rejected (__main__.EvidenceEncodingTests.test_unpaired_surrogate_rejected)",
    "test_whitespace_not_canonical (__main__.EvidenceEncodingTests.test_whitespace_not_canonical)",
    "test_all_valid_synthetic_shapes (__main__.SchemaAndBindingTests.test_all_valid_synthetic_shapes)",
    "test_boolean_registration_generation_rejected (__main__.SchemaAndBindingTests.test_boolean_registration_generation_rejected)",
    "test_exit_disagreement (__main__.SchemaAndBindingTests.test_exit_disagreement)",
    "test_identifier_trailing_lf_rejected (__main__.SchemaAndBindingTests.test_identifier_trailing_lf_rejected)",
    "test_invalid_cases_rejected_at_declared_layer (__main__.SchemaAndBindingTests.test_invalid_cases_rejected_at_declared_layer)",
    "test_late_consumption (__main__.SchemaAndBindingTests.test_late_consumption)",
    "test_long_uptime_string_accepted_structurally (__main__.SchemaAndBindingTests.test_long_uptime_string_accepted_structurally)",
    "test_registered_clock_mismatch (__main__.SchemaAndBindingTests.test_registered_clock_mismatch)",
    "test_selected_semantic_response_negatives (__main__.SchemaAndBindingTests.test_selected_semantic_response_negatives)",
    "test_selected_valid_ready_bindings (__main__.SchemaAndBindingTests.test_selected_valid_ready_bindings)",
    "test_timestamp_number_rejected (__main__.SchemaAndBindingTests.test_timestamp_number_rejected)"
  ]
}

3,041 bytes · SHA-256 487ffda516fa2d6ba609769029313517fbe7f528fde0a26b5b84330fa139c196

test_astral_scalar_vector (__main__.EvidenceEncodingTests.test_astral_scalar_vector) ... ok
test_brackets_in_string_are_not_depth (__main__.EvidenceEncodingTests.test_brackets_in_string_are_not_depth) ... ok
test_byte_limit (__main__.EvidenceEncodingTests.test_byte_limit) ... ok
test_control_escape_vector (__main__.EvidenceEncodingTests.test_control_escape_vector) ... ok
test_decoded_codepoint_sort (__main__.EvidenceEncodingTests.test_decoded_codepoint_sort) ... ok
test_double_terminal_lf_rejected (__main__.EvidenceEncodingTests.test_double_terminal_lf_rejected) ... ok
test_evidence_lf_is_hashed (__main__.EvidenceEncodingTests.test_evidence_lf_is_hashed) ... ok
test_extra_stdout_rejected (__main__.EvidenceEncodingTests.test_extra_stdout_rejected) ... ok
test_float_rejected (__main__.EvidenceEncodingTests.test_float_rejected) ... ok
test_invalid_utf8_rejected (__main__.EvidenceEncodingTests.test_invalid_utf8_rejected) ... ok
test_literal_canonical_vector (__main__.EvidenceEncodingTests.test_literal_canonical_vector) ... ok
test_negative_zero_rejected (__main__.EvidenceEncodingTests.test_negative_zero_rejected) ... ok
test_nested_duplicate_rejected (__main__.EvidenceEncodingTests.test_nested_duplicate_rejected) ... ok
test_nesting_bound_before_decode (__main__.EvidenceEncodingTests.test_nesting_bound_before_decode) ... ok
test_non_nfc_rejected (__main__.EvidenceEncodingTests.test_non_nfc_rejected) ... ok
test_nonfinite_rejected (__main__.EvidenceEncodingTests.test_nonfinite_rejected) ... ok
test_unpaired_surrogate_rejected (__main__.EvidenceEncodingTests.test_unpaired_surrogate_rejected) ... ok
test_whitespace_not_canonical (__main__.EvidenceEncodingTests.test_whitespace_not_canonical) ... ok
test_all_valid_synthetic_shapes (__main__.SchemaAndBindingTests.test_all_valid_synthetic_shapes) ... ok
test_boolean_registration_generation_rejected (__main__.SchemaAndBindingTests.test_boolean_registration_generation_rejected) ... ok
test_exit_disagreement (__main__.SchemaAndBindingTests.test_exit_disagreement) ... ok
test_identifier_trailing_lf_rejected (__main__.SchemaAndBindingTests.test_identifier_trailing_lf_rejected) ... ok
test_invalid_cases_rejected_at_declared_layer (__main__.SchemaAndBindingTests.test_invalid_cases_rejected_at_declared_layer) ... ok
test_late_consumption (__main__.SchemaAndBindingTests.test_late_consumption) ... ok
test_long_uptime_string_accepted_structurally (__main__.SchemaAndBindingTests.test_long_uptime_string_accepted_structurally) ... ok
test_registered_clock_mismatch (__main__.SchemaAndBindingTests.test_registered_clock_mismatch) ... ok
test_selected_semantic_response_negatives (__main__.SchemaAndBindingTests.test_selected_semantic_response_negatives) ... ok
test_selected_valid_ready_bindings (__main__.SchemaAndBindingTests.test_selected_valid_ready_bindings) ... ok
test_timestamp_number_rejected (__main__.SchemaAndBindingTests.test_timestamp_number_rejected) ... ok

----------------------------------------------------------------------
Ran 29 tests in 0.317s

OK

7,110 bytes · SHA-256 a978f28c5a1e14c29304f8535e2c2ed5cdf23b05dc26a591b5b0c53cf1f7f886

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1080 650" role="img" aria-labelledby="architecture-title architecture-desc"><title id="architecture-title">Scientific evidence and recovery authority</title><desc id="architecture-desc">Science and protected observation exchange evidence; only the recovery authority can instruct a separate actuator.</desc><defs><marker id="architecture-arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0 0L10 5L0 10Z" fill="#247ea4"/></marker></defs><rect x="0" y="0" width="1080" height="650" rx="18" fill="#f8fbfc"/><text x="32" y="38" font-family="Arial, Helvetica, sans-serif" font-size="16" font-weight="700" fill="#247ea4" text-anchor="start">RESPONSIBILITY AND TRUST</text><g class="diagram-card" data-right="325"><rect x="32" y="72" width="305" height="132" rx="12" fill="#eff5f7" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="86" width="5" height="104" rx="2" fill="#247ea4"/><text x="52" y="105" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Scientific model</text><text x="52" y="135" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Compute and validate tasks</text><text x="52" y="160" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">No host or device authority</text></g><g class="diagram-card" data-right="680"><rect x="387" y="72" width="305" height="132" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="387" y="86" width="5" height="104" rx="2" fill="#247ea4"/><text x="407" y="105" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Lifecycle adapter</text><text x="407" y="135" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Intent · drain · resume</text><text x="407" y="160" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Registered operations only</text></g><g class="diagram-card" data-right="1036"><rect x="742" y="72" width="306" height="132" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="742" y="86" width="5" height="104" rx="2" fill="#117e75"/><text x="762" y="105" font-family="Arial, Helvetica, sans-serif" font-size="21.0" font-weight="700" fill="#142d43" text-anchor="start">Approved registration</text><text x="762" y="135" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Sources · units · limits</text><text x="762" y="160" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Protected release identity</text></g><polyline points="337,138 382,138" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#architecture-arrow)"/><polyline points="742,138 697,138" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#architecture-arrow)"/><g class="diagram-card" data-right="325"><rect x="32" y="283" width="305" height="132" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="297" width="5" height="104" rx="2" fill="#247ea4"/><text x="52" y="316" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Durable result store</text><text x="52" y="346" font-family="Arial, Helvetica, sans-serif" font-size="17.0" font-weight="400" fill="#56697a" text-anchor="start">Payloads and accepted catalog</text><text x="52" y="371" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Defined crash boundaries</text></g><g class="diagram-card" data-right="680"><rect x="387" y="283" width="305" height="132" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="387" y="297" width="5" height="104" rx="2" fill="#117e75"/><text x="407" y="316" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Protected observer</text><text x="407" y="346" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">OS identity + real artifacts</text><text x="407" y="371" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Independent readiness proof</text></g><g class="diagram-card" data-right="1036"><rect x="742" y="283" width="306" height="132" rx="12" fill="#fff6ec" stroke="#aac1ca" stroke-width="1.5"/><rect x="742" y="297" width="5" height="104" rx="2" fill="#c46735"/><text x="762" y="316" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Recovery manager</text><text x="762" y="346" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Incident · holds · budgets</text><text x="762" y="371" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Final action barrier</text></g><polyline points="184,204 184,277" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#architecture-arrow)"/><polyline points="540,204 540,277" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#architecture-arrow)"/><polyline points="337,349 382,349" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#architecture-arrow)"/><polyline points="692,349 736,349" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#architecture-arrow)"/><polyline points="897,204 897,276" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#architecture-arrow)"/><g class="diagram-card" data-right="1036"><rect x="742" y="481" width="306" height="112" rx="12" fill="#fff6ec" stroke="#aac1ca" stroke-width="1.5"/><rect x="742" y="495" width="5" height="84" rx="2" fill="#c46735"/><text x="762" y="514" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Separate actuator</text><text x="762" y="544" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Exact permitted operation</text></g><polyline points="897,415 897,475" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#architecture-arrow)"/><text x="36" y="509" font-family="Arial, Helvetica, sans-serif" font-size="25" font-weight="600" fill="#142d43" text-anchor="start">READY is scientific evidence.</text><text x="36" y="548" font-family="Arial, Helvetica, sans-serif" font-size="25" font-weight="600" fill="#142d43" text-anchor="start">Power authority remains separate.</text><text x="36" y="598" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">The workload cannot rewrite its observer, registration, or reset allowance.</text></svg>

6,148 bytes · SHA-256 906b3c4d800329d9bd6099d406c019d387b1998dd523a24a830cbc8d3a7be9d1

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1080 638" role="img" aria-labelledby="commit-title commit-desc"><title id="commit-title">The durable publication boundary</title><desc id="commit-desc">Payload publication precedes acceptance segment publication; a mutable head advances only after its immutable references are durable.</desc><defs><marker id="commit-arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0 0L10 5L0 10Z" fill="#247ea4"/></marker></defs><rect x="0" y="0" width="1080" height="638" rx="18" fill="#f8fbfc"/><text x="32" y="38" font-family="Arial, Helvetica, sans-serif" font-size="16" font-weight="700" fill="#247ea4" text-anchor="start">COUNT ACCEPTED WORK, NOT FINISHED ATTEMPTS</text><g class="diagram-card" data-right="322"><rect x="32" y="68" width="302" height="136" rx="12" fill="#eff5f7" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="82" width="5" height="108" rx="2" fill="#247ea4"/><text x="52" y="101" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">01  Candidate</text><text x="52" y="131" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Complete payload</text><text x="52" y="156" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Validate scientific content</text></g><g class="diagram-card" data-right="679"><rect x="389" y="68" width="302" height="136" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="389" y="82" width="5" height="108" rx="2" fill="#247ea4"/><text x="409" y="101" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">02  Durable object</text><text x="409" y="131" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">File synchronization</text><text x="409" y="156" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">No-clobber + directory sync</text></g><g class="diagram-card" data-right="1036"><rect x="746" y="68" width="302" height="136" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="746" y="82" width="5" height="108" rx="2" fill="#247ea4"/><text x="766" y="101" font-family="Arial, Helvetica, sans-serif" font-size="18.5" font-weight="700" fill="#142d43" text-anchor="start">03  Acceptance segment</text><text x="766" y="131" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Exact task IDs + hashes</text><text x="766" y="156" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Link to preceding segment</text></g><polyline points="334,136 383,136" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#commit-arrow)"/><polyline points="691,136 740,136" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#commit-arrow)"/><g class="diagram-card" data-right="1036"><rect x="746" y="280" width="302" height="130" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="746" y="294" width="5" height="102" rx="2" fill="#117e75"/><text x="766" y="313" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">04  Durable head</text><text x="766" y="343" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Advance after segment sync</text><text x="766" y="368" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Synchronize head directory</text></g><polyline points="897,204 897,274" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#commit-arrow)"/><g class="diagram-card" data-right="679"><rect x="32" y="280" width="659" height="130" rx="12" fill="#fff6ec" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="294" width="5" height="102" rx="2" fill="#c46735"/><text x="52" y="313" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Restart interprets the interruption point</text><text x="52" y="343" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Unaccepted candidate → validate or recompute</text><text x="52" y="368" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Accepted corruption → block and preserve evidence</text></g><polyline points="746,345 698,345" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#commit-arrow)"/><g class="diagram-card" data-right="502"><rect x="32" y="470" width="482" height="110" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="484" width="5" height="82" rx="2" fill="#247ea4"/><text x="52" y="503" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Before acceptance</text><text x="52" y="533" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">May be retried under the orphan policy</text></g><g class="diagram-card" data-right="1036"><rect x="566" y="470" width="482" height="110" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="566" y="484" width="5" height="82" rx="2" fill="#117e75"/><text x="586" y="503" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">After acceptance</text><text x="586" y="533" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Same task and digest recovered exactly once</text></g><text x="540" y="616" font-family="Arial, Helvetica, sans-serif" font-size="19" font-weight="400" fill="#56697a" text-anchor="middle">Atomic publication and storage durability are separate guarantees.</text></svg>

5,594 bytes · SHA-256 20e2d431323e70a067a15b6843c30e7768f4a509ba3070bc038ff496d67e1e1a

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1080 604" role="img" aria-labelledby="epochs-title epochs-desc"><title id="epochs-title">A numerical environment change creates a new acceptance gate</title><desc id="epochs-desc">Dispatch is fenced while a fixed panel is recomputed in a fresh stable environment; agreement accepts an epoch, mismatch preserves a block.</desc><defs><marker id="epochs-arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0 0L10 5L0 10Z" fill="#247ea4"/></marker></defs><rect x="0" y="0" width="1080" height="604" rx="18" fill="#f8fbfc"/><text x="32" y="38" font-family="Arial, Helvetica, sans-serif" font-size="16" font-weight="700" fill="#247ea4" text-anchor="start">ENVIRONMENT CHANGES REQUIRE EVIDENCE</text><g class="diagram-card" data-right="322"><rect x="32" y="71" width="302" height="125" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="85" width="5" height="97" rx="2" fill="#117e75"/><text x="52" y="104" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Accepted epoch A</text><text x="52" y="134" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Original payloads</text><text x="52" y="159" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Frozen panel and controls</text></g><g class="diagram-card" data-right="679"><rect x="389" y="71" width="302" height="125" rx="12" fill="#fff6ec" stroke="#aac1ca" stroke-width="1.5"/><rect x="389" y="85" width="5" height="97" rx="2" fill="#c46735"/><text x="409" y="104" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Detected change</text><text x="409" y="134" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Boot or runtime drift</text><text x="409" y="159" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Fence production admission</text></g><g class="diagram-card" data-right="1036"><rect x="746" y="71" width="302" height="125" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="746" y="85" width="5" height="97" rx="2" fill="#247ea4"/><text x="766" y="104" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Fresh replay</text><text x="766" y="134" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Recompute selected tasks</text><text x="766" y="159" font-family="Arial, Helvetica, sans-serif" font-size="16.0" font-weight="400" fill="#56697a" text-anchor="start">Check environment before/after</text></g><polyline points="334,134 383,134" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#epochs-arrow)"/><polyline points="691,134 740,134" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#epochs-arrow)"/><g class="diagram-card" data-right="679"><rect x="389" y="275" width="302" height="126" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="389" y="289" width="5" height="98" rx="2" fill="#247ea4"/><text x="409" y="308" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Comparison gate</text><text x="409" y="338" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Original numerical payloads</text><text x="409" y="363" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Frozen exactness/tolerance</text></g><polyline points="897,196 897,244 540,244 540,269" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#epochs-arrow)"/><g class="diagram-card" data-right="470"><rect x="32" y="440" width="450" height="120" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="454" width="5" height="92" rx="2" fill="#117e75"/><text x="52" y="473" font-family="Arial, Helvetica, sans-serif" font-size="21.5" font-weight="700" fill="#142d43" text-anchor="start">Agreement + stable environment</text><text x="52" y="503" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Accept epoch B; retain the original baseline</text></g><g class="diagram-card" data-right="1036"><rect x="598" y="440" width="450" height="120" rx="12" fill="#fff6ec" stroke="#aac1ca" stroke-width="1.5"/><rect x="598" y="454" width="5" height="92" rx="2" fill="#c46735"/><text x="618" y="473" font-family="Arial, Helvetica, sans-serif" font-size="20.5" font-weight="700" fill="#142d43" text-anchor="start">Mismatch or unstable environment</text><text x="618" y="503" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Preserve evidence; retain dispatch block</text></g><polyline points="470,401 470,422 257,422 257,434" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#epochs-arrow)"/><polyline points="610,401 610,422 823,422 823,434" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#epochs-arrow)"/><text x="540" y="591" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="middle">No baseline rewriting. No resampling until a mismatch disappears.</text></svg>

6,370 bytes · SHA-256 a6af8e733af7d8eaaeadb2037b8286d8997b1f148defb29f87c6c784625b9eae

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1080 630" role="img" aria-labelledby="installation-title installation-desc"><title id="installation-title">Activation is not installation completion</title><desc id="installation-desc">The installer stages and tests a release, activates the registration, completes the commissioned branch and finalization, and reports paused success before an explicit start.</desc><defs><marker id="installation-arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0 0L10 5L0 10Z" fill="#247ea4"/></marker></defs><rect x="0" y="0" width="1080" height="630" rx="18" fill="#f8fbfc"/><text x="32" y="38" font-family="Arial, Helvetica, sans-serif" font-size="16" font-weight="700" fill="#247ea4" text-anchor="start">THE RELEASE GATE INCLUDES FINALIZATION</text><g class="diagram-card" data-right="322"><rect x="32" y="69" width="302" height="124" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="83" width="5" height="96" rx="2" fill="#247ea4"/><text x="52" y="102" font-family="Arial, Helvetica, sans-serif" font-size="20.0" font-weight="700" fill="#142d43" text-anchor="start">01  Stage and preflight</text><text x="52" y="132" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Immutable release</text><text x="52" y="157" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Actual target prerequisites</text></g><g class="diagram-card" data-right="679"><rect x="389" y="69" width="302" height="124" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="389" y="83" width="5" height="96" rx="2" fill="#247ea4"/><text x="409" y="102" font-family="Arial, Helvetica, sans-serif" font-size="17.0" font-weight="700" fill="#142d43" text-anchor="start">02  Bootstrap and validate</text><text x="409" y="132" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Real model and pool</text><text x="409" y="157" font-family="Arial, Helvetica, sans-serif" font-size="15.5" font-weight="400" fill="#56697a" text-anchor="start">Baseline and durable acceptance</text></g><g class="diagram-card" data-right="1036"><rect x="746" y="69" width="302" height="124" rx="12" fill="#fff6ec" stroke="#aac1ca" stroke-width="1.5"/><rect x="746" y="83" width="5" height="96" rx="2" fill="#c46735"/><text x="766" y="102" font-family="Arial, Helvetica, sans-serif" font-size="18.5" font-weight="700" fill="#142d43" text-anchor="start">03  Activate registration</text><text x="766" y="132" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Record active generation</text><text x="766" y="157" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Finalization still pending</text></g><polyline points="334,130 383,130" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#installation-arrow)"/><polyline points="691,130 740,130" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#installation-arrow)"/><g class="diagram-card" data-right="1036"><rect x="746" y="285" width="302" height="124" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="746" y="299" width="5" height="96" rx="2" fill="#247ea4"/><text x="766" y="318" font-family="Arial, Helvetica, sans-serif" font-size="18.0" font-weight="700" fill="#142d43" text-anchor="start">04  Commissioned branch</text><text x="766" y="348" font-family="Arial, Helvetica, sans-serif" font-size="17.5" font-weight="400" fill="#56697a" text-anchor="start">Boot resolver and consumers</text><text x="766" y="373" font-family="Arial, Helvetica, sans-serif" font-size="15.5" font-weight="400" fill="#56697a" text-anchor="start">Restore only owned holds/timers</text></g><g class="diagram-card" data-right="679"><rect x="389" y="285" width="302" height="124" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="389" y="299" width="5" height="96" rx="2" fill="#117e75"/><text x="409" y="318" font-family="Arial, Helvetica, sans-serif" font-size="20.0" font-weight="700" fill="#142d43" text-anchor="start">05  Complete · PAUSED</text><text x="409" y="348" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Verify final installed state</text><text x="409" y="373" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">No bulk launch by installer</text></g><g class="diagram-card" data-right="322"><rect x="32" y="285" width="302" height="124" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="299" width="5" height="96" rx="2" fill="#117e75"/><text x="52" y="318" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">06  Explicit start</text><text x="52" y="348" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">New execution identity</text><text x="52" y="373" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Observe new accepted work</text></g><polyline points="897,193 897,279" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#installation-arrow)"/><polyline points="746,346 697,346" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#installation-arrow)"/><polyline points="389,346 340,346" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#installation-arrow)"/><g class="diagram-card" data-right="1036"><rect x="32" y="488" width="1016" height="97" rx="12" fill="#eff5f7" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="502" width="5" height="69" rx="2" fill="#247ea4"/><text x="52" y="521" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Interrupt and resume at every boundary</text><text x="52" y="551" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Preserve coherent registration, accepted science, owned holds, and spent recovery history.</text></g></svg>

5,697 bytes · SHA-256 6cfa1e005ef104db3247aa84a86fa847997f52443c3491c227ea00196f1c3349

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1080 689" role="img" aria-labelledby="lifecycle-title lifecycle-desc"><title id="lifecycle-title">Durable intent governs restart</title><desc id="lifecycle-desc">A new boot reconciles intent and evidence. Planned pause stays paused; accepted RUN validates before computation; integrity blocks and verified completion remain distinct.</desc><defs><marker id="lifecycle-arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0 0L10 5L0 10Z" fill="#247ea4"/></marker></defs><rect x="0" y="0" width="1080" height="689" rx="18" fill="#f8fbfc"/><text x="32" y="38" font-family="Arial, Helvetica, sans-serif" font-size="16" font-weight="700" fill="#247ea4" text-anchor="start">RESTART FROM DURABLE INTENT</text><g class="diagram-card" data-right="709"><rect x="359" y="66" width="362" height="108" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="359" y="80" width="5" height="80" rx="2" fill="#247ea4"/><text x="379" y="99" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Boot / process restart</text><text x="379" y="129" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Reconcile current registration</text></g><g class="diagram-card" data-right="322"><rect x="32" y="246" width="302" height="113" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="260" width="5" height="85" rx="2" fill="#247ea4"/><text x="52" y="279" font-family="Arial, Helvetica, sans-serif" font-size="17.5" font-weight="700" fill="#142d43" text-anchor="start">PAUSE or uncommissioned</text><text x="52" y="309" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Retain the production fence</text></g><g class="diagram-card" data-right="679"><rect x="389" y="246" width="302" height="113" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="389" y="260" width="5" height="85" rx="2" fill="#247ea4"/><text x="409" y="279" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Accepted RUN</text><text x="409" y="309" font-family="Arial, Helvetica, sans-serif" font-size="16.0" font-weight="400" fill="#56697a" text-anchor="start">Verify commits and environment</text></g><g class="diagram-card" data-right="1036"><rect x="746" y="246" width="302" height="113" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="746" y="260" width="5" height="85" rx="2" fill="#117e75"/><text x="766" y="279" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Verified COMPLETE</text><text x="766" y="309" font-family="Arial, Helvetica, sans-serif" font-size="15.5" font-weight="400" fill="#56697a" text-anchor="start">No further production scheduling</text></g><polyline points="450,174 450,211 183,211 183,240" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#lifecycle-arrow)"/><polyline points="540,174 540,240" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#lifecycle-arrow)"/><polyline points="630,174 630,211 897,211 897,240" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#lifecycle-arrow)"/><g class="diagram-card" data-right="322"><rect x="32" y="441" width="302" height="115" rx="12" fill="#fff6ec" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="455" width="5" height="87" rx="2" fill="#c46735"/><text x="52" y="474" font-family="Arial, Helvetica, sans-serif" font-size="20.5" font-weight="700" fill="#142d43" text-anchor="start">Unknown or mismatch</text><text x="52" y="504" font-family="Arial, Helvetica, sans-serif" font-size="17.0" font-weight="400" fill="#56697a" text-anchor="start">Visible block; preserve history</text></g><g class="diagram-card" data-right="679"><rect x="389" y="441" width="302" height="115" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="389" y="455" width="5" height="87" rx="2" fill="#117e75"/><text x="409" y="474" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Validation passed</text><text x="409" y="504" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Admit only missing work</text></g><g class="diagram-card" data-right="1036"><rect x="746" y="441" width="302" height="115" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="746" y="455" width="5" height="87" rx="2" fill="#247ea4"/><text x="766" y="474" font-family="Arial, Helvetica, sans-serif" font-size="20.0" font-weight="700" fill="#142d43" text-anchor="start">Current progress proof</text><text x="766" y="504" font-family="Arial, Helvetica, sans-serif" font-size="17.5" font-weight="400" fill="#56697a" text-anchor="start">Fresh identity + new commits</text></g><polyline points="455,359 455,400 183,400 183,435" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#lifecycle-arrow)"/><polyline points="540,359 540,435" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#lifecycle-arrow)"/><polyline points="691,498 740,498" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#lifecycle-arrow)"/><rect x="32" y="607" width="1016" height="54" rx="9" fill="#142d43"/><text x="540" y="641" font-family="Arial, Helvetica, sans-serif" font-size="20" font-weight="600" fill="white" text-anchor="middle">Planned maintenance records PAUSE before draining and preserves it across boot.</text></svg>

4,162 bytes · SHA-256 1908275f63615dad7601bbd06857cb7d5fd7ec3b2e88ad08eb4b87ccace6fb0d

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1080 597" role="img" aria-labelledby="processes-title processes-desc"><title id="processes-title">Workers and multiprocessing helpers have different roles</title><desc id="processes-desc">The recursive process boundary includes the executor, forkserver, resource tracker, and calculation workers. Every role requires authenticated identity.</desc><defs><marker id="processes-arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0 0L10 5L0 10Z" fill="#247ea4"/></marker></defs><rect x="0" y="0" width="1080" height="597" rx="18" fill="#f8fbfc"/><text x="32" y="38" font-family="Arial, Helvetica, sans-serif" font-size="16" font-weight="700" fill="#247ea4" text-anchor="start">ONE RECURSIVE PROCESS BOUNDARY</text><rect x="32" y="59" width="1016" height="442" rx="16" fill="none" stroke="#aac1ca" stroke-width="2" stroke-dasharray="8 6"/><g class="diagram-card" data-right="710"><rect x="358" y="87" width="364" height="104" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="358" y="101" width="5" height="76" rx="2" fill="#247ea4"/><text x="378" y="120" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Science executor</text><text x="378" y="150" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Registered service invocation</text></g><g class="diagram-card" data-right="484"><rect x="81" y="263" width="415" height="118" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="81" y="277" width="5" height="90" rx="2" fill="#247ea4"/><text x="101" y="296" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Forkserver helper</text><text x="101" y="326" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Verified interpreter, argv and lineage</text></g><g class="diagram-card" data-right="982"><rect x="579" y="263" width="415" height="118" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="579" y="277" width="5" height="90" rx="2" fill="#247ea4"/><text x="599" y="296" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Resource tracker helper</text><text x="599" y="326" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Verified interpreter, argv and lineage</text></g><polyline points="450,191 450,226 288,226 288,257" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#processes-arrow)"/><polyline points="630,191 630,226 786,226 786,257" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#processes-arrow)"/><g class="diagram-card" data-right="484"><rect x="81" y="411" width="415" height="71" rx="12" fill="#fff6ec" stroke="#aac1ca" stroke-width="1.5"/><rect x="81" y="425" width="5" height="43" rx="2" fill="#c46735"/><text x="101" y="444" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Calculation workers</text></g><polyline points="288,381 288,405" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#processes-arrow)"/><text x="580" y="429" font-family="Arial, Helvetica, sans-serif" font-size="19" font-weight="400" fill="#56697a" text-anchor="start">A pool may leave helpers alive.</text><text x="580" y="454" font-family="Arial, Helvetica, sans-serif" font-size="19" font-weight="400" fill="#56697a" text-anchor="start">A live calculation worker still</text><text x="580" y="479" font-family="Arial, Helvetica, sans-serif" font-size="19" font-weight="400" fill="#56697a" text-anchor="start">blocks the numerical barrier.</text><rect x="32" y="525" width="1016" height="54" rx="9" fill="#142d43"/><text x="540" y="559" font-family="Arial, Helvetica, sans-serif" font-size="20" font-weight="600" fill="white" text-anchor="middle">A recognized command string alone is never sufficient process identity.</text></svg>

5,411 bytes · SHA-256 a45f8cd8e889f9223e4ddcfde94ab517a47b8ed8a84e628f2174b65e9e303d94

<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 1080 442" role="img" aria-labelledby="release-gap-title release-gap-desc"><title id="release-gap-title">The branch that numerical commissioning did not cover</title><desc id="release-gap-desc">Bootstrap numerical success did not exercise the commissioned boot resolver, finalization, and production progress branches.</desc><defs><marker id="release-gap-arrow" viewBox="0 0 10 10" refX="8" refY="5" markerWidth="7" markerHeight="7" orient="auto-start-reverse"><path d="M0 0L10 5L0 10Z" fill="#247ea4"/></marker></defs><rect x="0" y="0" width="1080" height="442" rx="18" fill="#f8fbfc"/><text x="32" y="38" font-family="Arial, Helvetica, sans-serif" font-size="16" font-weight="700" fill="#247ea4" text-anchor="start">TWO BRANCHES, ONE RELEASE</text><g class="diagram-card" data-right="322"><rect x="32" y="65" width="302" height="125" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="79" width="5" height="97" rx="2" fill="#117e75"/><text x="52" y="98" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Bootstrap</text><text x="52" y="128" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Real model kernels</text><text x="52" y="153" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Baseline and replay panel</text></g><g class="diagram-card" data-right="679"><rect x="389" y="65" width="302" height="125" rx="12" fill="#fff6ec" stroke="#aac1ca" stroke-width="1.5"/><rect x="389" y="79" width="5" height="97" rx="2" fill="#c46735"/><text x="409" y="98" font-family="Arial, Helvetica, sans-serif" font-size="19.5" font-weight="700" fill="#142d43" text-anchor="start">Commissioned resolver</text><text x="409" y="128" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Different startup branch</text><text x="409" y="153" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Temporary-file allocation</text></g><g class="diagram-card" data-right="1036"><rect x="746" y="65" width="302" height="125" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="746" y="79" width="5" height="97" rx="2" fill="#247ea4"/><text x="766" y="98" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Finalization</text><text x="766" y="128" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Recovery holds and timers</text><text x="766" y="153" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">Installed consumer checks</text></g><polyline points="334,127 385,127" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#release-gap-arrow)"/><polyline points="691,127 742,127" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#release-gap-arrow)"/><g class="diagram-card" data-right="322"><rect x="32" y="237" width="302" height="111" rx="12" fill="white" stroke="#aac1ca" stroke-width="1.5"/><rect x="32" y="251" width="5" height="83" rx="2" fill="#117e75"/><text x="52" y="270" font-family="Arial, Helvetica, sans-serif" font-size="18.0" font-weight="700" fill="#142d43" text-anchor="start">Historical numerical pass</text><text x="52" y="300" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">73 FIT tiles · 19 comparisons</text></g><g class="diagram-card" data-right="679"><rect x="389" y="237" width="302" height="111" rx="12" fill="#fff6ec" stroke="#aac1ca" stroke-width="1.5"/><rect x="389" y="251" width="5" height="83" rx="2" fill="#c46735"/><text x="409" y="270" font-family="Arial, Helvetica, sans-serif" font-size="22" font-weight="700" fill="#142d43" text-anchor="start">Historical blocker</text><text x="409" y="300" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">No usable temporary space</text></g><g class="diagram-card" data-right="1036"><rect x="746" y="237" width="302" height="111" rx="12" fill="#e9f5f0" stroke="#aac1ca" stroke-width="1.5"/><rect x="746" y="251" width="5" height="83" rx="2" fill="#117e75"/><text x="766" y="270" font-family="Arial, Helvetica, sans-serif" font-size="20.0" font-weight="700" fill="#142d43" text-anchor="start">Later production proof</text><text x="766" y="300" font-family="Arial, Helvetica, sans-serif" font-size="18" font-weight="400" fill="#56697a" text-anchor="start">137 FIT tiles · 64 new</text></g><polyline points="183,190 183,231" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#release-gap-arrow)"/><polyline points="540,190 540,231" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#release-gap-arrow)"/><polyline points="897,190 897,231" fill="none" stroke="#247ea4" stroke-width="2.5" marker-end="url(#release-gap-arrow)"/><rect x="32" y="370" width="1016" height="54" rx="9" fill="#142d43"/><text x="540" y="404" font-family="Arial, Helvetica, sans-serif" font-size="20" font-weight="600" fill="white" text-anchor="middle">A complete release test must cross the commissioning boundary.</text></svg>