CERN Readiness — Gap Analysis¶

⚠️ SUPERSEDED — HISTORICAL ANALYSIS ONLY This document describes gap analysis conducted against an earlier, Rust-based architecture that has since been retired. The sovereign M⁸ system is now implemented entirely in pure Swift 6.2 (Franklin.app, SPM). No Rust, no cargo, no FFI, no WASM. This document is preserved for audit lineage only and must not be used as a technical reference for the current system. See Mac-Cell-Guide for the current architecture.

Independent Audit Against the Cursor Gap-Finding Plan (HISTORICAL)¶

This document audits the Cursor gap-finding plan against the source code in the earlier GAIAFTCL repository. This audit reads the underlying Rust crates that the Swift app called at that time. Both perspectives are preserved for audit lineage.

Summary Verdict¶

Cursor captured approximately 60% of the actual gap surface. The WASM blocker, the missing PQ-UI test suite, and the 81-swap UI test gap are all correctly identified. However, Cursor missed four gaps that are more fundamental than any it found, and made one evidence path error that will cause validation scripts to fail immediately.

Category	Cursor found	This audit found	Severity
WASM module wrong domain	✓	✓	BLOCKER
No plant-specific wireframe geometry (all nine plants are a cube)	✗	✓	BLOCKER
No geometry/render FFI exposed to Swift (Swift cannot drive Metal geometry)	✗	✓	BLOCKER
Single MTLRenderPipelineState, not 9	✗	✓	BLOCKER
Missing PQ-UI test suite (12 tests)	✓	✓	Critical
81-swap matrix needs UI-level execution	✓	✓	Critical
Evidence path structure wrong in Cursor scripts	✗	✓	Critical
No `pq_validate.sh` script in repo	✗	✓	High
Domain selector implementation unknown	✓	✓	High
Vertex count validation missing	✓	✓	High
7 domains not confirmed in UI	✓	✓	High

Part 1: What Cursor Got Right¶

1.1 WASM Module — Wrong Domain (BLOCKER, Confirmed)¶

Cursor correctly identified this as the top blocker. The current gaiafusion_substrate.wasm is an ATC physics engine. Its exports (PhysicsEngine, ingest_aircraft(), render(), tick(), set_camera()) have zero overlap with the five required UUM-8D exports.

This is correct and remains the most visible blocker. Every dashboard element that depends on the WASM module — the terminal state badge, the vQbit entropy/truth plane, the closure residual bar, the constitutional validation — cannot function without the correct module.

Cursor's proposed fix is also directionally correct: build a new WASM from Rust source using wasm-bindgen. However, there is no fusion_substrate_wasm/ directory in the GAIAFTCL repository. The source must be written, not just built.

1.2 Missing PQ-UI Test Suite (Confirmed)¶

All 12 PQ-UI-* tests are absent. Cursor's test matrix (PQ-UI-001 through PQ-UI-012) matches the requirements in [[Composite-App-UI-Requirements]], Section 9.1. The test matrix is complete and correct as specified.

1.3 81-Swap Matrix — API vs UI Gap (Confirmed)¶

Cursor correctly identified that the existing testPQCSE007_81SwapPermutationMatrix() test uses programmatic API calls, not UI plant-tab interactions. The composite app UI requirements, Section 9.2, require that the 81-swap matrix be executable through the UI plant selector. This gap is real.

However, as noted below, there is a more fundamental problem underneath this gap: the nine plant-specific wireframe geometries do not exist yet.

1.4 Domain Selector Unknown (Confirmed as Uncertainty)¶

Cursor correctly flags this as unknown. The wiki requirements define seven domains with specific icons and channel mappings. Whether the Next.js dashboard implements all seven is not determinable from the GAIAFTCL repository alone — it requires inspection of the GaiaFusion Swift app's web resources.

Part 2: What Cursor Missed — The Four BLOCKERS Cursor Did Not Find¶

2.1 BLOCKER: All Nine Plants Currently Render a Cube¶

This is the most critical gap in the entire system.

Reading gaia-metal-renderer/src/renderer.rs, line 253:

