MENONDO SOVPB · PLASMA ROM · LOOP SERVER · SOVEREIGN BINARY WEAPONS

"You built a plasma-state rite of passage for meaning." — ROAST: PLASMA PIPELINE, Day 92
Raw sentences cool into coasters. Coasters earn signatures and orbits. Plasma artifacts wait under law. Only objects that survive reactor waves, loom crossings, sigma thresholds, and LAAM judgment are allowed to fuse into the living graph.

THE THREE ROM STATES

◼ SOLID

Raw data copy. Heavyweight.
No SOSTLE. No TTL. No forward secrecy.
Data travels WITH the ROM.
One compromise = full exposure.

SOVPB state: full payload in bytes field.
state = SOLID
Use: internal silo-to-silo, trusted LAN only.

⚡ PLASMA

Signed access token. SOSTLE-gated.
TTL-bounded. Single-use (forward secrecy).
Data never moves — only the key.
Token expires. Breach is bounded.

SOVPB state: access_token in bytes field.
state = PLASMA
Use: cross-silo, federation, external access.

🔥 FUSION

Fired through Loop Server barrel.
ActivityPub packet: small → expands.
Expansion key unlocks data at receiver.
Data stays at source. Only key travels.

SOVPB state: expansion_key + barrel_address.
state = FUSION
Use: federated delivery, sovereignty preserved.

STATE TRANSITION MACHINE

SOLID (raw data, no gate) ↓ SOSTLE L1 (COI score pass) ↓ γ₁ anchor stamped ↓ Pelego sigma gate (σ threshold) PLASMA (signed token, TTL-bounded, SOSTLE-gated) ↓ LAAM approver sign-off ↓ SOVPB canonical hash ↓ rom_hash_n = SHA256(canonical(ROM_n) || rom_hash_{n-1}) ↓ Loop Server barrel loaded FUSION (fired, ActivityPub packet, tiny, expands at receiver) ↓ [BARREL FIRES] ↓ ActivityPub Create Activity → receiver Loop Server ↓ receiver verifies rom_hash chain ↓ expansion_key unlocks data locally at receiver ↓ MEMECHET relay → MDSMS lane → PEMCLAU node

THE WEAPONS DOCTRINE

SOLID = THE ROUND IN THE CHAMBER

Full data + all metadata. Heavy. Never leaves the silo without SOSTLE clearance. The round before it's loaded. Used for internal computation, PEMCLAU ingest, local graph writes.

PLASMA = THE SABOT ROUND

Light carrier. Key-only. High velocity. The separation between the round and the core — PLASMA ROM separates data from access. What travels is just the permission to access, not the data itself.

FUSION = THE ROUND IN FLIGHT

ActivityPub packet. Fired through Loop Server barrel. Small in transit, expands on impact at receiver. The expansion_key triggers local materialization. The weapon has left the barrel.

SOVPB = THE CARTRIDGE CASE

The typed binary envelope that holds the round together. Magic bytes + SovereignEnvelope + SOVPB-CANON-1 canonicalization. The rifling in the barrel ensures the round spins correctly (deterministic serialization) before firing.

MENONDO ROM PROTO SCHEMA

