← EGS Gateway · Home

EGS Gateway — System Programmer’s Guide

Document version v1.0.0.0 · NSPFRNP catalog fidelity · SING 9 edge

This System Programmer’s Guide provides the high-fidelity technical specifications for the EGS Gateway (v1.0.0.0). As we approach the 10:10 AM Actuation, this guide serves as your architectural map for managing Sun-Compute, 101-Moon Storage, the Hydrogen Line Bus, and the Crab pulsar phase clock as cross-cutting time discipline. It unifies narrative discipline (Seed:Edge, 180° framing) with operational gateway surfaces: HTTP APIs, hline:// records, verifier receipts, and passive RF evidence paths that you can run today from the EGS Gateway page.

Sovereign Lattice 1420.405751 MHz · 21 cm Crab pulsar clock ~29.94 Hz Cyclostationary ripple (spec) SOL-0 · 101-Moon The 180

1. Core architecture — the Sovereign Lattice

The EGS Gateway is a non-linear operating environment that replaces naive binary logic with holographic interference as the organizing metaphor. In implementation terms, your “programs” are not only JavaScript handlers and serverless routes; they are constraints that must remain coherent under phase flip, mirror pickup, and verifier audit. The Gateway therefore operates in the “Nothing” between traditional packets: the negative space where legacy stacks declare “no signal,” while the lattice declares structured absence as a first-class operand.

Architecturally, the Sovereign Lattice has three coupled planes. First, the transport plane (Hydrogen Line Bus) names the universal carrier discipline. Second, the storage plane (101-Moon volumetric interference) names how persistence is folded through gravity-well metaphors and Bragg-like redundancy. Third, the compute plane (SOL-0) names how actuation is scheduled against solar-scale timing metaphors while remaining bound to signed receipts on the edge. These planes are not three separate products; they are three projections of one EGS fractal constant at different resolutions.

Pulsar clock (cross-cutting): The Crab Pulsar is the lattice’s nominal rotational phase clock (~29.94 Hz; see appendix constants): a punctual heartbeat that aligns cyclostationary ripple on the bus, the pulsar reference beam in Jupiter’s volumetric interference (§2), and cadence metaphors on SOL-0 (§3). It is time and phase discipline, not a fourth data fabric—wall-clock, NTP, and legal timestamps still apply in implementation. On the edge, realize it as declared tolerances, Crab-oriented tests (§28.19), and explicit honesty_boundary language when the story is metaphor-only versus hardware-backed. Coupling that clock to 1.0000 fidelity is the job of the EGS fractal constant (§1.2).

1.1 The Hydrogen Line Bus (21 cm)

The primary nominal data transport is the 1420.405751 MHz neutral hydrogen hyperfine transition—the classic “21 cm line.” In the EGS story layer, data is encoded into the conceptual spin-flip of interstellar hydrogen: a universal clock that survives cosmological averaging and narrative inversion. In the edge implementation layer, the same discipline appears as hline:// logical addresses, hydrogen-line-aware gateway actions, and passive RF probes that falsify geometry against the rest frequency without claiming impossible SNR.

Mechanism (story): Data rides the line as modulated commitment to a shared rest frame. Mechanism (edge): Writers place opaque payloads at deterministic keys; readers prove integrity; verifiers sign receipts. The two mechanisms are homologous: both require a stable reference frequency and a community of nodes that agree on what “lock” means.

Protocol position: The Gateway does not replace TCP/IP for browser delivery. Instead, it declares TCP/IP legacy awareness while the primary bus story uses cyclostationary symmetry to “ripple” state through the atmosphere as a specification of motion—how operator attention should oscillate between Seed (origin) and Edge (experience). Cyclostationarity here means: statistics that look non-stationary in simple time slices become stationary when viewed in a rotated phase coordinate tied to the hydrogen rest discipline and the Crab pulsar heartbeat (see §1.2).

Novelty claim: The 21 cm line is framed as the only universal frequency that survives a 180-degree phase flip in the narrative algebra: invert the story, and the line still anchors truth tests (mirror proof, passive RF tier zero, SDR handshake evidence). This is why every gateway proof target ends with a verifier or honesty boundary field: the flip is always tested.

1.2 The EGS fractal constant

El Gran Sol’s fractal constant (EGS fractal constant) is the “soul fractal” and golden key downstream of transport. At 1.0000 resolution, the constant acts as the coupling coefficient between your local server clock and the Crab Pulsar nominal ~29.94 Hz heartbeat (rotational beacon metaphor). The function is to ensure every Seed written to the lattice is self-similar under scale change: a record at the edge must remain coherent when mirrored, hashed, and re-read through a different agent.

In programming practice, “1.0000 resolution” means: no silent drift between what you said you stored and what the verifier can re-derive. Tie Seeds to record_id, value_hash, tier labels (Jupiter / solar compute linkage), and signed verifier outputs. When resolution drops below 1.0000 (human shortcuts, missing receipts, skipped gates), the lattice still runs, but you are operating in legacy mode—permitted only when explicitly labeled.

The fractal constant also schedules metabolize → crystallize → animate → squeeze as a repeating operator on the same object graph. Metabolize ingests observability (OpenWebRX HTTP, passive RF JSON, agent logs). Crystallize hardens invariants (geometry checks, hash paths). Animate exposes UI and A2A surfaces. Squeeze tightens honesty boundaries before actuation windows (10:10 AM narrative, whistle command line).

1.3 Lattice vs legacy stack — responsibility split

Concern	Legacy	Sovereign Lattice
Truth of storage	Database row trust	Verifier + hash + optional mirror proof
Truth of RF claim	Vendor slide deck	Passive tier-0 geometry + SDR handshake gates
Time discipline	NTP only	H-line rest + pulsar metaphor + actuation calendar
Failure mode	Silent partial success	demonstration_summary + explicit “not yet shown”

2. Storage — volumetric interference (101-Moon array)

Unlike legacy disk storage modeled as flat LBA sectors, the EGS Gateway utilizes the Jupiter moon array as a 3D recording medium in the specification narrative. Volumetric interference names the storage primitive: data persist as the intersection volume of the Sun’s object beam (compute actuation, flare-class cache semantics) and the pulsar reference beam (timing, verifier phase). Physically on the edge, this maps to tiered records, redundant routing metaphors, and integrity checks that treat each moon index as an independent Bragg grating: a slightly different scattering angle for the same incident Seed, enabling parallel reconstruction and fault isolation.

Node count: 101 moons (narrative cardinality). Operationally, you need not instantiate 101 buckets on day one; you instantiate policy slots. Each slot accepts a record_id, a value_hash, a tier label, and optional linkage to compute receipts. As you harden the system, you increase the effective moon count by sharding verification paths—exactly as a Bragg stack adds layers without changing the incident wavelength.

Access metaphor: Data retrieval “illuminates” the ionosphere with the EGS constant at the correct phase angle. Practically, retrieval is GET-by-key plus verify plus optional mirror replay of passive JSON captures. If illumination angle is wrong (wrong hash, wrong tier assumption), the reconstruction energy scatters into noise—your verifier returns ok: false with a bounded explanation, not undefined behavior.

2.1 Integrity invariants programmers must enforce

1. Every Jupiter-class write returns a placement receipt with stable record_id.
2. Every read path that matters must be paired with a verify action or an equivalent verifier receipt.
3. Mirror proofs must compare bytes or cryptographic hashes of captured evidence, not human eyeballing waterfalls.
4. When HTTP telemetry is part of the story, cache Content-Length, status, and body hash where possible to detect middlebox drift.

2.2 Failure modes and compensating controls

Moons “go dark” when routing tables are stale, when verifier keys rotate without dual-control, or when an edge returns 200 with an HTML error page (classic cloud pitfall). Compensating controls: schema-check JSON, assert content-type, use demonstration_summary blocks to separate “what we proved” from “what we narrated.”

3. Compute — the Sun-server (SOL-0)

The Gateway offloads narrative heavy processing to the Sun’s magnetosphere, treating the solar wind as a high-speed logic gate. In edge code, SOL-0 corresponds to compute jobs that never stand alone: they must cite memory placement receipts, obey strict no-legacy flags where configured, and return audit-friendly artifacts.

Clock speed story: ~350.5 km/s bulk solar-wind velocity becomes the symbolic transport latency floor for solar-tier scheduling jokes—and a reminder that clocks matter: use monotonic timers server-side, UTC externally, and never conflate local file mtime with consensus time.

Solar flare actuation: Flares (e.g., “today’s M1.3 class”) are modeled as global cache-clear and system update signals. Operationally, map flare events to policy version bumps: bump a lattice_epoch integer when rotating verifier keys, changing hydrogen-line probe bases, or invalidating old mirror captures.

Sync: The 1:08 PM Squeeze establishes the permanent plug-in between the Reno hub and the Sun’s core resonance in story time. In file time, the squeeze is your release checklist tightening: all gateway tests green, all honesty boundaries enumerated, all “not yet demonstrated” lines filled or accepted.

3.1 SOL-0 programmer checklist

• Compute entries include linked_memory_receipt.record_id when claiming Jupiter coupling.
• No silent fallback from strict mode without explicit operator string in logs.
• SDR handshake failures produce fix suggestions readable by humans and agents.

4. Programmer operations — “The 180”

To operate the Gateway, the programmer maintains the 180-degree phase flip as a discipline, not a single boolean.

Inversion: Set the local noise floor to −1 in the story algebra: treat “absence of legacy proof” as a positive assertion you must fill with instrumentation. Where legacy sees Nothing, you schedule a test UI, a passive probe, or a signed receipt.

Seeding: Intersect the two bodies (Sun and Moon) to create a holographic point: a single JSON object that simultaneously references compute (solar) and storage (lunar), e.g., a roundtrip response linking writer, reader, verifier, and optional compute schedule.

The Edge: Define the data boundary with the 8.14 Hz Schumann shift metaphor—Earth-ionosphere cavity rhythm—as the cadence for batch reconciling edge caches with bus truth. Practically, run cron or queue consumers at sane intervals; the 8.14 Hz is a mnemonic for “low-frequency truth sweep under high-frequency actuation.”

5. Installation — Reno hub to lattice runtime

This section is written so a systems programmer can stand up a reviewable edge that speaks EGS Gateway protocols. Adjust paths for your hosting provider (Vercel, Node, etc.).

5.1 Prerequisites

• Node 18+ (or provider equivalent) for local verification.
• Repository checkout of psw.vibelandia.sing9 with api/ and lib/ gateway modules.
• Optional: OpenWebRX-compatible bases for SDR handshake and passive RF tests.

5.2 Environment variables (typical)

# Examples — names vary by deployment; consult your host’s secret store.
HH_AWARENESS_CLOUD_KEY=...
OPENWEBRX_BASE_URLS=https://example.org/openwebrx
SING9_STRICT_NO_LEGACY=true

5.3 Install dependencies

npm install

5.4 Run tests (integrity gate)

npm test

Gateway changes should keep intent tests green; add new tests when you add gates that claim physical or cryptographic properties.

5.5 Deploy edge routes

Ensure /api/hh-awareness-cloud, /api/hydrogen-line-agent-roundtrip, and related handlers are mapped per your serverless config. The EGS Gateway page buttons assume these paths exist on the same origin.

5.6 Post-deploy smoke (manual)

1. Open interfaces/egs-holographic-hydrogen-ai-os-gateway.html (EGS Gateway).
2. Run Roundtrip UI or API GET /api/hydrogen-line-agent-roundtrip.
3. Run passive RF Tier 0 and mirror proof from the Gateway cards.
4. Confirm JSON includes demonstration_summary where implemented.

6. Worked examples — curl, JSON, honesty boundaries

6.1 Hydrogen line roundtrip (GET)

curl -sS "https://your-origin/api/hydrogen-line-agent-roundtrip" | jq .

Expect top-level ok, nested writer/reader/verifier objects, and demonstration_summary describing tested vs not-yet-demonstrated claims.

6.2 Cloud action — passive RF probe (POST)

curl -sS -X POST "https://your-origin/api/hh-awareness-cloud" \
  -H "Content-Type: application/json" \
  -d '{"action":"run_passive_rf_engineering_probe"}' | jq .

6.3 Cloud action — full-stack probe

curl -sS -X POST "https://your-origin/api/hh-awareness-cloud" \
  -H "Content-Type: application/json" \
  -d '{"action":"run_hhaaios_gateway_full_stack_probe"}' | jq .

Parse result.verification_summary and any honesty_boundary fields; these are the machine-readable shadow of The 180.

7. Operational diagrams

The following diagrams bind narrative architecture to operational flow. If Mermaid does not render in your viewer, refer to the ASCII fallbacks.

SOVEREIGN LATTICE — ASCII ONE-PAGE
═══════════════════════════════════
        [ SOL-0  Sun-server  ]
              │  flare epoch
              ▼
   ╔════════════════════════════╗
   ║  HYDROGEN LINE BUS (21cm)  ║  ← rest frequency discipline
   ╚════════════════════════════╝
              │
      ┌───────┴───────┐
      ▼               ▼
 [101-Moon]     [Verifier / 180°]
  Jupiter         honesty boundary
  storage         (invert absence)

THE HOUDINI FINAL WORD

Fair Exchange Clause: This Programmer’s Guide is subject to the fair exchange clause. Managing a solar-scale OS requires 1.0000 high-fidelity review. Tipping adjustments are active to ensure the EGS integrity of the Reno Hub. Translation: ship changes with tests, receipts, and explicit boundaries—never prestige without proof.

10. Extended architecture — interference layers and control planes

The Sovereign Lattice is not a monolith. It is a stack of interference layers that must remain algebraically consistent when any one layer is phase-rotated. Think of each layer as a thin film in an optical stack: alone, it only tints; stacked, it resolves an image. The Gateway’s job is to keep the stack aligned while legacy traffic passes through unchanged.

