docs(isoz): identity rebrand to IsoZ + Geometric Determinism theory (Cycle 1)

.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "version": "1.0.0",
-  "name": "rotary-slider-matrix",
-  "description": "Infinite Recursive Swarm Evolution via jtechAi Labs",
+  "name": "isoz",
+  "description": "IsoZ — a Feature Studio + intent≡code≡value gate framework, by jtechAi Labs",
   "author": "ZuluYokohama",
   "mcpServers": {
     "rotary-slider": {
@@ -12,12 +12,12 @@
   "skills": [
     {
       "name": "ast-oracle-diagnosis",
-      "description": "Trigger the AST Oracle to scan for O(N^2) bottlenecks and inject MaxVal intent vectors.",
+      "description": "Trigger the AST oracle to scan for O(N^2) bottlenecks and inject value-intent vectors.",
       "command": "make oracle TARGET=${target_dir}"
     },
     {
       "name": "engage-aaa-matrix",
-      "description": "Boot the infinite recursive loop enforcing Flake8, Bandit, Radon, and Visual V&V.",
+      "description": "Run the [DEMO] evolution loop with the Flake8/Bandit/Radon quality gate.",
       "command": "make evolve TARGET=${target_dir}"
     }
   ],

README.md

@@ -1,3 +1,62 @@
-# ARS PROTOTYPE 0.001a - IN DEV. 
-##LAST UPDATE BY HUMAN -6JUN26
--mr.orange@jtech.ai
+# IsoZ
+
+> Prototype 0.001a — in dev. Last human update 6 Jun 26 (mr.orange@jtech.ai).
+
+**IsoZ** is a *Feature Studio* for agentic development — a Next.js + React-Three-Fiber 3D control surface (with a FastAPI backend and a SvelteKit telemetry panel) over a pluggable framework of verification **gates**. Its thesis is a single idea made runnable: a **deterministic `intent ≡ code ≡ value` alignment gate** (`scripts/truth_resolver.py`). IsoZ is built on the **Superpowers** development methodology and Andrej Karpathy's **autoresearch** training code, and is developed by **jtechAi Labs (ZuluYokohama)**.
+
+> The rotary dial is IsoZ's mark; the Alpha Rig is its mascot. (IsoZ ships from a repository historically named *RotarySlider*; "ARS" — Autoresearch Superpowers — is its prototype lineage.)
+
+## The thesis: intent ≡ code ≡ value
+
+IsoZ is the honest, minimal, **running** seed of a larger theory — *Geometric Determinism* / the *AxiomZ / Jones Framework* — in which **truth is structural coherence** (a sheaf "Global Section": local views that agree on their overlaps), **value warps the metric**, and a **contradiction is an obstruction that halts**. The theory and the roadmap from the current seed toward the full geometric model live in:
+
+- [`docs/theory/GEOMETRIC_DETERMINISM.md`](docs/theory/GEOMETRIC_DETERMINISM.md) — the synthesis (3 decks → one framework).
+- [`docs/theory/TRUTH_RESOLVER_ROADMAP.md`](docs/theory/TRUTH_RESOLVER_ROADMAP.md) — v1 (shipped) → v2 sheaf coherence → v3 commit-vs-resolve.
+
+**Honesty split:** the *theory decks are the vision*; the *code is the current seed*. Anything not yet in code (ATFT, the Ternary-Crystal hardware substrate, sheaf-v2) is labeled **roadmap**, never capability. Today, `truth_resolver` is a compact, deterministic gate that scores intent/context/value overlap; that is the real, shipped state.
+
+## What's IsoZ-original vs inherited
+
+**Inherited (credit where due):**
+- **Superpowers** — the composable skills + agent methodology (brainstorming, TDD, planning, subagent-driven development, code review) by Jesse Vincent. Install and use it per its own project; the `skills/` library here is that layer.
+- **autoresearch** — Karpathy's training/research code (`train.py`, `prepare.py`) rides along.
+
+**IsoZ-original:**
+- **The Feature Studio** — `ui/studio` (Next.js + R3F: a glowing rotary dial, intent-pulse interactions, camera parallax), `ui/telemetry` (Svelte), and `scripts/api_server.py` (FastAPI).
+- **The gate framework** — `scripts/`: a quality gate (Flake8 / Bandit security-lint / Radon), a weak-crypto denylist lint, an AST complexity oracle, a failure cache, and a demonstration evolution loop.
+- **`truth_resolver`** — the deterministic `intent ≡ code ≡ value` alignment gate (the thesis in code).
+
+## Run the Feature Studio
+
+```bash
+# 1. Backend (FastAPI) — serves /status, /intent, /gallery, /telemetry
+python scripts/api_server.py            # http://localhost:8000
+
+# 2. Telemetry panel (SvelteKit)
+cd ui/telemetry && npm install && npm run dev   # http://localhost:3001
+
+# 3. Studio (Next.js + R3F)
+cd ui/studio && npm install && npm run dev      # http://localhost:3000
+```
+
+Prerequisites: Node 18+, Python 3.11+, and (for the gates) `pip install rich fastapi uvicorn flake8 bandit radon`.
+
+## The gates (honest descriptions)
+
+- **Quality gate** (`scripts/aaa_quality.py`) — runs **Flake8** (style), **Bandit** (a security linter for unsafe code patterns — *not* cryptographic verification), and **Radon** (cyclomatic complexity).
+- **Weak-crypto denylist lint** (`scripts/quantum_gate.py`) — flags identifiers matching a small weak-crypto blocklist (`md5`, `sha1`, `rsa`, …). It is a denylist lint, *not* post-quantum cryptography.
+- **AST oracle** (`scripts/oracle.py`) — detects nested loops and naked recursion, injecting optimization intents.
+- **Failure cache** (`scripts/akashic_records.py`) — a SQLite cache that remembers, by content hash, which mutations previously failed.
+- **Evolution loop — DEMONSTRATION** (`scripts/recursive_evolution.py`, `evolve.py`) — a `[DEMO]` loop that deterministically tallies features to illustrate the gate flow. It does **not** run a real LLM swarm (clearly labeled in its output).
+
+## CLI
+
+```bash
+python scripts/cli.py intent <target> --name "Feature" --metric "O(1)"   # inject an intent vector
+python scripts/cli.py status <target>                                     # show the feature map
+python scripts/cli.py evolve <target>                                     # run the [DEMO] evolution loop
+```
+
+## License
+
+See [LICENSE](LICENSE). The inherited Superpowers and autoresearch layers retain their original authors' licenses and credit.

assets/brand/BRAND_IDENTITY.md

@@ -1,38 +1,45 @@
-# Surface & Structure UI | RotarySlider Matrix
+# IsoZ — Brand Identity
+
 ## Brand Identity & Logo Concepts (jtechAi Labs)
 
 ### The Abstraction: Energy Tech Conceptual
-The brand identity for **Surface & Structure UI** and the **RotarySlider Matrix** is rooted in the abstraction of raw, algorithmic energy being structurally harnessed. It is not just "software"—it is the physical manifestation of compute cycles, quantum gates, and infinite recursive loops bound by AAA industrial parameters.
+
+The brand identity for **IsoZ** is rooted in the abstraction of raw, algorithmic energy being structurally harnessed — compute cycles bound into verifiable structure. The visual language draws on the rotary dial (the mark) and the Alpha Rig (the mascot).
 
 ---
 
 ### Concept 1: The Dyson Sphere (RotarySlider Core)
+
 - **Visual Description:** A 3D isometric wireframe of a Dyson Sphere. The outer structural rings (The AAA Gates) rotate on different axes, trapping a hyper-luminous, energetic core (The Swarm/LLM).
 - **Color Palette:** 
   - Structural Rings: `#30363d` (Industrial Graphite)
   - Energy Core: `#3fb950` (Matrix Green) fading into `#58a6ff` (Quantum Blue).
 - **Meaning:** Represents the *Structure* (the framework, hardware piping, gates) containing and harnessing the *Surface/Energy* (the chaotic, generative power of the AI swarm).
 
-### Concept 2: The Quantum Akashic Lattice
-- **Visual Description:** A hexagonal, lattice-like structure where each node represents a piece of evolutionary memory (The Akashic Records). One specific node is glowing violently, representing a current active mutation. The lines connecting the nodes pulse with energy.
+### Concept 2: The Coherence Lattice
+
+- **Visual Description:** A hexagonal, lattice-like structure where each node represents a cached prior failure (the failure cache). One specific node is glowing violently, representing a current active mutation. The lines connecting the nodes pulse with energy.
 - **Color Palette:** 
   - Lattice Nodes: Deep Cyberpunk Violet `#8a2be2`
   - Active Mutation Node: Blinding Neon Cyan `#00ffff`.
-- **Meaning:** A nod to the Quantum-Resistant Cryptography gate and the Akashic Evolutionary Memory. It visualizes the system "remembering" and "routing" energy efficiently to solve problems.
+- **Meaning:** A nod to the weak-crypto denylist lint and the failure cache. It visualizes the system "remembering" prior failures and "routing" around them efficiently.
 
 ### Concept 3: The Playwright Shutter (Surface UI)
+
 - **Visual Description:** A mechanical camera shutter (representing the Playwright Visual V&V layer capturing UI screenshots), but instead of a lens in the center, there is an abstract "Eye" made of binary code or matrix rain.
 - **Color Palette:** Monochromatic grayscale with a single, piercing `#f85149` (V&V Red) or `#3fb950` (Pass Green) pupil.
 - **Meaning:** Represents the "Surface" aspect of the brand—the automated visual scrutiny and grading of the UI by the Vision Model.
 
 ### Concept 4: The Alpha Protocol
+
 - **Visual Description:** A minimalist, highly stylized geometric wolf/dog head (Alpha), composed entirely of intersecting laser-light planes and vector math lines. It looks mathematical, precise, and loyal.
 - **Color Palette:** Solid `#0d1117` (Void Black) background with `#58a6ff` (Holographic Blue) vector lines.
 - **Meaning:** A direct representation of the **Alpha Rig** from the 3D WebGL frontend, symbolizing the loyal, protective, and advanced nature of the AI agent guarding the codebase.
 
 ---
 
 ### Typography & Typography Integration
+
 - **Primary Font:** *Inter* or *SF Pro Display* (for structural, industrial weight).
 - **Secondary Font:** *Fira Code* or *JetBrains Mono* (for the energy/tech conceptual code-feel).
 - The text "jtechAi Labs" should always be anchored beneath or beside the main logo mark in the secondary monospaced font, acting as a structural foundation to the primary logo.

docs/ISOMORPHISM_MANIFESTO.md

@@ -1,26 +1,32 @@
 # 1:1 Isomorphism: Truth in Intent
 
-## The Doctrine of the RotarySlider Matrix
-In standard software engineering, there is always drift between what is desired (The Intent), what is written (The Code Ops), and what is delivered (The Value Gen). 
+## The Doctrine of IsoZ
 
-**RotarySlider eliminates this drift.** The architecture is built on a strict **1:1 Isomorphism**.
+In standard software engineering, there is always drift between what is desired (The Intent), what is written (The Code Ops), and what is delivered (The Value Gen).
+
+**IsoZ works to eliminate this drift.** Its architecture targets a strict **1:1 Isomorphism** (see the honest vision-vs-seed split in [`theory/GEOMETRIC_DETERMINISM.md`](theory/GEOMETRIC_DETERMINISM.md)).
 
 `[ INTENT ] ≡ [ CODE OPS ] ≡ [ VALUE GEN ]`
 
 ### 1. Truth in Intent (The Mathematical Bound)
-Intent is never ambiguous or conversational. It is a strict vector (e.g., `O(1) memory overhead`, `Contrast > 4.5:1`, `Zero Pre-Quantum Cryptography`). In RotarySlider, the `feature_map.json` and the AST Oracle serve as the absolute Truth in Intent.
+
+Intent is never ambiguous or conversational. It is a strict vector (e.g., `O(1) memory overhead`, `Contrast > 4.5:1`). In IsoZ, the `feature_map.json` and the AST oracle serve as the Truth in Intent.
 
 ### 2. Code Ops (The Execution Mesh)
-Code operations are not human approximations; they are the physical manifestation of the Intent. The infinite recursive LLM swarm, bounded by the `HardwarePipingManager`, mutates the syntax trees directly until they align perfectly with the mathematical bounds of the Intent. If Code Ops deviate from the Intent, the AAA Pre-Gate, Quantum Gate, and Visual Matrix instantly purge the mutation.
 
-### 3. Value Gen (MaxVal Effect)
-Value generation is not an arbitrary metric. It is the exact, 1:1 realization of the completed Code Ops passing the Evolution Gate. When the Matrix tallies a feature as `[PASS]`, maximum value (`MaxVal`) has been mathematically achieved.
+Code operations aim to be the manifestation of the Intent. Today a demonstration evolution loop (`[DEMO]` — no real LLM swarm yet; see the roadmap), bounded by the `HardwarePipingManager`, iterates over the feature map; the quality gate (Flake8/Bandit/Radon), the weak-crypto denylist lint, and the Playwright visual check screen each candidate. Where Code Ops deviate from the Intent, those gates flag it.
+
+### 3. Value Gen (the value score)
+
+Value generation is not an arbitrary metric. It is the 1:1 realization of the completed Code Ops passing the Evolution Gate. When a feature is tallied `[PASS]`, the value score is realized.
 
 ## Retrospective Alignment of All PRs and Reviews
+
 Every Pull Request, every CodeRabbit AI review, and every line of code committed to this repository represents this 1:1 Isomorphism:
+
 - **PR #2 & #3 (Visual Matrix & UI Mesh):** The visual intent maps 1:1 to the headless Playwright rendering operations, generating aesthetic value.
 - **PR #7 (AST Oracle):** The detection of O(N^2) loops maps 1:1 to the generation of memoization ops, yielding performance value.
-- **PR #8 & #11 (AAA & Quantum Gates):** The intent of security maps 1:1 to static AST parsing ops, yielding cryptographic value.
+- **PR #8 & #11 (quality gate & weak-crypto denylist lint):** the intent of code safety maps 1:1 to static AST parsing ops (a security/complexity lint — not cryptographic verification).
 
-There is no gap. There is no abstraction leak. 
+There is no gap. There is no abstraction leak.
 **The Intent IS the Code. The Code IS the Value.**