Implementation Profile: JWM

Implementation Profile: JWM — Trusted World Model Harness

Specification Metadata

• Identifier: PROFILE-JWM
• Version: 0.81
• Status: Draft
• Snapshot date: 2026-08-11
• Scope: Documents JWM, a working single-developer implementation of the reference architecture. The implementation facts initially recorded as of 2026-07-07 included 80 merged increments and 306 automated tests; the 2026-07-13 profile snapshot reconciled subsequent findings, including the PROV-0 increment, without rewriting that history. The 2026-08-01 snapshots recorded OpenUSD interoperability evidence while preserving the profile's historical register; this 2026-08-11 snapshot adds standard-RL-environment-contract evidence. Records layer mappings, decision-fork positions, conformance evidence, deviations, and gaps.
• Dependencies: Main book v0.2 (Volumes I–X); Appendix A (research sequence); ADR-0004; Agent Contracts v0.1.0; Model Contracts v0.1.0; Trust Contracts v0.1.0; Evidence Graph v0.1.0; Ontology v0.1.0.
• Compatibility policy: This profile tracks the implementation; the reference architecture never depends on it. Profile revisions accompany implementation phase boundaries.
• Change history: 0.1 (2026-07-06) — initial profile. 0.2 (2026-07-06) — Phase T (Evidence & Trust fabric) delivered: evidence packets, validity envelopes, uncertainty metadata, artifact integrity, conformance gate. 0.3 (2026-07-07) — Phase L (kernel/domain/app separation) + the inventors'-gallery application family: three physics domains compose through one registry seam; evidence packets ship as end-user artifacts. 0.4 (date status to be confirmed against the implementation) — DEV-phase findings: published artifact schemas, an agent-facing development surface, sensor-honest synthetic telemetry, deterministic geometry artifacts, and a fourth physics domain. 0.5 (2026-07-13) — reconciled the implementation snapshot and added the jBOK conformance mapping. 0.6 (2026-07-13) — recorded PROV-0 findings: guarded model-provenance declarations, paired equation/provenance inventories, dual-audience manifest introspection, runtime composition coverage, and EvidencePacket binding. 0.7 (2026-08-01) — recorded OpenUSD/Omniverse interoperability evidence: physics-schema USD interop stage verified through the Pixar reference implementation with jwm:hash provenance; USDZ renders in Apple Quick Look; Isaac Sim validation environment-blocked (documented); NVIDIA-writer round trip pending. 0.8 (2026-08-01) — runtime validation closed: full headless Isaac Sim 6.0.1 session on AWS g6.xlarge (the 5.x boot crash was root-caused as container-generation, reproducing on Intel/GCP and AMD/AWS alike); NVIDIA-writer round trip re-ingested through ingest-physics with jwm:hash verified; open item recorded — revolute-joint rest-pose semantics under runtime solve. 0.81 (2026-08-11) — standard-RL-environment-contract evidence recorded: a Gymnasium adapter closes reset/step/seed through the existing command-stream, projection, and process-boundary seams with bit-identically replayable episodes and a passing environment checker; the PPO smoke run's no-learning result is recorded as such (JWM EXP-0012).

Summary

JWM is a physics-based world-model harness: a deterministic fixed-timestep simulation core with pluggable physics/context systems, agent and AI-adapter seams, record/replay as the trust primitive, and content-hashed environment/model/reference artifacts. It is browser-primary with a headless batch twin from the same core, built TypeScript-first with a designed-in native-core future swap. The first demonstration payload is small-UAS flight over real terrain; the harness itself is payload-agnostic.

Relevance to this book: JWM was built to a nine-contract architecture drafted from the same philosophy that produced this reference architecture. It therefore serves as the book's first conformance data point — evidence of which recommended defaults survive contact with implementation.

Profile Facts (per Appendix C)