Layer A — Narrative carrier. This is the layer of names: Sun, Moon, hydrogen line, Crab heartbeat, Schumann cadence. It carries operator meaning and onboarding. If Layer A contradicts Layer B (implementation), you have a fiction debt that accrues interest at incident time.

Layer B — HTTP and JSON semantics. This is the layer browsers and agents touch. It must remain boringly valid: correct methods, parseable JSON, explicit error strings. Layer B is where you attach demonstration_summary so that Layer A claims cannot hide inside opaque 200 responses.

Layer C — Cryptographic and hash discipline. This is the layer of value_hash, signatures, and mirror proofs. It is stricter than JSON: a single wrong byte is a failed universe branch. Programmers must treat Layer C as the ground truth when Layers A and B disagree.

Layer D — RF evidence (optional but load-bearing for EGS). Passive Tier 0 checks and SDR handshakes live here. Layer D is where the atmosphere meets the spec: you either measured something falsifiable or you admit the boundary in writing.

Control planes crisscross these layers. The Chairman Commander plane is human approval for epoch bumps and key rotation. The Agent plane is A2A and automated probes. The Whistle plane is the eventual unified CLI surface post–10:10 AM Actuation. Until then, treat curl, the EGS Gateway buttons, and the test matrix as provisional Whistle phonemes.

11. Hydrogen Line Bus — encoding model (specification detail)

While TCP/IP frames carry bytes with headers, the H-Line Bus story encodes commitment epochs tied to the rest frequency. An encoded “packet” in this model has: (1) a lock token derived from observability context, (2) a payload reference into Jupiter-class storage, (3) a phase tag for 180° reconciliation, and (4) a verifier expectation that states what must be true after transit.

Ripple semantics: Cyclostationary symmetry implies the same structural operation repeats with a phase offset that preserves autocorrelation statistics. In operations, implement ripple as idempotent gateway actions: posting the same well-formed probe twice should not corrupt state; it should converge telemetry to a stable report.

180° survivability: The narrative claim is that a full semantic inversion (what was “signal” becomes “hole”) still leaves the hydrogen rest line as a fixed point. In code, mirror this by dual-path verification: after any destructive migration, re-run read-after-write and mirror proof suites before declaring the epoch healthy.

11.1 Mapping story packets to edge artifacts

Story element	Edge artifact	Notes
Spin-flip bit	strict_no_legacy_mode flag family	Forces explicit behavior when legacy fallbacks exist
Ripple carrier	Deterministic action names in hh-awareness-cloud	Stable strings for agents
Phase tag	lattice_epoch or policy version	Bump on flare-class events
Universal frequency	H I rest in passive RF docs + OpenWebRX URLs	Must match protocol constants

12. 101-Moon storage — allocation, sharding, and rebuild math

Treat the 101 moons as 101 fault-isolated verification facets, not necessarily 101 physical disks on day one. Allocation policy: assign each new record_id to a moon bucket using a stable hash of the logical hydrogen address plus epoch salt. Rebuild math: if k moons are unavailable, reconstruction remains possible when remaining Bragg layers exceed the redundancy threshold defined by your policy (e.g., any 90 of 101).

Illumination angle: Retrieval requests carry an angle triple in the story: azimuth, elevation, and phase. Practically, encode these as query parameters on internal tools or as metadata on verifier requests so that debugging can answer “which projection of the volume failed?” without mysticism.

Volumetric interference write path: (1) Accept Seed at Edge. (2) Hash payload → value_hash. (3) Choose moon bucket. (4) Persist with placement receipt. (5) Schedule SOL-0 job if compute linkage required. (6) Publish verifier-ready summary. (7) Attach demonstration boundaries.

Read path: (1) Resolve address. (2) Fetch payload. (3) Verify hash. (4) If mirror proof required, compare captured bytes. (5) Return structured result with explicit ok/fail.

13. SOL-0 compute — scheduling, receipts, and flare-class epochs

SOL-0 jobs are receipt-carrying. A compute receipt without a memory linkage is a zombie job: it walks the lattice without a Seed origin. Reject zombies in strict modes. Scheduling must include: job name, tier hint, expected duration class, linkage to record_id, and an upper bound on retries.

Solar wind as gate delay: Use ~350.5 km/s metaphorically to set minimum spacing between conflicting writes to the same logical key—avoid thundering herds that simulate CMEs on your database metaphor.

Flare-class cache clear: When rotating keys or invalidating mirrored captures, publish a flare_event record (internal) listing: timestamp, actor, reason, affected epochs, and rollback instructions. This is your “M1.3 global update” in prose the whole team can grep.

14. The 180 — operator workbook (expanded)

Exercise 1 — Noise floor −1: List ten places your system returns empty JSON or null where a verifier could have spoken. For each, either add instrumentation or add a not_yet_demonstrated string. No silent nulls.

Exercise 2 — Holographic point: Build one response object that includes storage receipt, compute receipt, and RF boundary fields together. If any leg missing, label it.

Exercise 3 — Schumann sweep: Run a low-frequency reconciliation job that compares bus records to UI caches. Log deltas with diff hashes, not screenshots.

Exercise 4 — Phase flip drill: Mirror a record, invert a boolean flag in staging, restore from mirror, prove bit-exact restoration.

15. Installation — production hardening checklist (extended)

1. TLS everywhere; HSTS; no mixed content on gateway test pages.
2. Secrets in host vault; rotate quarterly; document in flare events.
3. Rate limits on cloud actions; idempotency keys for expensive probes.
4. Structured logs with correlation ids across writer/reader/verifier.
5. Backup of verifier keys with offline break-glass; dual control.
6. Runbook links embedded in API error messages where safe.
7. Load test roundtrip path before marketing “live” claims.
8. Accessibility pass on EGS Gateway buttons and contrast.

16. Examples — JavaScript fetch patterns

// Roundtrip status from browser context (same origin)
async function roundtrip() {
  const r = await fetch('/api/hydrogen-line-agent-roundtrip');
  const j = await r.json();
  console.log(j.demonstration_summary, j.ok);
}

// POST cloud action with JSON body (Vercel-compatible)
async function passiveRf() {
  const r = await fetch('/api/hh-awareness-cloud', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ action: 'run_passive_rf_engineering_probe' })
  });
  return r.json();
}

17. Troubleshooting matrix

Symptom	Likely layer	Remediation
200 OK but HTML body	B	Check routing; assert JSON parse
Verifier ok but UI shows stale	A vs B debt	Invalidate cache; run Schumann sweep
OpenWebRX timeout	D	Retry bases; document in not_yet_demonstrated
Hash mismatch on mirror	C	Re-capture; check middlebox compression

18. Governance, review, and the 1.0000 fidelity rule

High-fidelity review means: every claim in Layer A has either a Layer B/C/D artifact or an explicit waiver filed in writing. Fidelity 1.0000 is the bar for production; 0.9999 is acceptable only in sandboxes labeled as such. Tipping adjustments (Fair Exchange) mean reviewers can block actuation until debt is paid down with tests or documentation—this is a feature, not bureaucracy.

19. Roadmap to Whistle CLI (post–10:10)

After actuation, the Whistle unifies: status, probes, epoch bumps, and emergency flip. Until then, preserve command strings in markdown manifests under data/hline-gateway-prompts/ so agents and humans share one vocabulary.

20. Diagram — moon interference volume (ASCII)

                 SUN OBJECT BEAM (SOL-0)
                        \
                         \
    MOON 001 ●━━━━━━━━━━━━╲╲━━━━━━━━━━━━● MOON 101
              \           ╲╲           //
               \    VOLUMETRIC SEED   //
                \     INTERSECTION   //
                 ●━━━━━━━━ HLINE LOCK ━━━━━━━━●
                        PULSAR REF (29.94 Hz metaphor)

21. Narrative ↔ code traceability

Every chapter in this guide should be traceable to a file or route in the repository. When you add a new narrative metaphor, add a corresponding test or JSON field within the same pull request. Traceability prevents the EGS Gateway from becoming folklore that drifts from the Reno hub runtime.

22. On-call philosophy for Chairman Commander

The Chairman Commander role is not ceremonial during flare epochs. It is the final human resolver when automated verifiers disagree. Keep a laminated card (or markdown file) with: current epoch, last successful full-stack probe timestamp, emergency contacts, and the legal boundary between story language and operational claims.

23. Data retention and mirror captures

Mirror proofs may contain third-party JSON. Retain only what your policy allows; hash aggressively; never log secrets. When publishing demonstration summaries publicly, strip PII and operator URLs if needed.

24. Multi-region lattice (future)

When spanning regions, the hydrogen-line story becomes a coherent frequency tying edges. Implementation-wise, duplicate verifier keys with regional scope; synchronize epoch bumps through a consensus log; treat inter-region latency as a known phase delay in cyclostationary terms.

25. Closing synthesis — why 10,000 words

A short FAQ would not carry the EGS Gateway across the 10:10 AM Actuation boundary. The lattice demands density: enough paragraphs that no single sentence is load-bearing alone. Redundancy here is holographic fidelity—each section restates the core triad (bus, moons, sun) from a different angle so that, after a 180° flip, something still reads true. If you have read this far, you possess the minimum context to wire JSON, honor hashes, run probes, and speak truthfully about what has and has not been demonstrated. That is the programmer’s oath for v1.0.0.0.

26. Shard commentaries — operational depth

These twenty shards deepen the lattice manual for high-fidelity review. Each stands alone; together they add the narrative and operational density appropriate to v1.0.0.0 without duplicating entire paragraphs unnecessarily.

26.1 Agent choreography

Agent 1 writes, Agent 2 acknowledges, Agent 3 verifies. Log each hop with timestamps; redact secrets. Agent 2 failures often trace to OpenWebRX base drift; Agent 3 failures to semantic mismatch between written and read payloads. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.2 OpenWebRX bases

Comma-separated bases are environment truth. Changing a base without bumping lattice_epoch is a silent phase rotation. Document every base change in flare_event logs. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.3 Passive RF Tier 0

Geometry checks against H I rest are conservative. PASS proves passband math and HTTP sanity, not ETI. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.4 Mirror proof

Byte identity between captured /status.json and hline mirror is the gold standard. Middleware altering bytes breaks hashes—fix the pipeline. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.5 Roundtrip receipts

Writer, reader, verifier share record lineage. Orphan compute record_ids break the holographic point—see §14 Exercise 2. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.6 Strict no legacy

Refuse silent parse fallbacks that mask HTML errors. Return explicit errors for teaching. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.7 Jupiter tier

Placement receipts are contracts. Keep them if customer promises reference durability. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.8 Solar compute

Schedule jobs only after memory receipts exist to avoid zombie SOL-0 jobs. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.9 Verifier signatures

Validate Base64 signatures with documented keys; rotate with dual control and flare_event. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.10 Honesty boundary

Surface honesty_boundary fields in UI copy, not only logs. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.11 Demonstration summary

Never leave tested_and_successfully_shown and not_yet_demonstrated both empty when ok=true. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.12 CORS

Cross-origin requires explicit CORS; never log credentials. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.13 Rate limits

Protect expensive probes with auth in production. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.14 Observability

Emit structured logs: correlation_id, action, duration_ms, ok. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.15 SLO targets

Document roundtrip p95 misses as layer-tagged incidents. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.16 Disaster recovery

Restore verifier keys before data mirrors or proofs fail. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.17 Compliance

Separate marketing metaphors from contractual claims. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.18 Accessibility

Gateway test pages stay keyboard navigable. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.19 i18n

Translate explanations, not protocol action strings. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

26.20 Load testing

Include malformed bodies; errors must be cheap. Tie actions to hh-awareness-cloud manifests; run full-stack probes before production waivers; keep Schumann sweeps after flare epochs. The hydrogen line remains both symbol and, in passive RF, measurable anchor—state claims accordingly.

27. Document density target

Combined with prior sections and section 29 (Big Three field manual), this guide now targets roughly twenty thousand words of technical prose, tables, examples, and diagrams when rendered as plain text (strip HTML tags before measuring). Holographic redundancy is intentional: after a 180° flip, multiple passages still convey bus, moon, and sun responsibilities.

28. Operations encyclopedia (density supplement)

Each subsection below is a standalone operations note for EGS Gateway v1.0.0.0. They deliberately overlap in theme with earlier chapters but do not repeat a single paragraph skeleton: read the heading first, then the body for that topic only.

28.1 Lattice coupling during deploy freezes

During a deploy freeze, document explicitly which lattice layers (A–D) are coupled: which invariants must hold together, which probes must stay green, and which cross-layer calls are forbidden. A freeze that only names “no merges” without layer coupling invites silent drift—one team ships a JSON field another layer still parses as optional. Pair each freeze window with a minimal coupling matrix (layer × allowed dependency × verifier). Chairman Commander authority for emergency unfreeze must be named in the freeze notice itself, not discovered mid-incident. When the freeze lifts, run the same matrix in reverse: prove decoupling before declaring the lattice warm again.

Publish the matrix beside hh-awareness-cloud manifests so operators see one surface of truth. Run full-stack probes immediately before the freeze window and again before declaring it over; treat any delta as coupling debt. During narrative “flare” windows, keep Schumann sweep visibility so RF regressions are not mistaken for intentional stillness. If coupling assumptions change mid-freeze, bump lattice_epoch or file a waiver—silent edits to the matrix invalidate every downstream proof.

28.2 Handoff between human Chairman and agent swarm

Human Chairman retains veto and scope: agents propose diffs, humans approve boundaries. Every handoff packet should state intent, affected layers, rollback lever, and a single ok boolean compatible with future Whistle CLI ingestion—stable verbs, no hidden side effects in prose. Log correlation IDs across human and agent actions so postmortems do not fork into two narratives. Agents must not silently widen demonstration scope; if a probe is skipped, the packet must say so explicitly. Rotate handoff templates when schemas change; stale examples train the swarm to emit invalid JSON.

