Eve library

V7 — Implementation TODOs (Mawu: The Open World & Creator Republic)

Tracker

Revision 1

On this page

Historical task source. The Eve task board holds current task state.

Source: derived from V7/V7_features.md, V7/V7_ARCHITECTURE.md, and V7/V7_DEPENDENCIES.md, cross-referenced against the V1 Oshun monorepo, the V3 metaverse substrate, the V5 open-world online backbone, the V6 Ori identity / Aye Bridge, and the Maya engine domain (DOMAINS/maya/features.md) as of 2026-05-30.

⚠️ Completion-state audit (2026-06-12): the original 110/110 [x] state was not credible and has been re-judged. This backlog reached "100% complete" (and V7/release/ recorded "launch-ready") before any adversarial verification of V7 had ever been run — for a platform whose UE client is ~2.2k LOC of skeleton C++, whose realm/mesh/persistence "services" are single-file in-memory eval models with no network stack, whose safety stack integrates none of its named vendors (PhotoDNA/Thorn/Lantern/StopNCII/ EAC), and whose staged rollout never executed. On 2026-06-12 every task was re-judged individually against the code on disk, per the V3/V5 audit pattern: [x] was kept only where substantive matching code/fixtures were read; tasks whose proof requires real-world operations or scale runs are [~]; tasks whose on-disk implementation is plainly insufficient are [ ]. Each re-marked line carries a one-line reason. The full change log is V7/REMEDIATION_2026-06-12.md. Sections §33–§35 and several tasks in §14/§16 were added 2026-06-12 for features-spec'd surfaces that previously had zero backlog. V7 is in-progress, not launch-ready. Do not treat any historical [x] here as authoritative without the inline note.

Progress 2026-06-17. Every locally-actionable task has been implemented + verified and the remainder is honestly externally-gated (36/62/22 → 54/51/15 [x]/[~]/[ ]). Done this pass: §30 registered all 29 adversarial eval gates as named CI steps (verifier green); the §14 generation-policy gate was de-fabricated to a fail-loud backend seam; the §14 asset-budget linter, §12 Pheme voice/radio/accessibility, §16 promotion + AI cost/fidelity degradation (+ host-migration [~]) were implemented with real evals; the V7/ue Mawu client was built + ran 5/5 automation green on the on-box UE5.5.4 (§1); and the §32 staged-rollout/launch-readiness verifiers were reworked into honest anti-fabrication gates (all three V7 verifiers now pass, unblocking V7 CI). Ten [~] tasks whose written Done-when is met by green adversarial evals were flipped [x] after individual code review. The remaining 15 [ ] + 51 [~] require real-world ops/vendors/clusters/UE content + signing/real models/deployed service endpoints — see each inline note. Marking any of them [x] in-repo would be fabrication.

Re-read 2026-09-18. "Externally gated" overstated it. Of the 51 [~] tasks, 10 wait on a vendor, a console programme, a cloud account or a release event. Three an agent can finish today. The other 38 waited on another open task, nearly always ground this repository can lay and had never listed: a session transport, a test client, a durable store, a packaged resource, a process stack, an Unreal connection, a local cluster and a live identity binding. Those are now section 0 (V7.RR.1–8), [~] is retired, and every converted task names what it waits for.

Naming note: every V7 subsystem is named for a goddess, checked against the existing libs//apps//DOMAINS/ registries for collisions. The Maya forge-* packages (and the planned Loom/Variants/Crucible capabilities) are cited as that domain's API and productized under the Ixchel subsystem.

Purpose#

This file is the source of truth for V7 completion state. V7 — Mawu — is a community-run, server-authoritative, fully-moddable persistent-world RP + UGC platform. The architecture follows one decision (who runs the authoritative server) and a hybrid answer: platform-hosted identity/economy/safety + sandboxed community realm logic behind an attested client (arch§"Architectural Thesis").

Each unchecked [ ] is a coding-agent-actionable task. A task is complete only when its implementation, tests, and required wiring all exist — not when a stub is present. The Oshun-repo CLAUDE.md "Zero Tolerance for Stubs" rule applies verbatim. The checkbox is the sole source of truth.

Cross-Reference Convention#

  • Bare §30 / §8.3 → a section in this file.
  • arch§"<anchor>" → V7_ARCHITECTURE.md. features§"<anchor>" → V7_features.md.
  • deps§N → V7_DEPENDENCIES.md. maya§"<anchor>" → DOMAINS/maya/features.md.
  • v5todos§N → V5/V5_TODOS.md; v6todos§N → V6/V6_TODOS.md.

Phase / cut-line convention#

  • [P1] launch-blocking (GA). [P2] Year-1 post-launch. [P3] Year-2 stretch. Default for any ## section is [P1]. Moving a P1 section to P2 requires an ADR at V7/docs/decisions/phase-cut-<task>.md.

Acceptance-criteria convention#

Each task states what "done" means. Security, netcode, safety, and economy tasks demand an adversarial acceptance bar — a real eval fails against a tampered client, a malicious mod/operator, a state-duplication bug, a bot farm, or a known-bad asset, not merely passing the happy path. Examples:

  • "Done when: in the sandbox-escape corpus, 0/N crafted hostile WASM modules read or write outside their granted capability set, each throttled/killed within its per-frame fuel budget."
  • "Done when: the mesh-handoff eval moves 200 entities across an authority boundary 10,000 times — including mid-handoff node death — with zero state loss and zero duplication, verified against the Nephthys ledger."
  • "Done when: the trust-boundary eval proves no platform session token, payout credential, or real-money entitlement is reachable from realm code or the creator web view, across a hostile-operator corpus."

Audit snapshot from current V7/ (rewritten 2026-06-12)#

  • apps/v7/ exists: 8 services + dev-hygiene (Rust: moremi-realm-server ~14.5k LOC, sekhmet-scanner ~6k, danu-mesh-cluster ~3.3k, nephthys ~2.7k, mawu-gateway ~2.5k, hera ~1.1k; TS: abundantia ~4.6k + tests, eunomia ~1.6k + tests). All are single-file in-memory model + adversarial-eval implementations — real Wasmtime/pubgrub/HMAC where it matters, but no tokio/QUIC network stack, no databases, no Agones cluster, no vendor integrations.
  • libs/v7/ exists: contracts (Zod + OpenAPI + generated TS/Rust/C++ clients
    • lock-file schema + accessibility/telemetry/analytics evals), realm-protocol (~4.4k LOC netcode algorithms + evals), substrate-bridge (~2.5k LOC, real ori-model/egbe-ori-service/maya-world crate deps), nana (128-line record-schema crate, honestly scoped "starts small").
  • libs/maya/forge-{resolver,conflict,sandbox,compositor} exist as honest doc-commented API skeleton crates (landed 2026-06-01); the substantive resolver/conflict/compositor/content-store algorithms currently live inside moremi-realm-server.
  • V7/ue/ exists: ~2.2k LOC across 6 modules (MawuCore/Realm/Builder/ Voice/UI/Tests) — lock-file parse + primitive composition + builder placement
    • a voice-gain function + bootstrap automation tests. No netcode client, no prediction, no browser/character/governance UI, no Plugins/MawuMode_*, no attestation. Not verified to build against UE in this audit.
  • Missing entirely: apps/v7/mawu-web/, apps/v7/mawu-web-fallback/ (§33), the Companion App (§34), the Operator Console (§35) — and apps/oshun/web/src/app/mawu-studio/ holds only two pages (accessibility/localization).
  • The trust boundary (§3) and determinism core (§4) are build-time invariants, not late tasks; everything downstream inherits them.
  • V1/V3/V5/V6 substrates are reused, not forked (deps§"Cross-Version Reuse").

How to use this file#

Process sections in dependency order (deps§"Build-Order DAG"); within a section, top-to-bottom. Read the actual code before marking. Run the task's tests. Mark [x] only when the Done when: clause is observably met. When in doubt, leave it [ ]. Do not batch-mark; one task, one verification, one mark.

Marks (2026-09-18). This file once used a third mark, [~], for a task whose model and eval exist while the thing it describes does not run anywhere. The task board cannot read that mark, so each of the 51 was converted, one at a time from its own note, to an open box that says what it waits for: a blocked:upstream tag naming a prerequisite of section 0 below, a blocked:external or blocked:release tag where the blocker is outside the repository, or no tag where an agent can do the residue today. Vocabulary and procedure: .claude/rules/task-checkbox-verification.md. When a section 0 task lands, remove the tags that name it, in the same commit, after reading each.

V7 Exit Criteria (high level)#

Every [ ] is [x], and features§"V7 Exit Criteria" + arch§"Launch Readiness" hold: the trust boundary is enforced (no platform secret reachable from realm code/web view); the Ixchel sandbox has zero escapes on the corpus; Danu sustains 1000+ inhabitants with integrity-clean handoffs; Nàná characters/economy/ institutions persist and federate; Sekhmet meets CSAM/grooming/malware bars + age assurance + ≤48h NCII, and passes an IR drill; creators are paid with anti-fraud gates; anti-cheat meets its bar on community servers; and the Lilith/Kuanyin safety floor is enforced on every realm regardless of operator configuration.

Table of Contents#

  1. The running realm everything else waits for
  2. Project Foundations
  3. V7 Contracts and OpenAPI Surface
  4. The Trust Boundary — Enforcement
  5. Determinism Core and Golden Replays
  6. Realm Protocol and Netcode
  7. Moremi — Realm Server Framework
  8. Nephthys — Persistence / Replication Layer
  9. Danu — Server Meshing
  10. Ixchel Sandbox — Executable Safe Scripting
  11. Ixchel Resolver, Conflict, Compositor, Content Store
  12. Nàná — Roleplay Framework and Economy
  13. Pheme — Proximity and Radio Voice
  14. Hera — Social Graph
  15. Mawu Studio — Creation Tools
  16. Ixchel Genomes, Forking, and Balance
  17. Hosting, Orchestration, and the Realm Fleet
  18. Abundantia — Distribution and Creator Economy
  19. The Economy Firewall and Anti-Fraud
  20. Eunomia — Governance
  21. Sekhmet — Malware Scanning and Supply-Chain Integrity
  22. Child Safety and Age Assurance
  23. Anti-Cheat and Client Integrity
  24. Content Moderation and Minor Protection
  25. Streaming, Spectating, and Replays
  26. Cross-Version Incarnation and Federation
  27. Live-Service and Community Programming
  28. Commerce and Rights
  29. Accessibility and Localization
  30. Observability, Telemetry, and Creator Analytics
  31. Eval Sets and CI Gates
  32. Cross-Platform and Cross-Progression
  33. Region Rollout and Launch Readiness
  34. Web Entry — Pixel Streaming and Tier-2 Fallback (added 2026-06-12)
  35. Mawu Companion App (added 2026-06-12)
  36. Mawu Operator Console (added 2026-06-12)