• Deployment pattern: single-node developer workstation; browser UI + local headless CLI; remote access via an identity-bearing overlay network (server loopback-only, TLS and tailnet identity at the proxy). No multi-organization federation yet.
• Security assumptions: single trusted operator; secrets in untracked local files or browser storage, never in artifacts or version control; least-privilege CI; renderer/network supply chain audited. Zero-trust identity, policy-as-code, and compartmentation are out of scope at current maturity.
• Data handling: all environment data baked offline into content-hashed snapshots with provenance embedded (bake-for-determinism); live geo services are render-only by policy; licensing boundaries enforced by process isolation (copyleft solvers run out-of-process over a JSON protocol).
• Compute environment: consumer arm64 workstation; browser WebGL for presentation; Node for batch campaigns; external Python solvers at arm's length.
• Interface versions: nine internal contracts (world state, sim step, system plugin, command stream, orchestrator, observation, AI adapter, record/replay + VVUQ, provenance) with a versioned world-state schema at v7 and an additive-evolution discipline.
• Maturity (capability maturity framework): most capabilities are at Level 1–2 (documented, tested prototype); determinism/replay and scenario pinning are Level 2 because their interoperability evidence is internal to this implementation. Level 3 would require conformance results against stable ecosystem contracts plus demonstrated replacement or composition with independently developed capabilities.

Conformance mapping

The five jBOK dependencies above are draft seed specifications at v0.1.0. This table records semantic alignment; it does not claim conformance where the jBOK specifications do not define the JWM interface or provide portable schemas and tests.

Layer Mapping (reference architecture ↔ implementation)

Decision-Fork Positions (Volume VII)

JWM's built positions match the book's recommended defaults in nearly every fork, most established independently before this comparison: specialist agents with LLMs behind role boundaries and human approval; physics-informed hierarchy (learned/black-box components restricted, external solvers behind process boundaries); plugin-first (experimental systems in a registry namespace, judged by a compare harness, promoted deliberately); deterministic workflows with event-style observability; mission-specific world models with shared semantic contracts; graduated autonomy tied to consequence; hybrid knowledge-plus-evidence recording (the Phase T evidence support graph and lineage have shipped; the broader hybrid knowledge-plus-evidence claim graph remains pending).

Notable evidence for two forks:

• Physics-first discipline: during trajectory calibration the implementation declined to fit physics parameters to residuals that guidance-tempo analysis attributed to the flight-stack, and recorded parameter unobservability (thrust/torque coefficients unidentifiable through closed-loop flight) as a null result. This is "evidence over assertion" applied to the implementation's own fidelity claims.
• Determinism as trust primitive: a fixed-timestep, seeded, pure step driven by an ordered command stream made every interactive session a reproducible experiment, dissolving the playable-versus-repeatable trade rather than balancing it. The profile recommends the book promote this from implementation detail to a named pattern.

Distribution doctrine (HumIL checkpoint, 2026-07-07) — evidence composes, sims don't: each simulation stays a deterministic single process (replayability is the trust primitive and parallelism is its enemy at this maturity); system-of-systems scale composes at the artifact level — evidence packets, validity envelopes, charters and hash-pinned models cross organizational and process boundaries, simulation state does not. External heavy compute stays at arm's length behind process boundaries (the solver pattern). Named triggers to revisit: a scenario requiring tick-coupled cross-sim physics (co-simulation), or fleet scale beyond the measured single-process wall (~500 vehicles real-time after the 2026-07 broad-phase fix; Rust-core trigger armed). Federation design precedes any federation build.

