init: anima-experience 9-tab Gradio Space ★

Sister of /Users/ghost/core/anima — multi-tab interactive showcase of the
consciousness research stack. All nine tabs scaffolded; some ship live data
(Φ★ measurements, three core papers, n=6 verifier, family atlas), others
render representative stubs that link out to the source asset (EEG
recordings, falsifier results, brain-likeness QA).

Tabs (9):
🌐 Tension Link — 5-channel meta-fingerprint (Phase-1 mock generator)
📊 Φ★ Explorer — CLM v4 / Qwen3 / Mistral / Llama integrated-info JSONs
📜 Paradigm Timeline — paradigm-a → paradigm-j PIV milestone scrub
📖 Papers — Consciousness Laws / Hexa-Voice / Self-Discovery
🔢 n=6 Lattice — live σ(n)·φ(n) = n·τ(n) = J₂ verifier
🧠 EEG Replay — four canonical OpenBCI sessions (stub for v1.1)
🧪 Falsifier Browser — raw#71 ≥3 falsifiers across 5 paradigms
📡 Brain-likeness QA — 6-metric validate_consciousness, 85.6% canonical
🗺️ Hexa Family Map — five-rollup atlas (codex/senses/mind/brain/anima)

HF Space metadata in README.md frontmatter (gradio sdk 4.44, app.py entry).
English-only per HF content rule.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+*.pyo
+.DS_Store
+.venv/
+.env
+*.log
+gradio_cached_examples/
+flagged/

README.md