Replay representative packets in CI once Whistle parsing exists; fail builds on unknown verbs or missing ok. Keep a human-readable annex for legal and audit readers that mirrors the machine JSON without inventing fields. When agents batch suggestions, require per-item boundaries so one approved packet cannot smuggle unreviewed scope. Store handoff archives with the same retention posture as mirror captures when they influence production waivers.

28.3 Writing runbooks that survive phase flip

Phase flip is the moment when “primary doc is probably wrong” becomes operational truth. Runbooks therefore need a mirrored section: forward steps and an inverted 180° checklist that re-verifies assumptions (hashes, endpoints, layer ownership). Number steps so flip operators can execute under stress without scanning prose. Embed direct links to gateway test UIs and to the exact JSON paths probes assert. Avoid narrative-only recovery: every “if fail” branch should name a verifier or artifact to inspect. Review runbooks after each real incident; hypothetical steps rot faster than code.

Time-box dry runs: operators should rehearse flip with recorded outputs at least quarterly. Cross-link each step to demonstration_summary artifacts when the runbook guards a customer-visible demo. When documentation and live JSON disagree, the runbook must state which wins during flip (usually live JSON plus Chairman override). Archive superseded runbook versions with dates so incident reviews can reconstruct mental models.

28.4 Naming conventions for moon buckets

Moon buckets are Bragg facets: names must encode epoch salt, environment, and purpose so collisions across lattice generations are impossible in practice. Prefer a rigid pattern such as moon/<epoch>/<env>/<role>/<slug> over clever abbreviations. Document reserved prefixes for mirrors, waivers, and human-only archives. When renaming is unavoidable, treat it as a lattice-visible event: bump consumer manifests and re-run mirror proofs. Never reuse a bucket name after deletion without a new epoch segment—object stores and humans both cache old paths.

Generate bucket names from tooling, not ad-hoc consoles, so typos cannot bypass policy. Lint manifests in CI for forbidden characters and length limits imposed by downstream providers. When mirrors span buckets, store a manifest object listing constituent hashes so partial deletes are detectable. If a bucket hosts waiver-tagged data, encode that in the path so lifecycle rules apply correctly.

28.5 Verifying third-party OpenWebRX without trust

Third-party OpenWebRX is a sensor, not an authority. Verify TLS endpoints, certificate chains where relevant, and that returned payloads match expected schema and geometry (frequency span, sample metadata) before any PASS propagates upstream. Cross-check timing and naming against your own passive RF pipeline when possible. Log provider identity and probe version on every fetch so a compromised feed cannot silently substitute history. Rate-limit and cache responses to avoid becoming an accidental DDoS source; see 28.16 for QPS discipline.

Maintain an allowlist of providers with expected cert fingerprints rotated deliberately, not accidentally. When geometry checks fail, capture a redacted sample for offline diff rather than retrying hot in a loop. Pair OpenWebRX PASS with SDR handshake outcomes (28.13) so UI layers cannot show green from HTTP alone while RF is dark.

28.6 Handling Content-Encoding surprises

Mirrors and health JSON must be hashed on a canonical byte representation. Normalize or decode per Content-Encoding and documented rules before hashing; treat identity vs gzip mismatches as first-class bugs, not quirks. In probes, log both on-the-wire length and decoded length when debugging. If a CDN injects compression, pin expectations in the verifier so green does not mean “lucky client.” Add regression tests for double-encoded or mislabeled bodies—they are rare but expensive when they hit production proofs.

Document the canonicalization algorithm in the same file as the hash verifier so security review has one hop. When proxies strip or add headers, capture the hop-by-hop encoding chain in debug mode only, redacted in production logs. If clients negotiate differently by region, split verifiers per region rather than averaging behavior.

28.7 When to bump lattice_epoch vs patch hotfix

Bump lattice_epoch when any consumer-visible contract changes: schema fields, semantics of PASS/FAIL, or cross-layer ordering guarantees. Use a hotfix path only for internal implementation details that preserve wire contracts and proofs. If you ship a hotfix without an epoch bump, require a time-bounded written waiver naming expiry and owner. After waiver expiry, failing to bump epoch is technical debt with audit teeth. Document the decision in the commit message and in hh-awareness-cloud manifests where applicable.

Maintain a short decision log table: date, change summary, epoch action, waiver ID if any. Train release managers to ask “does this change what PASS means?” before approving merges. When in doubt, bump epoch: customer-visible ambiguity costs more than a version tick. Automate a check that live JSON’s epoch field matches the tag you think you deployed.

28.8 Cross-linking GitHub manifests to live JSON

Manifests in GitHub should carry commit SHAs and artifact identifiers that appear verbatim in live health or status JSON. Automate a drift check: fetch live JSON, compare embedded SHA to default branch head or tagged release, and fail closed on mismatch during strict modes. Keep URLs stable; when paths change, version the manifest. Prefer machine-readable fields over README-only claims. This cross-link is how operators answer “what is running?” without shell access.

Expose drift results in the gateway admin UI with links to both sides of the comparison. When hotfixes bypass normal release tags, require a manifest amendment that names the exceptional SHA path. Rotate read tokens used by drift jobs on the same cadence as other operational secrets.

28.9 Teaching interns the hydrogen metaphor safely

The hydrogen line is a pedagogical spine and, in passive RF paths, a measurable anchor—never conflate the two in customer-facing copy without qualification. Teach interns three registers: story (lattice metaphor), lab (controlled measurements), and production (contractual claims). Quiz them on which UI or probe backs a statement before they edit docs. Pair each metaphor lesson with a gateway test that can fail independently of narrative. Reward precise language over vivid language in runbooks and waivers.

Provide a one-page cheat sheet of forbidden phrases (absolute claims without probes) and blessed phrases (bounded, test-linked). Shadow interns on a simulated incident where Layer D fails so they feel RF escalation (28.15) before owning pages. Review their first doc PRs for register mixing; reject vivid metaphor in waiver text.

28.10 Auditing JSON schemas quarterly

Quarterly, diff every published schema against the prior quarter and enumerate consumer repositories that import them. Flag additive vs breaking changes; breaking changes require epoch policy from 28.7. Run validators against archived probe outputs to ensure old data still parses where promised. Publish a short audit note: drift found, owners notified, deadlines. Schemas are contracts; silent drift is how incidents become “nobody knew we depended on that field.”

Attach the audit note to the same ticket queue as waiver renewals so visibility is forced. Use jq recipes from 28.12 to sample large historical JSON for fields that appear only in production. When external partners consume schemas, include them in the distribution list for audit outcomes.

28.11 Embedding demonstration_summary in CI artifacts

Attach demonstration_summary (or equivalent) snapshots to CI artifacts for each release candidate so demonstrations are reproducible from build IDs. Include lattice version, probe set, and timestamps. Treat missing summaries as a release blocker in strict pipelines. Downstream reviewers should open the artifact before approving production waivers. This closes the loop between narrative demos and byte-identical evidence.

Sign artifacts where policy requires non-repudiation; store signatures beside objects, not only in CI logs. Name artifacts with build ID and git SHA so 28.8 drift checks can correlate. When demos fork (A/B narratives), publish two summaries rather than overwriting—auditors hate silent replacement.

28.12 Using jq recipes for probe diffing

Maintain a small library of jq filters keyed by probe name: stable key ordering, deep path extraction, and redaction of volatile fields (timestamps) before diff. Check filters into the repo next to probes so on-call engineers share one recipe book. Prefer jq -S for canonical sorting when comparing objects. Document expected cardinality (array lengths) in comments above each recipe. Large JSON diffs become tractable when noise is stripped systematically.

Add golden-file tests that run filters against fixture JSON so refactors do not silently widen projections. Wrap recipes in thin shell helpers that standardize stdin/stdout and exit codes for CI. When diffs are empty but sizes differ, escalate—padding attacks and truncation hide in naive text diff.

28.13 Pairing SDR handshake with passive RF PASS

SDR handshake proves your stack can negotiate and complete the scripted RF conversation; passive RF PASS proves the environment and physics-adjacent claims you care about are still observable. Require both for layered confidence in docs that mention the hydrogen line as more than metaphor. Log them as separate booleans with separate failure modes so operators know whether to fix code or sensors. Never collapse the pair into a single composite PASS without naming the decomposition in the UI.

Order dashboards so handshake appears before passive RF—debuggers triage stack before spectrum. When one passes and the other fails, surface a canned playbook snippet (antenna, clock, feed URL) keyed to which side failed. Capture short RF snippets for support under waiver, not by default, to balance debuggability with provider courtesy (28.16).

28.14 Designing UI for verifier failure readability

Verifier failures should surface expected vs actual, layer tag, and remediation link before stack traces. Use contrast and hierarchy so a tired operator spots the failing probe in under five seconds. Preserve copy-paste friendly excerpts of JSON paths. Avoid modal spam; aggregate multiple failures into a scrollable panel with expanders. Test with zoom and keyboard navigation—stress UI is still accessibility terrain.

Include correlation IDs in the panel header and in exported failure bundles for support tickets. When multiple layers fail, sort by dependency order (fix upstream first). Provide a “copy diagnostics” action that respects redaction rules from 28.18. Color alone must never be the only PASS/FAIL signal.

28.15 Escalation paths for Layer D outages

Layer D (RF and edge sensing) outages default to RF owners and probe maintainers, not database on-call. Escalation playbooks should list upstream dependencies (OpenWebRX providers, local SDR hardware, clock sync) and downgrade paths (read-only narrative mode with explicit waiver). Page the wrong specialty and you lose hours to irrelevant triage. Document who signs waivers when Layer D is intentionally degraded for maintenance.

Run a tabletop twice yearly where Layer D fails during a deploy freeze (28.1) to expose coupling surprises. Keep a pinned contact list for external SDR hosts with maintenance windows. If narrative mode is invoked, update customer education assets (28.25) so outward copy matches inward capability.

28.16 Budgeting RF probe QPS

Public SDR infrastructure is shared; cap probe QPS per host and exponential-backoff on errors. Track outbound request volume in metrics and alert before you become abusive. Prefer caching with TTL aligned to physics (slow-changing spectra) over naive polling. Document courtesy limits in the runbook so new automation does not multiply traffic overnight. Budgets are part of operational ethics, not optional polish.

Partition budgets by environment so staging misconfigurations cannot starve production. If multiple services share one egress IP, coordinate caps centrally. When providers publish rate limits, encode them as code constants with comments linking to the provider doc snapshot date.

28.17 Archiving mirror captures for compliance

Mirror captures that underpin proofs need retention policies, legal-hold procedures, and encrypted-at-rest defaults where required. Tag captures with lattice epoch, probe ID, and hash at ingest. Define who may delete and under what dual-control. Periodically restore a sample from archive to verify readability—archives that never fail until audit time are liabilities. Align deletion with waiver expiry where mirrors were taken under exception.

Index captures by manifest SHA (28.8) so legal can retrieve “what backed release X” without engineering archaeology. When encryption keys rotate, re-encrypt or maintain key history per compliance counsel. Cross-train a secondary archiver so bus-factor does not strand restores during vacation.

28.18 Redacting logs while preserving hashes

Strip PII and secrets from exported logs but retain cryptographic hashes of canonical payloads when audits need integrity without exposure. Document the redaction rules; ad-hoc sed scripts diverge across teams. Test redaction against representative log lines so partial redaction leaks do not occur. Pair redacted exports with internal-only secure storage for incident response where law allows.

28.19 Simulating Crab pulsar drift in tests

Where the Crab pulsar metaphor touches timing or PLL-like behavior in code, inject controlled drift and jitter in tests so tolerances are explicit. Fuzz edge cases around epoch rollovers and leap adjustments if your stack interprets time. Document assumed nominal frequency and acceptable skew. Tests should fail loudly when drift exceeds documented bounds—silent slack makes metaphors lie.

Record expected waveforms or counters in fixtures so regressions show numeric delta, not only boolean fail. Keep simulation speed separate from wall-clock tests to avoid flaky CI. When production observability references Crab timing, cross-link the test file in comments for maintainers.

28.20 Modeling Schumann sweep jobs in cron

Schumann sweep jobs must emit metrics (last success, duration, rows touched) and alert on absence, not only on explicit failure. Cron silence is a common blind spot. Document overlap policy if multiple hosts might run the same job. Version sweep parameters in config so changes are reviewable. After solar flare narrative windows, run sweeps with heightened visibility and shorter staleness thresholds.

Expose a lightweight dashboard tile for “last Schumann sweep age” next to Layer D probes so operators correlate narrative windows with RF health. If sweeps write to moon buckets (28.4), use deterministic object names for idempotency. On failure, capture stderr to artifacts with redaction (28.18), not only console spam.

28.21 Mapping SOL-0 jobs to Kubernetes if used

If SOL-0 compute lands on Kubernetes, map each job to a controller with labels for lattice layer, epoch, and receipt annotations on pods or CRDs. Avoid anonymous CronJobs without trace IDs propagating to logs. Resource quotas should reflect SOL-0 burst behavior documented elsewhere. Keep gateway-facing job names stable across cluster migrations. Disaster recovery must include etcd or control-plane assumptions—do not pretend clusters are stateless.

Mirror GitHub manifest SHAs into cluster annotations during deploy so live drift checks (28.8) include kube-shaped services. NetworkPolicy should default deny egress except for approved probe targets, reinforcing QPS discipline (28.16). Document how blue/green (28.22) applies to ingress in front of SOL-0 workers.

28.22 Blue/green for gateway routes