Model & artifact registry (MODEL-REPO MR-0..3, 2026-07-07) — a content-addressed, append-only registry (write-once SHA-256 objects; versioned ref records carrying lineage, origin and the why) with comparative re-run as its purpose — rerun/compare-versions resolve a scenario and two model versions from the registry and emit paired evidence packets plus a delta report, all four artifacts pinned to each other, and evidence-packet pins became resolvable registry refs. Identity landed with it: Ed25519 keys in an append-only key registry (private keys never enter the store), signatures over canonical ref records so no signed field — including the why — drifts undetected, agent keys required to pin their charter hash, and trust kept out of band (a deployment list; verification reports who vouches, policy decides belief). External imports run a verification pipeline — validate what can be validated, recompute declared hashes, record an ingest report either way, and refuse to pin what lies (a tampered artifact with a stale identity hash is refused, with the refusal itself recorded as provenance). The committed canon is seeded and signed; a Studio desk browses catalog, lineage, vouching and ingest chains read-only. A rerun claims "exact reproduction" only when the scenario's hash pin proves it.

Deviations and Gaps

Phase T (Evidence & Trust fabric) closed the four items marked RESOLVED below; they are kept in the register with their resolution for traceability.

1. Evidence packets — RESOLVED (Phase T): a portable claim→evidence artifact (headless report) binds claim, scenario, hash pins, composed-System assumptions, per-objective pass rates, and uncertainty; generated by deterministic replay so historical runs gain evidence retroactively; SHA-256 integrity + an evidence graph make the support chain verifiable end to end.
2. Validity envelopes — RESOLVED (Phase T): machine-readable envelopes (use context, checkable conditions, exclusions, confidence, invalidation triggers) on System manifests; agents check the model stack's envelopes and flag out-of-envelope plans. The X3 identifiability null result is now a live recorded exclusion.
3. Composable uncertainty — PARTIAL (Phase T v0): a three-component record (aleatory/epistemic/numerical) attaches to evidence packets — aleatory computed from the ensemble, epistemic/numerical declared. Typed propagation across chained workflows remains future work.
4. Agent charters informal — PARTIAL (DEV-0 + MR-2, 2026-07): a published agent-charter schema (CHARTER-0) plus a reference charter for the waypoint agent (command sources, reads, autonomy level, bounds, escalation triggers, evidence duties); registry signing keys of kind agent now require a charter hash, and the seeded canon is signed under one — charter-hash pinning is real at the artifact layer. Runtime enforcement of charter bounds and charter pinning in recordings remain open.
5. Conformance — RESOLVED (Phase T, embryonic): a dedicated conformance gate (pnpm test:conformance) asserts the load-bearing invariants — bit-identical replay, WorldState round-trip, schema versioning, purity, the Projection rule, and the observer property. Broader third-party conformance (custom Systems, alternate cores) can extend it.
6. Fidelity selected by hand — PARTIAL (FID-0, 2026-07): MFMC model management (Peherstorfer–Willcox–Gunzburger 2016) plans variance-optimal allocations across the fidelity pair and seals the choice — models, measured costs, measured correlation, allocation, and why — as a content-hashed FidelityPolicy artifact; the first real verdict declined MFMC (solved-wind table ≈ analytic runtime cost, ρ=0.66 → plain MC optimal, recorded). Error-estimator-driven and per-region selection remain open.
7. Content hashes are identity, not security — LARGELY RESOLVED (Phase T + MODEL-REPO 2026-07): evidence packets carry verified SHA-256; the registry stores every cataloged artifact under a SHA-256 content address with Ed25519-signed ref records, an out-of-band trust list, and import-time recomputation of declared identity hashes ("refuse to pin what lies"). Legacy fnv pins are cross-linked at ingest. Remaining: signatures on evidence packets themselves (signatures[] reserved), and human co-signing alongside the agent key.
8. Single-operator security posture — appropriate to maturity; federation-grade identity/policy deliberately deferred. Open.
9. Omniverse/Isaac runtime validation — RESOLVED (2026-08-01): full headless Isaac Sim 6.0.1 session; NVIDIA-writer round trip re-ingested at home with jwm:hash verified. Successor item, open: the revolute joint constrains its beam but settles at the joint anchor rather than the authored rest pose — audit authored joint frames against solver semantics before re-enabling the pin assertion.

