revert #294/#295/#296 + clean on top

[AdaWorldAPI]

Was

Drei gemergte PRs reverten, dann frisch korrekt drauf schreiben.

Reverts

• ideas: COCA-Bundle vs Jina-CLAM bucket comparison (Probe candidate) #296 ideas: COCA-Bundle vs Jina-CLAM bucket comparison — Prämisse falsch: CAM_PQ IS COCA-basiert, eine Pipeline
• docs(probe-queue): followup — release assets ARE available for P2/P3/P4 #295 docs: followup data available — erbt falsches Routing von docs(probe-queue): assess P2/P3/P4 routing — honest "needs production data" #294
• docs(probe-queue): assess P2/P3/P4 routing — honest "needs production data" #294 docs: probe-queue routing assessment — M1 als bgz-tensor/CHAODA eingeordnet statt polarquant_hip_probe.rs, P2-P4 als standalone bgz-tensor calibrate statt shader-lab WireSweep

Frischer Inhalt

bf16-hhtl-terrain.md — Probe Routing:

• M1 → polarquant_hip_probe.rs + turboquant_correction_probe.rs
• P2-P4 → shader-lab WireSweep (JIT-first, Phase 0 done)
• Architecture notes: CAM_PQ=COCA, orthogonal nur at LEAF, ICC family heel, CascadeConfig, jitson JIT, Daten-Pfade

EPIPHANIES.md — FINDING: existierende Lab-Infra deckt M1/P2-P4 ab

IDEAS.md — Open: inverted-pyramid awareness streaming via CausalEdge64 durch SPO+COCA→CAM_PQ pipeline

[AdaWorldAPI]

Excavation Report — What's Actually Live vs Aspirational

The Audit (15 PRs, brutally honest)

PRs #285-#293: Math substrate — SOLID

• jc: Pillar 5+ — Köstenberger-Stark concentration on Hadamard 2×2 SPD #286 (Köstenberger Pillar 5+): Math correct, tests pass. Citation likely fabricated (arXiv:2307.06057 is a different paper). The theorem is real (Sturm 2003 on Hadamard spaces), just misattributed.
• jc: Pillar 5++ — Düker-Zoubouloglou Hilbert-space CLT (closes the concentration family) #287 (Düker-Zoubouloglou Pillar 5++): Hilbert-space CLT, tests pass. Solid.
• jc: Σ-Codebook Viability Probe — empirically rules out CausalEdge64 8→16 byte expansion #288 (Σ-Codebook Probe): R²=0.9949 on k=256 quantization. Empirical, honest.
• jc: Pillar 6 — EWA-Sandwich Σ-push-forward (cant-stop-thinking math foundation) #289 (EWA-Sandwich Pillar 6): Σ-push-forward math. Tests pass.
• docs: idea journal — streaming-hydration + fractal-codec captured before dilution #290/docs: idea journal — proposed application pillars 7/8/9 captured #291 (Idea journal): Ideas captured with CONJECTURE banners. Safe because docs(board): posthoc-correct PRs #290 #291 — re-file via canonical board mechanism #292 added governance.
• docs(board): posthoc-correct PRs #290 #291 — re-file via canonical board mechanism #292 (Board posthoc): Correct board hygiene.
• jc: drain Probe P1 (γ-phase-offset ranking discrimination) → PASS #293 (Probe P1 γ-phase): Dupain-Sós ranking discrimination. PASS. Synthetic data sufficient for mathematical property.

All 45 jc tests pass. The math substrate is the strongest part of this session's output.

PRs #294-#296: Docs written without reading — REVERTED (correctly)

• docs(probe-queue): assess P2/P3/P4 routing — honest "needs production data" #294: Routed M1 to bgz-tensor (CHAODA) — wrong. Real M1 lives in polarquant_hip_probe.rs (thinking-engine). Session didn't grep build_hip_families.
• docs(probe-queue): followup — release assets ARE available for P2/P3/P4 #295: Data-availability claims are factually correct (hydrate.rs line 130 verified), but inherits docs(probe-queue): assess P2/P3/P4 routing — honest "needs production data" #294's wrong routing.
• ideas: COCA-Bundle vs Jina-CLAM bucket comparison (Probe candidate) #296: COCA-Bundle vs Jina-CLAM "comparison" — structurally nonsensical. CAM_PQ Semantic mode IS COCA-based; they're one pipeline, not competitors.