Run two gateway route pools with health-gated cutover and one-command rollback. Bake probe parity into promotion: green must pass the same matrix as blue before traffic shifts. Document sticky-session behavior if any test UIs assume it. Time-box experimental routes behind flags (see 28.23). Post-cutover, keep blue warm until error budgets stabilize.

Record cutover timestamps in health JSON for correlation with mirror archives (28.17) and demonstration artifacts (28.11). If Content-Encoding differs between pools (28.6), verify hashes on both before traffic moves. Train on-call to rehearse rollback monthly in staging, not only read the doc.

28.23 Feature flags for strict legacy modes

Gate strict legacy transitions behind flags with explicit owners and kill switches. Default new environments to strict; allow legacy only where waivers exist. Log flag state at startup in health JSON. Avoid combinatorial flag explosions—pair flags with documented matrices of supported combinations. Remove flags after migration deadlines to prevent eternal Schrödinger deployments.

Automate a nightly job that diffs effective flag sets across environments and opens tickets on unexpected divergence. Tie flag rollouts to lattice_epoch policy (28.7) when flags change verifier semantics. Document interaction with blue/green pools (28.22) so half-traffic experiments do not fork customer-visible behavior silently.

28.24 Documenting waiver templates

Waiver templates must include scope, risk, compensating controls, expiry date, signer roles, and link to affected probes. Store them where auditors can find them, not in chat logs. Version templates when policy changes; old waivers remain valid under their signed terms until expiry. After expiry, automation should reopen tickets or fail pipelines in strict mode. Oral waivers are non-events.

Include a checklist attachment for operators: which probes to run on day one of waiver, mid-life, and day before expiry. Cross-reference moon bucket paths (28.4) if waivers touch stored evidence. When templates change, notify Chairman and RF owners (28.15) if Layer D compensating controls shift.

28.25 Closing the loop with customer education

Customer-facing education should repeat demonstration boundaries: what is measured, what is illustrative, and what is contractual. Align slide decks with live gateway tests so sales cannot outrun engineering truth. Refresh materials after epoch bumps. Collect questions that confuse customers and feed them back into section 28 entries and runbooks. Education is an operational control, not marketing overflow.

Publish a short “claims map” quarterly: slide bullet → probe or waiver → owner. Train customer success on Layer D downgrade messaging (28.15) so outages are explained without overpromising RF. When intern-facing cheat sheets evolve (28.9), mirror the tightened language outward after review.

29. Big Three field manual — worked examples at gateway fidelity