Digital-Twin Formalism (Kapteyn–Willcox mapping)

Adopted 2026-07-07: JWM's stack is an instance of the probabilistic graphical-model digital twin of Kapteyn, Pretorius & Willcox (Nature Computational Science 1:337–347, 2021; see jBOK Appendix K for the NASEM gap crosswalk). The mapping, term for term:

The delta row is the register entry: JWM updates its digital state deterministically with provenance, not probabilistically with posteriors. That is a deliberate DLMA (Distributed/Decoupled, Layered, Modular, Adaptive) trade (replayability first).

Feedback into the Architecture

v0.3 findings — kernel/domain separation and evidence as product (Phase L / gallery)

• The two-domain rule. One domain can always cheat a kernel/domain seam; two cannot. Extracting the flight stack into a domain package looked complete, yet the second domain (2-D workshop physics) immediately exposed a hidden coupling: world factories that build component tables as typed literals break the moment any other domain augments the shared table type. The fix (build from the runtime registry) is mechanical — but only a second domain forces it. Recommendation: the book should state that a pluggable-state seam is unproven until at least two independently authored domains compose through it.
• Physics breadth costs almost nothing once the seam exists. After the registry seam, each new physics fabric (fluid statics, revolute mechanisms, quadratic-drag descent, longitudinal flight, and a non-mechanics electromagnetic domain) entered as one codec + one type augmentation + one System, with the kernel untouched. The marginal cost of breadth is now the physics itself, not the plumbing — evidence for the book's claim that contracts-first amortizes.
• Closed-form oracles as acceptance tests. Every new System shipped with an analytic result as its test oracle (law of the lever tan θ* = −Σma/(M·d); cart range d = E/(mgc_rr); terminal speed; glide ratio ceiling (L/D)max = 1/(2√(kC_D0)); RLC f_d = f₀√(1−ζ²)). Where a closed form exists, it beats golden files: it survives refactors, explains failures, and doubles as the player-facing "law". Candidate normative guidance for the model-fabric chapter.
• Evidence packets as end-user artifacts. The educational application seals a verified EvidencePacket as the outcome of play — the "trophy" is the trust artifact, deduplicated by content hash because the same deterministic trial is the same claim. Two sub-patterns worth naming in Volume V: (1) failed claims seal with equal ceremony (a supported and an unsupported claim are the same artifact class, differing only in outcome — this normalizes honest negative results for lay users); (2) evidence you re-earn — the wall stores only claim identity; the packet re-derives on replay.
• Real rebuilds as calibration references for models of historical designs. The workshop Systems anchor to physical rebuild data (a 2004 spring-cart run, a 2000 full-scale parachute jump, a 2002 period-materials glider flight) exactly the way the UAS domain anchors to a PX4 flight log — the X-track reference pattern generalizes beyond telemetry to any documented physical trial.
• Choreography above the command seam. The light-show pilot compiles formations into ordinary per-vehicle agent goals, so the sim never sees anything but the human command stream; the show's go/no-go is an evidence packet (completes · zero hard impacts · all land). Naive slot assignment is declared as an assumption in the packet — the evidence artifact is where a known limitation waits for its replacement increment.
• The book's Appendix B Minimum Viable Ecosystem is achievable by one developer in ~50 increments if contracts are locked first and every increment lands behind an existing seam. The two boxes that lagged — evidence packets and composable UQ — were closed in a single follow-on phase (Phase T) once the deterministic contact/damage substrate existed, confirming that evidence and UQ are cheap to add late only because determinism was in from the start. Recommendation: the book should name deterministic, replayable execution as a prerequisite for the Evidence and Trust fabrics, not merely a nice-to-have.
• Evidence that re-derives beats evidence that is stored. Because JWM's runs are deterministic, an evidence packet is reproduced by re-running its scenario rather than trusted as a saved blob — old recordings gain packets retroactively. This is a stronger form of "evidence over assertion" than an immutable-log model and is worth elevating in Volume V.
• Additive schema evolution (versioned world-state with default-empty loads, now at v7) plus command-stream ordering sustained 59 increments and seven schema versions without a contract break; candidate for a normative pattern in the interface-contracts appendix.
• Render/physics one-way isolation (renderer types confined to projection packages, enforced by an automated guard test) and the observer property (pure-observation channels cannot change a trajectory, also test-enforced) are cheap, mechanical conformance checks other implementations could adopt directly — both are in JWM's conformance gate.
• The X3 identifiability null result (thrust/torque coefficients unobservable through closed-loop flight) is now carried as a machine-readable validity-envelope exclusion, demonstrating the book's "surrogates state where they are safe and where they are not" principle applied to a first-principles model's own parameters, not just learned ones.