fn default_geometry() -> (Vec<GaiaVertex>, Vec<u16>) {
    let vertices = vec![
        GaiaVertex::new([-0.5, -0.5,  0.5], [0.0, 0.6, 1.0, 1.0]),
        GaiaVertex::new([ 0.5, -0.5,  0.5], [1.0, 0.7, 0.0, 1.0]),
        GaiaVertex::new([ 0.5,  0.5,  0.5], [1.0, 1.0, 1.0, 1.0]),
        GaiaVertex::new([-0.5,  0.5,  0.5], [0.0, 0.3, 0.8, 1.0]),
        GaiaVertex::new([-0.5, -0.5, -0.5], [0.0, 0.3, 0.8, 1.0]),
        GaiaVertex::new([ 0.5, -0.5, -0.5], [0.0, 0.6, 1.0, 1.0]),
        GaiaVertex::new([ 0.5,  0.5, -0.5], [1.0, 0.7, 0.0, 1.0]),
        GaiaVertex::new([-0.5,  0.5, -0.5], [1.0, 1.0, 1.0, 1.0]),
    ];
    // 6 faces × 2 triangles × 3 vertices = 36 indices
    let indices: Vec<u16> = vec![
        0,1,2, 2,3,0,  1,5,6, 6,2,1,
        5,4,7, 7,6,5,  4,0,3, 3,7,4,
        3,2,6, 6,7,3,  4,5,1, 1,0,4,
    ];
    (vertices, indices)
}

8 vertices. 36 indices. A unit cube.

There is no Tokamak geometry. No Stellarator twisted torus. No Spheromak spherical flux conserver. No Fibonacci icosphere for MIF. No geodesic shell for Inertial. No Z-Pinch cylinder with spoke structure.

The renderer has upload_geometry_from_primitives() and upload_geometry() — methods that can receive and display geometry from outside. But the geometry data itself does not exist anywhere in the repository. The 81-swap matrix, even if driven through the UI, would cycle through 81 transitions between nine cube variants with different vQbit colour encodings. That is not what the patents describe and not what CERN needs to see.

What the Plant Catalogue specifies vs what exists:

Plant	Required min vertices	Required min indices	Currently exists
Tokamak (nested torus + PF coils + D-shaped TF)	48	96	None — cube (8 vertices)
Stellarator (twisted vessel + helical coils)	48	96	None — cube
SphericalTokamak (cored sphere + solenoid)	32	64	None — cube
FRC (cylinder + end coils + confinement rings)	24	48	None — cube
Mirror (central field rings + end choke coils)	24	48	None — cube
Spheromak (spherical conserver + coaxial injector)	32	64	None — cube
ZPinch (cylinder + electrode plates + spokes)	16	32	None — cube
MIF (icosphere + Fibonacci plasma guns)	40	80	None — cube
Inertial (geodesic shell + hohlraum + beamlines)	40	80	None — cube

Constitutional constraint C-005 is not violated by the cube (8 > 0 vertices). But the patents, the Plant Catalogue, and the CERN demonstration requirement are violated. At CERN, a Tokamak should look like a Tokamak.

2.2 BLOCKER: The Rust FFI Surface Cannot Drive Metal Geometry from Swift¶

Reading gaia-metal-renderer/gaia_metal_renderer.h — the C header that GaiaFusion Swift links against — it exposes exactly four functions:

GaiaRendererHandle gaia_metal_renderer_create(void);
void gaia_metal_renderer_destroy(GaiaRendererHandle handle);
void gaia_metal_renderer_set_tau(GaiaRendererHandle handle, uint64_t block_height);
uint64_t gaia_metal_renderer_get_tau(GaiaRendererHandle handle);

That is the entire FFI surface. τ (Bitcoin block height) only.

The following functions exist in Rust but are not in the C header and therefore not callable from Swift:

pub fn upload_geometry(&mut self, vertices: &[GaiaVertex], indices: &[u16])
pub fn upload_geometry_from_primitives(&mut self, primitives: &[vQbitPrimitive])
pub fn render_frame(&mut self, width: u32, height: u32)
pub fn resize(&self, width: u32, height: u32)
pub fn frame_count(&self) -> u64
pub fn set_tau(&mut self, block_height: u64)  // struct method, different from lib.rs FFI

The MetalRenderer struct itself is not exposed through the FFI. Swift cannot create a MetalRenderer, cannot call render_frame(), cannot call upload_geometry(). The only thing Swift can do through the current C header is manage a TauState handle — set and get the Bitcoin block height.

The implication is significant: The gaia-metal-renderer binary (via main.rs) is a standalone winit application that runs its own event loop and renders its own window. It is not a framework that GaiaFusion Swift embeds and controls. The Swift app and the Metal renderer are two separate processes or the Swift app has a completely different Metal renderer implementation of its own.