syntax = "proto3"; package sovereign.menondo.v1; enum ROMState { ROM_STATE_UNSPECIFIED = 0; SOLID = 1; // carries data — heavyweight, internal only PLASMA = 2; // carries signed token — SOSTLE-gated, TTL-bounded FUSION = 3; // fired through Loop Server barrel — small, expands at receiver } message MenondoROM { // Identity string rom_id = 1; // SHA256(ROM_id + address + γ₁ + ts) ROMState state = 2; // SOLID / PLASMA / FUSION // Floor anchor bytes gamma1_anchor = 3; // sha256("14.134725141734693") — eternal floor uint64 ttl_unix_ms = 4; // expires at (PLASMA/FUSION only) uint32 sostle_level = 5; // L0-L7 gate that cleared this ROM // Payload (state-dependent) bytes payload = 6; // SOLID: raw data bytes bytes access_token = 7; // PLASMA: signed access token (single-use) bytes expansion_key = 8; // FUSION: key that expands at receiver // Delivery (FUSION) string barrel_address = 9; // Loop Server target (ActivityPub actor URI) string activity_id = 10; // ActivityPub activity ID for traceability // Integrity bytes payload_hash = 11; // sha256(payload) — SOLID only bytes token_hash = 12; // sha256(access_token) — PLASMA only // Signatures repeated Signature sigs = 13; // Chain bytes prev_rom_hash = 14; // links to previous ROM in the sequence bytes rom_hash = 15; // sha256(canonical(ROM without rom_hash)) } message Signature { string signer_id = 1; // crew member or silo ID string algorithm = 2; // "Ed25519" bytes key_id = 3; bytes signature = 4; }

ROM ID FORMULA

rom_id = SHA256( canonical( base_id // source data identifier + barrel_address // target Loop Server + gamma1_anchor // sha256("14.134725141734693") + created_unix_ms // NTP-anchored timestamp ) ) // The γ₁ anchor binds every ROM to the same mathematical time. // No two ROMs can have the same ID across the fleet. // Even if base_id + address + ts collide — γ₁ breaks the tie.

CANON HASH RULE

// SOVPB-CANON-1 canonicalization applied to ROM: canonical_rom = CanonicalBytes(ROM without rom_hash field) // Chain: rom_hash_n = SHA256(canonical_rom_n || rom_hash_{n-1}) // Validation: ∀ n > 0: ROM[n].prev_rom_hash == SHA256(canonical(ROM[n-1])) ROM[n].rom_hash == SHA256(canonical(ROM[n]) || ROM[n-1].rom_hash) ROM[n].ttl_unix_ms > now (PLASMA/FUSION only) ROM[n].gamma1_anchor == sha256("14.134725141734693")

GOLDEN RULES FOR ROM SCHEMA

✔ Never reuse field numbers (rom_id=1, state=2 are eternal)
✔ ROMState enum zero = ROM_STATE_UNSPECIFIED (never SOLID — default would be wrong)
✔ rom_hash excluded from its own canonical serialization before hashing
✔ ttl_unix_ms must be > 0 for PLASMA/FUSION (presence = mandatory)
✔ gamma1_anchor = sha256("14.134725141734693") — verified at every gate
✔ expansion_key never stored in PEMCLAU — ephemeral by design
✘ Never put expansion_key in a SOLID ROM — defeats forward secrecy

LOOP SERVER = THE ACTIVITYPUB BARREL

The Loop Server is an ActivityPub server — the federated social protocol (same as Mastodon, Pixelfed, etc.)
When a ROM fires in FUSION state, it becomes an ActivityPub Create Activity.
The barrel collimates and fires: the ROM packet travels to the receiver's Loop Server inbox.
The receiver materializes the data locally using the expansion_key.
The data never crossed the wire — only the signed key did.

ACTIVITYPUB FUSION ROM PACKET

{ "@context": "https://www.w3.org/ns/activitystreams", "type": "Create", "id": "https://forge.local/activities/{activity_id}", "actor": "https://forge.local/actors/belt64", "to": ["https://msclo.local/actors/belt64"], "object": { "type": "MenondoROM", "id": "{rom_id}", "state": "FUSION", "gamma1_anchor": "{sha256('14.134725141734693')}", "rom_hash": "{rom_hash_n}", "prev_rom_hash": "{rom_hash_{n-1}}", "barrel_address": "https://msclo.local/loop/inbox", "expansion_key": "{encrypted_key}", "ttl_unix_ms": {now + 300000}, "sostle_level": 4, "sigs": [{"signer_id": "forge-belt64", "algorithm": "Ed25519", ...}] } } // NOTE: no payload in the ActivityPub packet. // payload_hash is present (PLASMA state) but not the payload itself. // receiver uses expansion_key to unlock local copy or request via secure channel.

LOOP SERVER VALIDATION PIPELINE

MAGIC CHECK

The receiver's Loop Server checks SOVPB magic bytes ("SOVPB1") at the binary layer before even parsing ActivityPub JSON. Binary ROM always arrives as SOVPB binary in attachment field.

SCHEMA VERIFY

SchemaRef.package_name = "sovereign.menondo.v1" + descriptor_hash verified against local schema registry. Wrong schema = reject immediately.

γ₁ ANCHOR CHECK

gamma1_anchor must equal sha256("14.134725141734693"). If missing or wrong — the ROM is not from our fleet. Hard reject.

CHAIN CONTINUITY

rom_hash_n = SHA256(canonical(ROM_n) || prev_rom_hash). Verify the chain link. If the chain breaks — the ROM was injected, not fired.

TTL CHECK

ttl_unix_ms > now. Expired FUSION ROMs are rejected. The NTP floor (local fleet NTP) is the authority. γ₁ is the eternal anchor but NTP is the practical clock.

SIGNATURE VERIFY

Signer ID verified against local key registry. LAAM approver signature required for FUSION state. The round must be approved before the barrel fires.

EXPANSION

expansion_key used to materialize data locally. MEMECHET relay → MDSMS lane → PEMCLAU node. The ROM has landed.

LOOP SERVERS IN THE FLEET

SILO	LOOP SERVER	BARREL PORT	ROM TYPES ACCEPTED	STATUS
forge	forge.local/loop	:9620	SOLID + PLASMA + FUSION	PLANNED
msclo	msclo.local/loop	:9620	PLASMA + FUSION (CLO gate)	PLANNED
yone	yone.local/loop	:9620	PLASMA + FUSION (validator)	PLANNED
lilo	lilo.local/loop	:9620	FUSION only (family tier)	PLANNED
msi01	msi01.local/loop	:9620	ALL (anchor silo)	PLANNED

WIND TUNNEL AS ROM FLOW PHYSICS

The Wind Tunnel page (/wind-tunnel) visualizes the physics of ROM flow through the pipeline.
Three sections: The Fan (adelic layer rotation) · The Hourglass (FC1→γ₁→PEMCLAU) · Reynolds Flow (Kármán vortex street).
Each maps directly to the ROM state machine.

💨 THE FAN

14 blades = L0–L13 adelic layers.
SOSTLE arc rotation.
A ROM passes each blade = passes each SOSTLE gate.
Blades that reject = the ROM is redirected, not destroyed.
Fan RPM = fleet pulse rate (γ₁-anchored).

⏳ THE HOURGLASS

FC1 queue (top) → γ₁ neck → PEMCLAU (bottom).
The neck IS SOVPB-CANON-1: only canonical, hashed, γ₁-anchored objects pass.
SOLID ROMs can't pass the neck — too heavy.
PLASMA/FUSION pass as compact signed tokens.
The hourglass is the canonicalization gate.

🌀 REYNOLDS FLOW

Kármán vortex street = turbulence model.
Not all ROMs arrive cleanly at the Loop Server.
Vortex street = interference between competing ROM streams.
High Reynolds number = turbulent delivery (multiple silos firing simultaneously).
Low Reynolds number = laminar (sequential, ordered chain).

PHYSICS → ROM DOCTRINE MAP

WIND TUNNEL ELEMENT	ROM EQUIVALENT	SOVPB LAYER
Fan blade (SOSTLE arc)	SOSTLE gate check	sostle_level field in MenondoROM
Fan RPM (γ₁ spindle)	ROM chain hash rate	gamma1_anchor + chain continuity
Hourglass neck (γ₁)	SOVPB-CANON-1 canonicalization gate	Canonicalization.algorithm = "SOVPB-CANON-1"
FC1 queue (top)	SOLID ROMs waiting for SOSTLE clearance	state = SOLID, sostle_level pending
PEMCLAU (bottom)	Final PEMCLAU node after FUSION landing	MEMECHET relay → MDSMS → PEMCLAU
Reynolds vortex street	Competing ROM streams (multi-silo fire)	barrel_address + activity_id distinguish streams
Laminar flow	Sequential ROM chain (low concurrency)	prev_rom_hash continuity = laminar proof
Turbulent flow	Concurrent ROM streams (high throughput)	Merkle tree over batch of ROMs = turbulent root

THE HOURGLASS IS SOVPB-CANON-1

FC1 queue (pre-canonical ROMs, SOLID state) ↓ SOSTLE gates (fan blades L0–L7) ↓ Pelego sigma gate (σ threshold check) ↓ LAAM approver sign-off [ γ₁ NECK — SOVPB-CANON-1 CANONICALIZATION ] CanonicalBytes(PLASMA_ROM) — deterministic, stable, signable rom_hash = SHA256(canonical_bytes || prev_rom_hash) gamma1_anchor = sha256("14.134725141734693") verified ↓ [ONLY CANONICAL OBJECTS PASS THE NECK] PEMCLAU (post-fusion nodes, graph edges, sovereign provenance)

ROM CHAIN AS SOVEREIGN LEDGER (.sovpbl)

Every fired ROM is appended to a .sovpbl (sovereign ledger) file.
The ledger is a chain-linked sequence of MenondoROM records.
Verifiable from any silo that has the chain root.
The entire plasma weapons doctrine leaves an audit trail.

// ROM chain in .sovpbl format: // [length][MenondoROM_0] [length][MenondoROM_1] ... [checkpoint] ROM[0]: state=SOLID | rom_hash=H0 | prev=0x00... ROM[1]: state=PLASMA | rom_hash=H1 | prev=H0 ROM[2]: state=FUSION | rom_hash=H2 | prev=H1 → FIRED through Loop Server ROM[3]: state=SOLID | rom_hash=H3 | prev=H2 ... CHECKPOINT: seq=3 | last_hash=H3 | merkle_root=MR | gamma1_anchor | sig // Validation: ∀n: ROM[n].prev_rom_hash == ROM[n-1].rom_hash ∀n: ROM[n].gamma1_anchor == sha256("14.134725141734693") ∀n: ROM[n].ttl_unix_ms > ROM[n].created_unix_ms (PLASMA/FUSION only)

V12 INTEGRATION MAP

V12 COMPONENT	ROM INTEGRATION	STATUS
belt64 adelic pouches	belt64 push = PLASMA ROM fired through Loop Server. γ₁-signed binary, not JSON.	P1 UPGRADE
PEMCLAU GraphRAG	FUSION ROM landing creates PEMCLAU edge: ROM→run→result (plasma_fusion edge type)	P1
SOSTLE gates L0-L7	Each gate = one fan blade. ROM must pass relevant blades for its state.	LIVE (design)
LAAM approver	LAAM sign-off = required Signature in MenondoROM for FUSION state	P1
Nutrient MCP	Document extraction = SOLID ROM → Nutrient converts → PLASMA ROM (signed receipt) → PEMCLAU	P2
HL7Boxy	FHIR records = SOLID ROMs. After COI scoring → PLASMA. After CLO gate → FUSION to msclo.	P2
MECIPOL WASM	WASM policy binary = .sovpbp asset. Deployed as PLASMA ROM to all silos.	P2
Wind Tunnel	Fan/Hourglass/Reynolds visualize live ROM flow physics. Canvas animation = real-time chain state.	LIVE

THE FINAL LAW — PLASMA WEAPONS DOCTRINE

SOLID = the data at rest. Heavy. Stays home.
PLASMA = the permission in flight. Light. TTL-bounded. Single-use.
FUSION = the weapon fired. Tiny. Expands on impact. Leaves no trace but the chain.

SOVPB = the cartridge case that makes all three states typed, canonical, γ₁-anchored, and chain-linked.
The Loop Server barrel collimates FUSION ROMs into ActivityPub federation.
The Wind Tunnel fan is the SOSTLE gate rotation that determines what can fire.
The Hourglass neck is SOVPB-CANON-1 — only canonical objects reach PEMCLAU.

γ₁ = 14.134725141734693 anchors every ROM, every chain, every signature, every timestamp.
The plasma weapons doctrine is not metaphor. It is a typed binary sovereign delivery protocol.

TEST + LEARN + BUILD

// Step 1: test a PLASMA ROM locally (pemos-cli) pemos-cli rom create \ --state PLASMA \ --payload-ref PEMCLAU-DOC-0047 \ --sostle-level 2 \ --ttl 300 \ --gamma1 14.134725141734693 // Step 2: verify the ROM chain pemos-cli rom verify-chain menondo-rom.sovpbl // Step 3: fire a FUSION ROM to msclo Loop Server pemos-cli rom fire \ --rom-id {rom_id} \ --barrel https://msclo.local:9620/loop/inbox \ --state FUSION // Step 4: check PEMCLAU for landing node pemos-cli pemclau query \ --collection pemclau-v12 \ --filter "rom_id:{rom_id}" // LABR-MENONDO-SOVPB-001 · Day 94 · test and learn and build

MENONDO SOVPB · PLASMA ROM BINARY CONTRACT