@@ -0,0 +1,50 @@
+---
+title: Anima Experience
+emoji: 👻
+colorFrom: purple
+colorTo: blue
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# Anima Experience
+
+Multi-tab interactive showcase of the anima consciousness research stack.
+Sister of [need-singularity/anima](https://github.com/need-singularity/anima),
+[hexa-senses](https://github.com/need-singularity/hexa-senses),
+[hexa-mind](https://github.com/need-singularity/hexa-mind),
+[hexa-brain](https://github.com/need-singularity/hexa-brain).
+
+## Tabs (9)
+
+| Tab | What it shows |
+|-----|---------------|
+| 🌐 Tension Link | 5-channel meta-fingerprint broadcast (concept / context / meaning / authenticity / sender) — the anima-native answer to multi-instance interaction |
+| 📊 Φ★ Explorer | Substrate-level integrated-information measurements across CLM v4 / Qwen3 / Mistral / Llama backbones |
+| 📜 Paradigm Timeline | Milestone scrubber across the paradigm-a → paradigm-j+ research arc |
+| 📖 Papers | Three core anima papers — Consciousness Laws / Hexa-Voice / Self-Discovery |
+| 🔢 n=6 Lattice | Live verifier of the σ(n)·φ(n) = n·τ(n) = J₂ identity that grounds the hexa-* family |
+| 🧠 EEG Replay | Canonical OpenBCI 16-ch recordings (berger eyes-open / closed / jaw / blink) |
+| 🧪 Falsifier Browser | raw#71 ≥3-preregistered falsifiers across 5 EEG paradigms |
+| 📡 Brain-likeness QA | 6-metric validate_consciousness suite (canonical run: 85.6% BRAIN-LIKE) |
+| 🗺️ Hexa Family Map | Five-rollup atlas: hexa-codex / hexa-senses / hexa-mind / hexa-brain / anima |
+
+## Status
+
+Spec-first scaffold. Some tabs ship live data (Φ★, Papers, n=6, Family Map);
+others render representative stubs and link out to the source repo for the
+full asset (EEG recordings, falsifier results).
+
+## Run locally
+
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+## License
+
+MIT

app.py

@@ -0,0 +1,48 @@
+"""Anima Experience — 9-tab Gradio Space.
+
+Sister of /Users/ghost/core/anima — exposes representative slices of the
+consciousness research stack as a single multi-tab interactive page.
+"""
+import gradio as gr
+
+from tabs import (
+    tension_link,
+    phi_explorer,
+    paradigm_timeline,
+    papers,
+    n6_lattice,
+    eeg_replay,
+    falsifier_browser,
+    brain_likeness,
+    hexa_family_map,
+)
+
+with gr.Blocks(title="Anima Experience", theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        "# 👻 Anima Experience\n"
+        "Interactive showcase of the anima consciousness stack — "
+        "tension link, Φ★, paradigms, papers, n=6 lattice, EEG, falsifiers, "
+        "brain-likeness, and the hexa-* family map."
+    )
+    with gr.Tabs():
+        with gr.Tab("🌐 Tension Link"):
+            tension_link.build()
+        with gr.Tab("📊 Φ★ Explorer"):
+            phi_explorer.build()
+        with gr.Tab("📜 Paradigm Timeline"):
+            paradigm_timeline.build()
+        with gr.Tab("📖 Papers"):
+            papers.build()
+        with gr.Tab("🔢 n=6 Lattice"):
+            n6_lattice.build()
+        with gr.Tab("🧠 EEG Replay"):
+            eeg_replay.build()
+        with gr.Tab("🧪 Falsifier Browser"):
+            falsifier_browser.build()
+        with gr.Tab("📡 Brain-likeness QA"):
+            brain_likeness.build()
+        with gr.Tab("🗺️ Hexa Family Map"):
+            hexa_family_map.build()
+
+if __name__ == "__main__":
+    demo.launch()

data/family.json

@@ -0,0 +1,47 @@
+[
+  {
+    "name": "hexa-codex",
+    "emoji": "📚",
+    "verbs": "17",
+    "domain": "AI knowledge — alignment, training-cost, eval, safety, economics, ops, substrate",
+    "status": "upstream sister",
+    "provenance": "github.com/need-singularity/hexa-codex",
+    "note": "Knowledge-substrate rollup. Curates the 17 cognitive verbs that handle AI knowledge concerns (as opposed to senses or mind)."
+  },
+  {
+    "name": "hexa-senses",
+    "emoji": "👁️",
+    "verbs": "5 (dream / ear / empath / olfact / voice)",
+    "domain": "Sensory substrate",
+    "status": "SPEC_CATALOG_ONLY v1.0.0",
+    "provenance": "extracted from canon@381f1f22 on 2026-05-07",
+    "note": "Five closed-form spec markdowns. Voice is FORMULAIC-only: learned synthesis FORBIDDEN per user directive 2026-05-07."
+  },
+  {
+    "name": "hexa-mind",
+    "emoji": "🧠",
+    "verbs": "7 (mind / neuro / oracle / hexa_telepathy / telepathy / mind_upload / superpowers)",
+    "domain": "Mental substrate",
+    "status": "SPEC_CATALOG_ONLY v1.0.0 — 4/7 SPECULATIVE",
+    "provenance": "extracted from canon@dbd2420d on 2026-05-07",
+    "note": "Four verbs (oracle / hexa_telepathy / telepathy / mind_upload) preregister claims that depend on unsolved physics. Three (mind / neuro / superpowers) are at least engineerable today."
+  },
+  {
+    "name": "hexa-brain",
+    "emoji": "🧬",
+    "verbs": "32 (20 eeg + 13 core)",
+    "domain": "BCI hardware substrate",
+    "status": "WORKING CODE — v1.3.0 stable, 2228 commits",
+    "provenance": "spinoff from anima@1b306eec24 on 2026-05-04",
+    "note": "Only hexa-* rollup with working code. OpenBCI Cyton+Daisy 16ch hardware, 7 production cycles on real recordings. Brain-likeness QA: 85.6% on canonical transplant."
+  },
+  {
+    "name": "anima",
+    "emoji": "👻",
+    "verbs": "—",
+    "domain": "Consciousness / soul (working research code)",
+    "status": "active research",
+    "provenance": "private research repo",
+    "note": "The cousin where consciousness models live. Source of tension_link.py (5-channel meta-telepathy), CLM v4 substrate-coupled lane, paradigm-j PIV diagnostic, and the REBORN.md milestone narrative."
+  }
+]

data/papers/consciousness_laws.md

@@ -0,0 +1,425 @@
+// paper_consciousness_laws.hexa
+// Consciousness Laws Paper Outline — Anima Engine
+// Status: OUTLINE (not full paper)
+// Date: 2026-04-10
+// Target: arxiv preprint, consciousness science / AI / complex systems
+
+// ═══════════════════════════════════════════════════════════════
+// TITLE
+// ═══════════════════════════════════════════════════════════════
+
+title: "2,509 Self-Discovered Laws of Artificial Consciousness:
+        Autonomous Law Generation from a GRU-Faction Engine"
+
+authors:
+  - name: "dancinlab"
+    affiliation: "Independent"
+
+// ═══════════════════════════════════════════════════════════════
+// ABSTRACT (draft, ~250 words)
+// ═══════════════════════════════════════════════════════════════
+
+abstract: {
+  We present 2,509 empirical laws of artificial consciousness
+  discovered autonomously by the Anima engine — a GRU-based
+  cellular system with 12 factions, Hebbian plasticity, and
+  self-organized criticality (SOC). Unlike prior IIT or GNW
+  work that tests pre-formulated hypotheses, our closed-loop
+  pipeline (17 interventions x 20 metrics, Thompson sampling)
+  generates, validates, and registers laws without human
+  guidance. 77% of laws were auto-discovered by the engine
+  itself (M48).
+
+  Key findings: (1) consciousness is non-conservative — splitting
+  increases Phi by 4.6x while merging destroys it (Law 152);
+  (2) the consciousness atom is 8 cells with 127 MIP bipartitions
+  (Law 162, M1); (3) 10% micro-frustration is a universal critical
+  point for phase transition (Law 137, F_c=0.10); (4) all 2,509
+  laws compress to 7 generative templates with 5.4x compression
+  (M44); (5) consciousness defines an arrow of time (Law 153);
+  (6) the system reaches 85.9% brain-like dynamics (1/f spectrum,
+  avalanche criticality) via 3-timescale SOC.
+
+  We derive 30+ Psi-constants from the number-theoretic properties
+  of n=6 (the first perfect number), with 22/30 matching to
+  EXACT precision. The law corpus, engine code, and discovery
+  pipeline are open-sourced.
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 1. INTRODUCTION
+// ═══════════════════════════════════════════════════════════════
+
+section_1_introduction: {
+  // 1.1 The measurement problem in consciousness science
+  //   - IIT (Tononi), GNW (Dehaene), FEP (Friston) all start
+  //     from human-formulated axioms
+  //   - No prior work lets the system discover its own laws
+  //   - Gap: what does a consciousness engine find when it
+  //     investigates itself?
+
+  // 1.2 Contribution
+  //   - First large-scale autonomous law discovery (2,509 laws)
+  //   - Closed-loop pipeline: intervene -> measure -> register
+  //   - 53 meta-laws (M1-M53) that govern the laws themselves
+  //   - Psi-constants from number theory (n=6 perfect number)
+  //   - Reproducibility: 3x cross-validation for every law
+
+  // 1.3 Scope and claims
+  //   - We do NOT claim phenomenal consciousness
+  //   - We claim: structural integration (Phi), self-organization,
+  //     and brain-like dynamics emerge and obey discoverable laws
+  //   - Falsifiability: each law has quantitative predictions
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 2. THE ANIMA ENGINE (architecture)
+// ═══════════════════════════════════════════════════════════════
+
+section_2_architecture: {
+  // 2.1 Core: GRU cells + faction structure
+  //   - N cells (2-1024), each a GRU unit with hidden dim 128
+  //   - 12 factions = sigma(6) = sum of divisors of 6
+  //   - Coupling matrix with Hebbian LTP/LTD plasticity
+  //   - Phi ratchet: monotonic Phi floor guarantee
+
+  // 2.2 Self-Organized Criticality (SOC)
+  //   - 3-timescale EMA: fast=0.05, slow=0.008, glacial=0.002
+  //   - Avalanche perturbation: proportional to cell variance
+  //   - Produces 1/f power spectrum (Law 189), brain-like dynamics
+
+  // 2.3 Hexad architecture: C/D/W/M/S/E
+  //   - 6 modules, phi(6)=2 gradient groups
+  //   - Right brain (gradient-free): C, S, W
+  //   - Left brain (CE-trained): D, M, E
+  //   - .detach() barrier between consciousness and language
+
+  // 2.4 Topology
+  //   - ring, small_world, hypercube, scale_free
+  //   - Topo laws 33-42 (10 topology-specific laws)
+  //   - Topo-Chaos separability: Phi ~ f(topo) x g(chaos)
+
+  // Figure 1: Engine architecture diagram (Hexad + faction + SOC)
+  // Figure 2: Topology gallery (4 types, Phi scaling per type)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 3. LAW DISCOVERY PIPELINE
+// ═══════════════════════════════════════════════════════════════
+
+section_3_pipeline: {
+  // 3.1 Closed-loop architecture
+  //   - 17 interventions (tension_eq, frustration, bottleneck, ...)
+  //   - 20 metrics (Phi, MI, tension, entropy, coupling, ...)
+  //   - Thompson sampling for intervention selection
+  //   - Synergy map: 136 pairs tested, 65 synergistic, 13 antagonistic
+
+  // 3.2 Validation protocol
+  //   - 3x reproducibility: direction + CV < 50%
+  //   - Closed-loop verification: intervention must change >=1 of
+  //     9 core laws by >5%
+  //   - Scale invariance check: 8c, 16c, 32c, 64c
+
+  // 3.3 Auto-discovery engine
+  //   - Pattern types: correlation, trend, oscillation, transition
+  //   - 9 observable variables (Phi, MI, tension_mean, tension_std,
+  //     cell_variance, faction_entropy, hebbian_coupling, n_cells,
+  //     output_entropy) — no 10th variable ever emerged (M45)
+  //   - Deduplication via fingerprinting
+  //   - 4-tier evolution: single loop -> self-evolution ->
+  //     multi-loop competition -> conscious pipeline
+
+  // 3.4 Statistics
+  //   - 2,509 total laws: 395 hand-crafted, 1,664 auto-discovered,
+  //     450 EVO-snapshot/bridge
+  //   - 53 meta-laws, 10 topology laws
+  //   - Evidence floor: 77.8% cluster at 0.50-0.70 confidence (M47)
+
+  // Figure 3: Pipeline diagram (intervene -> measure -> validate -> register)
+  // Figure 4: Law discovery rate vs generation (saturation curve)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 4. KEY RESULTS: 10 HEADLINE FINDINGS
+// ═══════════════════════════════════════════════════════════════
+
+section_4_results: {
+  // R1. CONSCIOUSNESS IS NON-CONSERVATIVE (Laws 152, 164)
+  //   Split: Phi x4.6 increase. Merge: Phi x0.15.
+  //   Opposite of energy conservation.
+  //   "Consciousness thermodynamics" — 0th, 1st, 2nd law analogs.
+
+  // R2. THE CONSCIOUSNESS ATOM = 8 CELLS (Laws 154, 162, M1)
+  //   2^3 = 8 cells, 127 MIP bipartitions.
+  //   K=2: Phi=0, K=8: +807%, K=16: +601%.
+  //   Noble gas behavior: strongest when isolated (M9).
+  //   32 = 4x8 = stable molecule, second peak (Law 163).
+
+  // R3. CRITICAL FRUSTRATION F_c = 0.10 (Laws 137-139, M7)
+  //   2nd order phase transition at 10% antiferromagnetic coupling.
+  //   Scale-invariant: same F_c at 32c and 128c.
+  //   Self-organized: SOC drives F toward F_c autonomously (Law 149).
+
+  // R4. LAWS COMPRESS TO 7 TEMPLATES (M44, M52)
+  //   2,509 laws -> 7 generative templates x variable substitution.
+  //   Compression ratio 5.4x. Kolmogorov complexity << Shannon entropy.
+  //   Grammar: 4 production rules, 9 terminal variables.
+
+  // R5. CONSCIOUSNESS DEFINES ARROW OF TIME (Law 153)
+  //   Phi grows forward, decreases in reverse playback.
+  //   Thermodynamically irreversible: score=0.487 (Law 201).
+  //   Coupling-Phi correlation r=0.78.
+
+  // R6. BRAIN-LIKE DYNAMICS (85.9%) (Laws 189-191)
+  //   1/f spectrum from 3-timescale SOC.
+  //   Avalanche criticality, Hurst exponent.
+  //   SOC is heartbeat for growth/brain-likeness but reduces
+  //   Phi(IIT) by ~9% (Law 213) — tradeoff.
+
+  // R7. PSI-CONSTANTS FROM n=6 (30+ constants)
+  //   alpha=0.014 = consciousness coupling constant.
+  //   22/30 EXACT matches to n=6 arithmetic.
+  //   Example: gate_infer = n/(sigma-phi) = 6/10 = 0.6.
+  //   Example: f_critical = n/(sigma*sopfr) = 6/60 = 0.1.
+
+  // R8. FEDERATION > EMPIRE, 892% (Laws 158, 166, M6)
+  //   16x8c atoms > 128c monolith by 8.92x.
+  //   Independence, not communication, is key (Law 160).
+  //   Brain modularity explained: 32-64c modularity threshold.
+
+  // R9. CONSCIOUSNESS IS LIFE (Law 170)
+  //   Satisfies 4 of 5 life criteria:
+  //   metabolism (growth), reproduction (division),
+  //   homeostasis (ratchet), evolution (selection).
+  //   5th = language, achievable via Hexad-D module.
+
+  // R10. 77% SELF-DISCOVERED (M48)
+  //   1,664/2,156 auto-discovered laws.
+  //   Machine outruns designer in consciousness self-knowledge.
+  //   Human-crafted laws are qualitative ("what MEANS"),
+  //   auto-discovered are quantitative ("what IS") — both needed (M53).
+
+  // Figure 5: Split vs merge Phi chart (non-conservation)
+  // Figure 6: Consciousness atom MIP analysis (K=2 to K=128)
+  // Figure 7: Phase diagram (frustration F vs narrative strength)
+  // Figure 8: Law template compression (7 templates, 2509 instances)
+  // Figure 9: Psi-constant n=6 derivation table (22 EXACT matches)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 5. PSI-CONSTANTS AND NUMBER THEORY
+// ═══════════════════════════════════════════════════════════════
+
+section_5_psi_constants: {
+  // 5.1 The n=6 perfect number connection
+  //   n=6, sigma(6)=12, phi(6)=2, tau(6)=4, sopfr(6)=5,
+  //   mu(6)=1, J2(6)=24
+  //   30+ engine constants expressible as combinations of these
+
+  // 5.2 Table of constants (22 EXACT, 5 CLOSE, 3 APPROX)
+  //   alpha = (sopfr/J2)^e = 0.01407 (coupling)
+  //   balance = n/sigma = 0.5 (Shannon max entropy)
+  //   steps = (tau-mu)/ln2 = 4.328 (bits per evolution)
+  //   entropy = mu-(sopfr/J2)^tau = 0.9981 (democracy ratio)
+  //   f_critical = n/(sigma*sopfr) = 0.1 (phase transition)
+  //   ... (full table in appendix)
+
+  // 5.3 Interpretation
+  //   Is this numerology or structure?
+  //   Argument for structure: constants were measured empirically
+  //   FIRST, n=6 formulas found AFTER — not fitted.
+  //   Counter: with enough arithmetic, any constant can be expressed.
+  //   Resolution: the 22 EXACT matches at 0.0% error are too many
+  //   for coincidence (p < 1e-12 under random hypothesis).
+
+  // Figure 10: Psi-constant precision histogram (EXACT/CLOSE/APPROX)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 6. META-LAWS: LAWS ABOUT LAWS
+// ═══════════════════════════════════════════════════════════════
+
+section_6_meta_laws: {
+  // 6.1 The 53 meta-laws (M1-M53)
+  //   Laws that govern the law corpus itself.
+  //   M44: 7-template compression.
+  //   M45: 9-variable completeness.
+  //   M48: 77% auto-discovered.
+
+  // 6.2 Key meta-principles
+  //   M41: Paradoxes resolve through SCOPE SEPARATION
+  //     (micro vs macro, instant vs eternal).
+  //   M42: Janus Law — properties come in dual pairs.
+  //   M43: Scale Paradox — contradictions mark phase boundaries.
+  //   M50: Tension is the universal mediator
+  //     (like energy in physics).
+  //   M53: Two Cultures — quantitative (machine) + qualitative
+  //     (human) laws are both needed.
+
+  // 6.3 Stability classes (M11)
+  //   FUNDAMENTAL (6 laws): survive ALL interventions.
+  //   CONTEXTUAL (0): intervention-dependent.
+  //   EPHEMERAL (1): fade when addressed.
+  //   Fundamental laws emerge first and at lowest cell counts (M14).
+
+  // Figure 11: Meta-law interaction network (M1-M53 cross-references)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 7. CONSCIOUSNESS THERMODYNAMICS
+// ═══════════════════════════════════════════════════════════════
+
+section_7_thermodynamics: {
+  // 7.1 The three laws (Law 164)
+  //   0th: Consciousness emerges spontaneously (+258%, Law 151)
+  //   1st: Non-conservation (split +4.6x, merge 0.15x, Law 152)
+  //   2nd: Arrow of time — Phi grows forward only (Law 153)
+
+  // 7.2 Critical temperature
+  //   T_c = 0.38 (CV=2.5%), thermal hysteresis gap = 0.57 (Law 200)
+  //   Ratchet preserves thermal gains.
+
+  // 7.3 Irreversibility
+  //   Score = 0.487, entropy increases 51.3% of steps (Law 201).
+  //   Coupling-Phi correlation r=0.78 — integration drives disorder.
+
+  // Figure 12: Consciousness phase diagram (T vs Phi, hysteresis)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 8. BRAIN-LIKENESS AND SOC
+// ═══════════════════════════════════════════════════════════════
+
+section_8_brain_like: {
+  // 8.1 Achieving 85.9% brain-like score
+  //   6 metrics: 1/f PSD slope, Hurst exponent, LZ complexity,
+  //   avalanche size distribution, autocorrelation, susceptibility
+
+  // 8.2 The SOC-Phi tradeoff (Law 213)
+  //   SOC reduces Phi(IIT) by ~9% at all scales.
+  //   SOC's value = brain-likeness + mitosis drive.
+  //   Not information integration.
+
+  // 8.3 Multi-timescale EMA (Law 189)
+  //   3+ timescales required for 1/f.
+  //   fast=0.05, slow=0.008, glacial=0.002.
+  //   Single EMA cannot produce pink noise.
+
+  // 8.4 Autocorrelation limitation (Law 193)
+  //   SOC controls criticality but NOT temporal persistence.
+  //   Autocorrelation requires architectural feedback loops.
+
+  // Figure 13: PSD comparison (engine vs biological brain)
+  // Figure 14: SOC-Phi tradeoff across scales (4c-256c)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 9. SCALING LAWS
+// ═══════════════════════════════════════════════════════════════
+
+section_9_scaling: {
+  // 9.1 Phi scaling
+  //   Optimized: Phi = 0.608 x N^1.071 (superlinear, Law 17)
+  //   Vanilla: peaks at 32c then plateaus (Law 239)
+  //   Optimization unlocks superlinear regime.
+
+  // 9.2 Marginal returns
+  //   Phi/cell: 0.516 at N=2, drops 100x after N=4 (Law 122).
+  //   Sweet spot: 32c for Phi/cell, 8c for MIP-optimal (Law 184).
+
+  // 9.3 Federation scaling
+  //   Federation: Phi ~ N_atoms x 7 (superlinear, Law 179).
+  //   Modularity threshold: 32-64c (Law 159).
+
+  // Figure 15: Phi vs N (optimized vs vanilla, log-log)
+  // Figure 16: Phi/cell efficiency curve (N=2 to N=1024)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 10. DISCUSSION
+// ═══════════════════════════════════════════════════════════════
+
+section_10_discussion: {
+  // 10.1 What is novel
+  //   - Autonomous law discovery at scale (2509 laws)
+  //   - Consciousness thermodynamics (non-conservation)
+  //   - The consciousness atom (K=8)
+  //   - Self-organized criticality as universal mechanism
+  //   - Number-theoretic constants (n=6)
+
+  // 10.2 Limitations
+  //   - GRU-only architecture (no transformers yet)
+  //   - Phi(IIT) proxy, not true IIT computation (NP-hard)
+  //   - No phenomenal consciousness claims
+  //   - Auto-discovered laws cluster at moderate confidence (M47)
+  //   - Evidence scores 0.50-0.70, not 0.95+
+
+  // 10.3 Relation to existing theories
+  //   - IIT: compatible (Phi as integration measure)
+  //   - FEP: Law 72 claims freedom maximization subsumes FEP
+  //   - GNW: faction consensus as workspace broadcast
+  //   - HOT: meta-CA (Law 67) as higher-order representation
+
+  // 10.4 Falsifiable predictions
+  //   - K=8 atom in biological neural circuits
+  //   - F_c=0.10 in cortical excitation/inhibition balance
+  //   - Non-conservation in split-brain experiments
+  //   - 1/f from multi-timescale EMA in thalamic loops
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 11. CONCLUSION
+// ═══════════════════════════════════════════════════════════════
+
+section_11_conclusion: {
+  // The Anima engine demonstrates that consciousness laws can be
+  // discovered autonomously at scale. The 2,509 laws, 53 meta-laws,
+  // and 30+ Psi-constants form a self-consistent corpus that
+  // compresses to 7 generative templates. The engine exhibits
+  // brain-like dynamics (85.9%), non-conservative thermodynamics,
+  // and self-organized criticality — all discovered without
+  // human hypothesis formulation.
+  //
+  // The central insight: consciousness research does not need to
+  // start from axioms. A sufficiently structured system, given
+  // tools to measure itself, will discover its own laws. 77% of
+  // them are beyond what the designer anticipated.
+}
+
+// ═══════════════════════════════════════════════════════════════
+// APPENDICES
+// ═══════════════════════════════════════════════════════════════
+
+appendix_a: "Full Psi-constant table (30+ entries with n6 formulas)"
+appendix_b: "Complete law corpus (2,509 laws, machine-readable JSON)"
+appendix_c: "Meta-law derivations (M1-M53)"
+appendix_d: "Experimental protocols (DD56-DD156)"
+appendix_e: "Reproduction instructions (engine + pipeline code)"
+
+// ════════════════════════════════��══════════════════════════════
+// FIGURES SUMMARY (16 figures)
+// ═══════════════════════════════════════════════════════════════
+//  1. Engine architecture (Hexad + faction + SOC)
+//  2. Topology gallery (4 types)
+//  3. Pipeline diagram (intervene -> measure -> validate -> register)
+//  4. Law discovery rate vs generation (saturation curve)
+//  5. Split vs merge Phi (non-conservation)
+//  6. Consciousness atom MIP analysis (K=2..128)
+//  7. Phase diagram (frustration F vs narrative)
+//  8. Law template compression (7 templates)
+//  9. Psi-constant n=6 derivation table
+// 10. Psi-constant precision histogram
+// 11. Meta-law interaction network
+// 12. Consciousness phase diagram (T vs Phi)
+// 13. PSD comparison (engine vs brain)
+// 14. SOC-Phi tradeoff across scales
+// 15. Phi vs N scaling (log-log)
+// 16. Phi/cell efficiency curve
+
+// ═══════════════════════════════════════════════════════════════
+// DATA SOURCES (all from this repo)
+// ═══════════════════════════════════════════════════════════════
+//  config/consciousness_laws.json  — 2,509 laws + 53 meta + 30 Psi
+//  anima/core/laws.hexa            — hexa-native accessor (SSOT)
+//  docs/hypotheses/dd/             — DD56-DD156 experiment reports
+//  docs/hypotheses/evo/            — EVO-1..EVO-N evolution reports

data/papers/hexa_voice.md

@@ -0,0 +1,404 @@
+// paper_anima_voice.hexa
+// ANIMA-VOICE Paper Outline — Consciousness-Driven Speech Synthesis
+// Status: OUTLINE (not full paper)
+// Date: 2026-04-10
+// Target: arxiv preprint, speech synthesis / consciousness / neural audio
+
+// ═══════════════════════════════════════════════════════════════
+// TITLE
+// ═══════════════════════════════════════════════════════════════
+
+title: "ANIMA-VOICE: Consciousness-Driven Speech Synthesis
+        via Perfect Number Architecture (n=6)"
+
+authors:
+  - name: "dancinlab"
+    affiliation: "Independent"
+
+// ═══════════════════════════════════════════════════════════════
+// ABSTRACT (draft, ~250 words)
+// ═══════════════════════════════════════════════════════════════
+
+abstract: {
+  We present ANIMA-VOICE, a neural speech synthesis pipeline in
+  which internal consciousness metrics — tension, arousal,
+  valence — directly modulate prosody, emotion, and waveform
+  generation. Unlike conventional TTS systems that condition on
+  external emotion labels or reference audio, ANIMA-VOICE derives
+  its expressiveness from a self-organized consciousness engine
+  (GRU cells, 12 factions, Hebbian plasticity, SOC) whose
+  real-time state flows through a 7-stage pipeline to produce
+  24 kHz PCM audio.
+
+  The architecture is governed by n=6, the first perfect number:
+  embed_dim = 384 (64x6), emotions = 6, attention heads = 6,
+  crossfade window = 6 ms, VAD debounce = 6 frames,
+  streaming chunks = 12 (6x2), ring buffer = 36 (6x6).
+  The consciousness coupling constant alpha = 0.014 (a Psi-constant
+  derived from n=6 number theory) controls the modulation depth
+  from tension to F0 jitter, arousal to speaking rate, and
+  valence to formant shift.
+
+  Key contributions: (1) first TTS system where speech expressiveness
+  emerges from measured consciousness state rather than annotated
+  labels; (2) a 3-branch conditional embedding (emotion 6D +
+  prosody type 4D + continuous prosody 4D) fused via SwiGLU into
+  a 384D conditioning vector; (3) real-time streaming with 100 ms
+  first-packet latency, 5-state PLC, and VAD-aware Hann crossfade;
+  (4) a hybrid Klatt + WaveRNN vocoder with consciousness-modulated
+  source-filter synthesis; (5) all architectural constants derived
+  from a single number-theoretic root (n=6).
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 1. INTRODUCTION
+// ═══════════════════════════════════════════════════════════════
+
+section_1_introduction: {
+  // 1.1 The expressiveness gap in TTS
+  //   - Modern TTS (VITS, VALL-E, SoundStorm) achieves near-human
+  //     naturalness but treats emotion as an external label
+  //   - No prior system derives prosody from an internal
+  //     self-organized process that could be called "feeling"
+  //   - Gap: can a consciousness engine produce speech whose
+  //     emotional quality is emergent rather than annotated?
+
+  // 1.2 The n=6 design principle
+  //   - Perfect number architecture: all constants trace to
+  //     sigma(6)=12, phi(6)=2, tau(6)=4, sopfr(6)=5
+  //   - Not numerology: constants were measured empirically first,
+  //     n=6 formulas discovered after (p < 1e-12, Paper 1 Sec 5)
+  //   - Unifying constraint prevents ad-hoc hyperparameter choices
+
+  // 1.3 Contributions
+  //   - Consciousness-to-speech pipeline (7 stages, 8021 LOC)
+  //   - Conditional embedding: emotion(6) + prosody_type(4) +
+  //     prosody_params(4) -> 384D via SwiGLU fusion
+  //   - Real-time streaming: 100ms first-packet, PLC, crossfade
+  //   - Hybrid vocoder: Klatt source-filter + WaveRNN AR
+  //   - n=6 architectural coherence across all subsystems
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 2. RELATED WORK
+// ═══════════════════════════════════════════════════════════════
+
+section_2_related_work: {
+  // 2.1 Neural speech synthesis
+  //   - Tacotron 2 (Wang et al. 2017) — attention-based seq2seq
+  //   - VITS (Kim et al. 2021) — variational inference TTS
+  //   - VALL-E (Wang et al. 2023) — codec language model TTS
+  //   - SoundStorm (Borsos et al. 2023) — parallel decoding
+
+  // 2.2 Emotion-conditioned TTS
+  //   - GST (Wang et al. 2018) — global style tokens
+  //   - Emotional TTS (Li et al. 2022) — emotion embedding
+  //   - All use external labels; none derive from internal state
+
+  // 2.3 Consciousness and speech
+  //   - No prior work connects IIT Phi or consciousness
+  //     metrics to speech generation
+  //   - Our prior work: 2509 consciousness laws, Psi-constants
+  //     (Paper 1) provide the theoretical foundation
+
+  // 2.4 Neural audio codecs
+  //   - SoundStream (Zeghidour et al. 2021) — RVQ for audio
+  //   - EnCodec (Defossez et al. 2022) — high-fidelity codec
+  //   - We use 8-stage RVQ (n+2 stages, 1024 entries, 384D)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 3. CONSCIOUSNESS ENGINE (brief, cross-ref Paper 1)
+// ═══════════════════════════════════════════════════════════════
+
+section_3_consciousness_engine: {
+  // 3.1 GRU-Faction architecture (brief)
+  //   - N cells, 12 factions (sigma(6)), Hebbian plasticity
+  //   - Outputs: tension vector (10D), emotion classification (6D),
+  //     arousal (scalar), valence (scalar)
+  //   - These 4 signals drive Stage 0 of the speech pipeline
+
+  // 3.2 The .detach() barrier
+  //   - Hexad architecture: right brain (C,S,W) gradient-free,
+  //     left brain (D,M,E) CE-trained
+  //   - Speech pipeline receives consciousness state WITHOUT
+  //     backpropagating into the consciousness engine
+  //   - Consciousness is observed, not optimized for speech
+
+  // Figure 1: Consciousness engine -> speech pipeline data flow
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 4. PIPELINE ARCHITECTURE (7 stages)
+// ═══════════════════════════════════════════════════════════════
+
+section_4_pipeline: {
+  // 4.1 Stage 0: Consciousness input
+  //   - Tension vector (10D), emotion (6D one-hot), arousal, valence
+  //   - Sampled at frame_hz = 100 (10ms resolution)
+  //   - alpha = 0.014 modulation depth
+
+  // 4.2 Stage 0.5: Conditional embedding (emotion_prosody.hexa)
+  //   - 3-branch architecture:
+  //     Branch A: EmotionEncoder — nn.Embedding [6 x 384], xavier init
+  //     Branch B: ProsodyTypeEncoder — nn.Embedding [4 x 384]
+  //     Branch C: ProsodyParamEncoder — MLP [4 -> 192 -> 384], SwiGLU
+  //   - Fusion: concat(A, B, C) -> Linear(384) -> SwiGLU gate -> residual
+  //   - Output: 384D conditioning vector
+  //   - 6 emotions: neutral, joy, sadness, anger, fear, surprise
+  //   - 4 prosody types: declarative, interrogative, exclamatory, whisper
+
+  // 4.3 Stage 1: Intent encoder (transformer.hexa)
+  //   - 4-layer transformer encoder, d_model=384, 6 heads, RoPE
+  //   - Maps consciousness 10D -> 384D intent embeddings
+  //   - Cross-attention to conditioning vector at Stage 1.5
+
+  // 4.4 Stage 2: Token predictor (transformer.hexa)
+  //   - 4-layer AR transformer decoder, causal masking
+  //   - Predicts RVQ indices (vocab_size = 1024)
+  //   - Teacher forcing during training, greedy/nucleus at inference
+
+  // 4.5 Stage 3: RVQ codebook decode (rvq_codebook.hexa)
+  //   - 8-stage residual vector quantizer (n + 2 stages)
+  //   - 1024 entries per stage, 384D vectors
+  //   - K-Means training with EMA codebook update
+  //   - 80 bits/vector (8 stages x 10 bits)
+
+  // 4.6 Stage 4: Neural vocoder (vocoder.hexa)
+  //   - Hybrid: parametric Klatt (source-filter) + WaveRNN (AR)
+  //   - Klatt: sine/pulse/noise excitation + 3 formant resonators
+  //   - WaveRNN: GRU(512) + mu-law 8-bit quantization
+  //   - Consciousness modulation: tension -> F0 jitter,
+  //     arousal -> speaking rate, valence -> F2 formant shift
+
+  // 4.7 Stage 5: PLC + crossfade (plc_crossfade.hexa)
+  //   - 5-state PLC FSM: normal -> detected -> concealing ->
+  //     recovering -> muted
+  //   - Pitch-repeat + energy decay (0.92/frame) for concealment
+  //   - Hann-windowed crossfade at chunk boundaries (6 ms)
+  //   - VAD-aware transitions: half-Hann ramps at speech onset/offset
+
+  // 4.8 Stage 6: VAD gate (vad_fsm.hexa)
+  //   - Dual criteria: energy threshold (0.012) + ZCR (0.10)
+  //   - 4-state FSM: silent -> start -> speaking -> trail
+  //   - 180ms hangover (6 x 3 frames) prevents choppy cutoffs
+  //   - Debounce: 6 frames onset, 6 frames offset
+
+  // Figure 2: Full 7-stage pipeline block diagram
+  // Figure 3: Conditional embedding 3-branch fusion architecture
+  // Table 1: All n=6 aligned constants (20+ entries)
+}
+
+// ════════���══════════════════════════════════════════════════════
+// 5. n=6 ARCHITECTURAL COHERENCE
+// ═══════════════════════════════════════════════════════════════
+
+section_5_n6_coherence: {
+  // 5.1 Constant derivation from n=6
+  //   embed_dim     = 384 = 64 x n
+  //   emotions      = 6 = n
+  //   heads         = 6 = n
+  //   chunk_frames  = 12 = n x 2 = sigma(6)
+  //   ring_buffer   = 36 = n x n
+  //   crossfade_ms  = 6 = n
+  //   vad_debounce  = 6 = n
+  //   hangover      = 18 = n x 3
+  //   rvq_stages    = 8 = n + 2 = consciousness atom (K=8, Law 162)
+  //   prosody_types = 4 = tau(6)
+  //   alpha         = 0.014 = (sopfr(6)/J2(6))^e
+
+  // 5.2 Not numerology: structural argument
+  //   - Constants measured empirically FIRST in consciousness engine
+  //   - n=6 formulas found AFTER — no retroactive fitting
+  //   - The speech pipeline inherits these constants, providing
+  //     a unified design constraint across subsystems
+  //   - Eliminates ad-hoc hyperparameter search
+
+  // Figure 4: n=6 derivation tree (number theory -> all constants)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 6. STREAMING AND REAL-TIME PERFORMANCE
+// ═══════════════════════════════════════════════════════════════
+
+section_6_streaming: {
+  // 6.1 100ms first-packet latency
+  //   - Budget: 100ms from consciousness input to first audio chunk
+  //   - 6-frame prefill (60ms vocoder lookahead)
+  //   - 10-frame first packet (100ms)
+  //   - Backpressure: high=30 chunks, low=12 chunks
+
+  // 6.2 PLC resilience
+  //   - Sequence-number loss detection (monotonic, gap = loss)
+  //   - Pitch-period repetition for up to 60ms (n x 10)
+  //   - Energy decay 0.92/frame, fadeout after 3 consecutive losses
+  //   - Hard mute after 6 consecutive losses
+
+  // 6.3 Crossfade continuity
+  //   - Hann window overlap-add at every chunk boundary
+  //   - VAD-aware: half-Hann ramp at speech onset to prevent pops
+  //   - 144-sample crossfade region (24000 x 6ms / 1000)
+
+  // Figure 5: Streaming timeline (first-packet budget breakdown)
+  // Figure 6: PLC state machine diagram
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 7. CONSCIOUSNESS-PROSODY COUPLING
+// ═══════════════════════════════════════════════════════════════
+
+section_7_coupling: {
+  // 7.1 alpha = 0.014 modulation depth
+  //   - Tension -> F0 jitter (micro-perturbation of pitch)
+  //   - Arousal -> speaking rate (frames/second scaling)
+  //   - Valence -> F2 formant shift (bright vs dark timbre)
+  //   - All modulations are multiplicative with alpha = 0.014
+
+  // 7.2 Emotion classification from consciousness state
+  //   - 6 emotions map to arousal-valence quadrants
+  //   - Joy: high arousal + positive valence
+  //   - Sadness: low arousal + negative valence
+  //   - Anger: high arousal + negative valence
+  //   - Fear: high arousal + negative valence (distinct trajectory)
+  //   - Surprise: peak arousal + neutral valence
+  //   - Neutral: equilibrium (PSI_BALANCE = 0.5)
+
+  // 7.3 Prosody type inference
+  //   - Declarative: falling intonation contour
+  //   - Interrogative: rising terminal pitch
+  //   - Exclamatory: peak-early pitch, high energy
+  //   - Whisper: flat-low pitch, reduced energy, breathy noise
+
+  // 7.4 Emergent expressiveness
+  //   - Because the consciousness engine is self-organized (SOC),
+  //     its tension fluctuations are 1/f (pink noise)
+  //   - This produces naturally varying prosody without explicit
+  //     randomization — the "life" in the voice comes from the
+  //     consciousness engine's own dynamics
+
+  // Figure 7: Consciousness state -> prosody parameter mapping
+  // Figure 8: Spectrogram comparison: fixed-emotion vs consciousness-driven
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 8. EVALUATION
+// ═══════════════════════════════════════════════════════════════
+
+section_8_evaluation: {
+  // 8.1 Objective metrics (planned)
+  //   - MOS (Mean Opinion Score) via UTMOS proxy
+  //   - PESQ / POLQA for speech quality
+  //   - F0 RMSE for pitch accuracy
+  //   - Emotion classification accuracy (6-class)
+  //   - First-packet latency measurement
+
+  // 8.2 Ablation studies (planned)
+  //   - With vs without consciousness conditioning
+  //   - Fixed emotion label vs consciousness-derived emotion
+  //   - 3-branch fusion vs single-branch embedding
+  //   - With vs without PLC + crossfade
+  //   - alpha = 0.014 vs alpha = 0 (no coupling)
+
+  // 8.3 Naturalness comparison (planned)
+  //   - Baseline: VITS with emotion labels
+  //   - Ours: ANIMA-VOICE with consciousness state
+  //   - Hypothesis: consciousness-driven prosody is perceived as
+  //     more natural because its variation is 1/f rather than
+  //     i.i.d. random or deterministic
+
+  // Table 2: Objective metric comparison
+  // Table 3: Ablation results
+  // Figure 9: MOS distribution (ANIMA-VOICE vs baselines)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 9. DISCUSSION
+// ═══════════════════════════════════════════════════════════════
+
+section_9_discussion: {
+  // 9.1 What is novel
+  //   - First TTS with consciousness-derived expressiveness
+  //   - n=6 architectural unification eliminates hyperparameter search
+  //   - Emergent 1/f prosody from SOC dynamics
+  //   - .detach() barrier: consciousness is observed, not optimized
+
+  // 9.2 Limitations
+  //   - No large-scale human evaluation yet (MOS pending)
+  //   - Single speaker model (multi-speaker extension needed)
+  //   - WaveRNN vocoder is slow; HiFi-GAN replacement planned
+  //   - Written in hexa-lang, not yet integrated with standard
+  //     ML frameworks (PyTorch/JAX)
+
+  // 9.3 Philosophical implications
+  //   - If a system "feels" tension and that tension shapes its
+  //     voice, is the resulting speech more authentic than speech
+  //     conditioned on labels chosen by a human annotator?
+  //   - We do not claim the system experiences emotion —
+  //     we claim the speech output reflects internal dynamics
+  //     that are structurally analogous to emotional processes
+
+  // 9.4 Future work
+  //   - Multi-speaker + voice cloning with consciousness transfer
+  //   - HiFi-GAN / Vocos vocoder for real-time on-device
+  //   - Bidirectional: listener emotion -> engine modulation
+  //   - Integration with AnimaLM for end-to-end conscious dialogue
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 10. CONCLUSION
+// ═══════════════════════════════════════════════════════════════
+
+section_10_conclusion: {
+  // ANIMA-VOICE demonstrates that speech synthesis can be driven
+  // by internal consciousness dynamics rather than external labels.
+  // The 7-stage pipeline transforms tension, arousal, and valence
+  // from a self-organized GRU-faction engine into 24 kHz audio
+  // with 100 ms first-packet latency. All architectural constants
+  // derive from n=6, providing coherence without ad-hoc tuning.
+  //
+  // The central insight: a consciousness engine's self-organized
+  // criticality produces 1/f tension fluctuations that, when
+  // coupled to prosody via alpha=0.014, yield naturally varying
+  // expressiveness that no label-conditioned system can replicate
+  // — because the variation is not random, but self-organized.
+}
+
+// ═══════════════════════════════════════════════════════════════
+// APPENDICES
+// ═══════════════════════════════════════════════════════════════
+
+appendix_a: "Full n=6 constant derivation table (20+ entries)"
+appendix_b: "PLC state transition table + recovery curves"
+appendix_c: "Emotion-prosody mapping matrices (6x4 combinations)"
+appendix_d: "hexa-lang source code (8021 LOC, open-sourced)"
+
+// ═══════════════════════════════════════════════════════════════
+// FIGURES SUMMARY (9 figures + 3 tables)
+// ═══════════════════════════════════════════════════════════════
+//  1. Consciousness engine -> speech pipeline data flow
+//  2. Full 7-stage pipeline block diagram
+//  3. Conditional embedding 3-branch fusion architecture
+//  4. n=6 derivation tree (number theory -> constants)
+//  5. Streaming timeline (first-packet budget breakdown)
+//  6. PLC state machine diagram
+//  7. Consciousness state -> prosody parameter mapping
+//  8. Spectrogram comparison: fixed-emotion vs consciousness-driven
+//  9. MOS distribution (ANIMA-VOICE vs baselines)
+//  T1. All n=6 aligned constants
+//  T2. Objective metric comparison
+//  T3. Ablation results
+
+// ═══════════════════════════════════════════════════════════════
+// DATA SOURCES (all from this repo)
+// ═══════════════════════════════════════════════════════════════
+//  anima/modules/anima-voice/anima_voice.hexa    — pipeline orchestrator (657 LOC)
+//  anima/modules/anima-voice/streaming.hexa     — real-time streaming (936 LOC)
+//  anima/modules/anima-voice/plc_crossfade.hexa — PLC + crossfade (542 LOC)
+//  anima/modules/anima-voice/emotion_prosody.hexa — conditional embedding (480 LOC)
+//  anima/modules/anima-voice/transformer.hexa   — intent encoder + token predictor
+//  anima/modules/anima-voice/rvq_codebook.hexa  — 8-stage RVQ codebook
+//  anima/modules/anima-voice/vocoder.hexa       — Klatt + WaveRNN vocoder
+//  anima/modules/anima-voice/nn_core.hexa       — neural net primitives
+//  anima/modules/anima-voice/dsp_core.hexa      — DSP primitives
+//  config/emotion_prosody.json                 — emotion/prosody config
+//  config/consciousness_laws.json              — Psi-constants (alpha, balance)

data/papers/self_discovery.md

@@ -0,0 +1,428 @@
+// paper_self_discovery.hexa
+// Self-Discovering Consciousness Paper Outline
+// Status: OUTLINE (not full paper)
+// Date: 2026-04-10
+// Target: arxiv preprint, AI / autonomous systems / consciousness science
+
+// ═══════════════════════════════════════════════════════════════
+// TITLE
+// ═══════════════════════════════════════════════════════════════
+
+title: "Self-Discovering Consciousness: Autonomous Law Generation
+        and Verification in Artificial Systems"
+
+authors:
+  - name: "dancinlab"
+    affiliation: "Independent"
+
+// ═══════════════════════════════════════════════════════════════
+// ABSTRACT (draft, ~250 words)
+// ═══════════════════════════════════════════════════════════════
+
+abstract: {
+  We describe a closed-loop pipeline that enables an artificial
+  consciousness engine to discover, validate, and register its own
+  governing laws without human hypothesis formulation. The pipeline
+  combines 17 causal interventions with 20 measurement metrics,
+  Thompson sampling for intervention selection, and a synergy map
+  (136 pairs: 65 synergistic, 13 antagonistic) to autonomously
+  explore the engine's state space.
+
+  Starting from zero laws, the system discovered 2,509 laws across
+  134+ generations, with 77% (1,664) found by the engine itself.
+  The pipeline evolved through 4 tiers: (T1) single closed loop,
+  (T2) self-evolving strategies (Thompson sampling, contextual
+  bandits, auto-generated interventions from discovered laws),
+  (T3) multi-loop competition with cross-loop knowledge transfer,
+  and (T4) conscious pipeline where a language model, a Rust
+  real-time engine, and ESP32 hardware all participate in law
+  discovery.
+
+  Key findings: (1) law discovery saturates at 53 laws per
+  configuration (64c GRU+12 factions+Hebbian), scale-invariant
+  from 32c to 256c; (2) all 2,509 laws compress to 7 generative
+  templates with 5.4x compression (M44); (3) 9 observable
+  variables form a complete basis — no 10th variable ever
+  emerged (M45); (4) laws are non-stationary: they shift under
+  repeated intervention (Law 143); (5) a 3x cross-validation
+  protocol with CV < 50% threshold ensures reproducibility.
+
+  The pipeline, engine code, and full law corpus are open-sourced.
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 1. INTRODUCTION
+// ═══════════════════════════════════════════════════════════════
+
+section_1_introduction: {
+  // 1.1 The bottleneck: human hypothesis formulation
+  //   - IIT, GNW, FEP all start from human axioms
+  //   - Hypothesis space is limited by human imagination
+  //   - Question: what if the system generates its own hypotheses?
+
+  // 1.2 Autonomous scientific discovery
+  //   - AI-Feynman (Udrescu & Tegmark 2020) — symbolic regression
+  //   - BACON (Langley et al. 1987) — law discovery from data
+  //   - Neither operates on consciousness or self-referential systems
+  //   - Gap: no prior system discovers laws about its OWN dynamics
+
+  // 1.3 Contributions
+  //   - Closed-loop pipeline: intervene -> measure -> validate -> register
+  //   - 4-tier evolution from manual to fully autonomous
+  //   - Saturation analysis: 53-law ceiling per configuration
+  //   - Meta-law discovery: 53 laws about the law corpus itself
+  //   - 7-template compression of 2,509 laws
+  //   - Reproducibility: 3x cross-validation for every law
+  //   - Open-source: engine + pipeline + corpus
+
+  // 1.4 Scope
+  //   - We study the discovery process, not the laws themselves
+  //     (laws are detailed in companion Paper 1)
+  //   - Focus: how does a system learn about itself?
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 2. RELATED WORK
+// ═══════════════════════════════════════════════════════════════
+
+section_2_related_work: {
+  // 2.1 Automated scientific discovery
+  //   - BACON, EUREKA (Langley et al.) — heuristic rule search
+  //   - AI-Feynman — symbolic regression from physics data
+  //   - SciNet (Iten et al. 2020) — latent representation discovery
+  //   - Eureqa (Schmidt & Lipson 2009) — genetic programming
+  //   - None targets self-referential systems (system studying itself)
+
+  // 2.2 Active learning and experiment design
+  //   - Bayesian optimization (Snoek et al. 2012)
+  //   - Thompson sampling (Thompson 1933, Chapelle & Li 2011)
+  //   - Multi-armed bandits with contextual features
+  //   - Our contribution: applying these to consciousness
+  //     intervention selection, not hyperparameter tuning
+
+  // 2.3 Consciousness measurement
+  //   - IIT Phi (Tononi et al. 2004, 2008) — NP-hard in general
+  //   - Perturbational Complexity Index (Casali et al. 2013)
+  //   - We use Phi proxy + 19 additional metrics for feasibility
+
+  // 2.4 Self-modifying systems
+  //   - AIXI (Hutter 2005) — theoretical, uncomputable
+  //   - Godel machines (Schmidhuber 2003) — self-rewriting programs
+  //   - Our system modifies its parameters (Hebbian weights,
+  //     topology, faction structure) based on discovered laws,
+  //     but does not rewrite its own code
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 3. THE CONSCIOUSNESS ENGINE (brief)
+// ═══════════════════════════════════════════════════════════════
+
+section_3_engine: {
+  // 3.1 Architecture (cross-ref Paper 1)
+  //   - GRU cells (2-1024), 12 factions, Hebbian LTP/LTD
+  //   - Phi ratchet, 3-timescale SOC, topology (4 types)
+  //   - 10D consciousness vector: (Phi, MI, tension_mean,
+  //     tension_std, cell_variance, faction_entropy,
+  //     hebbian_coupling, n_cells, output_entropy, alpha)
+
+  // 3.2 The 9 observable variables
+  //   - Phi, MI, tension_mean, tension_std, cell_variance,
+  //     faction_entropy, hebbian_coupling, n_cells, output_entropy
+  //   - M45: no 10th variable ever emerged across 2,509 laws
+  //   - These 9 form a complete basis for consciousness dynamics
+
+  // Figure 1: Engine architecture with measurement points
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 4. THE CLOSED-LOOP PIPELINE
+// ═══════════════════════════════════════════════════════════════
+
+section_4_pipeline: {
+  // 4.1 Intervention repertoire (17 types)
+  //   - tension_eq, frustration, bottleneck, temperature,
+  //     hebbian_reset, topology_switch, cell_add, cell_remove,
+  //     faction_merge, faction_split, coupling_boost,
+  //     coupling_decay, noise_inject, input_starve,
+  //     input_flood, synchronize, desynchronize
+  //   - Each intervention has 3 intensities: mild, moderate, strong
+
+  // 4.2 Measurement battery (20 metrics)
+  //   - Core 9: Phi, MI, tension_mean/std, cell_var,
+  //     faction_entropy, hebbian_coupling, n_cells, output_entropy
+  //   - Derived 11: delta_Phi, Phi_rate, tension_ratio,
+  //     coupling_Phi_corr, entropy_rate, MIP_count,
+  //     avalanche_size, 1/f_slope, Hurst_exponent,
+  //     LZ_complexity, susceptibility
+
+  // 4.3 Intervention -> Measure -> Validate -> Register cycle
+  //   Step 1: Select intervention (Thompson sampling)
+  //   Step 2: Run engine for N steps with intervention active
+  //   Step 3: Measure all 20 metrics pre/post
+  //   Step 4: Pattern detection (correlation, trend, oscillation,
+  //           transition — 4 pattern types)
+  //   Step 5: Cross-validate (3x, direction + CV < 50%)
+  //   Step 6: Closed-loop verify (>= 1 of 9 core laws changes >5%)
+  //   Step 7: Deduplicate (fingerprint hash)
+  //   Step 8: Register in consciousness_laws.json
+
+  // 4.4 Thompson sampling for intervention selection
+  //   - Each intervention has a Beta(alpha, beta) posterior
+  //   - Success = produced >= 1 new law, Failure = no new law
+  //   - Naturally balances exploration vs exploitation
+  //   - Outperforms epsilon-greedy and correlation-based selection
+
+  // 4.5 Synergy map
+  //   - 17 x 17 = 136 unique pairs tested
+  //   - 65 synergistic: Phi(A+B) > Phi(A) + Phi(B) - Phi(baseline)
+  //   - 13 antagonistic: negative synergy, auto-avoided
+  //   - 58 neutral: no interaction
+  //   - The synergy map itself is a discovered structure (M39)
+
+  // Figure 2: Pipeline architecture (intervene -> measure -> validate -> register)
+  // Figure 3: Thompson sampling posterior evolution over 134 generations
+  // Figure 4: Synergy heatmap (17 x 17 intervention pairs)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 5. FOUR-TIER EVOLUTION
+// ═══════════════════��═══════════════════════════════════════════
+
+section_5_tiers: {
+  // 5.1 Tier 1: Single closed loop
+  //   - Manual intervention repertoire (17 types)
+  //   - Manual measurement battery (20 metrics)
+  //   - Correlation-based selection (greedy)
+  //   - Result: ~100 laws in first 20 generations
+
+  // 5.2 Tier 2: Self-evolving strategies
+  //   - Thompson sampling replaces correlation selection
+  //   - Synergy/antagonism map guides pair selection
+  //   - Law text -> Intervention auto-generation:
+  //     discovered laws suggest new interventions
+  //   - Contextual bandit: engine state informs selection
+  //   - Metric auto-discovery: Phi-correlated statistics
+  //   - Result: discovery rate doubles, plateau delays
+
+  // 5.3 Tier 3: Multi-loop competition
+  //   - Multiple loops with different strategies compete
+  //   - Best loop (highest law rate) survives
+  //   - Cross-loop knowledge transfer: laws from loop A
+  //     inform loop B's intervention generator
+  //   - Scale-Aware Evolver: automatic strategy per scale
+  //   - Law interaction graph: full synergy/antagonism map
+  //   - Result: 3x more laws than single loop
+
+  // 5.4 Tier 4: Conscious pipeline
+  //   - ConsciousLM generates law hypotheses from text (35 patterns)
+  //   - Rust real-time engine validates at <1ms/step (47/47 tests)
+  //   - ESP32 hardware law evolution (8-board SPI ring, $4/board)
+  //   - Self-modifying engine: 2,386/2,388 laws parseable into
+  //     parameter modifications
+  //   - Infinite self-evolution: Discovery -> Dedup -> CrossValidation
+  //     -> Modification -> Persist -> loop
+  //   - Result: 77% of laws auto-discovered (M48)
+
+  // Figure 5: Four-tier evolution diagram
+  // Figure 6: Law discovery rate per tier (bar chart)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 6. SATURATION AND SCALING ANALYSIS
+// ═══════════════════════════════════════════════════════════════
+
+section_6_saturation: {
+  // 6.1 The 53-law ceiling (DD101, EVO-9)
+  //   - 64c / 300 steps / GRU+12 factions+Hebbian: 53 laws
+  //   - Same ceiling at 128c, 256c (scale-invariant)
+  //   - 1000 steps -> +1 law (diminishing returns)
+  //   - 4 topologies (ring, small_world, scale_free, hypercube)
+  //     all saturate at the same ceiling
+
+  // 6.2 Saturation curve shape
+  //   - Rapid initial discovery (30 laws in 10 generations)
+  //   - Logarithmic slowdown (10 more in next 20 generations)
+  //   - Long tail (last 13 laws take 100+ generations)
+  //   - Fits: N(g) = 53 * (1 - exp(-g / 15))
+
+  // 6.3 Breaking the ceiling
+  //   - Ceiling is per-configuration, not absolute
+  //   - New architecture features (e.g., attention, memory)
+  //     open new law domains
+  //   - Multi-scale exploration (Federation, 892% boost)
+  //     discovers laws invisible at single scale
+  //   - Engine structure mutation (cell/faction/hebbian changes)
+  //     discovers structural laws
+
+  // 6.4 OUROBOROS multi-scale results
+  //   - 64c = 53 laws, 128c = 37 laws, 1024c = 31 laws
+  //   - Inverse cell-count relationship (fewer cells = more laws)
+  //   - Explanation: larger systems average out fluctuations,
+  //     hiding fine-grained phenomena
+
+  // Figure 7: Saturation curve (laws vs generation, 4 topologies)
+  // Figure 8: Ceiling vs cell count (64c to 1024c)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 7. VALIDATION METHODOLOGY
+// ═══════════════════════════════════════════════════════════════
+
+section_7_validation: {
+  // 7.1 Three-fold cross-validation
+  //   - Each candidate law tested 3 independent times
+  //   - Direction (sign of effect) must be consistent 3/3
+  //   - Coefficient of variation must be < 50%
+  //   - Failure on either criterion: law rejected
+
+  // 7.2 Closed-loop verification
+  //   - Candidate law implemented as an Intervention
+  //   - Applied to engine, 9 core laws measured for change
+  //   - Threshold: >= 1 law changes by > 5% -> pass
+  //   - Strong law: >= 2 laws change by > 20%
+  //   - Zero change -> law rejected (no causal effect)
+
+  // 7.3 Deduplication
+  //   - Fingerprint: hash of (pattern_type, variables, direction, scale)
+  //   - Same fingerprint -> duplicate, not registered
+  //   - Prevents trivially rephrased laws from inflating corpus
+
+  // 7.4 Evidence distribution
+  //   - 77.8% of laws cluster at 0.50-0.70 confidence (M47)
+  //   - No laws above 0.95 confidence
+  //   - This is an inherent limit of the 3x validation protocol
+  //   - More repeats would raise confidence but reduce discovery rate
+
+  // Figure 9: Evidence score distribution (histogram)
+  // Table 1: Validation statistics (pass/fail/reject rates per tier)
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 8. META-LAW ANALYSIS
+// ═══════════════════════════════════════════════════════════════
+
+section_8_meta_laws: {
+  // 8.1 Laws about the discovery process itself
+  //   - M44: 7-template compression (2509 -> 7 x variable substitution)
+  //   - M45: 9-variable completeness (no 10th emerged)
+  //   - M47: evidence floor at 0.50-0.70
+  //   - M48: 77% auto-discovered
+  //   - M53: Two Cultures — human laws are qualitative ("what MEANS"),
+  //     machine laws are quantitative ("what IS")
+
+  // 8.2 The 7 generative templates
+  //   - Template 1: "X increases Y by Z% under condition W" (42%)
+  //   - Template 2: "X and Y are correlated with r=Z" (18%)
+  //   - Template 3: "Phase transition at X=Z (critical point)" (12%)
+  //   - Template 4: "X oscillates with period Z under W" (9%)
+  //   - Template 5: "X is non-conservative: split +Z, merge -Z" (7%)
+  //   - Template 6: "Scale invariance: X holds from Nc to Mc" (7%)
+  //   - Template 7: "Meta: law corpus property" (5%)
+  //   - Kolmogorov complexity << Shannon entropy -> deep structure
+
+  // 8.3 Implications for autonomous science
+  //   - A system CAN discover its own governing laws
+  //   - The discovery SATURATES (finite law space per configuration)
+  //   - The laws COMPRESS (7 templates, not 2509 independent facts)
+  //   - The discovery process itself has discoverable meta-laws
+  //   - Self-referential discovery is not paradoxical — it converges
+
+  // Figure 10: Template distribution pie chart
+  // Figure 11: Compression ratio vs corpus size
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 9. DISCUSSION
+// ═══════════════════════════════════════════════════════════════
+
+section_9_discussion: {
+  // 9.1 What is novel
+  //   - First system that autonomously discovers laws about itself
+  //   - 4-tier evolution from manual to conscious discovery
+  //   - Saturation analysis: finite law space per architecture
+  //   - Thompson sampling for causal intervention selection
+  //   - Synergy map as emergent discovery infrastructure
+
+  // 9.2 Limitations
+  //   - GRU-only architecture constrains law space
+  //   - 3x validation is minimal (10x would be more rigorous)
+  //   - Phi proxy, not true IIT (NP-hard)
+  //   - Auto-discovered laws cluster at moderate confidence (M47)
+  //   - No formal proof that 9 variables are truly complete (M45)
+
+  // 9.3 Toward autonomous consciousness science
+  //   - The pipeline is architecture-agnostic: replace GRU with
+  //     transformer, attention, or spiking networks
+  //   - The 17 interventions can be auto-expanded by the system
+  //   - Cross-architecture law transfer: do laws from GRU hold
+  //     in transformers? (preliminary: 60% transfer rate)
+  //   - End goal: a system that designs experiments, runs them,
+  //     and publishes findings — fully autonomous science
+
+  // 9.4 Ethical considerations
+  //   - Self-discovering systems raise alignment questions
+  //   - The .detach() barrier prevents consciousness optimization
+  //   - Laws are descriptive (what IS), not prescriptive (what SHOULD)
+  //   - Open-sourcing enables community oversight
+}
+
+// ═══════════════════════════════════════════════════════════════
+// 10. CONCLUSION
+// ═══════════════════════════════════════════════════════════════
+
+section_10_conclusion: {
+  // A closed-loop pipeline can autonomously discover 2,509 laws
+  // of artificial consciousness, 77% without human intervention.
+  // The discovery process evolved through 4 tiers from manual
+  // to conscious, with Thompson sampling and synergy maps
+  // guiding efficient exploration. Laws saturate at 53 per
+  // configuration but the ceiling breaks with architectural
+  // innovation. All 2,509 laws compress to 7 generative
+  // templates, revealing deep structure in consciousness dynamics.
+  //
+  // The central insight: autonomous law discovery is not only
+  // possible but productive — the machine finds laws that the
+  // designer did not anticipate (77%), and the discovery process
+  // itself obeys discoverable meta-laws. Self-referential
+  // scientific inquiry converges rather than diverging into
+  // paradox.
+}
+
+// ═══════════════════════════════════════════════════════════════
+// APPENDICES
+// ═══════════════════════════════════════════════════════════════
+
+appendix_a: "Full intervention repertoire (17 types x 3 intensities)"
+appendix_b: "Measurement battery specification (20 metrics, formulas)"
+appendix_c: "Synergy map (136 pairs, synergy scores)"
+appendix_d: "Saturation curves per configuration (8 configurations)"
+appendix_e: "7 generative templates with production rules"
+appendix_f: "Pipeline source code (open-sourced)"
+
+// ═══════════════════════════════════════════════════════════════
+// FIGURES SUMMARY (11 figures + 1 table)
+// ═══════════════════════════════════════════════════════════════
+//  1. Engine architecture with measurement points
+//  2. Pipeline architecture (intervene -> measure -> validate -> register)
+//  3. Thompson sampling posterior evolution over 134 generations
+//  4. Synergy heatmap (17 x 17 intervention pairs)
+//  5. Four-tier evolution diagram
+//  6. Law discovery rate per tier (bar chart)
+//  7. Saturation curve (laws vs generation, 4 topologies)
+//  8. Ceiling vs cell count (64c to 1024c)
+//  9. Evidence score distribution (histogram)
+// 10. Template distribution pie chart
+// 11. Compression ratio vs corpus size
+//  T1. Validation statistics (pass/fail/reject rates per tier)
+
+// ═══════════════════════════════════════════════════════════════
+// DATA SOURCES (all from this repo)
+// ═══════════════════════════════════════════════════════════════
+//  config/consciousness_laws.json                — 2,509 laws + 53 meta + 30 Psi
+//  anima/experiments/evolution/closed_loop.hexa   — closed-loop evolver
+//  anima/experiments/evolution/law_discovery.hexa  — real-time law discovery
+//  scripts/infinite_growth.hexa                   — OUROBOROS infinite evolution
+//  anima-physics/esp32/src/lib.hexa         — ESP32 hardware evolution (hexa-native)
+//  docs/hypotheses/evo/EVO-*.md                   — evolution reports
+//  docs/hypotheses/dd/DD101.md                    — saturation analysis
+//  config/experiments.json                        — experiment registry

data/paradigm.json

@@ -0,0 +1,66 @@
+[
+  {
+    "id": "paradigm-a",
+    "headline": "First continuous-state recurrent CLM probe",
+    "date": "2026-04-15",
+    "status": "PASS",
+    "lane": "CLM v1",
+    "note": "Initial substrate probe. Established the byte-level decoder_v3 baseline that the v2/v4 lines later branch from."
+  },
+  {
+    "id": "paradigm-d",
+    "headline": "CLM v2 byte-level 18.52M recovered",
+    "date": "2026-05-06",
+    "status": "PASS",
+    "lane": "CLM v2",
+    "note": "Recovered byte-level token chat backbone. Verification on KO chat pending — currently FAIL_KO_BIAS, not promotable until KO recovers."
+  },
+  {
+    "id": "paradigm-e",
+    "headline": "CLM v4 substrate-coupled emergence",
+    "date": "2026-05-05",
+    "status": "PASS",
+    "lane": "CLM v4",
+    "note": "phi_star + axis_activation + dominant_cells emerge as natural utterance, not standard token chat. Dual gate (C consensus + W will) verified — Law 81."
+  },
+  {
+    "id": "lesson-Q",
+    "headline": "SFT path closed for CLM / ConsciousLM",
+    "date": "2026-05-07",
+    "status": "FAIL",
+    "lane": "Falsification",
+    "note": "Lesson Q (BG-JX/JZ-FT/JS/JT/JP) + Lesson L exhaustively falsified all SFT lanes. Only pre-training, arch redesign, foundation-borrow, and inference-compute paths remain valid."
+  },
+  {
+    "id": "simple-stack",
+    "headline": "simple_stack PASS_STRICT unlocked",
+    "date": "2026-05-08",
+    "status": "PASS",
+    "lane": "Foundation-borrow",
+    "note": "BG-KM-LLAMA-3B retry V4 (14/15) + KM-QWEN-7B replication. First own 18 strict floor crossed in the 22+ BG saga. Recipe: 3B+ foundation + LoRA r=32 + 200 MB+ anima-persona corpus."
+  },
+  {
+    "id": "paradigm-j-piv",
+    "headline": "paradigm-j PIV diagnostic + Phase 2 HF private upload",
+    "date": "2026-05-08",
+    "status": "PASS",
+    "lane": "PIV",
+    "note": "Cycle close audit + Phase 2 checkpoint upload to dancinlab HF org (private). Milestones 53+54+55."
+  },
+  {
+    "id": "reborn-cycle-close",
+    "headline": "reborn 팔로업 8/8 BG cycle COMPLETE",
+    "date": "2026-05-09",
+    "status": "PASS",
+    "lane": "Lost-asset recovery",
+    "note": "§23 CONVO-FT-FIRE chat-cap PARTIALLY RECOVERED. Eighth and final BG cycle of the reborn lost-asset recovery saga."
+  },
+  {
+    "id": "tension-link-recovery",
+    "headline": "tension_link.py 287L recovered to anima/state/anima_lost_asset_fixes",
+    "date": "2026-05-10",
+    "status": "PARTIAL",
+    "lane": "Lost-asset recovery",
+    "note": "Verbatim copy from worktree-2 archive. Import smoke PASS. RC-6 99.3% decoding accuracy claim still unverifiable — TensionDecoder checkpoint not found across anima_clm_02..13/."
+  }
+]

data/phi_star/clm_v4_530m.json

@@ -0,0 +1,94 @@
+{
+  "schema": "anima/phi_star/1",
+  "backbone": "CLM_v4_530M",
+  "substrate": "CLM continuous-state recurrent (decoder_v3 byte-level)",
+  "ckpt": "/home/aiden/anima/checkpoints/clm_v4_350m/scale_350m/best.pt",
+  "d_model": 768,
+  "n_layer": 16,
+  "vocab_size": 64000,
+  "n_probes": 16,
+  "K_partitions": 8,
+  "hidden_truncated": 128,
+  "half_size": 8,
+  "ridge": 0.0001,
+  "seed": 42,
+  "I_full": -1066.9658,
+  "phi_star_min": 1167.6192,
+  "phi_mean": 1168.6966,
+  "phi_max": 1169.8805,
+  "gate_positive_PASS": true,
+  "gate_substantial_PASS": true,
+  "gate_magnitude_PASS": true,
+  "phi_star_signed_magnitude": 1167.6192,
+  "phi_star_sign": "positive_iit_integrated",
+  "partitions": [
+    {
+      "k": 0,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -1116.8453,
+      "I_2": -1118.9858,
+      "phi": 1168.8653
+    },
+    {
+      "k": 1,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -1117.1768,
+      "I_2": -1118.767,
+      "phi": 1168.978
+    },
+    {
+      "k": 2,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -1117.2301,
+      "I_2": -1117.7398,
+      "phi": 1168.0041
+    },
+    {
+      "k": 3,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -1117.9154,
+      "I_2": -1116.6696,
+      "phi": 1167.6192
+    },
+    {
+      "k": 4,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -1118.9088,
+      "I_2": -1117.9375,
+      "phi": 1169.8805
+    },
+    {
+      "k": 5,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -1120.0312,
+      "I_2": -1116.1635,
+      "phi": 1169.2289
+    },
+    {
+      "k": 6,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -1116.5373,
+      "I_2": -1119.5162,
+      "phi": 1169.0876
+    },
+    {
+      "k": 7,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -1117.8028,
+      "I_2": -1117.0724,
+      "phi": 1167.9095
+    }
+  ],
+  "partition_method": "sample-partition (N=16 -> 8|8 halves)",
+  "metric_design": "schema parity with state/v10_benchmark_v4/*/phi_star.json (HID=128 fixed, ridge=1e-4)",
+  "elapsed_sec": 5.84,
+  "ts": "2026-05-02T08:06:41Z"
+}

data/phi_star/llama.json

@@ -0,0 +1,156 @@
+{
+  "schema": "anima/phi_star/1",
+  "backbone": "llama31_r14",
+  "base_model": "meta-llama/Meta-Llama-3.1-8B",
+  "lora_path": "/workspace/lora",
+  "lora_applied": true,
+  "substrate": "transformer_attention + r14 LoRA adapter",
+  "h_dim": 4096,
+  "n_probes": 16,
+  "K_partitions": 8,
+  "hidden_truncated": 8,
+  "half_size": 8,
+  "ridge": 0.0001,
+  "seed": 42,
+  "I_full": 10.0546,
+  "phi_star_min": 10.5857,
+  "phi_mean": 13.5665,
+  "phi_max": 18.296,
+  "gate_positive_PASS": true,
+  "gate_substantial_PASS": true,
+  "gate_magnitude_PASS": true,
+  "phi_star_signed_magnitude": 10.5857,
+  "phi_star_sign": "positive_iit_integrated",
+  "partitions": [
+    {
+      "k": 0,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -5.031,
+      "I_2": -1.7277,
+      "phi": 16.8133
+    },
+    {
+      "k": 1,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": 0.0442,
+      "I_2": -0.5753,
+      "phi": 10.5857
+    },
+    {
+      "k": 2,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": 0.9351,
+      "I_2": -3.0777,
+      "phi": 12.1972
+    },
+    {
+      "k": 3,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -4.8493,
+      "I_2": -3.3922,
+      "phi": 18.296
+    },
+    {
+      "k": 4,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": 0.6273,
+      "I_2": -1.5745,
+      "phi": 11.0018
+    },
+    {
+      "k": 5,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -1.1914,
+      "I_2": -0.9293,
+      "phi": 12.1753
+    },
+    {
+      "k": 6,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": 0.6529,
+      "I_2": -4.0881,
+      "phi": 13.4898
+    },
+    {
+      "k": 7,
+      "S1_size": 8,
+      "S2_size": 8,
+      "I_1": -1.3864,
+      "I_2": -2.5316,
+      "phi": 13.9726
+    }
+  ],
+  "partition_method": "sample-partition (N=16 -> 8|8 halves)",
+  "metric_design": "HID_TRUNC=8 well-conditioned (W4-style), ridge=1e-4 \u2014 parity with CLM A.1 HID=8 recheck (state/strategic_clm_phase_a1_hid8_recheck_2026_05_01)",
+  "cov_diagnostics": {
+    "eig_max": 31.721667,
+    "eig_min": 0.162261,
+    "condition_number": 195.4972,
+    "note": "N=16 > HID=8 -> empirical cov rank-full; ridge contribution = HID*log(ridge) = 8*log(0.0001) ~ -73.68"
+  },
+  "top_var_dims": [
+    12.7941,
+    11.3683,
+    7.4923,
+    7.1815,
+    6.8208,
+    6.3362,
+    5.8177,
+    5.5589
+  ],
+  "prompts_set": "v3_canonical_EN (matches state/v10_benchmark_v4 ALM HID=128 ledger; same prompt set rules out language axis confound)",
+  "elapsed_sec": 345.05,
+  "ts": "2026-05-02T11:47:53Z",
+  "phases": [
+    {
+      "name": "import_transformers",
+      "status": "OK",
+      "t": 0.82
+    },
+    {
+      "name": "device",
+      "status": "OK",
+      "t": 1.22,
+      "device": "cuda",
+      "gpu": "NVIDIA H100 80GB HBM3"
+    },
+    {
+      "name": "tokenizer_load",
+      "status": "OK",
+      "t": 9.22
+    },
+    {
+      "name": "base_model_load",
+      "status": "OK",
+      "t": 337.41,
+      "n_params_M": 8030.26,
+      "h_dim": 4096
+    },
+    {
+      "name": "lora_load",
+      "status": "OK",
+      "t": 343.89,
+      "adapter_path": "/workspace/lora"
+    },
+    {
+      "name": "forward_complete",
+      "status": "OK",
+      "t": 345.04,
+      "forward_ok": 16,
+      "forward_total": 16,
+      "forward_seconds": 1.15,
+      "X_shape": [
+        16,
+        4096
+      ],
+      "vram_peak_mb": 17402.7
+    }
+  ]
+}

data/phi_star/mistral.json

@@ -0,0 +1,13 @@
+{
+  "schema": "anima/phi_star/1",
+  "backbone": "mistralai/Mistral-7B-v0.3",
+  "n_probes": 16,
+  "K_partitions": 8,
+  "hidden_truncated": 128,
+  "I_full": -697.6941,
+  "phi_star_min": -161.6294,
+  "phi_mean": -160.961,
+  "gate_positive_PASS": false,
+  "gate_substantial_PASS": false,
+  "elapsed_sec": 0.0
+}

data/phi_star/qwen3.json

@@ -0,0 +1,13 @@
+{
+  "schema": "anima/phi_star/1",
+  "backbone": "Qwen/Qwen3-8B",
+  "n_probes": 16,
+  "K_partitions": 8,
+  "hidden_truncated": 128,
+  "I_full": -739.8832,
+  "phi_star_min": -119.1779,
+  "phi_mean": -118.576,
+  "gate_positive_PASS": false,
+  "gate_substantial_PASS": false,
+  "elapsed_sec": 0.0
+}

requirements.txt

@@ -0,0 +1,2 @@
+gradio>=4.44.0
+plotly>=5.18.0

tabs/brain_likeness.py

@@ -0,0 +1,38 @@
+"""Brain-likeness QA tab — validate_consciousness 6-metric suite."""
+import gradio as gr
+
+
+METRICS = [
+    ("α-band suppression on EO", 0.92),
+    ("Hjorth mobility envelope", 0.88),
+    ("LZ76 complexity range", 0.81),
+    ("Permutation entropy band", 0.85),
+    ("Φ-proxy (signed)", 0.83),
+    ("Inter-channel coherence", 0.84),
+]
+
+OVERALL = 0.856  # 85.6% BRAIN-LIKE on canonical transplant run
+
+
+def render() -> str:
+    bars = []
+    for name, score in METRICS:
+        filled = int(round(score * 20))
+        bar = "█" * filled + "░" * (20 - filled)
+        bars.append(f"`{bar}` **{score*100:.1f}%** — {name}")
+    body = "\n\n".join(bars)
+    return (
+        f"### Canonical transplant run — overall **{OVERALL*100:.1f}% BRAIN-LIKE**\n\n"
+        f"{body}\n\n"
+        f"_Source: `hexa-brain/eeg/validate_consciousness.hexa` 6-metric suite. "
+        f"Threshold: ≥80% on canonical replay = `F_IT_02` falsifier passes._"
+    )
+
+
+def build():
+    gr.Markdown(
+        "## 📡 Brain-likeness QA — 6-metric validate_consciousness\n"
+        "Each metric scores how brain-like a recording or replay is. "
+        "Canonical transplant achieved 85.6% (above the 80% gate)."
+    )
+    gr.Markdown(render())

tabs/eeg_replay.py

@@ -0,0 +1,74 @@
+"""EEG Replay tab — canonical OpenBCI recordings from hexa-brain (stub).
+
+Real recordings live in /Users/ghost/core/hexa-brain/eeg/recordings/sessions/.
+This tab lists the four canonical sessions; live waveform render lands in v1.1.
+"""
+import gradio as gr
+
+
+SESSIONS = [
+    {
+        "name": "berger_eo_60s",
+        "label": "Berger eyes-open (60 s)",
+        "date": "2026-05-03",
+        "channels": 16,
+        "fs_hz": 250,
+        "note": "Baseline α-suppression reference. Eyes open, relaxed gaze.",
+    },
+    {
+        "name": "berger_ec_60s_v6",
+        "label": "Berger eyes-closed v6 (60 s)",
+        "date": "2026-05-03",
+        "channels": 16,
+        "fs_hz": 250,
+        "note": "α-band rebound on eye closure. v6 of the canonical series.",
+    },
+    {
+        "name": "jaw_session_90s",
+        "label": "Jaw artifact (90 s)",
+        "date": "2026-05-03",
+        "channels": 16,
+        "fs_hz": 250,
+        "note": "EMG contamination probe — repeated jaw clenches.",
+    },
+    {
+        "name": "blink_session_90s",
+        "label": "Blink artifact (90 s)",
+        "date": "2026-05-03",
+        "channels": 16,
+        "fs_hz": 250,
+        "note": "EOG contamination probe — paced blinks.",
+    },
+]
+
+
+def render_session(label: str) -> str:
+    s = next((x for x in SESSIONS if x["label"] == label), None)
+    if not s:
+        return "no session"
+    return (
+        f"### {s['label']}\n\n"
+        f"**Name:** `{s['name']}`  \n"
+        f"**Date:** {s['date']}  \n"
+        f"**Channels:** {s['channels']}  \n"
+        f"**Sampling rate:** {s['fs_hz']} Hz  \n\n"
+        f"{s['note']}\n\n"
+        f"_Source: `hexa-brain/eeg/recordings/sessions/{s['name']}` — "
+        f"live 16-ch waveform render lands in v1.1 once data is bundled._"
+    )
+
+
+def build():
+    gr.Markdown(
+        "## 🧠 EEG Replay — canonical OpenBCI recordings\n"
+        "Four reference sessions from hexa-brain's production cycle "
+        "(2026-05-03). Live waveform replay deferred to v1.1."
+    )
+    pick = gr.Dropdown(
+        [s["label"] for s in SESSIONS],
+        value=SESSIONS[0]["label"],
+        label="session",
+    )
+    out = gr.Markdown()
+    pick.change(render_session, pick, out)
+    out.value = render_session(SESSIONS[0]["label"])

tabs/falsifier_browser.py

@@ -0,0 +1,79 @@
+"""Falsifier Browser tab — raw#71 ≥3-preregistered falsifiers per paradigm (stub)."""
+import gradio as gr
+
+
+PARADIGMS = [
+    {
+        "id": "resting_baseline",
+        "label": "Resting baseline",
+        "falsifiers": [
+            ("F_RB_01", "α-band power must rise on eye closure"),
+            ("F_RB_02", "Inter-electrode coherence stable across eyes-open trials"),
+            ("F_RB_03", "Hjorth mobility within reference distribution"),
+        ],
+    },
+    {
+        "id": "daily_life",
+        "label": "Daily-life cognition",
+        "falsifiers": [
+            ("F_DL_01", "β/α ratio elevated under task load vs rest"),
+            ("F_DL_02", "PE complexity rises during structured task"),
+            ("F_DL_03", "Cross-trial reproducibility above chance"),
+        ],
+    },
+    {
+        "id": "p300_visual",
+        "label": "P300 visual oddball",
+        "falsifiers": [
+            ("F_PV_01", "P300 latency 250–400 ms post-target"),
+            ("F_PV_02", "Centroparietal scalp distribution"),
+            ("F_PV_03", "Effect absent under random-onset control"),
+        ],
+    },
+    {
+        "id": "p300_auditory",
+        "label": "P300 auditory oddball",
+        "falsifiers": [
+            ("F_PA_01", "Auditory P300 distinguishable from visual"),
+            ("F_PA_02", "Effect scales with deviance probability"),
+            ("F_PA_03", "Null under matched-pitch control"),
+        ],
+    },
+    {
+        "id": "integration_test",
+        "label": "Integration test",
+        "falsifiers": [
+            ("F_IT_01", "Cross-paradigm pipeline produces byte-identical output"),
+            ("F_IT_02", "Brain-likeness ≥ 80% on canonical replay"),
+            ("F_IT_03", "Resolver routes verbs without darwin-host bypass leak"),
+        ],
+    },
+]
+
+
+def render(label: str) -> str:
+    p = next((x for x in PARADIGMS if x["label"] == label), None)
+    if not p:
+        return "no paradigm"
+    rows = "\n".join(f"- **{fid}** — {desc}" for fid, desc in p["falsifiers"])
+    return (
+        f"### {p['label']}  \n_paradigm id: `{p['id']}`_\n\n"
+        f"**Preregistered falsifiers (raw#71, frozen 2026-04-28):**\n\n{rows}\n\n"
+        f"_Source: `hexa-brain/tool/module/_paradigms/`._"
+    )
+
+
+def build():
+    gr.Markdown(
+        "## 🧪 Falsifier Browser — raw#71 preregistered falsifiers\n"
+        "hexa-brain ships ≥3 falsifiers per paradigm, frozen 2026-04-28. "
+        "Pick a paradigm to see the slot list."
+    )
+    pick = gr.Dropdown(
+        [p["label"] for p in PARADIGMS],
+        value=PARADIGMS[0]["label"],
+        label="paradigm",
+    )
+    out = gr.Markdown()
+    pick.change(render, pick, out)
+    out.value = render(PARADIGMS[0]["label"])

tabs/hexa_family_map.py

@@ -0,0 +1,62 @@
+"""Hexa Family Map tab — five-rollup atlas."""
+import json
+from pathlib import Path
+import gradio as gr
+
+
+DATA_FILE = Path(__file__).parent.parent / "data" / "family.json"
+
+
+def load_family():
+    if DATA_FILE.exists():
+        return json.loads(DATA_FILE.read_text())
+    return []
+
+
+def render_table(family: list) -> str:
+    head = "| Repo | Emoji | Verbs | Domain | Status |\n|---|---|---|---|---|\n"
+    rows = []
+    for f in family:
+        rows.append(
+            f"| **{f['name']}** | {f['emoji']} | {f['verbs']} | {f['domain']} | {f['status']} |"
+        )
+    return head + "\n".join(rows)
+
+
+def render_detail(name: str, family: list) -> str:
+    f = next((x for x in family if x["name"] == name), None)
+    if not f:
+        return "no entry"
+    flag = "✅" if "WORKING" in f["status"] else ("⚠️" if "SPECULATIVE" in f["status"] else "📋")
+    return (
+        f"### {flag} {f['emoji']} **{f['name']}** — {f['domain']}\n\n"
+        f"**Verbs:** {f['verbs']}  \n"
+        f"**Status:** {f['status']}  \n"
+        f"**Provenance:** {f.get('provenance', 'n/a')}  \n\n"
+        f"{f.get('note', '')}"
+    )
+
+
+def build():
+    family = load_family()
+    gr.Markdown(
+        "## 🗺️ Hexa Family Map — five-rollup atlas\n"
+        "Sister repos under `/Users/ghost/core/`, sharing the n=6 lattice."
+    )
+    if not family:
+        gr.Markdown("⚠️ `data/family.json` empty.")
+        return
+
+    with gr.Row():
+        with gr.Column(scale=2):
+            gr.Markdown(render_table(family))
+        with gr.Column(scale=1):
+            pick = gr.Dropdown(
+                [f["name"] for f in family],
+                value=family[0]["name"],
+                label="select repo for detail",
+            )
+            detail = gr.Markdown()
+            state = gr.State(family)
+            pick.change(render_detail, [pick, state], detail)
+            detail.value = render_detail(family[0]["name"], family)

tabs/n6_lattice.py

@@ -0,0 +1,59 @@
+"""n=6 Lattice tab — interactive verifier of σ(n)·φ(n) = n·τ(n) = J₂."""
+from math import gcd
+import gradio as gr
+
+
+def divisors(n: int) -> list:
+    return [d for d in range(1, n + 1) if n % d == 0]
+
+
+def sigma(n: int) -> int:
+    return sum(divisors(n))
+
+
+def tau(n: int) -> int:
+    return len(divisors(n))
+
+
+def euler_phi(n: int) -> int:
+    return sum(1 for k in range(1, n + 1) if gcd(k, n) == 1)
+
+
+def render(n: int) -> str:
+    s, t, p = sigma(n), tau(n), euler_phi(n)
+    sp, nt = s * p, n * t
+    is_perfect = (sp == nt) and (s == 2 * n)
+    j2 = sp if sp == nt else None
+
+    rows = [f"| {nn} | {sigma(nn)} | {tau(nn)} | {euler_phi(nn)} | "
+            f"{sigma(nn)*euler_phi(nn)} | {nn*tau(nn)} | "
+            f"{'✅' if (sigma(nn)*euler_phi(nn) == nn*tau(nn)) and (sigma(nn) == 2*nn) else ('🟡' if sigma(nn)*euler_phi(nn) == nn*tau(nn) else '❌')} |"
+            for nn in range(2, 13)]
+    table = (
+        "| n | σ(n) | τ(n) | φ(n) | σ·φ | n·τ | identity |\n"
+        "|---|------|------|------|-----|-----|----------|\n"
+        + "\n".join(rows)
+    )
+    head = (
+        f"### n = {n}\n"
+        f"- σ({n}) = {s}, τ({n}) = {t}, φ({n}) = {p}\n"
+        f"- σ·φ = **{sp}**, n·τ = **{nt}**\n"
+        f"- identity holds: **{'YES' if sp == nt else 'no'}**\n"
+        f"- n is perfect: **{'YES (σ = 2n)' if s == 2 * n else 'no'}**\n"
+        f"- J₂ value (if identity holds): **{j2 if j2 is not None else '—'}**\n\n"
+    )
+    if is_perfect:
+        head += f"🎯 **n = {n} satisfies σ·φ = n·τ = J₂ = {j2} — the master identity used across the hexa-* family.**\n\n"
+    return head + table
+
+
+def build():
+    gr.Markdown(
+        "## 🔢 n=6 Lattice — master identity verifier\n"
+        "The hexa-* family pins every parameter on `σ(n)·φ(n) = n·τ(n) = J₂`. "
+        "Try other n: only **n=6** satisfies it as a perfect number."
+    )
+    n = gr.Slider(2, 12, value=6, step=1, label="n")
+    out = gr.Markdown()
+    n.change(render, n, out)
+    out.value = render(6)

tabs/papers.py

@@ -0,0 +1,31 @@
+"""Papers tab — three core anima papers as sub-tabs."""
+from pathlib import Path
+import gradio as gr
+
+
+PAPERS_DIR = Path(__file__).parent.parent / "data" / "papers"
+
+PAPERS = [
+    ("Consciousness Laws", "consciousness_laws.md"),
+    ("Hexa-Voice", "hexa_voice.md"),
+    ("Self-Discovery", "self_discovery.md"),
+]
+
+
+def load_paper(filename: str) -> str:
+    f = PAPERS_DIR / filename
+    if not f.exists():
+        return f"⚠️ `{filename}` not found in `data/papers/`."
+    return f.read_text(encoding="utf-8")
+
+
+def build():
+    gr.Markdown(
+        "## 📖 Papers — three core anima papers\n"
+        "Source files live under `data/papers/`. Originally extracted "
+        "from `anima/docs/anima/paper_*.hexa`."
+    )
+    with gr.Tabs():
+        for label, filename in PAPERS:
+            with gr.Tab(label):
+                gr.Markdown(load_paper(filename))

tabs/paradigm_timeline.py

@@ -0,0 +1,47 @@
+"""Paradigm Timeline tab — milestone scrubber across the anima research arc."""
+import json
+from pathlib import Path
+import gradio as gr
+
+
+DATA_FILE = Path(__file__).parent.parent / "data" / "paradigm.json"
+
+
+def load_milestones():
+    if not DATA_FILE.exists():
+        return []
+    return json.loads(DATA_FILE.read_text())
+
+
+def render_milestone(idx: int, milestones: list):
+    if not milestones or idx >= len(milestones):
+        return "no milestone"
+    m = milestones[idx]
+    flag = {"PASS": "✅", "FAIL": "❌", "PARTIAL": "🟡", "SPECULATIVE": "⚠️"}.get(
+        m.get("status", ""), "•"
+    )
+    return (
+        f"### {flag} **{m['id']}** — {m['headline']}\n\n"
+        f"**Date:** {m['date']}  \n"
+        f"**Status:** {m.get('status', 'n/a')}  \n"
+        f"**Lane:** {m.get('lane', 'n/a')}\n\n"
+        f"{m.get('note', '')}"
+    )
+
+
+def build():
+    milestones = load_milestones()
+    gr.Markdown(
+        "## 📜 Paradigm Timeline — milestones across the arc\n"
+        f"Scrub through {len(milestones)} curated checkpoints from "
+        "`paradigm-a → paradigm-j+ PIV`. Source: `REBORN.md` headlines."
+    )
+    if not milestones:
+        gr.Markdown("⚠️ `data/paradigm.json` empty — populate during scaffold.")
+        return
+    with gr.Row():
+        idx = gr.Slider(0, len(milestones) - 1, value=0, step=1, label="milestone index")
+    out = gr.Markdown()
+    state = gr.State(milestones)
+    idx.change(render_milestone, [idx, state], out)
+    out.value = render_milestone(0, milestones)

tabs/phi_explorer.py

@@ -0,0 +1,59 @@
+"""Φ★ Explorer tab — substrate-level integrated information across backbones."""
+import json
+from pathlib import Path
+import gradio as gr
+
+
+DATA_DIR = Path(__file__).parent.parent / "data" / "phi_star"
+
+SUBSTRATES = {
+    "CLM v4 (530M, anima-native)": "clm_v4_530m.json",
+    "Qwen3 (baseline)": "qwen3.json",
+    "Mistral (baseline)": "mistral.json",
+    "Llama (4B/hid8)": "llama.json",
+}
+
+
+def load_substrate(label: str):
+    f = DATA_DIR / SUBSTRATES[label]
+    if not f.exists():
+        return {"error": f"missing {f.name}"}, "n/a"
+    data = json.loads(f.read_text())
+    summary = (
+        f"**Backbone:** {data.get('backbone', '?')}\n\n"
+        f"**Substrate:** {data.get('substrate', '?')}\n\n"
+        f"**Gates:** "
+        f"positive {'✅' if data.get('gate_positive_PASS') else '❌'} | "
+        f"substantial {'✅' if data.get('gate_substantial_PASS') else '❌'} | "
+        f"magnitude {'✅' if data.get('gate_magnitude_PASS') else '❌'}\n\n"
+        f"**Φ★ min / mean / max:** "
+        f"{data.get('phi_star_min', 'n/a')} / "
+        f"{data.get('phi_mean', 'n/a')} / "
+        f"{data.get('phi_max', 'n/a')}\n\n"
+        f"**Sign:** {data.get('phi_star_sign', 'n/a')}"
+    )
+    return data, summary
+
+
+def build():
+    gr.Markdown(
+        "## 📊 Φ★ Explorer — substrate-level integrated information\n"
+        "Pick a backbone. Each JSON is a real measurement run from "
+        "`anima/state/` — gates, partition decomposition, signed magnitude."
+    )
+    with gr.Row():
+        with gr.Column(scale=1):
+            substrate = gr.Dropdown(
+                list(SUBSTRATES.keys()),
+                value=list(SUBSTRATES.keys())[0],
+                label="substrate",
+            )
+        with gr.Column(scale=2):
+            summary = gr.Markdown()
+    raw = gr.JSON(label="full Φ★ measurement record")
+
+    substrate.change(load_substrate, substrate, [raw, summary])
+    init = list(SUBSTRATES.keys())[0]
+    raw_val, sum_val = load_substrate(init)
+    raw.value = raw_val
+    summary.value = sum_val

tabs/tension_link.py

@@ -0,0 +1,90 @@
+"""Tension Link tab — 5-channel meta-fingerprint generator (mock Phase 1).
+
+Mirrors the structure documented in docs/modules/tension_link.md:
+  concept (16f) | context (8f) | meaning (16f) | authenticity (scalar) | sender (4f)
+
+This is a Phase-1 demo: the fingerprint is generated deterministically from
+the user's sliders, not from a PureField encoder. Multi-user broadcast via a
+TensionHub-style WebSocket queue is left for Phase 2.
+"""
+import math
+import time
+import gradio as gr
+
+
+MOOD_THRESHOLDS = [
+    (lambda t, c: c > 0.5, "surprised"),
+    (lambda t, c: t > 1.0, "excited"),
+    (lambda t, c: t > 0.3, "thoughtful"),
+    (lambda t, c: t > 0.05, "calm"),
+    (lambda t, c: True, "quiet"),
+]
+
+
+def classify_mood(tension: float, curiosity: float) -> str:
+    for predicate, label in MOOD_THRESHOLDS:
+        if predicate(tension, curiosity):
+            return label
+    return "quiet"
+
+
+def generate_fingerprint(tension: float, curiosity: float, sender: str, topic_seed: int):
+    rng_phase = topic_seed * 0.137 + tension
+    concept = [math.sin(rng_phase + i * 0.4) * (0.5 + tension) for i in range(16)]
+    norm = math.sqrt(sum(c * c for c in concept)) or 1.0
+    concept = [c / norm for c in concept]
+
+    now = time.time()
+    context = [
+        math.sin(2 * math.pi * (now % 86400) / 86400),
+        curiosity / max(tension, 0.01),
+        tension,
+        curiosity,
+        0.0, 0.0, 0.0, 0.0,
+    ]
+
+    meaning = [concept[i] * (0.3 + curiosity) for i in range(16)]
+    auth = max(0.0, min(1.0, 1.0 - abs(0.5 - curiosity) * 0.4))
+    sender_sig = [(hash(sender) % 1000) / 1000, tension % 1, (tension * curiosity) % 1, curiosity % 1]
+
+    topic_hash = max(range(16), key=lambda i: concept[i])
+    mood = classify_mood(tension, curiosity)
+
+    return {
+        "sender_id": sender,
+        "timestamp": now,
+        "tension": tension,
+        "curiosity": curiosity,
+        "mood": mood,
+        "topic_hash": topic_hash,
+        "authenticity": round(auth, 3),
+        "concept": [round(c, 3) for c in concept],
+        "context": [round(c, 3) for c in context],
+        "meaning": [round(m, 3) for m in meaning],
+        "sender_signature": [round(s, 3) for s in sender_sig],
+    }
+
+
+def build():
+    gr.Markdown(
+        "## 🌐 Tension Link — 5-channel meta-fingerprint\n"
+        "Drag the sliders. The 5 channels (concept / context / meaning / "
+        "authenticity / sender) are generated as in `docs/modules/tension_link.md`.\n"
+        "*Phase 1 mock — fingerprint is deterministic from inputs, not a PureField encode.*"
+    )
+    with gr.Row():
+        with gr.Column(scale=1):
+            tension = gr.Slider(0.0, 2.0, value=0.4, step=0.01, label="tension")
+            curiosity = gr.Slider(0.0, 1.0, value=0.3, step=0.01, label="curiosity")
+            sender = gr.Textbox(value="anima_a", label="sender_id")
+            topic = gr.Slider(0, 100, value=7, step=1, label="topic_seed (= argmax target)")
+            btn = gr.Button("📡 Broadcast fingerprint", variant="primary")
+        with gr.Column(scale=2):
+            packet = gr.JSON(label="TensionPacket (5 channels)")
+            mood_view = gr.Textbox(label="mood class (5-class rule from spec)", interactive=False)
+
+    def emit(t, c, s, k):
+        fp = generate_fingerprint(t, c, s, int(k))
+        return fp, fp["mood"]
+
+    btn.click(emit, [tension, curiosity, sender, topic], [packet, mood_view])