For the composite app architecture to work as specified — where the Swift AppDelegate controls the Metal render pipeline and the WKWebView posts switchPlant messages that drive geometry uploads — the FFI surface must be extended to expose:

A MetalRenderer handle (or equivalent opaque pointer)
gaia_metal_renderer_upload_geometry(handle, vertices_ptr, vertex_count, indices_ptr, index_count)
gaia_metal_renderer_render_frame(handle, width, height)
gaia_metal_renderer_switch_plant(handle, plant_kind_id) — or equivalent

Without this, the WKWebView switchPlant message cannot trigger a Metal geometry change through the Rust FFI layer.

2.3 BLOCKER: Single MTLRenderPipelineState, Not Nine¶

The wiki architecture, the Mac Cell Guide, and the composite app requirements all specify: one MTLRenderPipelineState per plant kind, compiled at startup.

Reading renderer.rs:

pub struct MetalRenderer {
    device: Retained<ProtocolObject<dyn MTLDevice>>,
    command_queue: Retained<ProtocolObject<dyn MTLCommandQueue>>,
    pipeline_state: Retained<ProtocolObject<dyn MTLRenderPipelineState>>,  // SINGLE
    layer: Retained<CAMetalLayer>,
    vertex_buffer: Retained<ProtocolObject<dyn MTLBuffer>>,
    index_buffer: Retained<ProtocolObject<dyn MTLBuffer>>,
    uniform_buffer: Retained<ProtocolObject<dyn MTLBuffer>>,
    // ...
}

One pipeline_state. One shader pair (vertex_main + fragment_main in shaders.rs). All nine plants share the same vertex and fragment shader.

The spec rationale for nine separate pipeline states is: 1. Each plant kind has a distinct physical rendering regime (e.g., MIF has Fibonacci gun geometry that requires a different vertex processing approach than the geodesic shell of ICF) 2. Pre-compiled pipeline states allow instant hot-swap without runtime shader compilation — which is the performance guarantee behind the 16.7 ms swap budget in PQ-UI-001 3. If one plant kind's pipeline state fails to compile at startup, the application enters REFUSED for that plant while keeping the others live

With a single pipeline state, all nine plants share one shader. The swap budget is likely met (just a vertex buffer swap), but the plant-kind-specific visual differentiation that the patents describe — where each plant kind has its own compiled visual identity — is not present.

For CERN, the question is whether one general shader plus different geometry is sufficient, or whether plant-kind-specific shaders are required. This is a design decision that needs explicit resolution before PQ.

2.4 Evidence Path Structure — Cursor Scripts Will Fail on First Run¶

Cursor's validation scripts reference:

evidence/iq/iq_receipt.json
evidence/oq/oq_receipt.json
evidence/pq/pq_receipt.json

The IQ and OQ documents specify:

evidence/iq_receipt.json
evidence/oq_receipt.json
evidence/pq_receipt.json

Flat structure, no subdirectories. The current evidence/ directory in the repository contains:

evidence/vqbit_test_receipt.json
evidence/FUSION_PLANT_PQ_PLAN.md
evidence/GAP_PLAN.md
evidence/GFTCL-PQ-001_PQ_Specification.docx

There is no iq_receipt.json at all — IQ has never been run on this machine in this session. All three of Cursor's Phase 1 validation scripts that read from evidence/iq/ will return file-not-found before they check a single substantive requirement. The path mismatch must be fixed before any automated validation can begin.

Part 3: Additional Gaps Not in Cursor's Plan¶

3.1 No `pq_validate.sh` Script¶

The OQ wiki page documents running OQ via zsh scripts/oq_validate.sh. The repo contains:

scripts/iq_install.sh
scripts/oq_validate.sh
scripts/run_full_cycle.sh

There is no scripts/pq_validate.sh. The PQ wiki page and the composite app requirements reference PQ evidence collected by a script. That script does not exist. PQ evidence collection is currently manual.

3.2 The `τ` (Tau) Bridge Is Ready on the Rust Side¶

This is a positive finding that Cursor's plan understates. The τ FFI is fully implemented in lib.rs with four C-callable functions and four passing GxP tests (ti_ffi_001 through ti_ffi_004). The C header is generated and correct. When the NATS client in GaiaFusion Swift receives a gaiaftcl.bitcoin.heartbeat message, it has a complete, thread-safe FFI path to update τ in the Rust layer. TAU_NOT_IMPLEMENTED is a NATS connectivity gap, not a Rust implementation gap.