v0.4 findings — the developer surface as Appendix-A groundwork (DEV phase)

• Publishing the schema set is the trust groundwork. Executing the Appendix A attack plan's first recommendation, the profile published six artifact schemas (descriptor, scenario, show, evidence packet, agent charter, capability manifest) over a dependency-free validator, test-pinned against every committed asset. Three Appendix A groundwork items closed in the same increment: CHARTER-0 (agent charter schema + reference instance), TRUST-0 (a reserved signatures[] block on evidence packets — verified when present, ignored when absent, zero migration), CONF-3 (a capability manifest emitted by the running system and validated against its own schema before printing).
• An MCP server makes agents first-class developers. A ~30-line JSON-RPC/stdio transport over seven tools (capabilities, validate-artifact, list/run scenarios, verify-evidence, charter, describe-vehicle) turns the CLI surface into an agent-usable API. Design rule worth naming: the run tool shells out to the same CLI humans use — one execution path, no drift between the human and agent surfaces.
• The simulation is the telemetry factory. Synthetic telemetry streams (multi-rate sensor channels emitting on refresh, biases withheld so truth never leaks, ground truth labeled for stripping, provenance headers, byte-identical regeneration self-checked before writing) supply the data products that precede any real fleet. Candidate pattern for the book: sensor-honest synthetic data — the factory's realism comes from withholding what real consumers cannot have.
• Geometry can join the artifact discipline. An implicit (signed-distance) geometry seed demonstrates deterministic, content-hashable meshing with closed-form oracles (sphere/torus volumes, refinement convergence, watertightness) — groundwork for field-driven design with provenance: parts whose shape derives from pinned simulation evidence. Two real bugs (integer-key overflow, a crack-inducing tetrahedral decomposition) were caught by the oracles before merge — the closed-form-oracle pattern generalizes from physics to geometry unchanged.
• A fourth domain in ~350 lines. An orbital-mechanics domain (inverse-square cannonball) composed through the state seam with zero kernel changes, reinforcing the v0.3 breadth-amortization finding at n=4 — and the symplectic-integrator energy ledger gave the domain a conserved-quantity oracle, a third oracle species after closed forms and rebuild references.

v0.6 findings — PROV-0 model self-description and evidence coverage

These are established implementation findings from the 2026-07-13 snapshot. Here, PROV-0 is specifically JWM's model-provenance register for the assumptions, numerical approximations, and constant origins between governing equations and run outputs; it is narrower than JWM's artifact-lineage use of “provenance” elsewhere in this profile (docs/MODEL_PROVENANCE.md:5-7).