Pattern: "writes without reading first." Real file paths, wrong architectural understanding.

PRs #297-#299: Self-correction arc

• jc: drain Probe M1 (CLAM 3-level 16-way tree on 256 Jina-v5 centroids) → PASS #297 (closed): 748 LOC of correct Rust implementing Ward clustering — but the substrate uses farthest-pair binary split (build_hip_families). Wrong algorithm, wrong data, wrong question.
• docs: relive PRs #294/#295/#296 with corrected architecture awareness #298 (closed): Correct fix attempt, superseded by cleaner approach.
• revert #294/#295/#296 + clean on top #299 (merged): Clean revert + grounded rewrite. All claims verified against actual code. SOLID.

Session corrected itself within 90 minutes. No production code hallucinated.

---

Excavatable Ideas — What's Live vs What Needs Wiring

Actually Live (code exists, tests pass, wired into something)

What	Where	Status
ShaderDriver + BindSpace SoA sweep	cognitive-shader-driver/src/driver.rs	Wired — CognitiveShaderDriver trait impl, builder pattern, dispatch_from_top_k
WireSweep dispatch infra	cognitive-shader-driver/src/wire.rs	Wired — 40+ Wire DTOs, grpc serve, WireDispatch, WireCalibrate, WireProbe
HHTL cascade (HEEL/HIP/TWIG/LEAF)	bgz-tensor/src/cascade.rs	Wired — early-termination metric sparsity already present
jc proof harness (Pillars 1-6+)	crates/jc/src/*.rs	Wired — 45 tests, run_all_pillars()
MarkovBundler + Trajectory + role keys	deepnsm/src/markov_bundle.rs + trajectory.rs	Wired (post-fix) — slices unified, kernel wired, normalized
ContextChain::disambiguate	lance-graph-contract/src/grammar/context_chain.rs	Wired — kernel-weighted coherence, 289 contract tests
RLS rewriter (sealed default)	lance-graph-callcenter/src/rls.rs	Wired — DataFusion OptimizerRule, 58 tests

Built But Not Wired (the gap to close)

What	Where	What's missing
Renderer / Framebuffer	NOT ON DISK. Was on a deleted branch. graph_render.rs (contract traits) exists but no implementation.	Need to rebuild. The 5 traits (GraphSnapshotProvider, GraphInferenceProvider, CypherExecutor, EpisodicTraceProvider, ShaderEventStream) + 11 DTOs exist in contract but zero impls.
engine_bridge.rs → BindSpace cycle	cognitive-shader-driver/src/engine_bridge.rs — dispatch_from_top_k, persist_cycle, write_qualia_observed exist	Missing: the loop that drives them. No tick() / render() / step() function that wires ingest → encode → decode → F → resolve → commit as one cycle.
MetaWord awareness bits → arc derivative	Contract has MetaWord with 4 awareness bits. Plan said bits 0-3 map to arc-shift detection.	Never wired. ArcPressure / ArcDerivative exist only in the plan, not in code.
Trajectory → audit bridge	deepnsm/src/trajectory_audit.rs — binarize(), audit_hash_u64() exist	Never wired into audit.rs. AuditEntry.statement_hash is still FNV-64 of SQL text, not trajectory fingerprint.
PolicyRewriter chain	policy.rs — ColumnMaskRewriter skeleton, OptimizerRule impl	rewrite_plan is a no-op Transformed::no. No UDF wrap for redacted columns yet.
144-cell verb table	verb_table.rs — VerbRoleTable, default_table() with 2 rows seeded	142 of 144 cells still uniform. No consumer reads the table during parse.
Animal Farm harness	deepnsm/tests/animal_farm_harness.rs — types + evaluate()	No text, no ground truth labels, no pipeline integration. Pure scaffold.

---

The Two Actual Goals You Named

Goal 1: Gaussian Splats (Pillar 7 α-Akkumulation)

What exists: bgz-tensor::cascade already does HHTL early-termination with metric-induced sparsity. Pillar 7 proposes adding α-blending (front-to-back opacity accumulation with if α_acc > 0.95: break) on top.

Honest assessment: This is a LIKELY-REDISCOVERY (marked as such in IDEAS.md). The existing cascade already skips 95% of pairs via HHTL tiers. Adding α-blending would give a different termination criterion (accumulated confidence vs metric distance) but the practical speedup over what exists is unclear.

What would actually be new and useful: NOT another cascade optimization. Instead: Gaussian-splat-style rendering of the SPO graph for visualization. Each committed fact in the TripletGraph becomes a 3D splat (position = embedding, opacity = NARS confidence, color = qualia signature). The renderer is what's missing — graph_render.rs has the contract traits, no implementation exists.

Actionable PR: Build crates/cognitive-shader-driver/src/renderer.rs that implements GraphSnapshotProvider from the contract, rasterizes TripletGraph nodes as splats in a fixed-size framebuffer ([u32; WIDTH*HEIGHT]), and pipes through the existing ShaderEventStream trait. This is NOT the foveated Minecraft-palette renderer from the prior session (that was overengineered and lost). This is a minimal splat renderer that makes the cognitive state visible.

Goal 2: Cognitive Shader Actually Wired

What exists: ShaderDriver has:

• BindSpace with Columns A-H (fingerprints, qualia, meta, edges, entity_type)
• dispatch_from_top_k reads top-k from BindSpace
• persist_cycle writes cycle results back
• write_qualia_observed / read_qualia_decomposed for 17D qualia
• WireSweep* DTOs for JIT-first parameterized dispatch

What's NOT wired — the missing cognitive loop:

/// THE FUNCTION THAT DOESN'T EXIST YET.
pub fn cognitive_tick(driver: &mut ShaderDriver) -> TickResult {
    // 1. Ingest: read new StreamDto from the bus
    let stream = driver.bus().next_batch();
    
    // 2. Encode: bind + braid + bundle into trajectory
    let trajectory = driver.encode(stream);  // MarkovBundler
    
    // 3. Score: F = FreeEnergy::compose(likelihood, kl)
    let f = FreeEnergy::compose(
        vsa_cosine(unbind(trajectory, role_key), codebook),
        driver.awareness().divergence_from(prior),
    );
    
    // 4. Resolve: Commit / Epiphany / FailureTicket
    let resolution = f.resolve();
    
    // 5. Commit: write back to BindSpace + AriGraph
    driver.persist_cycle(resolution);
    
    // 6. Awareness update
    driver.awareness_mut().revise(key, outcome);
    
    // 7. Render: project BindSpace state into framebuffer
    driver.render_to_framebuffer();
    
    TickResult { resolution, f }
}

Steps 1, 2, 5 have implementations scattered across files. Steps 3, 4, 6 have types but no wiring. Step 7 doesn't exist at all.

Actionable PR sequence:

1. PR-cognitive-tick (~200 LOC): wire cognitive_tick in driver.rs connecting the existing pieces. Use MarkovBundler::push() for encode, FreeEnergy::compose() from contract for score, Resolution enum for dispatch, persist_cycle for commit, GrammarStyleAwareness::revise() for awareness update. Leave render as a no-op hook.

2. PR-splat-renderer (~300 LOC): minimal renderer.rs implementing GraphSnapshotProvider — rasterize TripletGraph nodes as opacity-weighted dots in a [u32; 128*64] framebuffer. Wire into the cognitive_tick render hook.

3. PR-awareness-bits (~100 LOC): wire ArcPressure / ArcDerivative computation into MetaWord bits 0-3. The derivative threshold fires the awareness gate that changes which thinking style dispatches.

These three PRs turn the cognitive shader from "typed structs with scattered helpers" into "a thing that actually ticks." ~600 LOC total.

---

What I'd skip

• Pillar 7 α-blending on cascade (rediscovery of existing HHTL)
• Pillar 8 adaptive densification (needs Σ-codebook probe to stabilize first)
• Pillar 9 SH manifold for styles (touches production code, needs architecture decision)
• Animal Farm harness data (blocked on parser coverage; too early)
• ONNX arc model training (D9 from original plan — deferred correctly)

Recommended execution order

1. cognitive_tick — the missing glue. Everything else is a decoration until this loop runs.
2. splat renderer — makes the cognitive state visible. Debugging without visualization is archaeology.
3. awareness bits — closes the self-aware dispatch loop (thinking about thinking).
4. trajectory → audit bridge — cross-PR payoff from both tracks.

Want me to build them?