3.3 All 32 OQ Tests Pass — This Is the Strong Foundation¶

Reading the source, all 32 GxP tests are present and correct: - 2 IQ series tests - 10 TP series tests (including TP-006 with all nine canonical plant scopes) - 4 TN series tests - 4 TR series tests - 4 TC series tests - 3 TI series tests - 5 RG series tests

The ABI regression guards (RG-001 through RG-005) lock the vQbitPrimitive layout at 76 bytes, GaiaVertex at 28 bytes, and Uniforms at 64 bytes. Any change to these structs breaks these tests immediately. This is the most important protective layer in the entire codebase. Cursor's plan does not mention these tests but they are critical to preserve.

3.4 MIF Fibonacci Lock Not Validated in UI¶

Constitutional constraint C-009 requires that the MIF plant's Fibonacci gun placement is a controlled configuration item that triggers full PQ-CSE re-execution on any change. No UI validation test covers this. The 81-swap matrix tests must verify that when the MIF plant is selected, the Fibonacci gun count and positions match the constitutional parameter exactly — not just that the swap completes.

3.5 ICF Float Overflow — PQ-PHY-006¶

The Inertial plant's n_e baseline is 10³¹ m⁻³. This is 16 orders of magnitude above a standard f32 max (~3.4 × 10³⁸ — technically representable, but normalisation to [0.0, 1.0] requires dividing by the configured max of 10³² which produces values around 0.1). The critical question is what happens in the WASM compute_closure_residual() function when passed 10³¹ as n_e. If the WASM module uses f32 internally, the 10³¹ value is representable but loses precision. PQ-UI-006 tests this, but the WASM module must first exist before the test can run.

Part 4: The Corrected Prioritisation¶

Cursor's priority order (WASM fix → PQ-UI tests → plant tabs validation) is correct in principle but incomplete in scope. The corrected priority order, accounting for all blockers:

P0 — Must resolve before any other work (true blockers)¶

Build the nine plant wireframe geometries. This is the foundational work that everything else depends on. Without correct Tokamak, Stellarator, FRC, Spheromak, Mirror, SphericalTokamak, ZPinch, MIF, and Inertial wireframes, every plant-swap test, every PQ-UI test, and the entire CERN demonstration shows nine variants of a rotating cube.
Extend the Rust FFI surface. Add gaia_metal_renderer_switch_plant(), gaia_metal_renderer_upload_geometry(), and gaia_metal_renderer_render_frame() to gaia_metal_renderer.h. Without this, the WKWebView switchPlant message cannot reach the Metal renderer through the FFI layer.
Fix the evidence path structure. Create evidence/iq_receipt.json by running iq_install.sh. Ensure oq_validate.sh and any PQ script write to the flat path evidence/*.json, not evidence/*/.

P1 — Critical for CERN, depends on P0¶

Build the UUM-8D fusion WASM module from scratch. Write the Rust WASM source implementing all five required exports: compute_vqbit, compute_closure_residual, validate_bounds, get_epistemic_tag, constitutional_check. Compile to wasm32-unknown-unknown, bind with wasm-bindgen.
Implement the PQ-UI test suite (12 tests). Write Tests/Protocols/UIValidationProtocols.swift with all 12 PQ-UI tests. These tests cannot pass until P0 is complete — they need real plant geometries and a working WASM module.
Write scripts/pq_validate.sh. Formalise PQ evidence collection. The script must execute the 81-swap matrix through the UI, collect timing data, and write evidence/pq_receipt.json.

P2 — CERN quality, depends on P1¶

Resolve: one pipeline state vs nine. Decide whether plant-kind-specific MSL shaders are required or whether one general shader with plant-specific geometry is sufficient for the CERN demonstration. If nine are required, add eight more MTLRenderPipelineState objects to the MetalRenderer struct.
Implement the 7-domain selector in the WKWebView dashboard. Confirm or build the domain tabs (Fusion, FSD, Drone, ATC, Maritime, AML, TB OWL) with correct channel label mapping per domain.
Add vertex count assertions to plant swap tests. Every plant swap must assert that vertex_count meets the Plant Catalogue minimum. This is a PQ-CSE requirement.

P3 — Complete the GxP evidence chain¶