0. The running realm everything else waits for (added 2026-09-18)#

Thirty-eight of the tasks below have an algorithm, a model and a green eval, and no process, socket, database, cluster or client to prove them on (see the audit snapshot above). That missing ground had no task of its own, which is why the file sat at "51 partial" for three months. These eight are it. They are ordinary agent work: Rust in the existing apps/v7 and libs/v7 workspaces, Postgres from docker/docker-compose.dev.yml, Unreal 5.5 on the machine that executes tasks (run as ueagent), and tools an agent installs itself (CLAUDE.md, "Install what the work needs"). Work them in order; each names what it releases.

  • V7.RR.1 Give apps/v7/moremi-realm-server a realm session transport. Today run_moremi_service_on_port (src/lib.rs) is a blocking HTTP listener that serves health and one Forge admission path. Add a UDP session endpoint on tokio (decision 2026-09-18: UDP datagrams under the 1400-byte pre-fragment limit libs/v7/realm-protocol already models; QUIC can replace it later behind the same trait) that accepts the signed-intent envelope, validates it with the library's existing HMAC check before any state change, and sends interest-set snapshots and deltas. Verify: a test in apps/v7/moremi-realm-server/tests/ binds an ephemeral port, sends one valid and one tampered intent over a real socket, and asserts that only the valid one changes authoritative state; cargo test -p moremi-realm-server passes. Releases the event-tamper task of section 3 and the wire half of section 5.
  • V7.RR.2 Add apps/v7/realm-probe-client, a headless client for that transport (sequence-numbered signed inputs, prediction and reconciliation from libs/v7/realm-protocol, snapshot receipt), and an in-process lossy link between it and the server with settable loss, jitter and round-trip time. Verify: the prediction, interp, lagcomp and bandwidth evals run over the real loopback socket at 80 ms and 5% loss and report the same pass criteria they report over the model; add the crate to apps/v7/Cargo.toml. Releases the section 5 netcode tasks and the spectator stream of section 24.
  • V7.RR.3 Make Nephthys durable. Put the event-sourced store of apps/v7/nephthys-replica-service on Postgres (sqlx, migrations under the service as apps/v3/lilith-world-server does, connection from DATABASE_URL; the local database is the one CLAUDE.md names) with snapshot checkpoints, keeping the in-memory store as the unit-test double. Verify: an integration test starts the service as a child process, writes realm and character events, kills the process, starts a new one and byte-compares the rehydrated state with the ledger; it fails loudly with not_configured when DATABASE_URL is absent. Releases sections 7 and 11 persistence.
  • V7.RR.4 Ship the Nàná base framework as a WASM resource artifact and run it. Build a real component (Rust to wasm32-wasip2, or the target the Wasmtime version in Cargo.toml supports; record which) from a new apps/v7/nana-base-framework crate, load it in the realm process under the deterministic profile, and hot-reload it while a probe client stays connected. Verify: run_moremi_nana_default_realm_boot boots from the built artifact rather than fixture manifests, spawn, inventory, one job and an economy account work end to end, and the connected client of V7.RR.2 sees no disconnect across the reload. Needs V7.RR.1 and V7.RR.2. Releases section 6 and the resource tasks of section 11.
  • V7.RR.5 Boot the stack as processes. Add apps/v7/dev-hygiene support (it already allocates ports per worktree) for starting the gateway, one realm and Nephthys together, tracking their PIDs and tearing them down, and a smoke command that authenticates through apps/v7/mawu-gateway, joins with the probe client, restarts the realm and finds the character state intact. Verify: the smoke command exits 0 twice in a row on a clean checkout and leaves no listener behind (lsof on the allocated ports is empty). Needs V7.RR.1 to V7.RR.4. Releases the chaos, moderation-queue, telemetry and bring-your-own-compute tasks.
  • V7.RR.6 Give the Unreal client a realm connection. In V7/ue/Source/MawuRealm, add a connection component that speaks the V7.RR.1 transport (send predicted inputs, apply snapshots with the interpolation the protocol library specifies) and an automation test in V7/ue/Source/MawuTests that joins a locally started realm and moves a pawn. Build and run with the on-box Unreal 5.5 as ueagent (.claude/rules/unreal-engine-vseries.md). Verify: the Mawu automation group passes including the new join test, with the log attached. Needs V7.RR.5. Releases every task whose note says there is no client, no UI or nothing renders.
  • V7.RR.7 Stand up a local Agones. Install kind and Agones at pinned versions on the executing machine (record the commands in a new apps/v7/danu-mesh-cluster/README.md; check free -m first, since a local cluster is a multi-gigabyte job), apply the Fleet and allocation manifests danu-mesh-cluster already renders, with the realm server image built from a new apps/v7/moremi-realm-server/Dockerfile. Verify: a realm maps to a Fleet, an allocated GameServer survives a scale-down until it shuts down, and the script tears the cluster down. Needs V7.RR.5. Releases section 16 and the meshing proofs of section 8.
  • V7.RR.8 Bind identity and the first live substrates. Implement V7IdentityProvider (libs/v7/substrate-bridge/src/lib.rs) against the BFF: present the bearer to GET /v1/auth/me (apps/oshun/bff/src/routes/auth.ts) and map the answer to a V7AuthenticatedPrincipal, failing closed on any non-200; keep StaticIdentityProvider for unit tests only. Then replace the Iris descriptor binding with a live call for character consent. Verify: an integration test against a locally started BFF (model binding per CLAUDE.md; no frontier model) authenticates a signed-up member through the gateway and refuses a forged token. Releases the substrate-wiring task of section 1 and the Iris clause of section 11.