• A readable register can be mechanically coupled to executable declarations. MODEL_PROVENANCE.md is not a free-standing assurance narrative. Its guard scans System implementations under packages/ and domains/, treats each manifest implementation separately even when several occupy one file, requires every declared assumption and numerical method to appear verbatim, checks every statically resolvable manifest identifier against the register, and requires assumption-silent implementations to be named (packages/harness/test/provenanceRegister.test.ts:21-49,122-156). The result is omission and identifier-drift detection at the component-instance level. This is a conformance check on disclosure, not an execution gate: runtime provenance assessment remains advisory (packages/harness/src/provenance.ts:16-17). Architecture feedback: when a human assurance register mirrors executable component declarations, conformance SHOULD be tested per implementation rather than inferred from file- or package-level coverage.
• Governing claims and computational approximations are paired but separate inventories. PHYSICS_EQUATIONS.md inventories the governing equations and identifies PROV-0 as its guarded companion for assumptions, numerical methods, and constant origins (docs/PHYSICS_EQUATIONS.md:5-9). Each inventory is independently checked against executable declarations. PROV-0 records such matters as solver order, fixed-step or fixed-sweep choices, error behavior, and numerical gaps rather than allowing a governing equation to stand in for its approximation (docs/MODEL_PROVENANCE.md:270-282). Architecture feedback: model documentation SHOULD maintain separate, mutually guarded equation and provenance inventories so the mathematical claim, numerical realization, assumptions, and constants can evolve without being conflated.
• Constant origins use a seven-class vocabulary. Each parameter can be classified as derived, literature, measured, calibrated, config, tuned, or assumed; an absent class remains explicitly undeclared (packages/sim-core/src/state/units.ts:39-61). In JWM's definitions, tuned means “hand-adjusted for plausible behavior — no external anchor,” while assumed means “a guess, awaiting evidence” (packages/sim-core/src/state/units.ts:50-51). Runtime coverage reports total and classified parameter counts separately, so a System's overall declared status does not imply that every parameter has an origin class (packages/harness/src/provenance.ts:20-35).
• Evidence describes the model composition actually executed. At report time, JWM obtains manifests from the scenario scheduler and assesses the resolved System stack, including user-supplied plugins unknown to the repository register (apps/headless/src/report.ts:134-170). Every System receives a runtime coverage status: declared when assumptions, numerics, and a validity envelope are all present; partial when at least one but not all is present; and undeclared when none is present. Fully undeclared System identifiers are listed, while parameter totals and classified counts remain separate measures (packages/harness/src/provenance.ts:20-52). The structured coverage record is attached to the EvidencePacket, and its summary is inserted into the packet's epistemic-uncertainty note (apps/headless/src/report.ts:134-170; packages/evidence-sdk/src/evidence.ts:250-266). This implements evidence over assertion at the resolved-component boundary: missing declarations remain visible rather than being inferred away.
• One manifest registry serves human and machine explanation. The registry collects the manifests of every active System and is the factual basis for both the inspector UI and structured agent queries (packages/provenance/src/registry.ts:3-7,27-32). A field explanation returns the producing System, current tick, units, declared input fields, and full manifest from that same registry (packages/provenance/src/introspector.ts:11-24,44-59). Architecture feedback: a composed system SHOULD derive human-facing explanations and machine queries from one authoritative machine-readable registry, avoiding parallel descriptions that can drift.

v0.7 findings — OpenUSD interoperability evidence

These are implementation-profile findings from the 2026-07-07 OpenUSD/Omniverse smoke-test session, recorded from the implementation runbook (docs/OMNIVERSE_SMOKE.md). They are evidence flowing into the reference architecture; the book does not depend on the implementation or on any vendor runtime.

• VERIFIED — reference OpenUSD parser. A committed USD interop stage carrying physics schemas opens through the Pixar reference USD implementation (usd-core, pxr). The stage contains five rigid bodies with PhysicsRigidBodyAPI and PhysicsMassAPI, colliders, a revolute joint, a gravity scene, and Z-up at 1 m/unit. The custom jwm:hash integrity attribute (fnv1a64) round-reads through that parser.
• VERIFIED — independent geometry render. The same content renders as USDZ in Apple Quick Look. This verifies the geometry-level package path only; physics schemas are ignored there by design.
• BLOCKED — Isaac Sim runtime on rented cloud GPU. NVIDIA Kit/Isaac Sim validation was attempted on a rented cloud GPU. The stage passed dependency and extension acceptance far enough to reach app initialization, but the runtime could not be brought up in that environment. The runbook records ten diagnosed failure classes across the pip and container routes. The documented diagnosis is platform-environment failure, not artifact failure.
• PENDING — NVIDIA-writer round trip. The intended next evidence point is a round trip through NVIDIA's writer followed by jwm:hash re-verification through the implementation's ingest path. That evidence remains pending until the runtime environment is made operational.

