Write the wall. Run the world.
Keep the proof.▋

A world is what it means, hashed.

trvs id lowers the source to its canonical semantic graph and hashes it. Presentation — where a node sits, its colour, the wire curve — never enters the hash; a rotor or a rewire does. Two files that mean the same world print the same SemanticArtifactID; one meaningful edit and the id moves. It is the world's fingerprint.

Prove the film. Show the coverage.

trvs verify folds the world through the pure-Python reference reducer, re-folds it through the compiled native reducer, and cross-checks both against an independent hand-written oracle where that oracle's domain applies. A film is not asserted — it is checked by every applicable verifier, and the coverage is explicit. Golden Spinner agrees 3/3; a verifier that cannot apply is reported not_applicable, never as pass or fail.

Pin a film. Prove it reproduces. Diff two worlds.

A film is content-addressed evidence. trvs replay re-folds a world and, given a pinned --expect id or --film hash, asserts the fold reproduces it — exit 0 when it does, 1 when it drifts. trvs diff folds two worlds and marks the first epoch where their films diverge. This is the replayable-reward substrate an RL loop can gate on.

See exactly what you wrote — as the engine sees it.

trvs inspect shows the lowered world: every actor with its resolved static config, every edge with its kind, and any diagnostics. The named rotor quarter_turn_z has already become [181, 0, 0, 181]; the wires carry their semantic kind. Nothing hides between your source and its identity.

One honest workflow.

trvs is a small, stable surface. Seven commands fold real worlds over the TRVM engine; the rest of the eighteen shipped below are the environment surface that turns a subject into something an agent can be evaluated against. Its beachhead is trvs eval-one — a one-shot evaluation of a single frozen subject. Nothing below embeds, selects, or routes a model.

shipped commands are real over the engine today, and every command in this list is one. What is not yet built is named in the roadmap below rather than here — a published roadmap, not a claim.

A neutral kernel. Protocols are adapters.

A tool list tells an agent what it can call. It does not define tasks, splits, rewards, episode completion, or reset. So TRAAVIIS's internal contract is a neutral Episode Kernel — and public protocols are adapters over it, not runtime law. The Open Reward Standard is the first and primary adapter; MCP is a compatibility adapter; a local JSONL surface is for automation and debugging.

The kernel carries no substrate semantics; any verb may be unsupported. Evidence Residency v1 is one-shot and implements only start → finalize. For the TRVM profile, observe is a label-free projection and step advances the fold to an epoch boundary.

Verbatim output, ids truncated to fit. The banner is the profile: nothing is advertised that cannot be done, and the three interactive routes exist only so they can refuse in the substrate's words (KERNEL_OPERATION_UNSUPPORTED, HTTP 501) rather than as a 404 — a 404 would claim the endpoint is missing, which is a statement about this server, not about the substrate. Everything is admitted before the socket binds, so there is no arrangement of failures that produces a listening server over a package that did not admit. The default bind is loopback; leaving it takes --allow-remote.

The live end-to-end run recorded in the closure memo, ids truncated to fit: a fresh scaffold, no fixtures, over real pipes. An MCP episode and an ORS episode over the same candidate are the same episode-…, because the thing that happened is the same thing — and the last block is that episode replaying offline, with no agent, no server and no protocol, to the same reward. On compatibility, precisely what was run: a client written against the wire for this server (~180 lines, importing nothing from TRAAVIIS). No third-party MCP SDK and no Claude Desktop has connected. Pagination is not implemented — a client that sends a cursor is ignored rather than refused — and the framing is POSIX-tested only.

Strategy: do not compete with hosting catalogs. TRAAVIIS aims to be one of the best ways to author deterministic environments that export to them.

One clean question each.

TRAAVIIS separates what a thing means from how it is shipped. The environment contract (env-…) fixes the subject, tasks, rewards, and splits; the outer package (bundle-…) carries presentation and docs and may change without moving env-…. Each layer answers exactly one question, and re-scoring a trace never pretends the behavior changed. The lowest rung is the substrate subject, sealed differently per substrate; everything above it is shared.

Prove the environment before you train in it.

The first job is not a trainer, and the first interface was not a batch — it was a one-shot trvs eval-one over a single frozen subject. Now that that is boring, trvs eval runs a whole split and emits one episode-… per task. Because every episode is verified and content-addressed, the numbers are reproducible and each trace is re-checkable on its own, with no agent process.

Verbatim output, ids truncated to fit. The package is reopened and every task-/rew-/snap- re-derived from the bytes on disk before the first agent process starts, so a tampered package costs zero episodes. eval mints no new id: the ladder stops at env-…, so its evaluation.json is an index over episodes that are each already content-addressed.

ok and episodes kept are two lines because they answer two questions: what the evaluation found, and whether the evidence you asked for is still on disk. A run can be fully ok and still have failed to retain its own proof — and a score with no retained proof is not a result you can take away. The exit code reads them in precedence: 0 all ok and all kept · 1 ran and disagreed · 2 could not run, or could not keep what was asked for.

One proves the mechanism. The next one earns the thesis.

The Spinner is the conformance artifact — exact, tiny, already folding three ways. Evidence Residency is the first end-to-end environment that shows what evidence-grade agent evaluation actually looks like. Two more worlds widen the surface after it lands.

One house. Four things you can actually run.

traaviis.com is the evaluation product; three siblings sit beside it on the same domain. They are separate programs with separate repositories — not editions of one another — and the seam between them is the point of the section below.

TRAAVIIS is the product. It stands on a stack.

The boundary is frozen on purpose. trvs carries no world semantics — it packages capabilities the layers below already provide, for someone who does not know the internal history of TRVM. Everything in this ladder is something TRAAVIIS stands on; code is deliberately absent from it, because a consumer is not a layer.

What TRAAVIIS is not.

trvs is a thin, honest terminal over an engine that already exists. Its credibility comes from what it refuses to do.