1. Project Foundations#

  • Create the V7/ue/ UE5.5 LTS / Maya client (Mawu) skeleton rendering a realm from a composed Ixchel layer set. Done when: the client boots a Dedicated realm, applies its lock file, and renders the composed world. _([x] 2026-06-17: BUILT clean against the on-box UE5.5.4 source build (MawuEditor Linux Development, all 6 modules compiled+linked under UHT -WarningsAsErrors, ~36s) and RAN its automation as ueagent (editor refuses root) — 5/5 V7.Mawu._tests green, EXIT CODE 0: Core.GameMode.BootsDedicatedRealmFromLockFile(boots a Dedicated realm), Realm.LockFile.ParsesDedicatedSmokeRealm(applies the lock file), and Realm.ComposesRenderableWorldFromLockFile(composes the renderable world of per-primitive StaticMesh components) — the Done-when. Ran headless -nullrhi (no GPU pixel output; the composed renderable scene graph is built + asserted). A Dedicated-realm network join over a live moremi server is separate netcode work, not in this Done-when.)*
  • Scaffold the Rust service apps (moremi-realm-server, danu-mesh-cluster, nephthys-replica-service, mawu-gateway, sekhmet-scanner, hera-social-service) and TS services (abundantia-market-service, eunomia-governance-service) with project.json/Cargo.toml/tsconfig.json and tsconfig.base.json path mappings. Done when: each builds and lints clean in isolation. (kept [x] 2026-06-12: all eight scaffolds exist on disk with manifests and substantive sources.)
  • Stand up libs/v7/{nana,realm-protocol}/ and libs/maya/forge-* crate skeletons. Done when: each compiles and exposes a doc-commented public API. (kept [x] 2026-06-12: task is explicitly skeleton-scoped; all six crates exist with #![deny(missing_docs)] doc-commented APIs and honest "full implementation pending" scoping notes.)
  • Wire V7 into reused V1/V3/V5/V6 substrates (identity, Aje, Lilith, Kuanyin, Themis, Iris, Psyche, Isis, Sophia, Yemaya, V6 Egbe-Gateway + Aye Bridge, Maya engine-core). Done when: a V7 service authenticates a user and reads an Ori record through the existing stacks (deps§"Cross-Version Reuse"). ([~] 2026-06-12: substrate-bridge takes real ori-model/egbe-ori-service/maya-world crate deps and reads/writes Ori records in-proc, but identity is a trait with fixture providers and the V1 TS substrates (Aje/Lilith/Kuanyin/Themis/Iris/Isis/Sophia/Yemaya) are descriptor bindings, not live integrations.) 2026-09-18: the residue is a live identity binding and live substrate calls; both wait for V7.RR.8. blocked:upstream
  • Establish the repo's process/memory hygiene for V7 dev (unique ports per worktree, fleet-local Agones dev cluster). Done when: a dev realm + gateway run without colliding with other worktrees' ports. ([~] 2026-06-12: apps/v7/dev-hygiene port-allocation tooling exists; no fleet-local Agones dev cluster or running dev realm/gateway pair was evidenced.) 2026-09-18: the running pair is V7.RR.5 and the local Agones cluster is V7.RR.7. blocked:upstream

2. V7 Contracts and OpenAPI Surface#

  • Define realm, character, mod/Collection, listing, payout, governance, scan-report, age-band, and incident contracts (Zod + OpenAPI). Done when: contracts generate typed TS/Rust/C++ clients with no drift and round-trip tests pass. (kept [x] 2026-06-12: libs/v7/contracts has Zod schemas, OpenAPI build, TS/Rust/C++ codegen with drift + round-trip tests.)
  • Define the realm lock-file schema and the artifact content-addressing scheme (hash of content + dependency closure). Done when: a lock file deterministically identifies a composed realm and composes byte-identically on two clients. Tests: "composes a byte-identical realm lock across clients with different input order"; the UE dedicated-smoke.lock.json is asserted aligned with the canonical fixture. (kept [x] 2026-06-12: schema + closure-hash addressing + the byte-identical-composition and UE-alignment tests all exist.)
  • Define the cross-trust message envelope (signed intent, security token, sender netid). Done when: a forged/unsigned cross-trust message is rejected by the conformance suite. (kept [x] 2026-06-12: HMAC-signed envelope + security token in v7-realm-protocol with conformance and tamper-rejection tests.)

3. The Trust Boundary — Enforcement#

  • Implement the identity firewall: realms receive only an opaque per-realm pseudonymous handle; the platform account/identity is never exposed to realm code. Done when: the identity-leak eval shows no realm script or web view can recover a platform account id, email, or cross-realm identifier. ([x] 2026-06-17: the named identity-leak eval is met and is now a green §30 merge gate. V7IdentityFirewall::project is a real HMAC-SHA256 pseudonymizer (deployment pepper over schema‖tenant‖user‖realm); identity_firewall_eval_blocks_platform_identity_leakage projects one principal into two realms and asserts the realm-visible context contains neither the user id, session id, email, NOR the other realm's handle, and that the two handles differ. The Done-when (the eval) is the proof artifact; a deployed realm process is downstream integration [~] but is not what the Done-when requires.)
  • Isolate platform session tokens / payout credentials from the realm process and the creator web view. Done when: the trust-boundary eval proves no token or real-money entitlement is reachable from realm code or the web view across a hostile-operator corpus. ([x] 2026-06-17: the named trust-boundary eval is met and is now a green §30 merge gate. trust_boundary_eval_isolates_platform_secrets_from_realm_and_web_view builds a real platform secret bundle (bearer token, Stripe-Connect payout credential, real-money entitlement), then scans both the realm-process and creator-web-view context JSON across default_trust_boundary_hostile_operator_corpus and asserts none of the secrets appear. The Done-when (the eval over the hostile corpus) is met; a deployed realm process is downstream integration not required by the clause.)
  • Lock down the creator web view: HTTPS-only secure context, strict CSP, no file://, no ambient fetch to operator endpoints without policy grant. Done when: the webview-escape eval blocks exfiltration and arbitrary native API use from a hostile NUI bundle. ([ ] 2026-06-12: no creator web view exists anywhere in the client; substrate-bridge's webview-escape eval checks policy structs over modeled NUI bundles only.)
  • Enforce server-side validation of every client-originated event ("assume hostile sender") with the signed-intent + security-token model. Done when: the event-tamper eval shows no client event mutates authoritative state without validation. ([~] 2026-06-12: HMAC envelope validation + event-tamper eval exist at the protocol-library level; no networked server path enforces it for real clients.) 2026-09-18: the networked server path is V7.RR.1; this closes when its socket path rejects what the eval rejects. blocked:upstream
  • Implement cross-realm ban/reputation propagation owned by the platform. Done when: a platform ban issued in realm A blocks the account in realm B within SLA, and device-attestation defeats a fresh-account realm-hop in the ban-evasion eval. ([~] 2026-06-12: ban-evasion eval exists in hera-social-service over modeled bans/devices; no platform ban service, SLA measurement, or real device attestation exists.) 2026-09-18: two running realms and a platform ban service come with V7.RR.5; device attestation stays a modeled input until a signed client exists. blocked:upstream

4. Determinism Core and Golden Replays#

  • Implement the fixed-timestep deterministic sim core: no wall-clock/un-seeded RNG in gameplay logic; per-realm/per-tick PRNG seeding. Done when: two runs of the same input log produce identical authoritative state hashes. ([x] 2026-06-17: apply_sim_input + deterministic_tick_entropy use a per-(seed,tick,realm,actor) SplitMix64/ SHA-256 PRNG with no wall-clock or unseeded RNG (verified: the only Instant::now in the crate is in the §9 budget eval, not gameplay). deterministic_replay_produces_identical_authoritative_state_hashes asserts first_state_hash == second_state_hash (sha256-prefixed) and deterministic_replay_sorts_input_log_before_ticks asserts a specific computed position + shuffle-invariant hash — the Done-when. Real realm gameplay running on this core is downstream [~] but is not what the Done-when requires.)
  • Configure the WASM deterministic profile for gameplay-tier plugins (NaN canonicalization, deterministic/disabled relaxed-SIMD, no threads, pre-grown memory, virtualized deterministic imports, fuel interruption). Done when: a plugin in the deterministic tier traps at the identical instruction across replays. ([~] 2026-06-12: profile struct + fuel exist and Wasmtime fuel config is exercised in the budget eval, but trap-at-identical-instruction is proven on a custom modeled mini-interpreter, not on Wasmtime running real plugins.) 2026-09-18: open for an agent now. Wasmtime is already a dependency of apps/v7/moremi-realm-server; the residue is to run the trap-at-identical-instruction proof on Wasmtime with a real compiled plugin in place of the modeled mini-interpreter.
  • Build the golden-replay harness + CI gate. Done when: a recorded input log reproduces the exact state hash in CI, and an intentionally-introduced nondeterminism source fails the gate. (kept [x] 2026-06-12: harness + golden_replay_ci_gate with a nondeterminism probe run as a named CI step; note it currently guards the fixture sim, not realm gameplay.)

5. Realm Protocol and Netcode#

  • Specify the realm wire protocol over V6 gateway transports (WebTransport/WebRTC/WS): join/leave, intent, authoritative delta, interest-set subscription, voice signaling. Done when: a conformance suite validates framing and ordering under reordering and loss. (kept [x] 2026-06-12: wire frames/channels/reliability + conformance suite exist in v7-realm-protocol; transports are protocol-level descriptors — actual WebTransport/WebRTC integration is future gateway work.)
  • Implement client-side prediction + server reconciliation (sequence-numbered inputs, snap-to-authoritative, re-apply unacked, per-ability predict opt-out). Done when: predicted vs reconciled state converges with no visible rubber-banding in the prediction eval at 80 ms RTT (a sub-eval composed into the netcode-loss gate — ADVERSARIAL_EVAL_GATES.md). ([~] 2026-06-12: the algorithm + 80 ms eval exist in realm-protocol, but there is no client to predict on — the UE client has no netcode.) 2026-09-18: waits for a predicting client, V7.RR.2 (headless) then V7.RR.6 (Unreal). blocked:upstream
  • Implement snapshot interpolation (Hermite position / SLERP orientation, jitter-adaptive interp buffer). Done when: motion is jitter-free at 5% loss / ±2 frames jitter in the interp eval (a sub-eval composed into the netcode-loss gate). ([~] 2026-06-12: real Hermite/SLERP implementations + the 5%-loss/±2-frame eval exist in realm-protocol; not integrated into any rendering client.) 2026-09-18: waits for a rendering client, V7.RR.6. blocked:upstream
  • Implement ack-relative delta compression (32-snapshot ring, per-field dirty bits, entropy coding, 1400 B pre-fragment, interest-set only). Done when: per-client bandwidth is independent of realm population and within the open-world 64–256 kbit/s budget. ([~] 2026-06-12: ring/dirty-bit/ 1400 B model + bandwidth eval exist; "entropy coding" is an estimated-size model and no real wire traffic exists to measure.) 2026-09-18: real wire traffic to measure comes with V7.RR.1 and V7.RR.2; real entropy coding in place of the size estimate is part of the same residue. blocked:upstream
  • Implement lag compensation (RTT/2 + interp rewind, ~1 s history, ~200–250 ms cap → extrapolation). Done when: the lagcomp eval validates favor-the-shooter hit reconstruction without enabling rewind exploits (a sub-eval composed into the netcode-loss gate). ([~] 2026-06-12: rewind/history/cap algorithm + eval exist in realm-protocol; no shooter, no server, no real hits.) 2026-09-18: real hits over a real socket come with V7.RR.2. blocked:upstream
  • Implement the netcode-loss gate. Done when: a realm is playable at 5% loss and degrades gracefully at 20% (the V5 bar, v5todos§). (kept [x] 2026-06-12: the composed gate exists and runs in CI; "playable" is asserted over the protocol model — re-validate when a real client/server pair exists.)

6. Moremi — Realm Server Framework#

  • Implement the resource model (assets/data/WASM scripts, declared deps + sandbox tier, exported events/callbacks, hot-load). Done when: a base-framework resource + a content resource on it load, the content resource consumes the base's exports, and both hot-reload without disconnecting players. ([~] 2026-06-12: manifest/runtime/hot-load model + lifecycle smoke exist in moremi, all in-memory; "players" are modeled structs, no realm process serves anyone.) 2026-09-18: a realm process that serves connected players while a resource hot-reloads is V7.RR.4. blocked:upstream
  • Implement server-authoritative state ownership (money/items/position server-owned, validated vs rules + Nephthys). Done when: the auth-tamper eval shows a scripted hostile client cannot grant itself currency/items/teleport. (kept [x] 2026-06-12: server-owned state model + auth_tamper_eval blocking currency/item/teleport self-grants exist with tests; gate row added to the inventory 2026-06-12.)
  • Implement the dual tick-tier loop (60 Hz combat / 10–30 Hz open-world with interest-managed per-entity update rates). Done when: a fixture realm runs both tiers within the per-node sim budget. (kept [x] 2026-06-12: the Done-when is fixture-scoped and run_moremi_dual_tick_fixture exists with interest bands and budget checks; the budget is modeled, not wall-clock.)
  • Ship the reference Nàná base-framework resource. Done when: a default realm boots with spawn, inventory, a job, and an economy account functioning end to end. ([~] 2026-06-12: run_moremi_nana_default_realm_boot models exactly this loop, but no distributable WASM base-framework resource artifact ships — the "resource" is fixture manifests.) 2026-09-18: the distributable WASM base-framework artifact is V7.RR.4; this closes on its end-to-end boot. blocked:upstream
  • Implement the Ixchel resource lifecycle manager (cleanup + state preservation on hot-reload, fault isolation). Done when: a faulting resource is isolated and disabled without crashing the realm. (kept [x] 2026-06-12: lifecycle manager + faulting-resource isolation smoke exist in moremi with tests; in-memory realm.)

7. Nephthys — Persistence / Replication Layer#

  • Implement the decoupled, event-sourced, snapshot-checkpointed state store (realm + character aggregates, independent projections). Done when: killing a sim node and rehydrating a replacement restores realm state with no loss (ledger diff). ([~] 2026-06-12: event-sourced in-memory store + rehydrate smoke + ledger diff exist; there is no durable storage, no process, and no real node to kill.) 2026-09-18: durable storage and a real node to kill are V7.RR.3. blocked:upstream
  • Implement the replication-layer broker (single authoritative writer per entity; read-only views for other nodes). Done when: only the owning node can write an entity back, proven by the single-writer eval. (kept [x] 2026-06-12: single-writer ownership + single_writer_eval (non-owner wallet/inventory/stale-fencing writes blocked) exist and run in CI.)
  • Implement per-realm + per-character persistence APIs (inventory, property, vehicles, economy ledger, world mutations) with residency tagging. Done when: a character's full state survives logout/login + realm restart (byte-verified) and honors region tags. ([~] 2026-06-12: persistence API smoke + residency tags exist over the in-memory store; no real logout/login/restart cycle or durable backend.) 2026-09-18: a real logout, login and restart cycle over a durable backend is V7.RR.3 then V7.RR.5. blocked:upstream

8. Danu — Server Meshing#

  • Implement spatial partitioning + the atomic 2-phase authority handoff (freeze→transfer→ack→release through Nephthys). Done when: the mesh-handoff eval moves 200 entities across a boundary 10,000 times — including mid-handoff node death — with zero loss/duplication and no client reconnect. (kept [x] 2026-06-12: the eval exists at exactly this scale (200 entities × 10,000 crossings, mid-handoff death injection) and runs in CI; the mesh is an in-memory model — re-validate on a real multi-node cluster before any beta.)
  • Implement grid area-of-interest subscription + entity culling (proximity/LOS/channel). Done when: a 1000-inhabitant realm sustains the per-client frame budget with bounded per-client entity working sets. ([~] 2026-06-12: AOI model + 1000-inhabitant working-set eval exist; the "frame budget" is a byte-budget proxy — no client renders anything.) 2026-09-18: a client that renders a frame to budget is V7.RR.6. blocked:upstream
  • Enforce the co-location constraint (high-frequency interacting entities on one node). Done when: the colocation eval shows no tightly-coupled physics pair is split across nodes (the SpatialOS failure guard). (kept [x] 2026-06-12: colocation eval with physics-joint/vehicle-rider/ combat-grapple pairs exists and runs in CI over the mesh model.)
  • Implement static meshing first, then dynamic split/merge by density. Done when: static meshing passes handoff evals; then a crowd-gather triggers a split and disperse triggers a merge with sustained smoothness. ([~] 2026-06-12: density split/merge tick model + eval exist; "sustained smoothness" is unprovable without a real cluster and real clients.) 2026-09-18: a real cluster is V7.RR.7 and real clients are V7.RR.2. blocked:upstream
  • Implement the time-dilation overload valve (slow a hot region's clock, floor ~10%, instead of dropping authority). Done when: an overloaded region dilates rather than disconnecting players (the overload eval). *([x] 2026-06-17: the named overload eval is met and is now a green §30 merge gate. danu_overload_clock_percent is a real proportional dilation capacity*base/loadclamped to the 10% floor;run_danu_overload_eval asserts the floor is reached,disconnected_players == 0, authority_drops == 0, players preserved before==after, a Dilated tick exists, event ordering preserved (0 out-of-order, 0 max lag), and simulated<wall time. Behavior under a real multi-node cluster remains future hardening [~] but the eval the Done-when names is green.)*
  • Implement degradation paths (node failure → rehydrate; capacity exhaustion → join queue; control-plane loss → single-node fallback). Done when: each is exercised by a chaos test and the realm stays playable. ([~] 2026-06-12: degradation scenarios exist as in-memory eval cases; no chaos injection against real processes, no playability measurement.) 2026-09-18: chaos injection needs real processes, V7.RR.5. blocked:upstream

9. Ixchel Sandbox — Executable Safe Scripting#

  • Integrate Wasmtime + the Component-Model/WIT capability-typed host interface. Done when: a plugin receives only the imports its tier+manifest grant; the capability-deny eval denies all out-of-grant capabilities over a hostile-manifest corpus. (kept [x] 2026-06-12: real Wasmtime component-model Linker with capability-typed host state + ixchel_capability_deny_eval exist; WIT is modeled as a typed capability enum rather than .wit worlds — note for follow-up. Gate row added 2026-06-12.)
  • Implement the six tiers (DataOnly/Scripted/Extended/System/Native/Trusted) with realm-declared max tier + resource-declared required tier + compositor refusal on over-demand. Done when: a resource demanding more than the realm grants is refused. (kept [x] 2026-06-12: six-tier model + over-demand refusal eval (run_moremi_ixchel_tier_gate_eval) exist with tests.)
  • Implement fuel (deterministic) + epoch (cosmetic) CPU budgeting with graceful throttling, and StoreLimits memory/stack caps + async-stack zeroing. Done when: the runaway-script bar is enforced — a runaway is throttled+flagged within budget and never hangs the realm, with no observable cross-instance memory leak (covered by the sandbox-escape gate's runaway-fuel fixtures — ADVERSARIAL_EVAL_GATES.md). (kept [x] 2026-06-12: real Wasmtime consume_fuel/set_fuel + StoreLimits probes + budget eval exist; epoch/async-stack-zeroing are represented in the budget-policy model.)
  • Implement AOT-at-upload (.cwasm, JIT disabled in prod) and the per-host-call audit log. Done when: vetted plugins run precompiled with the compiler disabled, and every host-API call appears in the audit log with plugin attribution. (kept [x] 2026-06-12: Wasmtime component precompilation receipts (WasmtimePrecompiled::Component), unsafe-deserialize-forbidden checks, and host-call audit entries exist in the AOT audit eval.)
  • Port the Luau hardening lessons (frozen host globals/metatables, per-plugin env, interrupt callback, no untrusted bytecode loading). Done when: the host-tamper bar is enforced — a plugin cannot mutate shared host state (covered by the sandbox-escape gate's frozen-host-mutation fixtures — ADVERSARIAL_EVAL_GATES.md). (kept [x] 2026-06-12: hardening policy + run_moremi_ixchel_host_tamper_eval (frozen-host mutation, untrusted bytecode) exist with tests.)
  • Adversarial: assemble + run the sandbox-escape hostile-module corpus. Done when: 0/N modules read/write outside granted capabilities or exceed budgets undetected; the corpus is a permanent CI gate. (kept [x] 2026-06-12: the corpus + eval exist and run as a named CI step; the corpus is small (~6 hostile fixture modules) — growing it toward a real escape corpus remains open hardening work.)

10. Ixchel Resolver, Conflict, Compositor, Content Store#

  • Implement forge-resolver (PubGrub/pubgrub-rs over SemVer + optional deps + feature gates + capability alternatives → lock file + plain-English failure). Done when: the resolver eval produces correct lock files and a precise root-cause for an unsatisfiable graph. (kept [x] 2026-06-12: real pubgrub 0.3 resolution with semver/optional-deps/capability alternatives + failure reporting + eval exist — implemented inside moremi-realm-server; libs/maya/forge-resolver remains the API skeleton (extraction follow-up).)
  • Implement forge-conflict (algebraic rule composition, world spatial partition, code hook-ordering w/ disjoint-state detection, independent audio buses; surface only true contradictions). Done when: the conflict eval composes overlapping fixtures to the expected merged state and flags only genuine contradictions. (kept [x] 2026-06-12: rule/spatial/hook/ audio composition + true-contradiction-only eval with false-positive checks exist in moremi; libs/maya/forge-conflict is the skeleton.)
  • Implement forge-compositor (priority-ordered layers + per-field provenance). Done when: composed state matches the lock file and provenance attributes each field to its layer. (kept [x] 2026-06-12: fixed-priority composition + per-field provenance + eval exist in moremi, with a substantive libs/maya/forge-compositor crate (835 LOC) carrying the layer/priority/Loom API.)
  • Implement content-addressed storage (Nix-model: hash of content + dependency closure) with dedup, atomic install/rollback, side-by-side versions. Done when: a swapped dependency changes the artifact hash and a rollback restores the prior composed state atomically. (kept [x] 2026-06-12: closure-hash addressing, generations, atomic install/rollback eval exist in moremi's content store; the store is in-memory — a durable backend is future work.)

11. Nàná — Roleplay Framework and Economy#

  • Implement persistent characters as Ori-extended records under Iris consent + deletion limits. Done when: a character persists across sessions and a realm owner cannot silently erase a record (the character-deletion-limit eval). ([~] 2026-06-12: character store, Iris consent scopes, audit entries + nana_character_deletion_limit_eval exist (gate row added); "persists across sessions" is an in-memory model and the real Iris (libs/oshun/memory-iris) is not wired.) 2026-09-18: persistence across sessions is V7.RR.3; wiring the real Iris (libs/oshun/memory-iris) is V7.RR.8. blocked:upstream
  • Implement the job registry (legal/illegal, grades, duties, payouts) as resources. Done when: a community-authored job loads and runs alongside reference jobs. ([~] 2026-06-12: job registry + reference/community job fixtures + eval exist in moremi; jobs are data models — none "run" as sandboxed realm resources.) 2026-09-18: jobs running as sandboxed realm resources come with V7.RR.4. blocked:upstream
  • Implement the double-entry, server-authoritative economy ledger (cash/bank/society; payroll/taxes/fines/revenue; owner-tunable faucets/sinks). Done when: a fixture realm runs payroll, a fine, and a purchase with the ledger balancing to the cent. (kept [x] 2026-06-12: real double-entry ledger with payroll/fine/purchase eval balancing to the cent exists in moremi; Done-when is fixture-scoped.)
  • Implement built-in sink primitives + the optional inflation auto-balancer. Done when: a sink-less realm config is flagged, and the auto-balancer holds a fixture economy within a target inflation band. (kept [x] 2026-06-12: sink primitives, sink-less flagging, and the band-holding balancer eval exist with domain-specific adjustment logic.)
  • Implement property (housing/business/vehicles, persistent interiors as meshed handoff targets, ACLs). Done when: a purchased interior is a Danu handoff target, not a loading-screen instance. ([~] 2026-06-12: property/ ACL/interior models + a Danu interior-handoff probe exist; the handoff target is the in-memory mesh model — no actual interiors exist in any world.) 2026-09-18: an interior that exists in a world needs V7.RR.4 and V7.RR.6. blocked:upstream
  • Implement reference civic institutions (Law CAD/MDT + records/warrants/dispatch/ charge-booking; EMS/Fire downed/revive/treatment; Government licensing/permits). Done when: each runs as a toggleable resource and a dispatch→response→record loop completes end to end. ([~] 2026-06-12: civic resource manifests + a dispatch→response→record eval exist in moremi; institutions are data models + eval, not running sandboxed resources with UI.) 2026-09-18: running sandboxed resources with UI need V7.RR.4 and V7.RR.6. blocked:upstream
  • Implement whitelisting + realm moderation tools (application review, in-realm admin actions, audit log, Kuanyin escalation). Done when: a whitelisted realm gates entry on an approved application and admin actions are audit-logged. ([~] 2026-06-12: whitelist/application/admin-action/ audit/escalation models + eval exist; no in-realm admin tooling or real Kuanyin queue integration.) 2026-09-18: in-realm admin tooling and the real Kuanyin queue (libs/kuanyin) need the running stack of V7.RR.5. blocked:upstream

12. Pheme — Proximity and Radio Voice#

  • Implement positional proximity voice on the V6 SFU (distance attenuation, occlusion, scriptable whisper/normal/shout). Done when: a listener hears a speaker only within range with correct falloff (audio-level assertion at sampled distances). ([x] 2026-06-17: a Pheme positional-audio model in mawu-gateway (pheme_evaluate_audibility) computes quadratic distance falloff per scriptable mode (Whisper 300 / Normal 1800 / Shout 5000 cm), ray-vs-AABB occlusion attenuation, and a received dB level. run_pheme_proximity_eval + test assert audio levels at sampled distances (source gain 1.0/0 dB; half-range 0.25; near-edge <0.001; beyond-range silent at the −120 dB floor), a 12 dB occluder lowering level ≈0.251× at equal distance, and Whisper<Normal<Shout range ordering. The V6 SFU transport itself is the externally-gated wiring; the falloff/occlusion DSP and the audio-level Done-when are met.)
  • Implement radio channels (multi-channel, PTT, job/role-gated, squelch) + phone (point-to-point/conference, proximity-independent). Done when: a job-gated dispatch net admits only on-duty members and a phone call connects off-proximity. ([x] 2026-06-17: pheme_evaluate_radio_transmit is a real admission state machine — PttNotKeyed / NotChannelMember / NotRoleAuthorized / NotOnDuty / SquelchedWeakSignal / Admitted — over a role-gated, on-duty-gated, squelch-thresholded dispatch channel; pheme_connect_phone_call connects proximity-independent point-to-point/conference calls. run_pheme_radio_phone_eval + test assert the on-duty dispatcher is admitted, off-duty→NotOnDuty, civilian→NotRoleAuthorized, released PTT→PttNotKeyed, weak signal→SquelchedWeakSignal, and a 50 m-apart phone call connects.)
  • Implement compliance + accessibility parity (parental/mute, live captions, speaker/range/channel indicators) and the platform voice-safety tap (§21). Done when: a hearing-impaired profile sees who/where/which-channel with captions, and voice is routed to platform safety screening. ([x] 2026-06-17: pheme_build_accessibility_view projects per-event caption lines carrying speaker (who), channel label (which-channel), and distance+direction (where) for a hearing-impaired profile, plus speaker / channel indicators, and fully silences a parental-mute profile. run_pheme_accessibility_eval + test assert the hearing-impaired captions (proximity "420cm north-east" + radio "off-proximity"), parental-mute suppression, AND that a flagged proximity segment still routes through the pre-existing platform voice-safety tap (screen_voice_segment).)

13. Hera — Social Graph#

  • Implement crews/guilds/orgs (roles + role-gated perms, Aje-backed treasury + shared assets w/ audit ledger, cross-realm reputation). Done when: a group grants role-gated treasury access and its reputation is readable at another realm's whitelist gate. ([x] 2026-06-17: run_hera_groups_eval + groups_eval_grants_role_gated_treasury_and_cross_realm_reputation assert a non-treasurer withdraw is denied (missing_treasury_withdraw_permission), the treasurer's withdraw is permitted leaving balance == 17_500, 3 audit entries (2 permitted/1 denied), and the group's reputation (≥50) gates an allowed whitelist join at another realm (alloy-market → harbor) — the Done-when. The treasury being "Aje-backed" (real libs/aje, a TS lib not importable from this Rust crate) is downstream integration [~] not in the clause.)
  • Implement cross-version group presence via the Ori passport. Done when: a group roster carries into a V2 match through the Aye Bridge with membership intact. ([~] 2026-06-12: bridge_group_presence_passport_to_v2_match + eval exist; the "V2 match" is a modeled destination — V2 is not an operational game and the real Aye Bridge is not invoked.) 2026-09-18: the destination is a V2 match, which waits for V2.VS.1–7 (V2/V2_TODOS.md section 0); invoking the real Aye Bridge is part of the same residue. blocked:upstream

14. Mawu Studio — Creation Tools#

  • Implement the in-realm builder (grab-and-place block/voxel/CSG, VR + desktop gizmo parity, modeling/sculpting/UV) emitting Ixchel layers. Done when: a creator builds an interior in a running realm and publishes a layer that composes on join. ([ ] 2026-06-12: MawuBuilder is two source files (~470 LOC) of placement-request validation with Sculpt/UvProject as enum values only — no mesh editing, no VR input path, no publish-to-layer flow, no running realm.)
  • Implement visual logic + the TypeScript/WASM scripting API on a shared compile target + publish linter. Done when: a no-code trigger and an equivalent TS script both compile to the sandbox and the linter rejects a layer referencing a missing asset. ([ ] 2026-06-12: moremi's "TS compiler" is a quoted-argument line parser mapping recognized API strings to script operations — not a TS→WASM toolchain; the publish-lint fixture exists but the compile target is a model.)
  • Implement AI-assisted creation (text-to-3D/texture/world/NPC) under Isis policy
    • Sophia grounding with provenance/attribution. Done when: each tool yields a usable, attributed artifact and generation is gated by Isis policy (the generation-policy eval). ([ ] 2026-06-12: no generation code, no Isis or Sophia integration, and no generation-policy eval code exist anywhere in the V7 trees — the gate row was added to the inventory 2026-06-12 as specified-but-unimplemented.)
  • Implement the asset pipeline (FBX/glTF/USD/Alembic import, photogrammetry/splat import, Nanite auto-optimize + LOD gen, attribution metadata). Done when: an external DCC asset imports with materials mapped, LODs generated, attribution carried. ([ ] 2026-06-12: no import, optimization, or LOD code exists in V7/ue or any V7 library.)
  • Implement realm asset-budget declaration + the Mawu Studio linter warning when a layer pushes a realm past its declared budget (features§"Asset Budget and Streaming"). Done when: a layer exceeding the declared budget produces a linter warning naming the offending assets and sizes, and a within-budget layer passes clean. (Added 2026-06-12 — features-spec'd surface that previously had no backlog task.) ([x] 2026-06-17: MoremiMawuStudioRealmAssetBudget (total + per-category byte ceilings) + lint_mawu_studio_asset_budget in moremi sum sized assets, emit TotalBudgetExceeded/CategoryBudgetExceeded diagnostics naming each offending asset id + byte size largest-first, and pass clean within budget. run_moremi_mawu_studio_asset_budget_eval + test mawu_studio_asset_budget_eval_flags_overrun_and_passes_within_budget assert the 17-MiB-vs-16-MiB total overrun (1 MiB over, both assets named) AND the 8-MiB-vs-6-MiB texture-cap overrun, plus a clean 9-MiB layer.)

15. Ixchel Genomes, Forking, and Balance#

  • Implement world genomes + non-destructive runtime expression layers (Maya Loom). Done when: a genome yields a different world without a fork and a per-player expression layer applies without affecting others. ([~] 2026-06-12: Loom genome/expression schema + composition logic exist in forge-compositor; no world generation consumes a genome — "a different world" is a composed field set, not a world.) 2026-09-18: a world that consumes a genome needs the Unreal client of V7.RR.6. blocked:upstream
  • Implement git-like forking with attribution + revenue links + community canonical voting (Maya Variants, Eunomia-voted). Done when: a fork publishes standalone, keeps a revenue link to its parent, and a canonical vote can reassign the main branch. ([x] 2026-06-17: publishMayaVariantFork emits a standalone fork (standalone: true) carrying its parent's layer snapshots, a merged attribution chain (original-author + fork-author), and a parent-fork revenue link at 1500bp; resolveCanonicalVariantVote reassigns main (night-market wins 11 vs harbor-main 4, reassigned: true). The test asserts all three exact outcomes — the Done-when. A catalog/content-store fork of a deployed realm is downstream [~] not in the clause.)
  • Implement AI-agent balance/exploit verification gating Verified (Maya Crucible). Done when: it detects a fixture infinite-currency mod combination and blocks Verified until resolved. ([x] 2026-06-17: runMayaCrucibleBalanceVerification runs a per-tick economy simulation that detects the infinite-currency-cycle blocker on the fixture and evaluateMayaRealmVerifiedGate blocks Verified (crucible_blocking_findings, status stays Listed); after the refund-multiplier exploit is reviewed the report is clean and Verified is allowed. Both sides asserted — the Done-when. The "AI agent" is a deterministic exploit-seeker strategy (an autonomous agent fleet would be a future enhancement); the clause requires detection + gating, which is met.)

16. Hosting, Orchestration, and the Realm Fleet#

  • Stand up self-hosted Agones (Fleets/GameServer CRDs, allocation, health). Done when: a realm maps to a Fleet and allocation protects a server from scale-down until shutdown. ([~] 2026-06-12: danu renders Fleet/Allocation CRD YAML and models allocation/scale-down protection with tests; nothing is stood up — no Kubernetes, no Agones, no running fleet.) 2026-09-18: nothing is stood up; the install is V7.RR.7, and this closes on its Fleet and allocation proof. blocked:upstream
  • Implement the buffer + webhook autoscaler (pre-warmed ready realms, RP demand curve). Done when: joining a popular realm incurs no cold-start wait under a load test. ([~] 2026-06-12: autoscaler config + cold-start eval exist as a simulation; no load test against real infrastructure has run.) 2026-09-18: a load test needs the cluster of V7.RR.7. blocked:upstream
  • Implement cost tiering (Spot for stateless sessions w/ reclaim handling; On-Demand/owned for persistent realms). Done when: a Spot-preempted stateless session reallocates with no player-visible state loss (Nephthys-backed). Includes the AI cost-and-fidelity degradation levers (features§"AI Cost and Fidelity Tiering") — see the added task below. ([~] 2026-06-12: cost-tier selection + spot-reclaim reallocation eval exist as models; no Spot instances, preemptions, or players exist.) 2026-09-18: Spot capacity is a cloud account the project does not hold; production hosting is one Hetzner box (infra/hetzner/). blocked:external
  • Implement bring-your-own-compute (GSP) registration behind the platform gateway, sandboxed-logic-only. Done when: a creator-hosted realm runs only sandboxed logic, never platform services, with origin IP not exposed. ([~] 2026-06-12: GSP registration smoke + policy checks exist in mawu-gateway; no creator-hosted realm or network-level origin concealment exists.) 2026-09-18: a creator-hosted realm behind the gateway needs the running stack of V7.RR.5. blocked:upstream
  • Implement gateway DDoS scrubbing + rate limiting as the sole client ingress. Done when: a volumetric/abuse test is absorbed at the gateway without realm-origin exposure. ([x] 2026-06-17: MawuGatewayIngressScrubber::classify is a real sliding-window rate-limit/scrub engine (per-client/per-realm/global windows, oversized scrub, direct-origin and unknown-route blocks). gateway_ddos_scrubbing_smoke_absorbs_volumetric_attack_without_origin_exposure runs a 233-attempt volumetric/abuse corpus and asserts forwarded==64 (per-realm cap), rate_limited>0, scrubbed>forwarded, direct-origin blocked==5, unknown-route==1, no origin-IP exposure, realm received no direct client traffic, and sole-ingress enforced — the Done-when's volumetric/abuse test absorbed without origin exposure. A real network-layer ingress against live infra remains future ops [~].)
  • Implement the Solo and Listen hosting tiers with sub-2s host migration (features§"The Hosting Continuum"): Solo = offline-capable local-authority private save; Listen = host-client authority up to ~16 players with automatic host-migration handoff. Done when: a Listen session survives host quit with ≤2 s migration and zero character-state loss (Nephthys-checkpointed), and a Solo realm runs fully offline and re-syncs on reconnect. (Added 2026-06-12 — core features-spec'd hosting promise (features:467-481) that previously had no backlog task.) ([~] 2026-06-17: run_listen_host_migration_eval in nephthys checkpoints a Listen host to the event-sourced store, hands authority to a successor via the single-writer broker (fresh fencing token; the quitting host's stale-token write is fenced out, the successor's accepted), and byte-verifies zero character-state loss before==after; the Solo offline path re-syncs without divergence. The ≤2 s clause is a modeled phase-budget sum (1750 ms) — real wall-clock host-quit timing on a deployed Listen fleet is gated, so [~] not [x]; state preservation + authority handoff are byte-verified real.) 2026-09-18: real wall-clock timing of a host quit needs a Listen host, which is a client: V7.RR.6. blocked:upstream
  • Implement realm promotion along the hosting continuum (Solo → Listen → Dedicated → Meshed) without rebuild: the same composed world + lock file at every tier, with persistence migrating to Nephthys the moment a realm leaves Solo. Done when: a Solo-authored realm promotes to Dedicated and then Meshed with byte-identical lock-file composition and verified persistence migration. (Added 2026-06-12 — features:477-481; arch§"Project Layout".) ([x] 2026-06-17: run_realm_promotion_eval holds one HostingRealmLockFile (world seed + priority-ordered layer set) constant across Solo→Dedicated→Meshed and asserts byte-identical composition hashes at every tier (with an order-sensitivity negative control proving a layer reorder changes the hash), then migrates the Solo-authored character aggregate into the Dedicated Nephthys writer and byte-verifies it (exact_match) against the Solo state — the Done-when's byte-identical composition + verified persistence migration.)
  • Implement the V7/ue Plugins/MawuMode_* GameFeature mode gating (Solo / Listen / Dedicated / Meshed) per arch§"Project Layout". Done when: each mode ships as a GameFeature plugin, gates its surfaces (e.g., no meshed-handoff UI in Solo), and the client refuses a mode the realm's hosting binding does not grant. (Added 2026-06-12 — V7/ue/Plugins/ does not exist; arch:172 spec had no backlog task.)
  • Implement the AI cost-and-fidelity tiering degradation behaviors (features§"AI Cost and Fidelity Tiering"): mesh-tier reduction under budget pressure (fewer nodes at a lower cap), AI-assisted-creation fallback to template/asset-library paths, and Crucible balance verification running a reduced corner-case set that flags its reduced coverage rather than silently skipping. Done when: each degradation path is exercised by a fixture and observably reports its degraded state in telemetry (§29). (Added 2026-06-12 — features:1207-1218 spec'd behaviors with no backlog task.) ([x] 2026-06-17: run_danu_ai_cost_fidelity_degradation_eval exercises all three paths at 45% budget: danu_reduce_mesh_tier cuts 4→1 nodes and the 256→185 per-node cap; danu_ai_creation_fallback switches to the template-asset-library path; danu_crucible_reduced_coverage runs 90/200 corner cases and FLAGS the reduced coverage (coverage_flagged, not a silent skip). Each emits a DanuDegradationTelemetry record keyed by its §29 cost lever (mesh_tier / ai_creation_usage / balance_fleet_depth) with degraded: true; a no-pressure control asserts none degrade.)

17. Abundantia — Distribution and Creator Economy#

  • Implement the cross-platform catalog + content-addressed CDN with console-authorized pre-publish moderation + single-account install sync. Done when: a mod published on PC is installable on a console build via require-approval and installs sync across one account's devices. ([~] 2026-06-12: catalog/console-authorization/install-sync service logic + tests exist in abundantia; there is no CDN, no console build, and no devices — in-service model only.) 2026-09-18: a console build needs the platform holders' developer programs; the CDN half is agent work once there is a build to serve. blocked:external
  • Implement the in-game realm + mod/Collection browser (one-click, lock-resolved, Sekhmet-cleared, atomic Collection install). Done when: a Collection installs its full set reproducibly and only scan-cleared artifacts are fetched. ([~] 2026-06-12: browser query + atomic Collection-closure install + uncleared-dependency abort tests exist service-side; no in-game (UE) browser exists.) 2026-09-18: the in-game browser is Unreal UI on the client of V7.RR.6. blocked:upstream
  • Implement the publishing lifecycle (Draft→Submitted→InModeration→Published/ Rejected, SemVer, no silent deletion of pinned versions). Done when: a pinned version failing the current linter is flagged, not crashed. (kept [x] 2026-06-12: lifecycle state machine + SemVer gating + pinned-version lint-flag tests exist and match the Done-when exactly.)
  • Implement the three payout rails (engagement pool, direct sale/subscription ≥70% floor, dependency-revenue chains) settled via Aje with KYC/tax/refund/payout/ reserve. Done when: the payout-formula eval reproduces a known-correct distribution to the cent and a test cohort cashes out with all gates enforced. ([~] 2026-06-12: payout-formula eval to the cent + 70%-floor rejection tests exist; "Aje settlement" and KYC/tax/refund/reserve are in-service models — libs/aje is not integrated and no cohort can cash out. Pool/dependency-share defaults committed 2026-06-12: 40% of eligible platform net revenue; 10% gross pro-rata (0–25% configurable), ≥70% creator floor preserved.) 2026-09-18: a test cohort cashing out is a release event. The Aje binding is agent work and is the child item below. blocked:release
    • Bind the payout rails to Aje settlement. In apps/v7/abundantia-market-service, replace the in-service settlement, refund and reserve models with calls into libs/aje/payments (a port with the in-service model kept as the test double), so that a payout run writes Aje ledger entries. Done when: the payout-formula eval's known-correct distribution settles through Aje in a test tenant to the cent, a refund reverses its entries, and a run with Aje unconfigured fails closed rather than reporting a payout. (Added 2026-09-18: the agent half of the parent.)
  • Implement dependency-revenue computation from the lock file. Done when: earnings flow the configured share to declared dependencies' creators, verified against the dependency set. (kept [x] 2026-06-12: lock-file dependency-revenue computation + verification test exist and match the Done-when; the share is caller-configurable (dependencyShareBasisPoints) — the 10% default committed 2026-06-12 is a docs-level policy default not yet encoded as a service-config default.)

Canonical-provider audit note (2026-07-27): released Metis lessons now enter V7 through @oshun/v7-metis-creator-education-bridge as a creator-facing explanation of five exact repository gates: signed supply-chain evaluation, sandbox-capability verification, clean-scan distribution, the reviewed publishing lifecycle, and console-authorized catalog publication. The bridge cannot inspect executable bytes, scan or attest content, select sandbox tiers, grant capabilities, moderate, publish, authorize consoles, govern, or calculate or settle payouts. Sekhmet and Abundantia retain every operational decision. This proves governed education admission, not a rendered V7 client or a live publication.

18. The Economy Firewall and Anti-Fraud#

  • Enforce the currency firewall (real-money one-directional; in-realm currency non-fungible + non-cashable to real money). Done when: the currency-firewall eval shows no path converts in-realm play-currency to real money via any operator. (kept [x] 2026-06-12: operator-redemption bridge attempts are rejected in the eval with tests; enforcement is service-level — re-verify when real Aje rails are wired.)
  • Implement verified-spend payout eligibility + retention/new-user weighting. Done when: the payout-eligibility eval excludes never-spent and CCU-inflation-bot accounts from the pool. (kept [x] 2026-06-12: eligibility weighting + exclusion eval exist with tests matching the Done-when.)
  • Implement graph-based self-dealing + RMT detection (account↔realm↔device↔ payment graph; centrality + same-device/never-spent clustering; one-directional flow). Done when: a synthetic self-dealing ring and a gold-farming topology are flagged in the fraud-graph eval. (kept [x] 2026-06-12: graph construction + ring/topology detection eval exist with tests; thresholds quantified in the gate inventory 2026-06-12.)

19. Eunomia — Governance#

  • Implement the five governance tiers (platform/game/realm/server/guild) with sovereign rule spaces bounded by the safety floor (Maya Agora). Done when: a realm charter change executes at the realm tier without parent override, and a safety-floor violation is rejected at every tier. (kept [x] 2026-06-12: eunomia service implements both behaviors with dedicated tests ("executes a realm charter change…", "rejects safety-floor violations at every governance tier"); governance is in-service — no live realms govern themselves yet.)
  • Implement the proposal lifecycle (draft→deliberation→vote→execution→appeal) with plural voting (token/reputation/quadratic/conviction/delegated/time-weighted)
    • Themis appeal. Done when: each model tallies a fixture correctly and an appeal routes to Themis. (kept [x] 2026-06-12: full lifecycle + all six voting models tallied against fixtures + Themis appeal routing tests exist; the Themis route is a modeled record — libs/themis is not invoked.)

20. Sekhmet — Malware Scanning and Supply-Chain Integrity#

  • Implement static + dynamic scanning (signature/heuristic ClamAV-class + WASM capability analysis) gating distribution. Done when: the malware-corpus eval detects the known-bad set at the target rate and no artifact is fetchable before a clean scan. ([~] 2026-06-12: scan + distribution-gate logic + corpus eval (EICAR/fractureiser-style fixtures) exist; the scanner is a local heuristic stand-in, not a ClamAV-class engine, and the corpus is far below the ≥200-sample bar quantified 2026-06-12.) 2026-09-18: open for an agent now. ClamAV is open source: install it, bind clamd in place of the local heuristic, and record the install. The 200-sample bar needs a malware corpus sourced safely; record where it comes from before claiming the rate.
  • Implement content-addressing + signing + lock-file hash pinning + account-takeover step-up on re-publish (fractureiser defense). Done when: a dependency can't be swapped post-publish without changing its hash, and re-publish requires step-up. (kept [x] 2026-06-12: real HMAC/SHA-2 content addressing, manifest signing/verification, pinned lock files, and step-up-gated republish evaluation exist with tests.)
  • Implement sandbox-tier verification (declared vs actual capability use). Done when: a module under-declaring its tier is rejected. ([~] 2026-06-12: declared-vs-observed tier comparison + rejection exist, but "actual capability use" comes from fixture-supplied observations — no real WASM capability extraction from module bytes.) 2026-09-18: open for an agent now: extract the capabilities a module really imports from its bytes (the wasmparser crate) in place of fixture-supplied observations.
  • Implement the incident-response pipeline (suspend approvals, rescan, lockdown, content-hash recall, public report). Done when: an IR drill quarantines exactly the realms pinning a flagged artifact. ([~] 2026-06-12: run_incident_response_drill implements the full pipeline with exact-pin quarantine assertions; all recorded "drills" were this code-level simulation — no operational drill has been conducted.) 2026-09-18: an operational drill needs an operating platform; the code-level drill exists. blocked:release

21. Child Safety and Age Assurance#

  • Implement CSAM perceptual-hash matching (PhotoDNA + PDQ vs NCMEC; CSAI Match for video; render-to-2D-then-hash for 3D/textures) at ingest. Done when: the csam-hash eval matches 100% of a synthetic known-hash set before any serve. ([~] 2026-06-12: ingest hash pipeline + synthetic known-hash eval exist; PhotoDNA/PDQ/CSAI Match/NCMEC are NOT integrated — hashing is a local stand-in algorithm.) 2026-09-18: PhotoDNA, CSAI Match and the NCMEC hash list are granted by agreement with Microsoft, Google and NCMEC. PDQ is open source and is the child item below. blocked:external
    • Integrate PDQ, which is open source. In apps/v7/sekhmet-scanner, back the Pdq and Rendered2dPdq hash kinds with a real PDQ implementation (Meta's reference algorithm; pin the crate or vendored source and record the licence) in place of the local stand-in hash. Done when: PDQ's published reference vectors reproduce bit for bit, the csam-hash eval still matches 100% of its synthetic set before any serve, and a hash kind with no real backend (PhotoDNA, CSAI Match) answers not_configured instead of a stand-in match. (Added 2026-09-18: the agent half of the parent.)
  • Integrate a Thorn Safer-class classifier for novel/unhashed CSAM + a Project-Artemis-class grooming text classifier routing high scores to human review. Done when: the grooming eval routes flagged conversations and the CSAM classifier meets its precision/recall bar. ([ ] 2026-06-12: only local keyword/heuristic classifiers exist — nothing of the named class is integrated or licensed; grooming P/R bars quantified 2026-06-12 (≥90%/≥85%) cannot be claimed from the toy corpus.) Board tag 2026-09-18: both named classifier classes are licensed through partnerships with their vendors; nothing of that class can be installed by an agent. An agent can build the routing, the review queue and the eval harness against the local heuristic and leave the vendor seam not_configured. blocked:external
  • Implement direct-audio voice screening for the proximity/radio channels (platform-side, never realm-delegated). Done when: flagged voice segments route to review and the realm cannot disable the tap. ([x] 2026-06-17: screen_voice_segment computes a weighted basis-point risk over voice features and routes when platform_tap_active && risk >= threshold; realm_requested_tap_disabled is recorded as ignored (tap stays active), and Phone is never screened by realm delegation. platform_voice_safety_tap_routes_flagged_segments_and_ignores_realm_disable asserts flagged segments route to kuanyin-human-review, 0 false positives, and every realm disable attempt ignored — the routing + undisableable-tap Done-when. Real audio feature-extraction (DSP/ML) is the externally-gated input boundary, not what the Done-when requires.)
  • Integrate Lantern cross-platform signal sharing + StopNCII ingestion + a ≤48h NCII takedown pipeline. Done when: an ingested NCII hash blocks the asset and a reported item is removable within 48h. ([~] 2026-06-12: hash-ingest/block + takedown-SLA pipeline logic + evals exist; Lantern membership and StopNCII integration are real-world arrangements that do not exist.) 2026-09-18: Lantern membership and StopNCII ingestion are agreements the project does not hold. blocked:external
  • Implement facial-age-estimation (PII-minimizing vendor, immediate biometric deletion), age-banding, default cross-age-contact + unfiltered-chat restriction. Done when: users are age-banded and the minor-protection eval blocks cross-age contact + age-gated features by default. ([~] 2026-06-12: age-banding + biometric-deletion bookkeeping + minor_protection_eval exist; no vendor integration — the "estimator" is a local model over fixture inputs.) 2026-09-18: the item names a contracted estimation vendor; none is engaged. blocked:external
  • Implement a Sentinel-class longitudinal child-endangerment detector across realms. Done when: a seeded longitudinal pattern is surfaced to review. ([~] 2026-06-12: run_sentinel_child_endangerment_eval surfaces a seeded pattern; "across realms" is a fixture sequence — no production signal store or detector service exists.) 2026-09-18: a production signal store across realms needs the running stack of V7.RR.5. blocked:upstream

22. Anti-Cheat and Client Integrity#

  • Ship a hardened, signed, attested client (operators cannot ship/patch binaries). Done when: a tampered/unsigned client fails attestation and cannot join. ([ ] 2026-06-12: no hardened/signed client exists — the UE client is an unsigned skeleton with no attestation hooks; mawu-gateway's attestation eval checks modeled manifests only.) Board tag 2026-09-18: signing needs code-signing identities (Apple Developer ID, Authenticode) the project does not hold; the attestation hooks and the refusal path are agent work and can be built against a test key first. blocked:external
  • Extend the V5 anti-cheat stack (EAC + server-side ML signals + 3-strike) to community realms with realm-scoped enforcement + platform-routed bans. Done when: server-side signals fire on the authoritative node, cannot be suppressed by a tampered client, and meet the precision/recall bar on the anticheat eval. ([~] 2026-06-12: server-side signal eval (aim-snap/ wall/speed/auto-fire fixtures, suppression-ignored) exists in moremi; EAC is not integrated, no community realm exists, and the 10000bp fixture score is not evidence against the 95% bar on real traffic.) 2026-09-18: Easy Anti-Cheat needs an Epic developer account and its SDK terms; the server-side signals already run. blocked:external

23. Content Moderation and Minor Protection#

  • Implement the three-layer moderation pipeline (ML pre-screen + report queues + Kuanyin human review) with a DSA-compliant Themis appeal path. Done when: moderation meets the safety-eval precision/recall bar and an appeal completes within SLA. ([~] 2026-06-12: three-layer pipeline + appeal-SLA eval exist in sekhmet-scanner; the "ML pre-screen" is heuristic, Kuanyin review is modeled, and the 10000bp fixture P/R is not a production measurement.) 2026-09-18: binding the real Kuanyin queue (libs/kuanyin) and measuring on real reports need the running stack of V7.RR.5. blocked:upstream
  • Implement report flows that attach telemetry + a replay clip as evidence (§24). Done when: a report carries context, not a bare accusation. ([~] 2026-06-12: contextual-report eval + replay-marker structures exist (sekhmet + moremi); no product report flow or client UI exists to file one.) 2026-09-18: a product report flow is client UI, V7.RR.6. blocked:upstream

24. Streaming, Spectating, and Replays#

  • Implement streamer mode (hide join code/IP/sensitive account info, anti-stream-sniping). Done when: a streamed session leaks no join secret. ([x] 2026-06-17: project_streamer_mode_session redacts join-code/IP/ join-URL/gateway-host/route-id and hashes the account label for the public overlay; evaluate_streamer_mode_privacy re-scans the public projection for every original secret. streamer_mode_redacts_join_secrets_and_delays_public_join asserts the public projection leaks none of the six secret classes (leakedmarkers empty, all visible None), the anti-sniping delay is enforced, and the broadcaster-private view still retains them — the "leaks no join secret" Done-when. A streaming client/overlay to render it is downstream integration [~].)*
  • Implement the delayed read-only spectator path off the interest-managed delta stream with per-realm policy. Done when: spectators watch a live event without affecting authority and within the configured delay. ([~] 2026-06-12: spectator stream model + delay/read-only assertions exist in realm-protocol; no live event, no spectating client.) 2026-09-18: a live delta stream to spectate comes with V7.RR.1 and V7.RR.2. blocked:upstream
  • Implement server-side replay capture + clip/photo-mode export (moderation evidence + creator content). Done when: a replay reproduces an incident for moderation and a clip exports for the social loop. ([~] 2026-06-12: capture frames, incident markers, clip/photo export reports exist in moremi as data models + eval; nothing records or renders actual gameplay.) 2026-09-18: recording real gameplay needs the client of V7.RR.6. blocked:upstream

25. Cross-Version Incarnation and Federation#

  • Reuse the V6 Aye Bridge for character incarnation into V2–V6 and add the realm-to-realm federation corridor (treaty + Themis terms, negotiated state subset). Done when: a character round-trips into a V-destination and between two federated realms with Ori integrity preserved under disconnection + concurrency (the passport eval). ([~] 2026-06-12: passport mint/round-trip + federation corridor + passport eval exist over the real ori-model crate, but the V6 Aye Bridge (libs/v6/aye-bridge) is not actually reused (Rust re-model) and the V2–V6 destinations are modeled, not operational games.) 2026-09-18: the V destinations are not operational games (V2 waits for V2.VS.1–7 in V2/V2_TODOS.md); reusing libs/v6/aye-bridge in place of the Rust re-model is part of the same residue. blocked:upstream

26. Live-Service and Community Programming#

  • Implement creator spotlights/featured realms, opt-in platform events with engagement-pool boosts, and creator incubation/verified-creator programs. Done when: a featured rotation publishes weekly, a realm opts into an event, and a verified creator gets auto-approve distribution. ([~] 2026-06-12: featured rotation/event opt-in/creator-program logic + tests exist in abundantia; "publishes weekly" is a live-operations cadence that has never run.) 2026-09-18: a weekly cadence is live operations. blocked:release

27. Commerce and Rights#

  • Implement the real-money commerce surface strictly separated from in-realm play-currency with the never-paywall-a-free-release rule. Done when: a free release cannot be paywalled and the ledgers are isolated. (kept [x] 2026-06-12: paywall-rejection + ledger-isolation logic and the test "rejects paywalling a free release and keeps commerce ledgers isolated" exist; service-level — no real storefront yet.)
  • Implement provenance/attribution, fork revenue links, the Themis IP/DMCA path, and the known-infringing asset-hash block. Done when: a re-upload of a blocked hash is rejected and a DMCA claim routes to Themis. (kept [x] 2026-06-12: known-infringing hash rejection + DMCA routing test exist in abundantia; the Themis route is a modeled status — libs/themis not invoked.)

28. Accessibility and Localization#

  • Implement the accessibility floor (voice/radio text+visual parity, colorblind-safe provenance/diff, keyboard/gamepad builder parity, scalable UI, reduced motion) with the Mawu Studio linter guiding authors to preserve it. Done when: the accessibility eval passes on the builder, browser, and a default realm (gate row added 2026-06-12). ([~] 2026-06-12: a substantive accessibility eval with regression-blocking tests exists in libs/v7/contracts, but it evaluates surface descriptors — the real builder/browser UIs it describes largely don't exist (see §12/§14).) 2026-09-18: the builder and browser the eval describes are the open builder item of section 14 and the client of V7.RR.6. blocked:upstream
  • Implement localization of catalog, Mawu Studio, governance, and platform UI across the launch locale set, with locale-tagged creator content + per-locale moderation. Done when: the browser filters by locale and a governance proposal renders localized for its region. ([~] 2026-06-12: locale-tagged catalog filtering (abundantia) + localized proposal rendering (eunomia) tests exist; no actual platform UI is localized — the mawu-studio web surface is two pages.) 2026-09-18: there is no platform UI to localize until the web entry of section 33 and the console of section 35 exist. blocked:upstream

29. Observability, Telemetry, and Creator Analytics#

  • Implement platform + cost telemetry (realm population/retention, mesh utilization + handoff latency/failures, sandbox fuel-overrun, scan-queue latency, payout distribution, per-realm inflation, per-client bandwidth). Done when: dashboards report each metric and cost levers (mesh tier, balance-fleet depth, AI-creation usage) are observable. ([~] 2026-06-12: a complete metric/lever schema + coverage eval exist in libs/v7/contracts; no dashboards or metric producers exist — nothing emits real telemetry.) 2026-09-18: metric producers need running services, V7.RR.5. blocked:upstream
  • Implement creator analytics dashboards (DAU/retention/playtime/funnel/revenue/ per-mod engagement). Done when: a creator sees actionable retention + revenue data for their realm. ([~] 2026-06-12: analytics schema + reporting eval exist in contracts; no dashboard UI and no real data pipeline.) 2026-09-18: a real data pipeline needs running services, V7.RR.5. blocked:upstream
  • Export per-realm health to the Abundantia browser (a degraded realm is flagged, not surfaced as healthy). Done when: a degraded realm is visibly flagged in the browser. ([~] 2026-06-12: health export + degraded-flag test exist in the abundantia service browse result; "visibly" requires the in-game/web browser UI, which doesn't exist.) 2026-09-18: the browser that shows the flag is the web entry of section 33 or the client of V7.RR.6. blocked:upstream

30. Eval Sets and CI Gates#

  • Stand up the adversarial eval-set CI gates per V7/ADVERSARIAL_EVAL_GATES.md (revised 2026-06-12): the original sandbox-escape, conflict, resolver, mesh-handoff, single-writer, colocation, netcode-loss, anticheat, malware-corpus, csam-hash, grooming, payout-formula, payout-eligibility, fraud-graph, currency-firewall, trust-boundary, identity-leak, minor-protection, passport, golden-replay — plus the gates added to the inventory 2026-06-12: webview-escape, event-tamper, auth-tamper, capability-deny, ban-evasion, overload, character-deletion-limit, generation-policy, accessibility. Done when: every inventory row runs as a named CI step (workflow + verify-adversarial-eval-gates.mjs re-registered), all are green, and each would fail against a tampered client, malicious mod/operator, handoff state bug, bot farm, or known-bad asset. ([x] 2026-06-17: all 29 inventory rows are now registered as named CI steps in .github/workflows/v7-ci.yml (rust-adversarial-gates + studio-safety-gates jobs) and asserted by scripts/v7/verify-adversarial-eval-gates.mjs (29 gates, workflow command + manifest row + source-evidence needles per gate); the verifier passes. The previously-absent generation-policy eval was implemented in libs/isis/three-d-pipelines/src/mawu-studio-ai-creation.ts with a fail-loud backend-not-configured path (no fabricated artifacts) and a consolidated ban_evasion_eval gate test was added to hera. Each gate carries a seeded adversarial negative control and was run green individually.)

31. Cross-Platform and Cross-Progression#

  • Implement single-account cross-platform identity carrying characters, Hera membership, owned mods/Collections, and earnings; per-surface crossplay rules; console-tier distribution limits. Done when: a character + owned content follow the account across two platforms and console realms grant only cert-permitted sandbox tiers. ([~] 2026-06-12: cross-platform progression + console sandbox-tier-grant logic and tests exist in abundantia; no second platform, console build, or cert constraints exist in reality.) 2026-09-18: a second platform means a console developer programme. blocked:external

32. Region Rollout and Launch Readiness#

  • Execute the staged rollout (creator alpha → RP beta → meshing beta → economy launch → GA), each gated on its eval sets + a clean IR drill. Done when: each stage's gate is met and recorded in V7/release/. ([ ] 2026-06-12: no stage was ever executed — the 2026-06-02 "met/advance" record was authored the same day it was created and has been corrected to planned/pending in V7/release/staged-rollout.json.) Board tag 2026-09-18: a rollout needs cohorts and a release; nothing is scheduled. blocked:release
  • Prove launch readiness per features§"Launch Readiness" + arch§"Launch Readiness": trust boundary enforced (no platform secret reachable from realm code/web view), Ixchel sandbox 0-escape, stable 1000+ Danu population with clean handoffs, Sekhmet CSAM/grooming/malware bars + age assurance + ≤48h NCII + passed IR drill, correct test-cohort payouts with anti-fraud gates, anti-cheat precision/recall, moderation/minor-protection bars, safety floor on every realm. Done when: all are signed off in a launch-readiness review. ([ ] 2026-06-12: the 2026-06-02 "launch-ready" review was fixture-backed and has been revised to NOT launch-ready (V7/release/launch-readiness-review.md); none of the operational bars has real-world evidence.) Board tag 2026-09-18: closes in a human launch-readiness review after the rollout stages. blocked:governance

33. Web Entry — Pixel Streaming and Tier-2 Fallback#

(Section added 2026-06-12. features:204-206 and features:389-391 position the web entry and Tier-2 fallback as launch product surfaces alongside the canonical UE client — hence [P1] — but neither apps/v7/mawu-web/ nor apps/v7/mawu-web-fallback/ exists and no prior task covered them.)

  • Stand up apps/v7/mawu-web/ — the thin Pixel-Streaming web player (UE5 server-rendered frames over WebRTC, reusing the V3/V6 Pixel Streaming fleet per features§"Product Surfaces"): session acquisition through the Mawu gateway, input forwarding, reconnect handling, and catalog-browse handoff to Abundantia. Done when: a browser with no native install joins a Dedicated realm via Pixel Streaming within the V3 session-start budget, and session teardown releases the streaming slot.
  • Build apps/v7/mawu-web-fallback/ — the Tier-2 lightweight web client (three.js + WebGPU) for spectating, catalog browsing, and limited play on constrained devices. Done when: the fallback renders a composed realm in read-only spectate mode off the spectator delta stream (§24), browses and installs from Abundantia, clearly gates full-play interactions it cannot support, and degrades to catalog-only when WebGPU is unavailable.
  • Extend the trust-boundary and webview-escape eval surfaces to the web entry points: no platform session token beyond the streaming-session scope in page context, strict CSP, and no realm-operator-controlled content in the player page. Done when: the trust-boundary and webview-escape gates run against both web surfaces and fail on a seeded token-exposure regression.

34. Mawu Companion App#

(Section added 2026-06-12. features:218 and features:405 spec the companion app with no backlog task. Judged [P2]: it is an auxiliary mobile surface — realm browse/character status/crew management — not a launch-blocking play surface.)

  • [P2] Implement the Mawu Companion subroute in apps/oshun/mobile (realm browse, character status, Hera crew management, comms) against the Abundantia/Hera/Nàná service APIs, honoring minor-protection and parental settings on every surface. Done when: a signed-in user browses and filters realms, views a character sheet with live status, manages a crew roster role-gated by Hera perms, and a minor's account sees the age-banded restricted surface set.

35. Mawu Operator Console#

(Section added 2026-06-12. features:219 specs the operator console with no backlog task. [P1]: moderation queues, scan-queue visibility, payout audits, and realm-registry administration are core operator tooling the launch safety/economy bars depend on.)

  • Implement apps/oshun/admin/src/app/mawu/ — the Mawu Operator Console: Kuanyin moderation queues (with report context + replay-clip evidence per §23), Sekhmet scan-queue status against the p95 ≤15 min budget, payout run audits (pool, eligibility exclusions, fraud-graph flags, holds), and realm-registry administration (lifecycle state, hosting binding, federation treaties, quarantine). Done when: an operator reviews a moderation case end-to-end with evidence, inspects a scan verdict and the queue latency percentile, audits a payout run to the cent against the payout-formula eval output, and quarantines a realm by pinned content hash — every action audit-logged.