Run IQ on the primary CERN demonstration machine. Execute iq_install.sh, confirm all 12 IQ checks pass, commit evidence/iq_receipt.json.
Run OQ after any code changes. Every code change that touches vQbitPrimitive, GaiaVertex, Uniforms, or any shader must be followed by oq_validate.sh with 32/32 passing. The RG series tests are the sentinel — if any of RG-001 through RG-005 fail, the change has broken the ABI.
Run PQ with the completed plant geometries. The 81-swap matrix under PQ must use real plant wireframes, not cubes. The timing data must show each swap completing within 16.7 ms.

Part 5: What CERN Sees If We Ship Today¶

If the composite app were demonstrated at CERN today, with the code as it currently stands:

Metal viewport: A single rotating blue-white cube. When the operator clicks any of the nine plant tabs, the cube re-renders with different vQbit-derived colours but the same geometry. A CERN physicist looking at the "Tokamak" view and the "Stellarator" view would see identical shapes.

Terminal state badge: Not functional — the WASM module is an ATC physics engine and cannot compute CALORIE/CURE/REFUSED for fusion telemetry. The badge would show a static or incorrect state.

vQbit entropy/truth plane: Not functional — same reason.

Closure residual bar: Not functional — compute_closure_residual() does not exist in the current WASM module.

Telemetry readouts: Possibly functional for static display if the Next.js dashboard hardcodes baseline values. Not live, not WASM-computed.

τ clock: Shows "τ=PENDING" (acceptable per spec, TAU_NOT_IMPLEMENTED is a known warning).

Evidence status: Shows IQ/OQ/PQ as absent or unknown because evidence/iq_receipt.json does not exist.

What a CERN physicist would conclude: The platform is structurally sound at the GxP test level (32/32 OQ tests pass) but the human-facing demonstration layer is not complete. The wireframes that represent the nine fusion plant topologies — the visual centrepiece of the patent — are not rendered.

Part 6: What CERN Sees When All Gaps Are Closed¶

The composite app as fully specified:

Nine distinct, physically accurate 3D wireframe geometries rotating at 60 fps, each immediately recognisable to a fusion physicist as the correct topology for its plant kind
A terminal state badge that flips between CALORIE (green), CURE (blue), and REFUSED (red) in real time as the WASM UUM-8D engine evaluates each measurement
A live vQbit entropy/truth plane showing where the current measurement sits in the information/confidence space
A closure residual bar that the operator can watch creep toward the 9.54 × 10⁻⁷ threshold as more measurements accumulate
All nine plant tabs swapping geometry within one frame budget, validated by PQ-UI-001
Seven domain tabs showing that the same constitutional substrate governs fusion, autonomous vehicles, ATC, maritime routing, and biomedical diagnosis
A complete GxP evidence chain: IQ receipt (sovereign identity established), OQ receipt (32/32 tests passed), PQ receipt (81 swaps × 9 plants completed without REFUSED)

That is the system the patents describe. That is the system CERN needs to see.

Summary Table — Complete Gap Register¶

Gap	Cursor found	Severity	Blocks
Nine plant wireframe geometries missing (all nine are a cube)	No	BLOCKER	CERN demo, all swap tests, PQ
FFI surface missing geometry/render functions	No	BLOCKER	WKWebView→Metal drive path
Single MTLRenderPipelineState (not 9 per plant)	No	BLOCKER	Architectural completeness
WASM module is ATC physics engine, not UUM-8D fusion	Yes	BLOCKER	All WASM-dependent UI elements
Evidence path structure mismatch in Cursor scripts	No	Critical	All automated validation scripts
PQ-UI test suite missing (12 tests)	Yes	Critical	PQ compliance
No `pq_validate.sh` script	No	High	PQ evidence collection
81-swap matrix needs UI execution not API calls	Yes	High	PQ-UI acceptance
Domain selector (7 domains) not confirmed	Yes	High	Cross-domain requirement
Vertex count per plant not validated	Yes	High	Plant Catalogue compliance
MIF Fibonacci placement lock not UI-validated	No	High	Constitutional constraint C-009
ICF n_e overflow path not WASM-tested	No	High	PQ-PHY-006 / PQ-UI-006
τ FFI is complete on Rust side (positive finding)	Partial	(positive)	No action needed
All 32 OQ tests pass with ABI regression guards	No	(positive)	Foundation is solid

Federation cosignature: pending

This page is not yet in the signed manifest. Run gaiaftcl wiki sign --all.