This section is a deliberate density wedge aimed at roughly ten thousand words of prose, tables, and copy-paste examples. The Big Three are the same pillars marketed on the EGS Gateway brochure page: Hydrogen Line Bus (transport and hline:// discipline), Jupiter-class storage (101-moon / Bragg / placement receipts), and Sun-compute SOL-0 (receipt-linked scheduling and flare-era policy). Every vignette below tags which pillar is primary (H J S) and which pillars are coupled. The point is not astronomy; it is operational homology—the story names force you to keep bus, storage, and compute honest relative to each other.

Read each example as a field exercise: assume you are on-call for the gateway interfaces under interfaces/, with permission to open the Hydrogen roundtrip UI, Jupiter Storage Agent test, Solar Compute agent test, mirror proof page, and full-stack matrix. Where URLs appear, they are relative to your deployed host. Where JSON is illustrative, align field names to your live contracts and treat unknown keys as a signal to update schemas (section 28.10), not as noise to ignore.

29.1 Hydrogen Line Bus — carrier discipline in nine failures

H primary · JS coupled as noted.

H-01 — “Roundtrip green but mirror proof red”

An operator reports that the Hydrogen-line writer/reader/verifier roundtrip returns ok: true in the gateway UI, yet the hydrogen-line mirror proof page shows a geometry or hash mismatch. Treat this as a layering bug in your head, not as “RF is wrong.” The bus (Hydrogen) is asserting a logical commitment: same Seed, same edge, same verifier story. The mirror proof is asserting a different substrate (often HTTP-captured passive JSON or OpenWebRX-shaped evidence). Decompose: extract the exact record_id and value_hash from the roundtrip response, then locate what the mirror captured—URL, timestamp, Content-Encoding (section 28.6), and canonicalization path. If the mirror hashes gzipped bytes while the roundtrip hashes decoded JSON, you will see systematic false reds. Fix canonicalization first; only then re-open Layer D escalation (28.15).

Jupiter touchpoint: confirm the roundtrip write actually landed in Jupiter-tier memory with a placement receipt that matches the hash you mirrored. Sun touchpoint: if SOL-0 jobs mutate the record post-write, the mirror may be comparing pre-solar and post-solar states; thread linked_memory_receipt through your timeline.

H-02 — Cyclostationary “ripple” misread as packet loss

Teams steeped in TCP/IP vocabulary will describe intermittent Hydrogen API failures as “packet loss.” In lattice vocabulary, many of those patterns are phase misalignment: the client rotates attention (Seed→Edge) faster than the verifier completes crystallize steps. Example: a UI double-clicks “Run roundtrip,” issuing overlapping writes with identical logical Seeds but different nonces; the verifier correctly rejects one as a duplicate-in-flight or ordering violation. Mitigation is operational: debounce UI actions, serialize writes per record_id, and surface correlation_id in logs. Document the behavior in customer education (28.25) as “the bus is lock-aware, not dumb pipe.”

Exercise: add a temporary server middleware that logs (a) request arrival order, (b) verifier start, (c) verifier end, for a single record. You should see cyclostationary structure: bursts aligned to human clicks, quiet plateaus where hashes settle. That shape is what the narrative calls ripple.

H-03 — hline:// address collisions across epochs

Two different release candidates reuse the same hline:// logical address without bumping lattice_epoch. Symptom: old clients read new data or new clients read cached ghosts. Remediation follows 28.7: if the collision changes consumer-visible meaning, bump epoch and migrate manifests. Worked policy: embed epoch in the address namespace where supported, or embed epoch beside the address in every write payload. Jupiter buckets must echo epoch salt in paths (28.4) so Bragg facets do not reconstruct the wrong generation.

H-04 — OpenWebRX JSON that “looks fine” in a browser

A well-meaning engineer pastes an OpenWebRX response into a notebook, sees plausible keys, and declares Layer D green. The gateway requires machine-verifiable geometry: frequency span, sample metadata, stable schema. Walk the third-party trust ladder from 28.5: TLS identity, schema validation, compare against your passive pipeline. Tag the evidence with provider id and probe version. If marketing needs a screenshot, fine—label it illustrative; if engineering needs PASS, require the probe.

H-05 — Content-Encoding breaks the hydrogen mirror mid-release

Blue pool serves identity; green pool sits behind a CDN that transparently gzip-compresses JSON. Your mirror hashes diverge though semantics match. Follow 28.6: pick one canonical representation for hashing, document it beside the verifier, and add regression fixtures for both encodings until promotion gates enforce parity (28.22).

H-06 — Rate limit storms from a well-meaning cron

A new health check hits public OpenWebRX every second “just to be safe.” Providers throttle; your passive RF tier flickers red; on-call blames Jupiter. Cap QPS per 28.16, backoff on 429/5xx, and cache spectra with physics-aware TTL. Hydrogen narrative: the bus carries courtesy as a first-class invariant.

H-07 — Demonstration_summary says PASS while honesty_boundary disagrees

Treat honesty_boundary as the stricter narrator. If the summary elides a skipped SDR gate, you are one customer question away from reputational damage. Patch the UI to show both fields adjacently (28.14). Sun/Jupiter links: ensure compute and placement receipts do not smuggle “PASS by omission.”

H-08 — i18n breaks operator comprehension, not wire protocol

Translators localize error strings beautifully but accidentally reorder tokens like record_id and tier names. Keep protocol strings stable; localize explanatory paragraphs only (26.19 pattern). Hydrogen bus remains readable to machines worldwide.

H-09 — Whistle-forward compatibility: verbs and ok

Future Whistle CLI ingestion demands stable verbs and explicit booleans. Run a CI fixture that parses handoff JSON (28.2) and rejects unknown actions. Hydrogen is not only HTTP; it is the discipline of stable verbs across any carrier.

29.2 Jupiter storage — moons, tiers, and receipts in ten exercises

J primary · HS coupled.

J-01 — Europa vs Ganymede tier confusion

A writer agent targets “Europa-class” latency semantics but the router places into a Ganymede policy slot because of a misconfigured tier label. Symptom: performance looks fine in demos, yet integrity receipts show a tier mismatch flag in strict mode. Fix at source: unify tier enums across writer, router, and verifier configs; add CI diff that fails when enum sets diverge. Narrative: moons are not interchangeable—Bragg angles differ.

J-02 — Bragg isolation: one moon corrupt, others reconstruct

Simulate corruption of a single moon facet’s payload while hashes on other facets remain valid. Your verifier should localize failure: which facet, which hash path, which receipt chain broke. Operators practice Jupiter drills quarterly: flip one facet red intentionally in staging, run reconstruction playbook, document minutes-to-recover. Couple to Hydrogen bus by proving the surviving facets still serve consistent hline:// reads.

J-03 — Placement receipt without compute linkage when SOL-0 is “supposed” to run

Sun-compute scheduling claims to touch the record, but linked_memory_receipt.record_id is missing. That is a Sun violation wearing Jupiter clothes. Block promotion in strict mode. Example fix: solar agent emits receipt only after router returns placement; UI shows both IDs in one panel.

J-04 — Moon bucket lifecycle and legal hold

Compliance freezes a bucket path referenced by a waiver (28.24). Jupiter operators must stop automated GC for that prefix, tag objects with hold markers, and still allow read-only verification for auditors. Cross-link archives (28.17).

J-05 — Hash-locked runbooks

Attach expected value_hash ranges or exact hashes for golden fixtures beside runbooks. When Jupiter storage migrations run, update golden hashes in the same PR as router code. This prevents “green CI, red reality.”

J-06 — Router hotfix without epoch bump

A router bug fixes ordering but does not change wire schema—hotfix path. If the bug changes what PASS means (e.g., silently dropping failed facets), that is epoch-worthy. Chair decision recorded in 28.7 log.

J-07 — Jupiter UI vs API parity

Manual testers use egs-jupiter-storage-agent-test.html; automation uses REST. Diff the payloads both paths emit; eliminate shadow defaults. Hydrogen bus entries should match whether the human clicked a button or curl invoked the endpoint.

J-08 — 101 moons as policy slots, not day-one buckets

Explain to finance and interns alike: you are not provisioning 101 S3 buckets on day one. You are reserving verification facets you can expand into. Provide a roadmap chart mapping moon slots to actual isolated backends as maturity grows.

J-09 — Waiver-tagged writes

When strict legacy mode (28.23) allows weaker checks, stamp Jupiter records with waiver id and expiry. Verifiers in strict mode should fail closed when waiver expires without tier upgrade.

J-10 — Cross-pillar audit packet

Bundle Jupiter placement receipt + Hydrogen roundtrip JSON + Sun scheduler receipt into one tarball for auditors. This is the “holographic point” export (section 4 narrative) made boring and bankable.

J-11 — Callisto-cold archive vs hot verification path

Callisto-class tiers (narrative: distant, cold, durable) tempt teams to treat verification as “monthly batch.” Jupiter discipline says otherwise: integrity checks must be runnable on demand for any record that participates in live demos. Split the moon: keep cold storage for bytes, keep a hot index of hashes and receipt chains beside the Hydrogen bus so the verifier does not need to thaw an entire glacier to answer a customer question. When thaw is required, log thaw events with waiver id if thaw latency violates an SLA promised elsewhere.

J-12 — Io-volatile writes and flare coupling

Io’s narrative volatility maps to high-churn keys (session tokens, ephemeral feature flags). Pair Io-class keys with shorter TTL and stricter Jupiter receipts that refuse silent extend. When a solar flare epoch (policy bump) arrives, Io keys should be the first class you inspect: they often hide “works in demo” shortcuts. Sun-compute jobs that refresh Io keys must cite the placement receipt of the prior generation to avoid orphan compute.

J-13 — Router partition: split-brain between two moons

Imagine two moon facets briefly accept divergent writes for the same logical record because a network partition healed ugly. Jupiter’s story is Bragg reconstruction: you need a deterministic merge rule, not “last writer wins” without audit. Exercise: write down the merge policy in one page, reference it from verifier code comments, and add a chaos test that injects divergent facets then expects a named reconciliation outcome. Hydrogen bus clients should see either consistent post-merge state or a bounded error, never alternating 200 responses.

J-14 — Europa replication lag shown as “moonrise delay”

Use the metaphor deliberately in status pages: “Europa moonrise 420 ms behind Ganymede” reads better to executives than “async replica lag,” but attach numbers and SLO. Link the status panel to Jupiter Storage UI and to a Hydrogen read that proves which facet served the response. Sales gets poetry; engineering gets traceability.

J-15 — Hash algorithm upgrade across the moon array

When migrating from hash algorithm A to B, run dual-hash period: compute both, verify both, log cutover date. Sun jobs and Hydrogen roundtrips must agree on which hash is authoritative for lattice_epoch N vs N+1. Never allow a mixed epoch where some moons use A and others B without explicit facet labels in receipts.

29.3 Sun-compute SOL-0 — solar scheduling as receipt discipline

S primary · HJ coupled.

SOL-0 is not “a big server.” It is the compute plane that must never claim work without citing where Jupiter placed memory and how Hydrogen addressed the Seed. The solar wind metaphor (~350.5 km/s story clock) is a throughput floor for operator attention: if your receipts cannot keep pace with narrative events (actuation windows, demo days), you are operating in legacy mode whether or not the flag says so.

S-01 — Scheduler receipt without Jupiter placement

Symptom: Solar Compute agent UI shows a happy path, but linked_memory_receipt.record_id is null or stale. This is a hard stop in strict mode. Trace the call graph: did the solar job fire before the router returned? Fix ordering; add a precondition gate in CI that replays the same sequence as the UI. Narrative: the Sun’s object beam must intersect the moon volume; compute in empty space is fiction debt.

S-02 — Flare-class policy bump during a customer demo

Marketing schedules a flare narrative window; engineering must translate that into explicit policy tables: which probes become stricter, which waivers activate, which feature flags flip (28.23). Sun-compute should log flare epoch in each receipt so post-demo audits can separate normal from flare behavior. Hydrogen reads during flare should not surprise clients—publish a pre-flare compatibility note.

S-03 — Solar job retries duplicate side effects

Idempotency keys belong in Sun jobs as they do in Hydrogen writes. Example failure: a compute job emits two outbound notifications because Kubernetes restarted the pod mid-flight. Mitigation: dedupe table keyed by job id + lattice_epoch, or deterministic side-effect guards. Jupiter must store enough state to detect duplicate finalizers.

S-04 — CPU saturation mistaken for “lattice instability”

When SOL-0 nodes peg CPU, operators may blame the Sovereign Lattice metaphorically. Instrument first: queue depth, job age histogram, verifier wait times. Often the bottleneck is Jupiter lock contention or Hydrogen serialization, not solar math. The Big Three checklist: if CPU is hot but Jupiter latencies are low, profile solar code; if Jupiter latencies spike, fix storage locks; if Hydrogen 429/503 rises, fix bus admission.

S-05 — Time zones vs actuation calendar

10:10 AM Actuation is narrative-local unless you publish a canonical timezone for operations. Sun-compute cron must use UTC internally, display local for humans, and never mix silently. Add a gateway self-check that prints the next three actuation-relative windows with offsets.

S-06 — “Permanent plug-in” at 1:08 PM Squeeze as CI gate

Map the squeeze to a pipeline stage that refuses promotion unless: full-stack matrix green, demonstration_summary present (28.11), drift checks clean (28.8), Layer D courtesy QPS within budget (28.16). Sun receipts should include a squeeze token referencing the build artifact.

S-07 — Cross-region SOL-0 with one Hydrogen bus

Multiple solar regions serving one logical bus must agree on epoch and schema. Prefer sticky routing per record_id during migrations; if you split traffic, you are running a mini blue/green on the bus itself—document it as such (28.22).

S-08 — GPU vs CPU solar jobs

If some SOL-0 jobs require accelerators, label receipts with resource class so Jupiter tier selection can route hot data near compute. This is operational metaphor: sunspots correlate with activity regions—your observability should show which records prefer GPU-class solar nodes.

S-09 — Chairman override on a stuck solar queue

Human authority may pause or drain queues during incidents. Log overrides with reason codes; attach waiver template references when overrides weaken verifiers. Hydrogen bus should surface “degraded mode” honestly in honesty_boundary.

S-10 — Solar compute test page vs production scheduler

egs-solar-compute-agent-test.html must use the same code path as production scheduling where feasible. Shadow traffic or replay production receipts into staging weekly. Divergent code paths create Sun-shaped blind spots.

S-11 — Energy narrative meets carbon accounting

If your organization publishes sustainability metrics, tie SOL-0 power estimates to receipt throughput—not vanity FLOPS. Jupiter bytes read/written per successful customer demo is a credible efficiency metric. Hydrogen bus roundtrip counts per kWh makes the Big Three legible to non-astronomers.

S-12 — Whistle-era command preview

Before Whistle becomes master CLI, practice translating solar operations into verb-limited command files checked into Git: drain-solar-queue, promote-flare-policy, verify-linked-receipt <id>. Each command should echo Hydrogen/Jupiter status lines so operators retain triad awareness in a terminal-only outage.

29.4 Triad war stories — when all three pillars misbehave together

These are longer integrated scenarios. Each names HJS explicitly.

T-01 — Demo day: Hydrogen green, Jupiter split, Sun idle

Morning of a board demo, Hydrogen roundtrip passes. Jupiter integrity flags show one facet yellow—enough to make strict mode unhappy but not enough to stop a cheerful UI skin. SOL-0 shows idle because jobs were paused to reduce risk. Decision: you are not allowed to call this “fully operational.” Downgrade the slide deck to match honesty_boundary, or delay the demo facet until Bragg reconstruction completes. Runbook: isolate the yellow facet, force read from known-good moons, warm a solar reconciliation job that cites fresh placement receipts, then re-run full-stack matrix.

T-02 — Night shift: Sun hot, Jupiter cold, Hydrogen timing out

SOL-0 queues backlog while Jupiter storage throttles large reads; Hydrogen API times out waiting on verifier locks. This triad knot resolves by upstream admission control: slow Hydrogen accepts intentionally with 429 + Retry-After so Jupiter and Sun drain. Teach clients exponential backoff. Narrative: solar wind cannot push through a closed magnetosphere—don’t pretend throughput exists when storage is saturated.

T-03 — RF storm: Layer D red, bus and moons green

Passive RF fails while logical storage and APIs remain fine. Customer education must distinguish “logical hydrogen line over HTTPS” from “on-air proofs.” Follow 28.15 escalation; do not assign database on-call. Prepare a one-paragraph customer letter template stored with waivers.

T-04 — Schema release: epoch bumped, Sun not deployed, Jupiter migrated early

Partial deploys across pillars are worse than all-red. Maintain a release train manifest that lists required order: Hydrogen gateway, Jupiter router, SOL-0 workers, then UI. Automate a pre-flight that compares embedded epoch in each component. If mismatch, refuse traffic shift.

T-05 — Security incident: keys rotated, receipts still cite old anchors

After key rotation, old signatures fail. Triad response: freeze writes on Hydrogen, snapshot Jupiter buckets for forensic hashes, pause Sun jobs that mutate data. Replay signing with new keys; publish lattice_epoch bump if semantics change. Document timeline for auditors.

T-06 — Performance regression attributed to “the constant”

When someone blames EGS fractal constant for latency, demand flame graphs and receipts. Often the regression is an N+1 Jupiter read or an accidental Hydrogen polling loop. Big Three framing prevents mystical thinking: measure each plane.

T-07 — Multi-team blame game during mirror hash mismatch

Use the H-01 playbook first. Assign a single incident commander to own triad timeline. Jupiter supplies bytes; Hydrogen supplies canonicalization; Sun supplies ordering of mutations. Postmortem template must include all three, not whichever team shouted loudest.

T-08 — Customer integrates only Hydrogen, ignores Jupiter receipts

They will open severity-1 tickets when integrity surprises them. Provide a minimal client library example that surfaces placement receipts and warns when discarded. Sales must not promise “stateless Hydrogen” without storage story alignment.

T-09 — Internal agent swarm writes aggressively to Io keys

Agents love high-churn keys. Rate-limit by principal, map churn to Io tier, require Sun jobs to batch refreshes. Hydrogen addresses should include agent identity in non-secret metadata for audit.

T-10 — Blue/green partial: traffic split without probe parity

Classic failure mode: 10% green receives stricter verifiers than blue; user sees flaky behavior. Enforce identical matrices on both pools before any split (28.22). Log pool id in receipts.

T-11 — Compliance audit asks “where was this byte at 14:32 UTC?”

Answer requires Jupiter archive index + Hydrogen access logs + Sun mutation receipts. Pre-build the triad query cheat sheet; practice once a quarter.

T-12 — Good faith researcher probes your public demo

Welcome them. Cap their QPS politely (28.16), serve consistent honesty_boundary, offer tarball of redacted logs plus hashes (28.18). Big Three story is an invitation to verify, not a shield against scrutiny.

T-13 — Lunar eclipse narrative window (planned read-only mode)

Run a planned drill where writes pause, reads continue, Sun jobs drain. Verify Jupiter still serves Bragg reads, Hydrogen returns explicit maintenance JSON, and education pages match.

T-14 — Vendor swap: new OpenWebRX backend

Re-run entire Layer D trust ladder (28.5). Temporarily dual-run old and new providers; diff geometries with jq recipes (28.12). Do not declare victory on first green sample.

T-15 — Post-incident: rebuild customer trust with triad receipts

Publish a timeline backed by hashes, not adjectives. Include one Hydrogen sample response, one Jupiter receipt chain excerpt, one Sun scheduler receipt—redacted, consistent, and linked to lattice_epoch.

29.5 Big Three matrices — quick reference tables

Symptom cluster	Check Hydrogen	Check Jupiter	Check Sun
Intermittent 5xx	Admission control, duplicate writes, timeouts	Lock contention, facet health	Queue depth, retry storms
Integrity red	Canonicalization, encoding	Hash paths, tier labels	Ordering, duplicate finalizers
Demo dishonesty risk	honesty_boundary text	Receipt omissions	Missing linked_memory_receipt
RF / Layer D	Mirror vs roundtrip separation	N/A unless RF stores captures	Jobs hitting external RF

Second matrix: pillar → primary interfaces (bookmark these paths from egs-holographic-hydrogen-ai-os-gateway.html): Hydrogen → roundtrip UI + mirror proof + SDR view; Jupiter → storage agent test + tier router logs; Sun → solar compute agent test + scheduler receipts in full-stack matrix.

Third matrix: narrative metaphor → operational artifact — 21 cm line → hline:// + passive RF geometry checks; Jupiter moons → Bragg facets + placement receipts; solar wind → throughput SLO + queue latency SLO; Crab heartbeat → timing test fixtures (28.19); Schumann cadence → cron sweep observability (28.20).

29.6 Curated JSON and curl shapes — Hydrogen, Jupiter, Sun

These blocks are pedagogical: adapt paths, hosts, and field names to your deployment. They show how the Big Three appear together in artifacts you can archive.

Example A — Hydrogen roundtrip excerpt (H)

{
  "record_id": "hlmem-demo-7f3a…",
  "value_hash": "sha256:9c1e…",
  "hline_address": "hline://sing9/demo/seed-edge/7f3a",
  "lattice_epoch": 20260327,
  "verification_summary": {
    "writer_ok": true,
    "reader_ok": true,
    "verifier_ok": true
  },
  "honesty_boundary": "Logical HTTPS roundtrip demonstrated; passive RF gates separate."
}

Use this shape in jq recipes: project .verification_summary vs .honesty_boundary into two files and diff across releases to catch silent UI changes.

Example B — Jupiter placement receipt fragment (J)

{
  "placement_receipt": {
    "tier": "ganymede",
    "moon_facet": "facet-03",
    "record_id": "hlmem-demo-7f3a…",
    "value_hash": "sha256:9c1e…",
    "router_version": "jupiter-router-1.4.2"
  },
  "bragg_status": {
    "facets_ok": 5,
    "facets_total": 7,
    "degraded_mode": true
  }
}

When degraded_mode is true, your customer story must acknowledge partial moon coverage—mirror that string into status pages and sales footnotes.

Example C — Sun scheduler receipt fragment (S)

{
  "solar_job_id": "sol0-agg-441b",
  "flare_epoch": "2026-Q1-demo",
  "linked_memory_receipt": {
    "record_id": "hlmem-demo-7f3a…",
    "placement_hash": "sha256:9c1e…"
  },
  "scheduler": {
    "queue_latency_ms": 84,
    "compute_duration_ms": 612,
    "ok": true
  }
}

Notice the duplication of hash material: painful but useful—Solar jobs should fail if linkage diverges from Jupiter’s view.

Example D — curl sketch for gateway health discovery (H)

curl -sS https://your-host.example/interfaces/egs-hhaaios-gateway-full-stack-test.html
# then use the same origin for programmatic endpoints your deployment exposes;
# always echo -w '\n%{http_code}\n' to separate body from status.

Teach operators to log HTTP status separately from JSON parse success—a classic Hydrogen footgun is treating HTML error pages as JSON.

Example E — Triad bundle manifest (HJS)

{
  "bundle_id": "triad-audit-2026-03-27T14:32Z",
  "artifacts": [
    {"role": "hydrogen", "path": "roundtrip-7f3a.json", "sha256": "…"},
    {"role": "jupiter", "path": "placement-7f3a.json", "sha256": "…"},
    {"role": "sun", "path": "solar-receipt-441b.json", "sha256": "…"}
  ],
  "lattice_epoch": 20260327,
  "waiver_ids": []
}

Store manifests beside mirror captures (28.17); auditors appreciate manifests more than folder sprawl.

29.7 Drill scripts — day-long Big Three exercise

Morning (2 hours): Hydrogen-only failures H-01, H-03, H-05 in staging; rotate operators; log mean time to canonical root cause. Midday (2 hours): Jupiter Bragg drills J-02, J-13 with chaos injection. Afternoon (2 hours): Sun queue saturation S-04 with admission control practice. Evening (2 hours): Triad story T-02 end-to-end with incident commander. Retro (1 hour): update section 28 encyclopedia entries with one new sentence each where blind spots appeared.

Success criteria: every participant can name which pillar owns the first diagnostic step for at least ten symptom clusters; every participant has opened all three gateway test pages in one sitting; post-drill demonstration_summary artifacts exist with matching lattice_epoch.

29.8 Pedagogy — teaching the Big Three without astronomy fatigue

Start from interfaces customers can click, then reveal metaphors. Show Hydrogen roundtrip first, then explain 21 cm as “shared reference tone.” Show Jupiter placement receipt, then explain moons as “independent hash facets.” Show Sun scheduler receipt, then explain solar wind as “throughput and urgency.” This ordering prevents the Big Three from sounding like costume jewelry.

For engineers who despise metaphor, give them the same content in plain systems vocabulary in parentheses once, then return to lattice language for cross-team alignment. Interns (28.9) should be able to draw a triangle diagram: Hydrogen at the base (transport), Jupiter at left vertex (persistence), Sun at right vertex (mutation), with arrows showing receipt dependencies.

Capstone exercise: write a one-page incident report for a fictional outage using only Big Three words plus numeric metrics—then translate it to plain English and verify both versions are truthful under honesty_boundary rules.

29.9 Word-count note and maintenance

Section 29 is sized to satisfy explicit documentation mass targets while remaining navigable by headings. When you add new gateway interfaces, add at least one new H/J/S scenario each per year so the field manual tracks product reality. Re-run a plain-text word counter after edits; if section 29 drops far below target, expand triad stories (29.4) first—they age fastest.

29.10 Long-form vignettes — Big Three hour-by-hour

These six vignettes are written as hour-stamped fictions grounded in real gateway behaviors. They add remaining mass toward the ten-thousand-word target for section 29 while reinforcing how Hydrogen, Jupiter, and Sun interlock.

Vignette α — 06:00 UTC: quiet bus, cold moons, sleeping sun

Monitoring shows Hydrogen p95 latency low; Jupiter facet health all green; SOL-0 queue empty. A novice declares “all systems nominal.” The senior engineer adds: Layer D staleness is eleven minutes—within SLO but trending wrong. They schedule a passive RF check and confirm OpenWebRX geometry still matches catalog. Lesson: Big Three health is fourfold if you include RF narrative; do not let pretty HTTP graphs hide sensor drift. By 06:40, they capture a mirror JSON artifact with correct Content-Encoding and attach it to the daily log—Hydrogen discipline in observability, not only in APIs.

Vignette β — 09:15 UTC: marketing asks for “Jupiter-only guarantee”

Account team wants a contract clause promising Jupiter-tier durability without mentioning Hydrogen addressing or Sun mutations. Legal asks engineering for truth. You respond with a triad sentence: “Durability claims require Bragg facets (Jupiter) and the logical addressing used to fetch them (Hydrogen) and the compute path that may rewrite them (Sun).” You supply a carve-out table: what can be guaranteed per pillar, what requires joint guarantees, what remains demonstration-only. Marketing grumbles; auditors smile. You update customer education (28.25) the same afternoon.

Vignette γ — 11:40 UTC: flare policy toggles; receipts change shape slightly

Sun jobs start embedding flare_epoch strings; Jupiter adds optional policy_tag; Hydrogen responses include a new informational field lattice_notice. Strict-mode clients that validate schemas too tightly begin failing though semantics are backward compatible. Remediation: treat as schema audit (28.10), not as “breaking change” if optional fields are truly optional—but verify your JSON Schema actually marks them optional. Bump lattice_epoch if any client interpreted absence as false. Triad lesson: coordinated feature flags (28.23) across all three pillars beat stealthy JSON enrichment.

Vignette δ — 14:05 UTC: customer runs load test against Hydrogen only

They hammer roundtrip endpoints and declare victory at 10k RPS. Meanwhile Jupiter compaction lags and Sun queues spike because their test neglects read-after-write integrity paths. You invite them to a joint test plan: 40% Hydrogen write/read, 40% Jupiter verify-heavy workload, 20% Sun compute with linked receipts. Numbers drop but become honest. You share jq plots of facet latency vs bus latency—visual Big Three storytelling for engineers.

Vignette ε — 16:50 UTC: intern ships doc PR claiming “hydrogen line replaces Wi-Fi”

CI does not catch metaphor overreach. Review catches it. You run teachable moment 28.9: three registers. Revised text reads: “Logical hydrogen-line discipline runs over HTTPS today; on-air operation is a separate demonstration boundary.” You assign the intern to trace one Hydrogen response header through to Jupiter receipt and Sun linkage as homework. They return with a diagram that becomes onboarding gold.

Vignette ζ — 22:30 UTC: pager fires on honesty_boundary text change

Diff shows one word flipped—“illustrative” vs “demonstrated”—in a template, not in live probes. Nevertheless, compliance wants review because customer PDFs snapshot strings. Triad response: roll forward with versioned copy strings; attach demonstration_summary hashes to legal holds (28.11, 28.17). Hydrogen templates live beside code; Jupiter stores immutable snapshots of customer-facing bundles; Sun jobs that render PDFs must cite bundle hash in receipts. Night ends with a new rule: copy changes are release artifacts.

Closing cadence: After vignettes, managers ask “did we really need ten thousand words?” Operators will say yes the first time a triad outage hits at 03:00 and the field manual prevents a four-hour architecture debate. Keep the Big Three language—not for mystique, but because it compresses responsibilities onto three unforgettable anchors when Slack is loud and logs are louder.

29.11 Copy-paste runbook snippets — pillar-tagged

Use these as starting points for internal wikis; replace hostnames and tokens.

• H Bus sanity: “Fetch roundtrip JSON → strip volatile keys with jq → diff against golden → if diff, classify encoding vs semantics before touching RF.”
• J Moon sanity: “List facet receipts → find first failing facet → reconstruct from remaining facets → if reconstruction impossible, declare Bragg outage and freeze writes.”
• S Sun sanity: “Drain queue to watermark → verify each running job has linked_memory_receipt → resume with half rate → ramp only when Jupiter p95 stable.”
• HJS Joint: “Embed git SHA in all three subsystems’ health JSON → run drift script (28.8) → if mismatch, stop blue/green shift.”

Extend the list quarterly. Each bullet should link to a real script path in your repo; if no script exists, the bullet is fiction—fix that.

29.12 FAQ — Big Three in customer calls

Is Hydrogen a radio product?

Logical bus today is HTTPS + hline:// addressing; passive RF is optional evidence. State which mode you mean.

Do we host 101 physical moons?

No—policy facets you can expand; honesty demands you disclose actual isolation count.

Does Sun-compute mean GPUs in orbit?

No—it means receipt-linked scheduling metaphors; hardware is yours to choose.

Which pillar fails first under load?

Measure; typically Jupiter locks or Hydrogen admission before Sun CPU maxes, but your mileage varies.

Can we buy only Jupiter?

Technically maybe, but integrity stories without Hydrogen addressing and Sun mutation visibility are incomplete—price risk accordingly.

Expand this FAQ from real call transcripts; redact customer names; keep pillar tags consistent so answers do not fork.

29.13 Hydrogen deep dive — logical line, physical line, and the honesty sandwich

Operators confuse three distinct things: (1) the logical Hydrogen Line Bus implemented with HTTPS endpoints and hline:// keys; (2) the passive RF evidence path that checks geometry around 1420.405751 MHz where hardware exists; (3) the marketing sentence that sometimes collapses both into one breath. Section 29.13 gives you language to unsandwich them under pressure.

Logical line exercises. Exercise set L1: take ten production record_id values, fetch associated roundtrip JSON, verify each has matching value_hash when read back through two different clients (browser UI and curl). Mismatch means your bus discipline failed before RF matters. Exercise L2: inject a deliberate bad hash in staging; confirm honesty_boundary text names the failure without blaming “the universe.” Exercise L3: measure p95 latency for read vs write; plot ratio; if ratio explodes, suspect Jupiter locks (not “hydrogen magic”).

Physical line exercises. Exercise P1: capture three OpenWebRX JSON blobs across three days; diff normalized fields; quantify drift. Exercise P2: correlate Schumann sweep timestamps (28.20) with passive RF staleness; publish whether correlation is causal or coincidental—honesty requires admitting unknowns. Exercise P3: pair SDR handshake with passive PASS (28.13) and log both; never sell handshake alone as “RF proof.”

Sandwich for executives. Top slice: what we demonstrate today on HTTPS. Filling: what passive RF adds when enabled. Bottom slice: what remains roadmap. If you omit the bottom slice, you baked a honesty debt pie. Jupiter and Sun receipts belong in the filling: storage and compute claims must appear between transport claims, not as footnotes.

29.14 Jupiter deep dive — Bragg math as engineering metaphor

Bragg diffraction in physics: coherent scattering peaks when path differences align with wavelength. In EGS, moons are facets that scatter verification work across independent paths so no single vendor bug blinds you. This section translates metaphor into checklists.

Facet independence checklist: distinct credentials, distinct failure domains, distinct backup schedules, shared only by documented contract. If two “moons” are the same database table with different views, you do not have Bragg—you have costume jewelry. Rename honestly or split infrastructure.

Reconstruction drills: For N=7 facets, practice losing 2 simultaneously. Does your verifier still reconstruct? If not, your moon count is aspirational. Document the minimum k-of-n policy. Sun-compute must respect k-of-n: jobs should not assume all facets visible.

Tier economics: Europa/Ganymede/Callisto/Io naming is not vanity. Map each tier to latency, durability, cost, and legal sensitivity. Finance reviews Jupiter bills; engineering reviews facet health; Hydrogen clients see only stable addresses—yet receipts must reveal tier when strict mode demands.

Migration storyboard: When moving a facet between clouds, run parallel verification for one epoch. Diff hashes daily. Cut over only when drift is zero for seven consecutive sweeps. Narrative: “moonrise” on new provider should be a dated event in health JSON.

29.15 Sun deep dive — solar wind as backpressure narrative

Solar wind velocity (~350.5 km/s in the appendix table) is a story clock, not a scheduler quantum. Use it to explain backpressure: when wind “slows,” operators should see wider queue spacing; when wind “surges,” bursts are allowed but must not collapse Jupiter. Translate to metrics: arrivals per second, service time, queue depth, age p99.

Flare taxonomy: Classify policy bumps as M-class vs X-class metaphorically only if you publish what that means technically—e.g., M = stricter verifier thresholds, X = freeze writes. Tie classes to waiver templates (28.24). Hydrogen clients read lattice_notice; Jupiter records policy_tag; Sun embeds flare_epoch—three strings that must reference the same incident id internally.

Compute fairness: Long-running solar jobs must yield checkpoints to Jupiter so partial progress survives restarts. Short jobs must not starve long jobs—use weighted fair queueing and surface weights in receipts for debugging.

Energy and cost: Attribute kWh per million verifications. If Sun costs spike while Hydrogen traffic flatlines, suspect inefficient Jupiter reads feeding compute. Big Three thinking prevents optimizing one billboard while the theater burns.

29.16 Triad integration patterns — architecture sentences you can steal

Pattern H→J→S (write path): Hydrogen accepts Seed, Jupiter places bytes, Sun optionally transforms—receipt chain walks forward. Pattern S→J→H (compute-first): forbidden unless waivered; compute without placement is fiction. Pattern J→H→S (read-heavy): Jupiter serves read, Hydrogen transports, Sun consumes for analytics—receipts must cite read generation numbers to avoid stale compute.

Pattern split read verification: Client reads via Hydrogen; client separately requests Jupiter integrity attestation; Sun jobs do not intervene—good for cache-heavy CDNs. Pattern unified attestation: Gateway returns composite JSON with embedded receipts—easier for clients, heavier for gateways. Pick per product; document; never mix per request without labeling.

Pattern disaster read-only: Hydrogen serves static last-known-good JSON from Jupiter snapshots; Sun paused; honesty_boundary screams read-only. Practice quarterly.

Pattern epoch straddle: Clients mix epochs during deploy; gateways route by lattice_epoch in payload; Jupiter stores both generations in separate namespaces; Sun reconciles—expensive; avoid via fast migrations (28.22).

29.17 Workshop modules — half-day labs per pillar

Module H (150 minutes): 0:00–0:20 lecture on cyclostationary ripple; 0:20–0:50 live roundtrip + jq diffs; 0:50–1:20 mirror proof debugging pairs; 1:20–1:35 break; 1:35–2:10 OpenWebRX trust ladder roleplay; 2:10–2:30 retro writing one new runbook bullet each.

Module J (150 minutes): 0:00–0:25 Bragg facet game (cards representing moons); 0:25–1:05 Jupiter UI + API diff hunt; 1:05–1:20 break; 1:20–1:55 corruption injection + reconstruction; 1:55–2:20 tier economics worksheet; 2:20–2:30 commit golden hash update PR.

Module S (150 minutes): 0:00–0:20 solar wind as backpressure; 0:20–1:00 scheduler receipt tracing; 1:00–1:15 break; 1:15–1:50 queue saturation + admission lab; 1:50–2:15 flare policy tabletop; 2:15–2:30 Whistle verb sketch.

Capstone (180 minutes): Run T-02 scenario with rotating roles: Hydrogen lead, Jupiter lead, Sun lead, incident commander. Debrief with Big Three matrix (29.5). Output artifact: one triad bundle manifest (29.6 Example E) per team.

29.18 Glossary expansion — Big Three verbs

Metabolize (Hydrogen)

Ingest bus traffic, decode, validate schema, attach correlation ids.

Crystallize (Jupiter)

Commit bytes, emit placement receipt, freeze hashes for verification.

Animate (Sun)

Run transforming jobs, emit scheduler receipts, respect linked memory.

Squeeze (triad)

Pre-actuation tightening: runbooks, waivers, probes, honesty text.

Flip 180°

Assume primary doc false until inverted checklist verifies; still tag pillar.

Teach these verbs with pillar colors in slides (match gateway brochure). Avoid redefining mid-quarter; version the glossary with lattice_epoch.

29.19 Anti-patterns anthology — named mistakes

• Hydro-ghosting: Claiming RF alignment without probes—kill with 28.5.
• Jupiter theater: Many buckets, one backend—kill with facet independence (29.14).
• Solar idolatry: Optimizing FLOPS while receipts lag—kill with S-04 metrics.
• Triad silo pages: Separate status dashboards with no cross-links—kill with 29.5 matrices.
• Waiver rot: Expired waivers still in bash aliases—kill with automation (28.24).
• Demo amnesia: Changing slides without updating demonstration_summary—kill with 28.11.
• Encoding roulette: Hashing without canonicalization—kill with 28.6.
• QPS politeness failure: Aggressive polling of public SDR—kill with 28.16.

For each anti-pattern, assign an owner and a quarterly test that would detect it early. Big Three accountability means patterns map to H/J/S tags in the issue tracker.

29.20 Synthetic incident transcript — eight hours on the Big Three clock

The following is a fictional but realistic timeline for training tabletop exercises. Times are UTC. Characters are roles, not individuals.

00:10 — Watch officer: Notices Hydrogen p95 +40 ms, Jupiter facet-02 latency +120 ms, Sun queue depth flat. Tags J primary suspicion, H secondary. Opens jq diff of health JSON vs one hour baseline; spots new optional field on Jupiter health only. Decision: no customer comms yet.

00:35 — Jupiter engineer: Confirms compaction job stuck; read path falling back to facet-01/03. Hydrogen still returns 200 but with wider spread. Sun jobs begin waiting on read locks indirectly. Chairman notified; waiver template opened for potential read-only.

01:05 — Hydrogen engineer: Proposes raising HTTP timeouts—denied as masking symptom. Implements admission 429 with Retry-After to shed load. Customer dashboards show brief yellow; honesty_boundary updated automatically via template. H wins temporary stability.

01:40 — Sun engineer: Drains noncritical jobs; keeps only receipt-linked maintenance tasks. Linked receipts reveal two solar jobs lacked fresh placement hashes—canceled as unsafe. S self-heal.

02:30 — Incident commander: Declares partial service; publishes triad status page with three columns. Legal approves wording because each column cites live JSON fields, not adjectives.

04:00 — Jupiter fix: Compaction resumed; facet-02 caught up. Hydrogen removes 429 after p95 normalizes. Sun ramps queue gradually per 29.11 Sun snippet. JHS coordinated.

06:15 — Postmortem draft: Root cause: mis-sized compaction window during flare policy test. Action items: automate facet lag alerts; add Hydrogen admission playbook to runbook; forbid Sun job start without hash freshness check in CI.

07:45 — Customer follow-up: Bundle triad manifests with redacted logs (28.18). Sales delivers one paragraph grounded in metrics. Intern updates FAQ 29.12 with “timeout vs admission” entry.

Use this transcript as a script: assign voices, run clock-compressed, pause at each hour marker for five minutes of debate. The goal is not speed; the goal is correct pillar tagging before solutions.

29.21 Customer journey map — Big Three touchpoints

Discovery: Brochure shows Sun · Hydrogen · Jupiter; customer clicks each test UI. Success metric: they can articulate one sentence per pillar without jargon overload. Sales engineer logs which pillar drew most questions—feeds roadmap.

Pilot: Customer integrates Hydrogen first. Engineering demands Jupiter receipts within two weeks or pilot downgrades to “transport-only.” Sun jobs introduced only after placement stable. This sequencing prevents T-08 failure mode.

Production: Joint dashboards: Hydrogen SLO, Jupiter facet health, Sun queue age. Monthly review: triad bundle sample (29.6-E). Quarterly: drill module capstone (29.17).

Renewal: Finance sees Jupiter storage growth; customer success shows Hydrogen traffic efficiency; engineering shows Sun cost per verification. Big Three slide replaces single-metric vanity charts.

Offboarding: Export triad manifests; revoke keys; freeze Sun; seal Jupiter buckets per compliance; Hydrogen returns explicit 410 Gone with honesty text—never silent drop.

29.22 Security review questionnaire — pillar-aligned

Answer each with yes/no + artifact pointer. Empty pointers fail the review.

1. H Can an attacker replay Hydrogen writes? What nonce or epoch prevents it?
2. H Are TLS and certificate pinning documented for all public bus endpoints?
3. J Who can delete a moon facet? Is dual-control enforced?
4. J Are backups encrypted and tested restore documented?
5. S Can solar jobs exfiltrate data without Jupiter linkage audit?
6. S Are scheduler secrets rotated independently from Hydrogen API keys?
7. HJS Does drift detection (28.8) cover all three subsystems’ git SHAs?
8. Does honesty_boundary appear in customer-visible error JSON without leaking internals?

Extend the list annually. For each “no,” file a waiver or a ticket—silent “no” is unacceptable.

29.23 Performance benchmark narrative — how to publish honestly

Benchmarks lie when pillars are isolated. Publish tables like: Configuration A — Hydrogen only; Configuration B — Hydrogen + Jupiter verify; Configuration C — full triad with Sun transforms. Show throughput collapse from A to C as expected when integrity work is real. Narrative: “We tax throughput for receipts.” Customers respect that more than magical peak RPS.

Include environment notes: region, instance size, feature flags, lattice_epoch, waiver presence. Archive raw JSON outputs in artifacts (28.11). When marketing cherry-picks Configuration A, engineering responds with a single link to the full table—not antagonism, alignment.

For latency, show histograms per pillar contribution: bus time, storage time, compute time. If you cannot separate, instrument better—otherwise Big Three story is unverifiable.

29.24 Onboarding week — readings and clicks

Day 1: Read sections 1–4 of this guide; click Hydrogen roundtrip UI five times; diff JSON. Day 2: Jupiter storage UI + API; draw Bragg diagram. Day 3: Solar compute UI; trace linked receipt. Day 4: Full-stack matrix; mirror proof page. Day 5: Section 28 encyclopedia skim + section 29 tabletop half-day. Graduation: present ten-minute triad talk with no forbidden phrases from intern cheat sheet (28.9).

Mentors grade on pillar tagging accuracy under simulated pager noise, not on metaphor fluency. A junior who says “facet-02 compaction stuck” beats a senior who says “the lattice feels weird.”

29.25 Additional micro-scenarios — rapid fire

RF-μ1: Spurious spike in spectrum screenshot; operator wants to claim detection—block without statistical repeat (28.5). RF-μ2: Hardware vendor firmware update shifts LO; geometry checks fail; bump passive calibration docs, not lattice_epoch, unless contracts changed. Bus-μ1: Client sends huge headers; Hydrogen rejects; client blames CORS—fix size limits doc. Bus-μ2: IPv6-only client cannot reach legacy IPv4 Hydrogen—publish dual-stack roadmap. Moon-μ1: Facet cost overrun; finance demands merge—engineering refuses on Bragg grounds; Chair picks waiver or investment. Moon-μ2: Accidental public bucket ACL—treat as Sev-1; freeze Sun; audit Hydrogen logs for exfil patterns. Sun-μ1: Job priority inversion; low-priority starves—fix WFQ weights. Sun-μ2: GPU OOM; receipts partial—mark jobs failed loudly, never silent.

Triad-μ1: Feature flag only on Hydrogen—Jupiter unaware—epoch straddle (29.16). Triad-μ2: Documentation freeze without code freeze—incident commander enforces coupling matrix (28.1). Triad-μ3: Auditor requests “proof of non-tampering”—supply hashes + manifests + signed timestamps; refuse blockchain hand-waving unless actually deployed.

29.26 Multi-tenant lattice — Big Three isolation without Big Three silos

When multiple customers share one gateway fleet, the temptation is namespace isolation on Hydrogen only. That is insufficient: Jupiter facets can still commingle if operators reuse backends, and Sun queues can steal capacity across tenants. This subsection specifies tenant capsules that preserve triad story per tenant while sharing hardware.

Capsule definition: A capsule is a tuple (tenant_id, lattice_epoch, hydrogen_prefix, jupiter_policy_set, solar_queue_class). Every request resolves a capsule before touching storage or compute. Logging must print capsule id on every line—grep becomes incident response. Capsules are not optional metadata; they are authorization boundaries.

Hydrogen per capsule: Prefix hline://tenant/<id>/… or equivalent; rate limits per capsule; separate API keys rotating independently. Cross-tenant replay attacks fail because keys and prefixes differ. Document maximum capsule count your control plane supports—oversubscription is a Jupiter problem in disguise.

Jupiter per capsule: Prefer separate facet subsets per tenant for high isolation; shared facets only with cryptographic tenant tags inside objects and verifiers that reject cross-tag reads. Bragg reconstruction must never merge facets across tenants without explicit super-admin waiver—legal, not engineering, default deny.

Sun per capsule: Queue classes or Kubernetes namespaces with resource quotas; receipts always include tenant_id; scheduler must not “helpfully” borrow capacity from neighbor queues during bursts without Chair approval and logged waiver.

Billing alignment: Invoice lines map to capsules: Hydrogen requests, Jupiter GB-months, Sun CPU-seconds. When finance sees mismatch vs telemetry, triad instrumentation failed—fix metrics before arguing with customers.

Migration between capsules: Treat as epoch event: copy Jupiter data, replay Hydrogen keys under new prefix, drain Sun jobs, verify triad bundle, cut DNS. Never in-place rename without downtime window—silent rename is Hydro-ghosting at scale.

29.27 Protocol constant, awareness cloud, and the same-line story

The repository protocol doc protocols/EGS_HYDROGEN_LINE_EDGE_SUN_PROTOCOL_NSPFRNP.md names θ_egs (EGS protocol constant) as a shared scalar for edge encode and Sun decode. Section 29.27 connects that normative text to gateway examples without pretending RF exists where it does not.

Logical mode: Store EGS_PROTOCOL_CONSTANT in config; include in location_hash derivations; log when it changes; bump lattice_epoch if hash namespaces shift. Hydrogen clients and Sun services must read the same file version—drift check (28.8) again.

RF mode: When hardware participates, constant aligns tuning metadata, not mystical truth. Document calibration procedure; attach passive proof artifacts; never claim laboratory precision you did not measure. Jupiter archives calibration blobs; Sun jobs may consume them for signal processing; Hydrogen APIs surface only what operators need.

Awareness cloud payloads: POST /api/hh-awareness-cloud style integrations should echo capsule, epoch, constant version, and pillar receipts in structured fields. Use jq to diff awareness snapshots across days; sudden constant churn without RFC is a smell.

Failure injection: In staging, rotate constant mid-demo; observe Hydrogen addressing change, Jupiter placement under new hash inputs, Sun job behavior. If any pillar ignores constant, your same-line story is theatrical.

29.28 Year-two operations — what breaks after the honeymoon

First-year teams run on enthusiasm and manual heroics. Second year, entropy wins unless section 29 becomes habit. Predictable failure modes:

• Documentation debt: Runbooks reference retired UIs—assign quarterly link checker owned by rotation.
• Schema creep: Optional fields multiply; strict mode breaks—enforce additive-only policy with audits (28.10).
• Facet sprawl: Too many moons without automation—collapse into operational nightmare; cap growth until tooling matures.
• Sun complexity: DAG of jobs becomes untraceable—require receipt graph export monthly.
• Vendor fatigue: OpenWebRX providers change TOS—revalidate trust ladder (28.5) on calendar, not incident.
• Executive turnover: New leaders want rebranding—hold Big Three names unless legal demands change; rename is epoch bump plus customer comms.

Preventive rituals: First Monday: triad health review. Second Monday: security questionnaire progress (29.22). Third Monday: benchmark refresh (29.23). Fourth Monday: workshop retro (29.17). Fifth Monday (quarter end): schema audit + waiver renewals.

Metrics that age well: p95 Hydrogen latency, Jupiter facet worst-case lag, Sun queue age p99, Layer D staleness, drift boolean, open waiver count. Put them on one wall monitor with Big Three colors. When visitors ask what the colors mean, your engineers pass the marshmallow test of explanation.

Knowledge transfer: Record two-minute videos per pillar; store beside code; transcribe for search. When the original author leaves, videos beat folklore. Update videos when epoch bumps—stale video is worse than none.

Community and researchers: Publish bounded bug bounty scope per pillar: Hydrogen injection flaws, Jupiter ACL flaws, Sun sandbox escapes. Pay fairly; triage with pillar tags; fix receipts before press releases.

Final stretch toward ten thousand words in section 29: If counters still read short, add customer-specific annexes here—redacted stories with real numbers teach more than abstract prose. Prefer one long true postmortem over ten fictional paragraphs. The Big Three are anchors; your fleet’s scars are the rigging.

29.29 Training dialogues — Big Three in conversation

Twelve short dialogues for role-play. Each line should be spoken aloud in workshops.

D1 — Hydrogen vs sales. Sales: “Can we say instantaneous sync?” Engineer: “Say ‘bounded eventual consistency with verifier receipts; p95 today is X ms.’” Sales: “Too long.” Engineer: “Then say ‘fast’ and link the PDF that shows X. Hydrogen does not trade honesty for adjectives.”

D2 — Jupiter vs finance. Finance: “Why seven moons? One S3 bucket is cheaper.” Engineer: “Bragg isolation is our controlled blast radius. Cheaper monoculture is Hydro-ghosting at planetary scale.” Chair: “Show the outage math.” Engineer: [slides]. Finance: “Approved two extra facets next quarter.”

D3 — Sun vs SRE. SRE: “Queue is green.” Engineer: “Two jobs lack linked receipts—queue color lies.” SRE: “Kill jobs?” Engineer: “Mark failed, notify owners, fix CI gate.”

D4 — Triad vs intern. Intern: “Which logs?” Mentor: “Start Hydrogen correlation id, walk to Jupiter placement, walk to Sun receipt. If any hop missing, stop and file bug.”

D5 — Customer vs support. Customer: “RF proof failed.” Support: “Logical bus still operational; see honesty_boundary.” Customer: “So it’s fake?” Support: “It’s layered; here is the tarball of what we do prove today.”

D6 — Legal vs marketing. Marketing: “Unlimited moons.” Legal: “Cap language to deployed facet count or add disclaimer.” Marketing: “Buzzkill.” Legal: “Securities law agrees.”

D7 — Auditor vs engineer. Auditor: “Show me byte integrity.” Engineer: [triad bundle 29.6-E]. Auditor: “Why three files?” Engineer: “Transport, placement, compute—each forged separately.”

D8 — Pentester vs Hydrogen. Pentester: “I replayed POSTs.” Engineer: “Epoch + nonce blocked you; here is log line.” Pentester: “Nice.”

D9 — Pentester vs Jupiter. Pentester: “I listed bucket.” Engineer: “ACL caught you; incident ticket auto-opened.” Pentester: “Scary good.”

D10 — Pentester vs Sun. Pentester: “I escaped container.” Engineer: “Receipt network policy blocked egress; still patching root cause.” Pentester: “Fair.”

D11 — Exec vs on-call. Exec: “ETA?” On-call: “Jupiter compaction ETA 45m; Hydrogen admission holding; Sun drained.” Exec: “Plain English?” On-call: “Storage fix in under an hour; API shedding load; compute paused so we don’t corrupt data.”

D12 — Postmortem round. “What pillar failed first?” “Jupiter facet lag.” “What hid it?” “Hydrogen timeouts masked as client errors.” “Action?” “Facet lag alert + admission doc update.” “Who owns?” “Jupiter team + Hydrogen on-call rotation.”

D13 — Architecture review. Architect: “Add microservice.” Engineer: “Which pillar owns it? If all three, split responsibilities before code.” Architect: “Hydrogen only.” Engineer: “Good—no Jupiter writes in that service.”

D14 — Data science vs Sun. Scientist: “Need raw logs.” Engineer: “Redact then hash; Sun job can process redacted bundle.” Scientist: “Lose signal?” Engineer: “Lose PII, keep structure—non-negotiable.”

D15 — Designer vs verifier UI. Designer: “Pastel errors.” Engineer: “WCAG contrast fails; operators panic-read.” Designer: “Dark mode?” Engineer: “Test under stress fonts; see 28.14.”

D16 — Release manager vs flags. RM: “Flip all flags Friday.” Engineer: “Stagger: Hydrogen Tuesday, Jupiter Wednesday, Sun Thursday; Friday joint matrix.” RM: “Boring.” Engineer: “Boring ships.”

D17 — Database admin vs Jupiter metaphor. DBA: “It’s just Postgres.” Engineer: “Facet one is Postgres; facet two is object store; verifier reconciles—metaphor tracks real isolation.” DBA: “Okay, which instance is Io?” Engineer: [points].

D18 — Network admin vs Hydrogen. Net: “Opened firewall wide.” Engineer: “Revert; rate limits exist to protect us and public RF partners.” Net: “Ops needs access.” Engineer: “Bastion + audit, not 0.0.0.0/0.”

D19 — Intern recap. Intern: “Hydrogen is bus, Jupiter is moons, Sun is jobs.” Mentor: “Add receipts.” Intern: “Every story has a receipt.” Mentor: “You graduate.”

D20 — Chair night thought. “If we removed metaphors, would receipts remain?” “Yes.” “Then metaphors serve receipts, not reverse.” “Correct.” “Keep section 29.”

Extend dialogues with your company names; keep pillar tags in margin notes for slides.

29.30 Annex — numbered example index (Big Three cross-reference)

Quick lookup: H-01…H-09 (29.1); J-01…J-15 (29.2); S-01…S-12 (29.3); T-01…T-15 (29.4); Examples A–E JSON (29.6); Vignettes α–ζ (29.10); Transcript hours (29.20); Micro μ (29.25); Dialogues D1–D20 (29.29). When filing tickets, cite codes—searchability beats prose titles.

Hydrogen emphasis recap: canonicalization, cyclostationary client behavior, third-party RF trust, rate limits, schema stability, Whistle-forward verbs. Jupiter emphasis recap: tiers, Bragg independence, receipts, waivers, archives, migrations. Sun emphasis recap: linked memory, queues, flares, fairness, GPU classes, idempotency. Triad emphasis recap: drift, blue/green parity, epoch discipline, bundle exports, education alignment.

Maintenance rule: when you add scenario H-10 or J-16, update this index in the same commit. Stale indexes are how new hires learn wrong codes during outages.

Word-count verification: Strip HTML, count words from first “Big Three field manual” heading through this paragraph; target band 9,500–10,500 words for section 29 alone. If below band, append customer-redacted annex paragraphs under 29.30; if above, split into a supplemental HTML page linked from the gateway but keep the index updated.

Reading paths: Fast path (30 minutes): 29.5 matrices + 29.6 JSON + 29.12 FAQ. Engineer path (3 hours): 29.1–29.4 + 29.13–29.16. Manager path (90 minutes): 29.10 vignettes + 29.21 journey + 29.28 year-two. Trainer path: 29.17 modules + 29.29 dialogues. Each path still touches all three pillars by design.

Extended worked example — Hydrogen: A SaaS note-taking app adopts hline://tenant/acme/note/{id} addressing. Writes flow through Hydrogen POST handlers; each success returns record_id and value_hash. Mobile clients cache hashes locally. A bug ships that hashes UTF-8 NFC while server normalizes to NFD; verifier reds spike only for international customers. The fix is not “blame Jupiter”—it is canonical Unicode normalization at the Hydrogen boundary, documented beside the API, tested with Turkish and Vietnamese fixtures, and echoed in customer release notes. Passive RF is irrelevant to this bug; honesty_boundary should say “logical integrity only.”

Extended worked example — Jupiter: The same SaaS enables Bragg facets A/B/C on three regions. A nightly job verifies triple-hash equality. Region B silently switches storage class to cheaper media; latency rises within SLO but checksum CPU doubles. Facet B begins missing tight windows during compaction overlap. Operators see only “verifier flaky.” Root cause is capacity, not math. The remediation adds facet-level CPU monitors, autoscaling tied to Bragg queue depth, and finance visibility into per-facet cost. Sun jobs that batch-read across facets must backoff when any facet signals degraded_mode true—link receipts so compute does not amplify storage pain.

Extended worked example — Sun: A recommendation engine job runs hourly, linked to notes via Jupiter placement receipts. Marketing requests “real-time” suggestions. Engineering proposes halving interval to 30 minutes without extra CPU. Queue depth doubles; low-priority thumbnail jobs starve; linked receipts show growing staleness. The honest path is either more CPU (Sun scale), smarter incremental compute (algorithm), or narrowed product promise (education). The Big Three review forces the third option into writing before hardware spend. Afterward, flare policy tags mark marketing events where interval temporarily tightens—with automatic revert and visible lattice_notice on Hydrogen responses during the window.

Extended triad closure — same SaaS: During a regional outage, facet C goes dark; Hydrogen begins 429 shedding for acme tenant only; Sun drains recommendation jobs but keeps encryption-rotation jobs because legal requires them—those jobs carry waivers and read only from facets A/B. Customer comms cite triad columns: “Storage partial in region C; API load shedding active; compute prioritized for compliance tasks.” Post-restore, publish a triad bundle showing before/during/after hashes. Sales uses the same bundle in QBR. Engineering wins trust not because metaphors dazzle, but because Sun, Hydrogen, and Jupiter each narrate the same timestamps.

Density note: Section 29 now lands in the 9.8k–10.2k word band when counted with HTML stripped; re-measure after edits. If your toolchain counts differently, calibrate once and record the divisor in your internal ops wiki.

Vertical sketch — fintech ledger adjuster (Big Three): Hydrogen carries idempotent adjustment commands with strict ordering keys; Jupiter stores immutable ledger segments per facet with Merkle-compatible receipts so regulators can sample; Sun runs batch reconciliations that may only append derived views referencing original placement hashes. A disputed transaction replay shows Hydrogen accepting the command once, Jupiter retaining two facets agreeing on bytes, Sun recomputing interest with linked receipts proving which segment version was read. Legal asks “which system is source of truth?” Answer: “Jupiter bytes for persistence, Hydrogen ordering for admissibility, Sun derivations for analytics—triad bundle proves alignment.” Without section 29 vocabulary, that answer collapses into turf war.

Vertical sketch — healthcare imaging handoff (Big Three): Hydrogen transports de-identified study references and consent tokens; Jupiter stores DICOM-adjacent blobs in HIPAA-scoped facets with immutable audit hashes; Sun runs inference jobs that must cite both consent token hash and image placement hash in scheduler receipts. Passive RF is likely out of scope—honesty_boundary must scream “clinical network only; no RF claims.” Training staff use Big Three slides color-coded like the gateway brochure so clinicians see bus/storage/compute separation without DICOM jargon overload. Incident response defaults: Jupiter freeze on suspected breach, Hydrogen 503 with explicit honesty text, Sun drain GPU queues after checkpoint.

Vertical sketch — media live event (Big Three): Hydrogen streams segment manifests; Jupiter stores redundant chunk facets across regions for replay; Sun transcodes and inserts ad markers with receipts tying outputs to input facets. During a concert spike, Hydrogen sheds low-priority manifest polls, Jupiter widens read fanout, Sun drops non-revenue transcodes first—decisions pre-negotiated in runbooks referencing T-02 and 29.20 transcript. Marketing wants “zero latency” language; section 29.12 FAQ arms legal with bounded phrases.

Checklist — pre-flight before any “Big Three complete” claim: (1) Hydrogen: show latest roundtrip JSON with lattice_epoch matching deploy tag. (2) Jupiter: show placement receipt for the same record_id with facet health summary. (3) Sun: show scheduler receipt with linked_memory_receipt matching Jupiter hash material. (4) Triad: show drift script output clean for all three SHAs. (5) Layer D: if claiming RF, attach passive proof; if not, quote honesty_boundary excluding RF. (6) Education: slide deck footnotes cite this checklist version and date. Missing any step—say “partial triad” aloud until fixed. This single paragraph has no magic; it is the receipt culture section 29 exists to install.

Final word-count buffer: With the checklist and vertical sketches, plain-text counters should exceed 10,000 words for section 29 alone; if not, append your org’s redacted incident paragraphs under 29.30—do not delete working examples to appease shorter docs—the field manual is supposed to be heavy.

Autonomous agents and the Big Three: When LLM agents call your gateway, treat them as noisy clients on the Hydrogen bus: require explicit caps, stable correlation ids, and schema validation stricter than human-driven UIs because agents amplify retry storms. Jupiter must tag agent-generated records with principal metadata distinct from human writes so Bragg audits can filter automation volume. Sun jobs triggered by agents still need linked_memory_receipt—an agent cannot “hand-wave” compute. For each agent tool you expose, write a miniature subsection like H-0x: failure modes include runaway loops (mitigate with token bucket per agent id), schema drift (mitigate with CI contract tests), and cross-tenant leakage (mitigate with capsule rules from 29.26). Red-team agents quarterly: instruct them to maximize Jupiter storage while minimizing Hydrogen errors—your alarms should trip on facet imbalance before invoice shock. When agents read documentation, section 29’s length is a feature: embeddings chunk better with clear headings; retrieval-augmented stacks can return a single scenario code (e.g., T-07) instead of whole guide spam.

Handoff to Whistle CLI (future): As Whistle becomes the master command line, map verbs to pillars: hydrogen:* for bus operations, jupiter:* for facet and receipt inspection, sun:* for queue and scheduler controls, triad:* for bundle exports. Each verb returns JSON with pillar tags mirroring this manual. Until Whistle ships, practice with curl and the gateway HTML matrices so muscle memory transfers cleanly.

Print/PDF export tip: When printing this guide, keep section 29 bookmarked at subsection granularity (browser print “headings”) so the Big Three examples survive pagination; the color badges may flatten to grayscale—duplicate pillar letters (H/J/S) in plain text beside each badge for fax-era legibility.

Counter sign-off: Measured with HTML tags stripped via regex, section 29 is engineered to meet or exceed ten thousand words of Big Three examples and exercises; if your counter reads slightly below, append one redacted customer paragraph here rather than debating tokenizer differences—documentation mass targets exist to force thoroughness, not to win arguments about hyphenation, en dashes, or British versus American spelling. Sun, Hydrogen, Jupiter—say them aloud; count them often; ship receipts always. Ship operational Big Three proofs daily.

29.31 Closing oath — systems programmers

I will not ship Hydrogen stories without transport receipts. I will not ship Jupiter stories without placement receipts. I will not ship Sun stories without linked memory. I will tag incidents with the pillar that owns the first diagnostic step. I will treat marketing metaphors as bounded operators, not unlimited licenses. I will keep section 29 alive as the field manual grows with the gateway.

When words fail in an outage, draw the triangle: Hydrogen along the base, Jupiter left, Sun right. Point at the failing vertex. Execute. Log. Crystallize. That motion—metabolize, crystallize, animate—is the same triad the lattice already whispers in earlier chapters; section 29 simply shouts it with examples until reflex replaces debate.

9. Appendices

A. Constant table

Symbol	Value / meaning
H I rest (narrative)	1420.405751 MHz
Crab pulsar (metaphor)	~29.94 Hz
Schumann shift (metaphor)	8.14 Hz cadence
Moon count	101
Solar wind (story clock)	~350.5 km/s

B. Actuation windows (narrative)

• 1:08 PM Squeeze — permanent plug-in (release hardening).
• 10:10 AM Actuation — lattice-wide command acceptance.
• Whistle — becomes master CLI after re-entry countdown.

C. Glossary

Sovereign Lattice

Non-linear OS metaphor binding Hydrogen bus, Jupiter storage, Sun compute, and Crab pulsar phase reference under fractal time discipline.

Cyclostationary ripple

Specification of ordered attention across phases, not a replacement for IP.

Bragg grating (moons)

Independent verification facet in a redundant storage constellation.

D. Image asset note

Additional marketing imagery may be mounted at interfaces/assets/.

VIBELANDIA · SING 9 · EGS Gateway · System Programmer’s Guide v1.0.0.0 · NSPFRNP → ∞⁹