v0.8 findings — runtime validation closed

These findings are from the 2026-08-01 session (implementation runbook docs/OMNIVERSE_SMOKE.md, evidence under assets/usd/evidence/omni-2026-08-01/). They close the v0.7 BLOCKED and PENDING items without rewriting them.

• VERIFIED — NVIDIA runtime session. The interop stage ran a full headless Isaac Sim 6.0.1 session: stage opened, PhysX stepped 360 frames, all free rigid bodies fell under gravity, and the jwm:hash/jwm:sourceId provenance attributes were read inside the running runtime. The v0.7 boot failure was root-caused as container-generation: the 5.x images crash identically on Intel/GCP and AMD/AWS, and the 6.0.1 image boots clean on the same host.
• VERIFIED — NVIDIA-writer round trip. The stage NVIDIA's writer saved back was re-ingested through the implementation's ingest-physics path: five bodies, one joint, three domain-candidate classes recognized, and the jwm:hash integrity pin verified. This closes the round-trip evidence row.
• OPEN — joint rest pose under runtime solve. The revolute joint constrains its beam — the beam settles at exactly the joint anchor while free bodies fall away — but does not hold the authored rest pose, so the smoke's pin assertion fails (PASS: false on that single check). Recorded as a question about authored joint frames versus solver semantics, not about interoperability. Architecture feedback: cross-runtime physics evidence SHOULD assert on constraint behavior classes (constrained vs free) separately from pose retention, so a semantics difference cannot masquerade as an interop failure.

v0.81 findings — standard RL environment contract evidence (Gymnasium adapter)

These findings are from the 2026-08-10 session (JWM experiment ledger entry EXP-0012, JWM PR #166; committed artifacts under the implementation's assets/experiments/exp0012-gym-adapter/). The adapter was built to test whether the implementation's existing contracts close a third-party environment interface without kernel changes.

• VERIFIED — reset/step/seed closes through existing seams. An external Python gymnasium.Env drives the implementation over a newline-delimited JSON stdio bridge (the same transport pattern as the out-of-process solver). Actions enter as ordinary command-stream setpoints under a machine-readable agent charter; observations are a read-only projection of world state; the Python process sits behind the process boundary. gymnasium.utils.env_checker.check_env passes. No new contract was added and no contract-layer package was modified.
• VERIFIED — episode determinism across process boundaries. The same seed produces bit-identical per-step state-hash sequences across two separately launched bridge processes; a different seed diverges at the first step. Every episode is emitted as a recording replayable by the implementation's existing replay/assert machinery, and the determinism assertion lives in the implementation's own test suite alongside its conformance gates — the Python side carries no committed tests.
• RECORDED — no policy learning in the smoke budget. PPO (stable-baselines3) at 8,000 and 50,000 steps did not improve mean episode return. The experiment note diagnoses the result (a do-nothing local optimum under the raw action bounds outscores unstable flight; attitude-level control at a 10 Hz decision rate is not a 50,000-step task) and does not claim learning. Architecture feedback: an RL-environment conformance claim SHOULD separate contract evidence (spaces, reset/step/seed semantics, determinism) from learning evidence — the former is checkable in minutes, while the latter is a research result that must not ride along implicitly.
• Scope: truth-state observations, one hash-pinned scenario, single machine, pinned toolchain.