From e0134558a5cd2035397440f657ae918c9667da05 Mon Sep 17 00:00:00 2001 From: ZuluYokohama Date: Sat, 6 Jun 2026 10:34:00 -0500 Subject: [PATCH 1/6] docs: add IsoZ identity spec + Geometric Determinism theory foundation - docs/theory/GEOMETRIC_DETERMINISM.md: synthesis of the 3 decks (Geometry of Truth / Geometric Determinism / ZuluYokohama Protocol) into the AxiomZ/Jones Framework, with an explicit buildable-core vs aspirational-vision split. - docs/theory/TRUTH_RESOLVER_ROADMAP.md: v1 (shipped) -> v2 sheaf coherence -> v3 commit-vs-resolve -> v4 Oracle seam upgrade path. - specs/2026-06-06-isoz-identity-design.md: Cycle-1 rebrand to IsoZ (hybrid Z-brand, honest substance), README rewrite around the intent=code=value thesis, repo rename, doc demotions; Cycle 2 = code-symbol renames, Cycle 3 = website. Co-Authored-By: Claude Opus 4.8 (1M context) --- .../specs/2026-06-06-isoz-identity-design.md | 97 +++++++++++++++++++ docs/theory/GEOMETRIC_DETERMINISM.md | 54 +++++++++++ docs/theory/TRUTH_RESOLVER_ROADMAP.md | 64 ++++++++++++ 3 files changed, 215 insertions(+) create mode 100644 docs/superpowers/specs/2026-06-06-isoz-identity-design.md create mode 100644 docs/theory/GEOMETRIC_DETERMINISM.md create mode 100644 docs/theory/TRUTH_RESOLVER_ROADMAP.md diff --git a/docs/superpowers/specs/2026-06-06-isoz-identity-design.md b/docs/superpowers/specs/2026-06-06-isoz-identity-design.md new file mode 100644 index 0000000..f5ce0fb --- /dev/null +++ b/docs/superpowers/specs/2026-06-06-isoz-identity-design.md @@ -0,0 +1,97 @@ +# IsoZ Identity & Positioning — Design Spec (Cycle 1) + +> **Status:** Approved-in-brainstorm 2026-06-06 (direction, name, and key decisions chosen by the user). +> **Author:** ZuluYokohama (b.jones@jtech.ai) via Claude Code brainstorming. +> **Cycle 1 of 3.** Cycle 2 = code-symbol demotion (module/function renames). Cycle 3 = website (deferred for a real screenshot). + +## 1. Goal + +Unify the project's four-way fragmented identity (repo *RotarySlider* · README *Autoresearch Superpowers* · +plugin *rotary-slider-matrix* · website *Surface & Structure UI*) under one honest brand — **IsoZ** — +and rewrite the README around the project's true thesis: **the honest, minimal, *running* embodiment +of Geometric Determinism** (`intent ≡ code ≡ value` as a sheaf Global Section), seeded by +`scripts/truth_resolver.py`. + +**Direction (chosen):** *Hybrid with a Z-brand* — honest substance, a deliberate Z-harmonized brand skin, +never a false-capability claim. + +## 2. Identity model + +- **Canonical brand: IsoZ**, content-facing everywhere (README H1, website headline, CLI banner, + plugin description). "IsoZ" = *isomorphism* — the project's real thesis (`intent ≡ code ≡ value` = + Global Section), grounded in the user's **AxiomZ / Jones Framework** theory (see `docs/theory/`). +- **Repo: rename `RotarySlider` → `IsoZ`** (chosen). GitHub auto-redirects old clone/Pages URLs; + perform the rename when no other PRs are mid-flight, and update the local remote + the live Pages + URL reference (`github.io/RotarySlider` → `/IsoZ`). +- **Visual marks:** the **rotary dial** (now real, built in C2) = the logo; the **Alpha Rig** = the + sanctioned mascot flourish. +- **Author identity:** unify attribution to *jtechAi Labs (ZuluYokohama)* going forward (`git config`). + The three historical commit identities (BravoWon / Nomo Yokahaaka / ZuluYokohama) are one author — + noted, not history-rewritten. + +## 3. Vocabulary — honest substance, Z-brand skin + +Rule: **brand-skin is allowed on *presentation*, never on *capability claims*.** Cycle 1 applies the +demotions to **user-facing docs/strings**; Cycle 2 applies them to **code symbols** (module/function +renames) — the user chose *aggressive demotion everywhere incl. code*, split across the two cycles by risk. + +| Current (overclaim) | IsoZ (honest) | Cycle | +|---|---|---| +| "Autoresearch Superpowers" (README H1) | **IsoZ** + honest descriptor; credit inherited layers | 1 | +| "Surface & Structure UI" / "rotary-slider-matrix" | **IsoZ** (website headline, plugin description) | 1 | +| CLI banner "Autoresearch Superpowers – Swarm CLI" | **IsoZ** CLI | 1 | +| "Quantum-Resistant Cryptography Gate" | **weak-crypto denylist lint** (drop "Quantum-Resistant") | 1 docs / 2 code (`quantum_gate.py`→`crypto_denylist.py`) | +| "Akashic Records / evolutionary memory" | **failure cache** | 1 docs / 2 code (`akashic_records.py`→`failure_cache.py`) | +| "Infinite Recursive LLM Swarm" | **evolution loop (demo)** | done (`[DEMO]`, PR #24) | +| Bandit = "cryptographic checks" | **security linter** | 1 | +| "MaxVal" / "the Matrix" | **value score** / **3D scene** | 1 docs / 2 code/skill | + +## 4. README rewrite (Cycle 1) + +New structure: + +1. **H1 IsoZ** + a one-paragraph honest "what it is": a Feature Studio (Next.js + R3F 3D control + surface, FastAPI backend, Svelte telemetry) plus a pluggable gate framework, whose thesis is a + deterministic `intent ≡ code ≡ value` alignment gate (`truth_resolver`). +2. **The thesis** — link `docs/theory/GEOMETRIC_DETERMINISM.md`; state plainly that the decks are the + *vision* and `truth_resolver` is the current *seed* (the honesty split). Link the roadmap. +3. **Two-layer credit split** — *Inherited* (Jesse Vincent's superpowers methodology + Karpathy's + autoresearch; honest attribution, scoped install notes) vs *IsoZ original* (the Studio, the gate + scripts, `truth_resolver`). +4. **Document the Feature Studio** (currently absent): real run instructions — + `python scripts/api_server.py`, `cd ui/studio && npm run dev`, `cd ui/telemetry && npm run dev`. +5. **Honest gate descriptions** (apply the §3 demotions in prose); fix the Bandit mislabel. + +## 5. Theory foundation (Cycle 1 — already drafted) + +- `docs/theory/GEOMETRIC_DETERMINISM.md` — synthesis of the three decks + the buildable-vs-vision split. +- `docs/theory/TRUTH_RESOLVER_ROADMAP.md` — v1→v2(sheaf coherence)→v3(commit-vs-resolve)→v4(Oracle) path. + +These ground the IsoZ thesis in real theory while enforcing the honesty discipline. + +## 6. Scope & sequencing + +- **Cycle 1 (this spec):** repo rename → IsoZ; README rewrite; user-facing doc/string demotions + (manifesto, brand doc, CLI banner, plugin.json description, website-URL references); theory docs. +- **Cycle 2:** code-symbol demotion — rename `akashic_records.py`/`quantum_gate.py`, demote + `MaxVal`/`Matrix` symbols, fix all imports/callers/Makefile/MCP/skill, **run-verify each**. Own spec. +- **Cycle 3:** website `index.html` rewrite (IsoZ, a11y, honest copy) — deferred for a real studio screenshot. + +Each cycle is its own worktree → PR → CodeRabbit → merge, human-gated (outward-facing). + +## 7. Definition of Done (Cycle 1) + +- Repo renamed to IsoZ; local remote + Pages reference updated. +- README rewritten: IsoZ H1, honest thesis with the decks=vision / code=seed split, two-layer credit, + Feature Studio documented, gate descriptions demoted, Bandit mislabel fixed. +- User-facing strings (CLI banner, plugin.json description, manifesto/brand-doc headers) say IsoZ and + drop false-capability terms (esp. "Quantum-Resistant"). +- `docs/theory/` reference + roadmap committed. +- No code-symbol renames yet (that's Cycle 2); nothing broken. + +## 8. Risks + +- **Repo rename timing** — do it with no PRs mid-flight; verify redirects; update the gh-pages URL note. +- **Re-inflation risk** — folding the decks could re-import overclaim; mitigated by the explicit + vision/seed honesty split in both the README and `docs/theory/`. +- **Scope discipline** — Cycle 1 must NOT touch code symbols (defer to Cycle 2) to keep it low-risk. diff --git a/docs/theory/GEOMETRIC_DETERMINISM.md b/docs/theory/GEOMETRIC_DETERMINISM.md new file mode 100644 index 0000000..d90d0a3 --- /dev/null +++ b/docs/theory/GEOMETRIC_DETERMINISM.md @@ -0,0 +1,54 @@ +# Geometric Determinism — The Theory Behind IsoZ + +> **What this is:** a faithful synthesis of the three foundational decks authored by ZuluYokohama +> (jtechAi Labs) — *The Geometry of Truth*, *Geometric Determinism*, and *The ZuluYokohama Protocol*. +> Together they are one layered theory (the **AxiomZ / Jones Framework**). IsoZ is its honest, +> minimal, *running* seed. +> +> **Honesty discipline (read first):** the decks are *manifesto-grade*. They name heavy mathematics +> (ATFT, a claimed Berry–Keating/Riemann correspondence, "mathematically guaranteed zero +> hallucination", a Ternary-Crystal hardware substrate) that is **asserted, not proven**, and is far +> beyond any code that exists. This document extracts the **buildable core** and explicitly separates +> it from the **aspirational vision**. Per the project's own `intent ≡ code ≡ value` doctrine: the +> decks are the *vision*; the code is the *current truth*; this file labels which is which. + +## 1. The three decks are one stack + +| Deck | Layer | Core claim | +|------|-------|-----------| +| **The Geometry of Truth** | WHY (conceptual) | Truth is geometric, not statistical. Truth = a **Global Section** of a cellular sheaf: all local views ("stalks") agree on their overlaps, so the **Sheaf Laplacian reaches zero (Dirichlet) energy**. **Value warps the metric** (the Information-Geometric Valuation Framework, IGVF): human intent is a "gravity well", and the aligned solution is the geodesic / "path of least resistance". A contradiction is a **cohomological obstruction** → the action is hard-blocked. Organizing metaphor: Map (Sheaves) · Compass (IGVF) · Pilot (the human, "MaxOp") · Engine (the Protocol). | +| **Geometric Determinism** | WHAT (formal) | Structure → *deterministic* computation → truth/value. The **Configurational Term Series** `X → f(x) → ℳ → v → ℳ_v → H_k → Q(Φ)`. The discrete **Sheaf Laplacian** `L_F = (δ⁰)*δ⁰`; cohomology diagnostics `H⁰` (coherence) / `H¹` (voids) / `H²` (obstructions). A **Commit-vs-Resolve** safety protocol: simulate, accept only if the spectral gap is preserved (`Δλ₁ ≥ 0`) and coherence strictly increases, else hard-block and log. Type-theory equality (isomorphism = inverse-morphism pairs) is chosen over set/category theory for computational V&V. A **Z-Axis "ladder of abstraction"** (Layers 0–5) forbids layer-skipping to prevent "Zombie" (syntactically valid, semantically ungrounded) states. | +| **The ZuluYokohama Protocol** | HOW (systems) | A bandwidth-first execution substrate: SHEAF-OS / ATFT, a quantized **Ternary Crystal** (Void/Identity/Prime) weight alphabet, sparse zero-copy dataflow, an **edge→Oracle** offload of unsolvable obstructions, and **geometry-penalized learning** (loss weighted by topological coherence shift `Δλ₁`). | + +## 2. Topic abstraction — the six load-bearing, *buildable* ideas + +Stripped of the manifesto framing, six ideas survive that are implementable today: + +1. **Truth = coherence.** A claim-set is "true" when its local parts glue into a consistent global whole (sheaf global section / low Dirichlet energy) — not when it is probable. +2. **Alignment = agreement-on-overlap.** Model actors/views as stalks with restriction maps; consistency is measured on their *overlapping intersections*. This argues *for* set-overlap and *against* flat cosine-on-embeddings as the source of truth. +3. **Value = metric-warp.** Value is a *weighting field* over the space (IGVF), not a separate similarity. What you value bends the geometry so the valued solution becomes lowest-cost. +4. **Contradiction = obstruction.** An irreconcilable conflict is a cohomological obstruction (`H¹ ≠ 0`) → a deterministic **hard halt** ("zero-bypass gate"), not a soft low score. +5. **Determinism over stochastic.** Truth/value should be a *reproducible* function of structure (spectral invariants), not an LLM's judgment — so the same input always yields the same verdict. +6. **Commit-vs-Resolve.** Don't act, then filter. *Simulate* a change against the structure and **commit only if coherence does not decrease** (`Δλ₁ ≥ 0`). + +## 3. The formal anchors (transcribed from the decks) + +- **Sheaf Laplacian** (Geometric Determinism, slide 8): `L_F = (δ⁰)*δ⁰`; on a graph `G=(V,E)` acting on a 0-cochain `x`: + `(L_F⁰ x)(v) = Σ_{e:v∼w} ℱ_{v⊴e}^T ( ℱ_{v⊴e} x(v) − ℱ_{w⊴e} x(w) )`, with restriction maps `ℱ`. + Diagnostics: `H⁰` coherence (nullspace dim / `λ₁` stability), `H¹` voids (cycles / missing deps), `H²` obstructions. +- **Configurational Term Series** (calculus of emergence): `X → f(x) → ℳ → v → ℳ_v → H_k → Q(Φ)` — substrate → constrained dynamics → manifold → **value-warp `v`** → value-warped manifold → persistent homology (`β₀` clusters, `β₁` loops) → `Q(Φ)` the irreducible truth-form. +- **Truth = Global Section** (Geometry of Truth, slide 8): all locals agree on overlaps ⇔ Sheaf Laplacian zero energy ⇔ Dirichlet energy minimized. +- **Value geometry** (slides 11–13): base = Fisher Information Metric; an observer-dependent **Value Function `v`** warps it into a gravity well; aligned solution = geodesic. +- **Commit/Resolve invariant** (ZuluYokohama, slide 13; Geometric Determinism, slide 11): `loss = ce_loss · (1 + max(0, Δλ₁)·w)`; accept iff `Δλ₁ ≥ 0`; successful transitions emit "Shape Pairs" `(K_pre, K_post)`. + +## 4. Buildable core vs. aspirational vision + +**Buildable now (informs IsoZ / `truth_resolver`):** sheaf-style overlap/coherence scoring, value-weighted overlap, obstruction-as-halt, deterministic reproducibility, commit-vs-resolve gating, the pluggable Oracle/O-Box seam, no-layer-skipping verification. + +**Aspirational vision (NOT code; label as roadmap/manifesto):** ATFT, the claimed exact Berry–Keating/Riemann (zeta) correspondence, "mathematically guaranteed zero hallucination", the Ternary-Crystal hardware substrate, HBM4/NVLink/NoC execution, persistent-homology phase detection at scale. These are named but unproven in the decks and unimplemented in code. Cite them as *direction*, never as *capability*. + +## 5. Why this matters for IsoZ + +IsoZ's thesis is not "a 3D studio + some gates." It is **the honest, minimal, running embodiment of Geometric Determinism**: a place where `intent ≡ code ≡ value` is the *Global Section / isomorphism* condition, made concrete by `scripts/truth_resolver.py`. The upgrade path from that 187-line seed toward the sheaf-coherence model is in [`TRUTH_RESOLVER_ROADMAP.md`](./TRUTH_RESOLVER_ROADMAP.md). + +> Source decks (image-based PPTX): `The_Geometry_of_Truth.pptx` (21 slides), `Geometric_Determinism.pptx` (15), `The_ZuluYokohama_Protocol.pptx` (14). Full per-slide extractions were produced during the 2026-06-06 session. diff --git a/docs/theory/TRUTH_RESOLVER_ROADMAP.md b/docs/theory/TRUTH_RESOLVER_ROADMAP.md new file mode 100644 index 0000000..a824375 --- /dev/null +++ b/docs/theory/TRUTH_RESOLVER_ROADMAP.md @@ -0,0 +1,64 @@ +# truth_resolver Roadmap — From Jaccard Seed to Sheaf Coherence + +> Maps the [Geometric Determinism theory](./GEOMETRIC_DETERMINISM.md) onto a concrete, honest +> upgrade path for `scripts/truth_resolver.py`. Each stage is independently shippable and keeps the +> determinism + pluggable-seam discipline the prototype already has. **This is a direction, not a +> promise** — only v1 exists today. + +## v1 — Shipped (PR #19) + +A deterministic gate: each actor's `intent`/`context`/`value` is distilled into token/tag sets; +alignment = mean Jaccard overlap across the three dimensions; value = a shared-value-gated claim +score; output = `Verdict{passed, alignment, value, rationale, dissent}` where `dissent` names the +`actor:dimension` pairs that broke alignment. A `Distiller` Protocol is the pluggable seam +(`DeterministicDistiller` now; an LLM distiller later). 26 tests, stdlib-only, no API key. + +**Theory mapping:** Jaccard-on-overlap ≈ a poor-man's *agreement-on-intersections*; `dissent` ≈ a +coarse *obstruction localization*; the `Distiller` seam ≈ the decks' **O-Box / Oracle**. + +## v2 — Sheaf coherence (the core upgrade) + +Replace ad-hoc Jaccard with the actual sheaf model from the theory. + +| Aspect | v1 | v2 | +|--------|----|----| +| Representation | flat token sets per actor | **stalks**: a vector per actor over a shared concept base + **restriction maps** between actors | +| Alignment | mean Jaccard | **`1 − normalized Dirichlet energy`** of the sheaf Laplacian `L_F` (true Global-Section coherence; perfect agreement → 1.0) | +| Value | shared-value gating of claims | **value-weighted overlap** — value is a weighting field over cells (IGVF metric-warp); already foreshadowed by `score_value`'s shared-value gate | +| `dissent` | `actor:dimension` list | **`H¹` obstruction localization** — the specific edges/cells whose restriction maps fail to glue | +| Gate | soft `passed` (alignment ≥ θ AND value > 0) | soft score **plus** a deterministic **obstruction halt** (any irreconcilable cell ⇒ blocked, not low-scored) | + +Deliverable: a `sheaf.py` helper (build incidence/coboundary `δ⁰`, restriction maps, `L_F = (δ⁰)*δ⁰`, +Dirichlet energy, nullspace/`λ₁`) wired behind the existing `resolve()` API. Still deterministic, +still unit-testable with exact numbers (small graphs have closed-form Laplacians). + +## v3 — Commit-vs-Resolve gate + +Turn `truth_resolver` from a standalone scorer into a **pre-commit / evolution gate**: + +1. **Propose** a change (a diff, a spec edit, an agent action). +2. **Resolve** — recompute the intent≡code≡value sheaf coherence *with the change simulated*. +3. **Commit** only if coherence does not decrease (`Δλ₁ ≥ 0`); else **halt + log** the obstruction. + +This is the decks' Commit-vs-Resolve / "zero-bypass" protocol, scaled down to a CI/commit hook — +a principled "does this change preserve intent-alignment?" check. It composes with the existing +`evolution_gate_template.py` and the (now-honest) `aaa_quality.py` gate family. + +## v4+ — Pluggable semantics (the Oracle), still bounded + +Swap `DeterministicDistiller` for an `LLMDistiller` behind the *same* `Distiller` Protocol — the +decks' **O-Box / Oracle** that injects richer meaning while the deterministic sheaf skeleton (and its +reproducible verdict structure) stays fixed. The gate never becomes stochastic; only the *distillation +of raw input into stalks* gains semantics. + +## Out of scope (vision, not roadmap) + +ATFT, the Berry–Keating/Riemann correspondence, the Ternary-Crystal hardware substrate, and +bandwidth-level execution claims from *The ZuluYokohama Protocol* are **not** on this roadmap. They +are research-vision; cite them as such, never as shipped capability. + +## Guardrail + +Every stage must preserve the prototype's three invariants: **deterministic** (same input → same +verdict), **unit-tested with exact expected values**, and **honest** (the README/docs state which +stage actually exists). v1 is real; v2+ are proposals until built and merged. From baa08204b0de70f41a704a0748781100687834ee Mon Sep 17 00:00:00 2001 From: ZuluYokohama Date: Sat, 6 Jun 2026 10:47:22 -0500 Subject: [PATCH 2/6] =?UTF-8?q?docs(isoz):=20add=20isomorphic=20grounding?= =?UTF-8?q?=20(=C2=A70)=20=E2=80=94=20condition:state=20derived=20from=20r?= =?UTF-8?q?ealized=20activity:states?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Bind the IsoZ identity isomorphically across concept/framework/process/pattern, grounded in actual merged work (PRs #17-#24, truth_resolver, docs/theory), with semantic truth as the invariant (every assertion traces to a realized activity:state; vision-tier labeled roadmap). Process = product. --- .../specs/2026-06-06-isoz-identity-design.md | 29 +++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/docs/superpowers/specs/2026-06-06-isoz-identity-design.md b/docs/superpowers/specs/2026-06-06-isoz-identity-design.md index f5ce0fb..4c33bb8 100644 --- a/docs/superpowers/specs/2026-06-06-isoz-identity-design.md +++ b/docs/superpowers/specs/2026-06-06-isoz-identity-design.md @@ -4,6 +4,35 @@ > **Author:** ZuluYokohama (b.jones@jtech.ai) via Claude Code brainstorming. > **Cycle 1 of 3.** Cycle 2 = code-symbol demotion (module/function renames). Cycle 3 = website (deferred for a real screenshot). +## 0. Isomorphic grounding (the binding frame) + +The IsoZ identity must be **isomorphic across four layers** — *concept, framework, process, pattern* — +each a faithful image of the others, and the requested **condition:state** (the target identity) must be +*derived from and constrained by* the **activity:states** this effort has actually realized (not +aspiration). **Semantic truth is the binding invariant:** IsoZ may only assert what the activity:states +realize; vision-tier content is labeled roadmap, never capability. + +**One pattern, four images** — the pattern is *align intent to verified reality; halt on contradiction; never overclaim*: + +| Layer | Image of the pattern | Grounded in (activity:state) | +|---|---|---| +| **Concept** | Geometric Determinism — truth = coherence (sheaf Global Section); value warps the metric; obstruction → halt. | `docs/theory/` (3-deck synthesis + roadmap) | +| **Framework** | IsoZ / `truth_resolver` — a deterministic `intent ≡ context ≡ value` alignment gate with a pluggable Oracle seam. | `scripts/truth_resolver.py` (PR #19, merged) | +| **Process** | The dev method — every claim verified against ground truth before assertion; CodeRabbit-gated; false findings refuted with evidence; `[DEMO]` / vision-vs-seed labeling. | PRs #17–#24 (spec→TDD→two-stage review→PR→CodeRabbit→merge) | +| **Pattern** | worktree → spec → plan → TDD → review → PR → adversarial gate → merge. | Every merge this effort produced | + +These four are **the same isomorphism at four scales** — most pointedly, the *process* that built IsoZ is +itself an instance of `truth_resolver` (**process ≡ product**). + +**Activity:states the condition:state is an image of** (merit already realized, all on `master`): +C4 #17 (buildable, 3D-visible studio) · C1 #18 (intent tunnel, end-to-end verified) · C2 #20 (instanced +dial) · C3 #21 (camera parallax) · #22 (plan reconciled to truth) · `truth_resolver` #19 (the concept's +seed) · #23 (AAA gate repaired) · #24 (swarm honestly `[DEMO]`-labeled — language brought into isomorphism +with code) · `docs/theory/` (concept). + +**Maximum optimization, to the point this effort is at:** the rebrand is not a fresh claim — it is the +*minimal, truthful naming* of what already coheres. Every IsoZ assertion below must trace to a row above. + ## 1. Goal Unify the project's four-way fragmented identity (repo *RotarySlider* · README *Autoresearch Superpowers* · From 73a7d3046e1848be3a1daad827b3b1fe0ac93c1c Mon Sep 17 00:00:00 2001 From: ZuluYokohama Date: Sat, 6 Jun 2026 11:23:56 -0500 Subject: [PATCH 3/6] docs: add IsoZ Cycle-1 identity rebrand implementation plan 6 tasks: README rewrite (full new content inline), CLI/plugin/manifesto/brand string demotions, and a GATED repo rename. Strings + identity only; no code symbols (Cycle 2) or website (Cycle 3). Every assertion traces to a realized activity:state per spec section 0. --- .../plans/2026-06-06-isoz-identity.md | 297 ++++++++++++++++++ 1 file changed, 297 insertions(+) create mode 100644 docs/superpowers/plans/2026-06-06-isoz-identity.md diff --git a/docs/superpowers/plans/2026-06-06-isoz-identity.md b/docs/superpowers/plans/2026-06-06-isoz-identity.md new file mode 100644 index 0000000..56258b0 --- /dev/null +++ b/docs/superpowers/plans/2026-06-06-isoz-identity.md @@ -0,0 +1,297 @@ +# IsoZ Identity Rebrand — Implementation Plan (Cycle 1) + +> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking. + +**Goal:** Unify the project's fragmented identity under the honest brand **IsoZ** by rewriting the README around the `intent ≡ code ≡ value` thesis, demoting user-facing overclaim strings, and renaming the GitHub repo — every claim traceable to a realized activity:state (spec §0). + +**Architecture:** Pure documentation + identifier changes. No code-symbol/module renames (Cycle 2) and no website (Cycle 3). One worktree → PR → CodeRabbit → merge; the `gh repo rename` is a gated, human-approved admin step performed when no other PRs are open. "Tests" are verification greps (residual-overclaim scans, link/run-instruction presence). + +**Tech Stack:** Markdown, JSON, a Python docstring/string edit, `gh`/`git` for the rename. The two theory docs (`docs/theory/GEOMETRIC_DETERMINISM.md`, `TRUTH_RESOLVER_ROADMAP.md`) are already written + committed (e013455) — the README links them; this plan does not re-create them. + +--- + +## File Structure + +- **Rewrite:** `README.md` — IsoZ H1, honest "what it is", thesis link, two-layer credit, Feature Studio run docs, demoted gate descriptions. +- **Modify (strings only):** `scripts/cli.py` (3 lines), `.claude-plugin/plugin.json` (name + descriptions), `docs/ISOMORPHISM_MANIFESTO.md` (1 line + a theory pointer), `assets/brand/BRAND_IDENTITY.md` (title + false-capability lines). +- **Admin (gated):** GitHub repo rename `RotarySlider` → `IsoZ` + local remote update. +- **Untouched:** all `scripts/*.py` symbol/module names, `ui/` website, code logic. (Cycles 2/3.) + +--- + +## Task 1: Rewrite the README + +**Files:** Rewrite `README.md` + +- [ ] **Step 1: Write the new README** + +Replace the entire contents of `README.md` with exactly: + +```markdown +# IsoZ + +**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*.) + +## 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 187-line 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 --name "Feature" --metric "O(1)" # inject an intent vector +python scripts/cli.py status # show the feature map +python scripts/cli.py evolve # run the [DEMO] evolution loop +``` + +## License + +See [LICENSE](LICENSE). The inherited Superpowers and autoresearch layers retain their original authors' licenses and credit. +``` + +- [ ] **Step 2: Verify the rewrite (residual-overclaim + presence greps)** + +Run each; confirm the expected result: +```bash +cd /c/Users/Deving-1/rs-isoz +grep -c "^# IsoZ" README.md # expect 1 (H1 is IsoZ) +grep -ci "Quantum-Resistant" README.md # expect 0 +grep -ci "Infinite Recursive LLM Swarm" README.md # expect 0 +grep -ci "cryptographic security checks" README.md # expect 0 +grep -c "truth_resolver" README.md # expect >=1 +grep -c "docs/theory/GEOMETRIC_DETERMINISM.md" README.md # expect >=1 +grep -c "npm run dev" README.md # expect >=1 (studio documented) +grep -ci "Jesse Vincent\|Superpowers\|Karpathy\|autoresearch" README.md # expect >=1 (credit kept) +``` +Expected: H1=1, overclaims=0, thesis+studio+credit all present. + +- [ ] **Step 3: Commit** + +```bash +git add README.md +git commit -m "docs(isoz): rewrite README around the intent=code=value thesis (IsoZ)" +``` + +--- + +## Task 2: Demote CLI strings (`scripts/cli.py`) + +**Files:** Modify `scripts/cli.py` (lines 3, 37, 106 — strings only, no symbol renames) + +- [ ] **Step 1: Edit the three strings** + +- Line 3 (module docstring): change `Autoresearch Superpowers CLI with Rich TUI` → `IsoZ CLI with Rich TUI`. +- Line 37: change `description=f"Booting Infinite Recursive Matrix for {target}..."` → `description=f"[DEMO] Booting the IsoZ evolution loop for {target}..."`. +- Line 106: change `argparse.ArgumentParser(description="Autoresearch Superpowers - Swarm CLI")` → `argparse.ArgumentParser(description="IsoZ - Feature Studio & Gate CLI")`. + +- [ ] **Step 2: Verify (no behavior change; parses + strings updated)** + +```bash +python -c "import ast; ast.parse(open('scripts/cli.py').read()); print('PARSE OK')" +grep -ci "Autoresearch Superpowers" scripts/cli.py # expect 0 +grep -ci "Infinite Recursive Matrix" scripts/cli.py # expect 0 +grep -c "IsoZ" scripts/cli.py # expect >=2 +``` +Expected: PARSE OK; old strings gone; IsoZ present. (No argparse subcommand names changed — only description strings.) + +- [ ] **Step 3: Commit** + +```bash +git add scripts/cli.py +git commit -m "docs(isoz): rebrand CLI banner/strings to IsoZ (no symbol changes)" +``` + +--- + +## Task 3: Rebrand the plugin manifest (`.claude-plugin/plugin.json`) + +**Files:** Modify `.claude-plugin/plugin.json` (the `name`, top-level `description`, and command `description` strings — NOT command `name` identifiers) + +- [ ] **Step 1: Edit the manifest strings** + +- `"name": "rotary-slider-matrix"` → `"name": "isoz"`. +- `"description": "Infinite Recursive Swarm Evolution via jtechAi Labs"` → `"description": "IsoZ — a Feature Studio + intent≡code≡value gate framework, by jtechAi Labs"`. +- Command description `"Trigger the AST Oracle to scan for O(N^2) bottlenecks and inject MaxVal intent vectors."` → `"Trigger the AST oracle to scan for O(N^2) bottlenecks and inject value-intent vectors."` +- Command description `"Boot the infinite recursive loop enforcing Flake8, Bandit, Radon, and Visual V&V."` → `"Run the [DEMO] evolution loop with the Flake8/Bandit/Radon quality gate."` +- Leave all command `"name"` identifiers (e.g. `ast-oracle-diagnosis`, `engage-aaa-matrix`) unchanged — identifier renames are Cycle 2. + +- [ ] **Step 2: Verify (valid JSON + strings updated)** + +```bash +python -c "import json; json.load(open('.claude-plugin/plugin.json')); print('JSON OK')" +grep -ci "rotary-slider-matrix\|Infinite Recursive Swarm\|MaxVal" .claude-plugin/plugin.json # expect 0 +grep -c "isoz\|IsoZ" .claude-plugin/plugin.json # expect >=2 +``` +Expected: JSON OK; old identity/overclaim strings gone; IsoZ present. + +- [ ] **Step 3: Commit** + +```bash +git add .claude-plugin/plugin.json +git commit -m "docs(isoz): rebrand plugin manifest description/name to IsoZ" +``` + +--- + +## Task 4: Fix the manifesto overclaim + link the honest theory + +**Files:** Modify `docs/ISOMORPHISM_MANIFESTO.md` (line 23 + a pointer) + +- [ ] **Step 1: Fix the false-capability line + add a theory pointer** + +- Change line 23 `- **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).` +- Append at the end of the file: +```markdown + +--- + +> **See also:** [`docs/theory/GEOMETRIC_DETERMINISM.md`](theory/GEOMETRIC_DETERMINISM.md) extends this doctrine into the full IsoZ thesis, with an explicit *vision-vs-shipped-seed* honesty split. +``` + +- [ ] **Step 2: Verify** + +```bash +grep -ci "cryptographic value" docs/ISOMORPHISM_MANIFESTO.md # expect 0 +grep -c "theory/GEOMETRIC_DETERMINISM.md" docs/ISOMORPHISM_MANIFESTO.md # expect 1 +``` +Expected: overclaim gone; theory linked. + +- [ ] **Step 3: Commit** + +```bash +git add docs/ISOMORPHISM_MANIFESTO.md +git commit -m "docs(isoz): fix manifesto crypto overclaim; link the honest theory" +``` + +--- + +## Task 5: Rebrand the brand-identity doc + +**Files:** Modify `assets/brand/BRAND_IDENTITY.md` (title + false-capability lines) + +- [ ] **Step 1: Rebrand the title and demote false-capability claims** + +- Line 1 `# Surface & Structure UI | RotarySlider Matrix` → `# IsoZ — Brand Identity`. +- Line 5: replace the sentence containing `"quantum gates, and infinite recursive loops bound by AAA industrial parameters"` so the paragraph reads: `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).` +- Line 21 (`Concept 2` meaning): change `A nod to the Quantum-Resistant Cryptography gate and the Akashic Evolutionary Memory.` → `A nod to the weak-crypto denylist lint and the failure cache.` Leave the visual descriptions (lattice, glowing node) as design language; only the false-capability nouns change. + +- [ ] **Step 2: Verify** + +```bash +grep -ci "Quantum-Resistant\|RotarySlider Matrix\|Surface & Structure" assets/brand/BRAND_IDENTITY.md # expect 0 +grep -c "IsoZ" assets/brand/BRAND_IDENTITY.md # expect >=1 +``` +Expected: false-capability + old identity gone; IsoZ present. + +- [ ] **Step 3: Commit** + +```bash +git add assets/brand/BRAND_IDENTITY.md +git commit -m "docs(isoz): rebrand brand-identity doc to IsoZ; demote false-capability nouns" +``` + +--- + +## Task 6: Repo rename — GATED human admin step + +> **Do NOT run this until: (a) the human partner gives explicit go, AND (b) no other PRs are open/mid-flight** (renaming mid-PR can disrupt refs). This is the one outward-facing, semi-irreversible action in Cycle 1. GitHub auto-redirects old clone/Pages URLs, but external bookmarks may need updating. + +- [ ] **Step 1: Confirm preconditions** + +```bash +gh pr list -R ZuluYokohama/RotarySlider --state open # expect: no open PRs (the IsoZ PR itself merged first, OR rename after merge) +``` +Recommended sequence: merge the Cycle-1 docs PR FIRST, then rename, to avoid renaming with this PR open. + +- [ ] **Step 2: Rename the repo (after explicit human OK)** + +```bash +gh repo rename IsoZ -R ZuluYokohama/RotarySlider --yes +``` +Expected: repo is now `ZuluYokohama/IsoZ`; GitHub creates redirects from the old name. + +- [ ] **Step 3: Update the local remote in the main worktree** + +```bash +git -C /c/Users/Deving-1/RotarySlider remote set-url origin https://github.com/ZuluYokohama/IsoZ.git +git -C /c/Users/Deving-1/RotarySlider remote -v # confirm origin -> .../IsoZ.git +``` + +- [ ] **Step 4: Verify Pages still serves** + +```bash +gh api repos/ZuluYokohama/IsoZ/pages --jq '{url,status}' # expect status "built"; url is github.io/IsoZ (redirect from /RotarySlider) +``` +Expected: Pages still built (URL moves to `/IsoZ`; old URL redirects). The website *content* rebrand is Cycle 3. + +--- + +## PR & Review Ritual (Tasks 1–5 ship as one PR; Task 6 is post-merge admin) + +1. Self-review via `superpowers:requesting-code-review`. +2. Fill `.github/PULL_REQUEST_TEMPLATE.md` completely (model/harness/plugins disclosure; problem = fragmented identity + overclaims; core-appropriate = No, fork rebrand; existing-PR search). +3. Show the human partner the complete diff; get explicit approval. +4. Open PR against `master`; wait for CodeRabbit; triage via `superpowers:receiving-code-review` (verify before applying; push back on false findings with evidence). +5. Merge once CodeRabbit is satisfied. +6. THEN perform Task 6 (gated rename) with explicit human go. + +--- + +## Definition of Done + +- README rewritten: IsoZ H1, honest "what it is", thesis + theory links with vision/seed split, two-layer credit (upstream credited), Feature Studio run instructions, honest gate descriptions, Bandit correctly labeled. +- CLI banner/strings, plugin manifest description+name, manifesto crypto line, and brand-doc title/claims all say IsoZ and drop false-capability terms; no code symbols/module names changed. +- All verification greps pass; `cli.py` parses; `plugin.json` is valid JSON. +- PR merged to `master`; repo renamed to IsoZ (gated) with redirects verified. +- Every IsoZ assertion traces to a realized activity:state (spec §0); vision-tier labeled roadmap. + +--- + +## Self-Review + +**1. Spec coverage:** §1 goal → all tasks; §2 identity model (IsoZ brand, repo rename, dial/Alpha-Rig marks) → Task 1 (marks line) + Task 6 (rename); §3 vocabulary demotions (Cycle-1 docs layer) → Tasks 1–5 (Quantum-Resistant dropped, Akashic→failure cache, Bandit→security linter, MaxVal→value, Infinite-Recursive→[DEMO]); §4 README structure → Task 1 (H1, what-it-is, thesis, two-layer credit, studio docs, honest gates); §5 theory docs → already committed, linked in Task 1/4; §6 scope (no code symbols/website) → enforced (Tasks 2/3 strings-only, command names untouched); §0 invariant (trace to activity:state, vision labeled roadmap) → README thesis section + DoD. All spec sections map to a task. ✅ + +**2. Placeholder scan:** No TBD/TODO; the full new README content is inline; every edit gives exact old→new strings and a verification command. ✅ + +**3. Consistency:** "IsoZ" used as the brand uniformly; demotion targets identical across tasks and the spec §3 table (Quantum-Resistant→dropped, Akashic→failure cache, Bandit→security linter, MaxVal→value, Matrix/Infinite→[DEMO]/honest); command/symbol identifiers explicitly deferred to Cycle 2 in both Task 3 and the DoD. ✅ From 9e1fd52e805cda2356c9075c62446044e8e727dd Mon Sep 17 00:00:00 2001 From: ZuluYokohama Date: Sat, 6 Jun 2026 12:02:17 -0500 Subject: [PATCH 4/6] docs(isoz): rebrand identity to IsoZ + demote overclaims (Cycle 1) - README rewritten around the intent=code=value thesis; honest 'what it is', two-layer credit (Superpowers/autoresearch credited), Feature Studio run instructions, honest gate descriptions, links docs/theory with vision/seed split - CLI banner/strings, plugin manifest name+description, manifesto, brand doc: unify to IsoZ; drop Quantum-Resistant/cryptographic/Infinite-Recursive-swarm/ MaxVal false-capability terms (manifesto swarm line corrected to [DEMO] reality) - strings/docs only; no code symbols/module names (Cycle 2), no website (Cycle 3) --- .claude-plugin/plugin.json | 8 +- README.md | 284 +++++---------------------------- assets/brand/BRAND_IDENTITY.md | 10 +- docs/ISOMORPHISM_MANIFESTO.md | 14 +- scripts/cli.py | 6 +- 5 files changed, 57 insertions(+), 265 deletions(-) diff --git a/.claude-plugin/plugin.json b/.claude-plugin/plugin.json index 4ce6d25..707d554 100644 --- a/.claude-plugin/plugin.json +++ b/.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}" } ], diff --git a/README.md b/README.md index 9b89c89..c3637b0 100644 --- a/README.md +++ b/README.md @@ -1,268 +1,60 @@ -# Autoresearch Superpowers +# IsoZ -Autoresearch Superpowers is a complete software development methodology for your coding agents, built on top of a set of composable skills and some initial instructions that make sure your agent uses them. It merges the capabilities of Andrej Karpathy's `autoresearch` project and Jesse Vincent's `superpowers` framework into a single, cohesive research and development environment. +**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)**. -## Quickstart +> The rotary dial is IsoZ's mark; the Alpha Rig is its mascot. (IsoZ ships from a repository historically named *RotarySlider*.) -Give your agent Superpowers: [Claude Code](#claude-code), [Codex CLI](#codex-cli), [Codex App](#codex-app), [Factory Droid](#factory-droid), [Gemini CLI](#gemini-cli), [OpenCode](#opencode), [Cursor](#cursor), [GitHub Copilot CLI](#github-copilot-cli). +## The thesis: intent ≡ code ≡ value -## How it works +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: -It starts from the moment you fire up your coding agent. As soon as it sees that you're building something, it *doesn't* just jump into trying to write code. Instead, it steps back and asks you what you're really trying to do. +- [`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. -Once it's teased a spec out of the conversation, it shows it to you in chunks short enough to actually read and digest. +**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 187-line deterministic gate that scores intent/context/value overlap; that is the real, shipped state. -After you've signed off on the design, your agent puts together an implementation plan that's clear enough for an enthusiastic junior engineer with poor taste, no judgement, no project context, and an aversion to testing to follow. It emphasizes true red/green TDD, YAGNI (You Aren't Gonna Need It), and DRY. +## What's IsoZ-original vs inherited -Next up, once you say "go", it launches a *subagent-driven-development* process, having agents work through each engineering task, inspecting and reviewing their work, and continuing forward. It's not uncommon for Claude to be able to work autonomously for a couple hours at a time without deviating from the plan you put together. +**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. -There's a bunch more to it, but that's the core of the system. And because the skills trigger automatically, you don't need to do anything special. Your coding agent just has Superpowers. +**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 -## Sponsorship - -If Superpowers has helped you do stuff that makes money and you are so inclined, I'd greatly appreciate it if you'd consider [sponsoring my opensource work](https://github.com/sponsors/obra). - -Thanks! - -- Jesse - - -## Installation - -Installation differs by harness. If you use more than one, install Superpowers separately for each one. - -### Claude Code - -Superpowers is available via the [official Claude plugin marketplace](https://claude.com/plugins/superpowers) - -#### Official Marketplace - -- Install the plugin from Anthropic's official marketplace: - - ```bash - /plugin install superpowers@claude-plugins-official - ``` - -#### Superpowers Marketplace - -The Superpowers marketplace provides Superpowers and some other related plugins for Claude Code. - -- Register the marketplace: - - ```bash - /plugin marketplace add obra/superpowers-marketplace - ``` - -- Install the plugin from this marketplace: - - ```bash - /plugin install superpowers@superpowers-marketplace - ``` - -### Codex CLI - -Superpowers is available via the [official Codex plugin marketplace](https://github.com/openai/plugins). - -- Open the plugin search interface: - - ```bash - /plugins - ``` - -- Search for Superpowers: - - ```bash - superpowers - ``` - -- Select `Install Plugin`. - -### Codex App - -Superpowers is available via the [official Codex plugin marketplace](https://github.com/openai/plugins). - -- In the Codex app, click on Plugins in the sidebar. -- You should see `Superpowers` in the Coding section. -- Click the `+` next to Superpowers and follow the prompts. - -### Factory Droid - -- Register the marketplace: - - ```bash - droid plugin marketplace add https://github.com/obra/superpowers - ``` - -- Install the plugin: - - ```bash - droid plugin install superpowers@superpowers - ``` - -### Gemini CLI - -- Install the extension: - - ```bash - gemini extensions install https://github.com/obra/superpowers - ``` - -- Update later: - - ```bash - gemini extensions update superpowers - ``` - -### OpenCode - -OpenCode uses its own plugin install; install Superpowers separately even if you -already use it in another harness. - -- Tell OpenCode: - - ``` - Fetch and follow instructions from https://raw.githubusercontent.com/obra/superpowers/refs/heads/main/.opencode/INSTALL.md - ``` - -- Detailed docs: [docs/README.opencode.md](docs/README.opencode.md) - -### Cursor - -- In Cursor Agent chat, install from marketplace: - - ```text - /add-plugin superpowers - ``` - -- Or search for "superpowers" in the plugin marketplace. - -### GitHub Copilot CLI - -- Register the marketplace: - - ```bash - copilot plugin marketplace add obra/superpowers-marketplace - ``` - -- Install the plugin: - - ```bash - copilot plugin install superpowers@superpowers-marketplace - ``` - -## The Basic Workflow - -1. **brainstorming** - Activates before writing code. Refines rough ideas through questions, explores alternatives, presents design in sections for validation. Saves design document. - -2. **using-git-worktrees** - Activates after design approval. Creates isolated workspace on new branch, runs project setup, verifies clean test baseline. - -3. **writing-plans** - Activates with approved design. Breaks work into bite-sized tasks (2-5 minutes each). Every task has exact file paths, complete code, verification steps. - -4. **subagent-driven-development** or **executing-plans** - Activates with plan. Dispatches fresh subagent per task with two-stage review (spec compliance, then code quality), or executes in batches with human checkpoints. - -5. **test-driven-development** - Activates during implementation. Enforces RED-GREEN-REFACTOR: write failing test, watch it fail, write minimal code, watch it pass, commit. Deletes code written before tests. - -6. **requesting-code-review** - Activates between tasks. Reviews against plan, reports issues by severity. Critical issues block progress. - -7. **finishing-a-development-branch** - Activates when tasks complete. Verifies tests, presents options (merge/PR/keep/discard), cleans up worktree. - -**The agent checks for relevant skills before any task.** Mandatory workflows, not suggestions. - -## What's Inside - -### Skills Library - -**Testing** -- **test-driven-development** - RED-GREEN-REFACTOR cycle (includes testing anti-patterns reference) - -**Debugging** -- **systematic-debugging** - 4-phase root cause process (includes root-cause-tracing, defense-in-depth, condition-based-waiting techniques) -- **verification-before-completion** - Ensure it's actually fixed - -**Collaboration** -- **brainstorming** - Socratic design refinement -- **writing-plans** - Detailed implementation plans -- **executing-plans** - Batch execution with checkpoints -- **dispatching-parallel-agents** - Concurrent subagent workflows -- **requesting-code-review** - Pre-review checklist -- **receiving-code-review** - Responding to feedback -- **using-git-worktrees** - Parallel development branches -- **finishing-a-development-branch** - Merge/PR decision workflow -- **subagent-driven-development** - Fast iteration with two-stage review (spec compliance, then code quality) - -**Meta** -- **writing-skills** - Create new skills following best practices (includes testing methodology) -- **using-superpowers** - Introduction to the skills system - -## Philosophy - -- **Test-Driven Development** - Write tests first, always -- **Systematic over ad-hoc** - Process over guessing -- **Complexity reduction** - Simplicity as primary goal -- **Evidence over claims** - Verify before declaring success - -Read [the original release announcement](https://blog.fsck.com/2025/10/09/superpowers/). - -## Contributing - -The general contribution process for Superpowers is below. Keep in mind that we don't generally accept contributions of new skills and that any updates to skills must work across all of the coding agents we support. - -1. Fork the repository -2. Switch to the 'dev' branch -3. Create a branch for your work -4. Follow the `writing-skills` skill for creating and testing new and modified skills -5. Submit a PR, being sure to fill in the pull request template. - -See `skills/writing-skills/SKILL.md` for the complete guide. - -## Updating - -Superpowers updates are somewhat coding-agent dependent, but are often automatic. - -## License - -MIT License - see LICENSE file for details - -## Community +```bash +# 1. Backend (FastAPI) — serves /status, /intent, /gallery, /telemetry +python scripts/api_server.py # http://localhost:8000 -Superpowers is built by [Jesse Vincent](https://blog.fsck.com) and the rest of the folks at [Prime Radiant](https://primeradiant.com). +# 2. Telemetry panel (SvelteKit) +cd ui/telemetry && npm install && npm run dev # http://localhost:3001 -- **Discord**: [Join us](https://discord.gg/35wsABTejz) for community support, questions, and sharing what you're building with Superpowers -- **Issues**: https://github.com/obra/superpowers/issues -- **Release announcements**: [Sign up](https://primeradiant.com/superpowers/) to get notified about new versions +# 3. Studio (Next.js + R3F) +cd ui/studio && npm install && npm run dev # http://localhost:3000 +``` -## The 1:1 Isomorphism -RotarySlider is built on the philosophical and architectural doctrine of **1:1 Isomorphism** between `Intent`, `Code Ops`, and `Value Gen`. Read the [Isomorphism Manifesto](docs/ISOMORPHISM_MANIFESTO.md) to understand the Truth in Intent. +Prerequisites: Node 18+, Python 3.11+, and (for the gates) `pip install rich fastapi uvicorn flake8 bandit radon`. -## Evolution Matrix & CLI +## The gates (honest descriptions) -This framework contains an infinite recursive evolution loop designed to test, validate, and optimize code autonomously. +- **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 Usage -To interact with the framework, use the included Makefile or Python CLI: -```bash -make help -make evolve TARGET=/path/to/project -``` +## CLI -### FastMCP Server -The framework natively supports the Model Context Protocol (MCP). To allow your local agents (like Claude Desktop or Cursor) to execute the Evolution Gate autonomously: ```bash -python scripts/mcp_server.py +python scripts/cli.py intent --name "Feature" --metric "O(1)" # inject an intent vector +python scripts/cli.py status # show the feature map +python scripts/cli.py evolve # run the [DEMO] evolution loop ``` -### Google Project IDX -This repository is pre-configured for **Google Project IDX**. Simply import the GitHub repository, and the `.idx/dev.nix` file will automatically provision your Nix environment, Python dependencies (`rich`, `mcp`), and boot the CLI. - -### Hardware Piping & Resource Management -The matrix is bounded by a `HardwarePipingManager` which protects your OS from Out-Of-Memory (OOM) errors and CPU throttling. It features: -- **VRAM Time-Slicing**: Safe CUDA cache flushing during hypothesis benchmarking. -- **CPU Leasing**: Restricts parallel swarm subprocesses to available physical cores. -- **Aggressive GC**: Forces Python garbage collection at the end of every epoch. +## License -### The AST Oracle -You do not have to manually inject intents. RotarySlider includes a static analyzer that reads the Abstract Syntax Tree (AST) of your codebase, detects O(N^2) loops and naked recursion, and autonomously pipes them into the matrix for optimization: -```bash -make oracle TARGET=/path/to/project -``` +See [LICENSE](LICENSE). The inherited Superpowers and autoresearch layers retain their original authors' licenses and credit. diff --git a/assets/brand/BRAND_IDENTITY.md b/assets/brand/BRAND_IDENTITY.md index d40ebaa..55c1d58 100644 --- a/assets/brand/BRAND_IDENTITY.md +++ b/assets/brand/BRAND_IDENTITY.md @@ -1,8 +1,8 @@ -# 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). --- @@ -13,12 +13,12 @@ The brand identity for **Surface & Structure UI** and the **RotarySlider Matrix* - 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. diff --git a/docs/ISOMORPHISM_MANIFESTO.md b/docs/ISOMORPHISM_MANIFESTO.md index e7740d7..a37b77d 100644 --- a/docs/ISOMORPHISM_MANIFESTO.md +++ b/docs/ISOMORPHISM_MANIFESTO.md @@ -1,26 +1,26 @@ # 1:1 Isomorphism: Truth in Intent -## The Doctrine of the RotarySlider Matrix +## The Doctrine of IsoZ 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). -**RotarySlider eliminates this drift.** The architecture is built on a strict **1:1 Isomorphism**. +**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. +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 (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. +### 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. **The Intent IS the Code. The Code IS the Value.** diff --git a/scripts/cli.py b/scripts/cli.py index 37d646a..f045075 100755 --- a/scripts/cli.py +++ b/scripts/cli.py @@ -1,6 +1,6 @@ #!/usr/bin/env python3 """ -Autoresearch Superpowers CLI with Rich TUI +IsoZ CLI with Rich TUI Command-line interface for managing maxval vectors, evolution gates, and swarm recursion. """ @@ -34,7 +34,7 @@ def cmd_evolve(args): TextColumn("[progress.description]{task.description}"), transient=True, ) as progress: - progress.add_task(description=f"Booting Infinite Recursive Matrix for {target}...", total=None) + progress.add_task(description=f"[DEMO] Booting the IsoZ evolution loop for {target}...", total=None) # Execute the recursive script, streaming output subprocess.run([sys.executable, script, target]) @@ -103,7 +103,7 @@ def cmd_status(args): console.print(table) def main(): - parser = argparse.ArgumentParser(description="Autoresearch Superpowers - Swarm CLI") + parser = argparse.ArgumentParser(description="IsoZ - Feature Studio & Gate CLI") subparsers = parser.add_subparsers(dest="command", required=True) # evolve From 9e0b6c04d26334537a4fc400651351b2869a6a28 Mon Sep 17 00:00:00 2001 From: ZuluYokohama Date: Sat, 6 Jun 2026 15:26:21 -0500 Subject: [PATCH 5/6] docs(isoz): address CodeRabbit review on #25 (thesis equation, CLI honesty, doc lint) - spec: fix thesis-equation drift `intent =\xC2\xA0context =\xC2\xA0value` -> `intent = code = value` (CodeRabbit Major; canonical form used everywhere else in the doc set). - cli.py: demote remaining overclaim strings (module docstring, status table title, evolve --help) to honest IsoZ/[DEMO] framing. STRINGS ONLY; no code symbols renamed (those stay Cycle 2). - BRAND_IDENTITY / ISOMORPHISM_MANIFESTO: fix MD022 heading-spacing (blank lines). - plan: replace machine-specific absolute paths with repo-relative commands. CodeRabbit finding on markdownlint fences in the internal plan doc is intentionally skipped (non-gating linter, internal process artifact) - explained in PR reply. Co-Authored-By: Claude Opus 4.8 (1M context) --- assets/brand/BRAND_IDENTITY.md | 7 +++++++ docs/ISOMORPHISM_MANIFESTO.md | 10 ++++++++-- docs/superpowers/plans/2026-06-06-isoz-identity.md | 7 ++++--- .../specs/2026-06-06-isoz-identity-design.md | 2 +- scripts/cli.py | 6 +++--- 5 files changed, 23 insertions(+), 9 deletions(-) diff --git a/assets/brand/BRAND_IDENTITY.md b/assets/brand/BRAND_IDENTITY.md index 55c1d58..c597d97 100644 --- a/assets/brand/BRAND_IDENTITY.md +++ b/assets/brand/BRAND_IDENTITY.md @@ -1,12 +1,15 @@ # IsoZ — Brand Identity + ## Brand Identity & Logo Concepts (jtechAi Labs) ### The Abstraction: Energy Tech Conceptual + 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) @@ -14,6 +17,7 @@ The brand identity for **IsoZ** is rooted in the abstraction of raw, algorithmic - **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 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` @@ -21,11 +25,13 @@ The brand identity for **IsoZ** is rooted in the abstraction of raw, algorithmic - **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. @@ -33,6 +39,7 @@ The brand identity for **IsoZ** is rooted in the abstraction of raw, algorithmic --- ### 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. diff --git a/docs/ISOMORPHISM_MANIFESTO.md b/docs/ISOMORPHISM_MANIFESTO.md index a37b77d..b552646 100644 --- a/docs/ISOMORPHISM_MANIFESTO.md +++ b/docs/ISOMORPHISM_MANIFESTO.md @@ -1,26 +1,32 @@ # 1:1 Isomorphism: Truth in Intent ## The Doctrine of IsoZ -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). + +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`). In IsoZ, the `feature_map.json` and the AST oracle serve as the Truth in Intent. ### 2. Code Ops (The Execution Mesh) + 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 (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.** diff --git a/docs/superpowers/plans/2026-06-06-isoz-identity.md b/docs/superpowers/plans/2026-06-06-isoz-identity.md index 56258b0..ccedc0d 100644 --- a/docs/superpowers/plans/2026-06-06-isoz-identity.md +++ b/docs/superpowers/plans/2026-06-06-isoz-identity.md @@ -94,7 +94,7 @@ See [LICENSE](LICENSE). The inherited Superpowers and autoresearch layers retain Run each; confirm the expected result: ```bash -cd /c/Users/Deving-1/rs-isoz +cd "$(git rev-parse --show-toplevel)" grep -c "^# IsoZ" README.md # expect 1 (H1 is IsoZ) grep -ci "Quantum-Resistant" README.md # expect 0 grep -ci "Infinite Recursive LLM Swarm" README.md # expect 0 @@ -254,8 +254,9 @@ Expected: repo is now `ZuluYokohama/IsoZ`; GitHub creates redirects from the old - [ ] **Step 3: Update the local remote in the main worktree** ```bash -git -C /c/Users/Deving-1/RotarySlider remote set-url origin https://github.com/ZuluYokohama/IsoZ.git -git -C /c/Users/Deving-1/RotarySlider remote -v # confirm origin -> .../IsoZ.git +# Run from inside the main RotarySlider/IsoZ checkout (the released worktree, not this PR's worktree): +git remote set-url origin https://github.com/ZuluYokohama/IsoZ.git +git remote -v # confirm origin -> .../IsoZ.git ``` - [ ] **Step 4: Verify Pages still serves** diff --git a/docs/superpowers/specs/2026-06-06-isoz-identity-design.md b/docs/superpowers/specs/2026-06-06-isoz-identity-design.md index 4c33bb8..3380740 100644 --- a/docs/superpowers/specs/2026-06-06-isoz-identity-design.md +++ b/docs/superpowers/specs/2026-06-06-isoz-identity-design.md @@ -17,7 +17,7 @@ realize; vision-tier content is labeled roadmap, never capability. | Layer | Image of the pattern | Grounded in (activity:state) | |---|---|---| | **Concept** | Geometric Determinism — truth = coherence (sheaf Global Section); value warps the metric; obstruction → halt. | `docs/theory/` (3-deck synthesis + roadmap) | -| **Framework** | IsoZ / `truth_resolver` — a deterministic `intent ≡ context ≡ value` alignment gate with a pluggable Oracle seam. | `scripts/truth_resolver.py` (PR #19, merged) | +| **Framework** | IsoZ / `truth_resolver` — a deterministic `intent ≡ code ≡ value` alignment gate with a pluggable Oracle seam. | `scripts/truth_resolver.py` (PR #19, merged) | | **Process** | The dev method — every claim verified against ground truth before assertion; CodeRabbit-gated; false findings refuted with evidence; `[DEMO]` / vision-vs-seed labeling. | PRs #17–#24 (spec→TDD→two-stage review→PR→CodeRabbit→merge) | | **Pattern** | worktree → spec → plan → TDD → review → PR → adversarial gate → merge. | Every merge this effort produced | diff --git a/scripts/cli.py b/scripts/cli.py index f045075..a64e8e4 100755 --- a/scripts/cli.py +++ b/scripts/cli.py @@ -1,7 +1,7 @@ #!/usr/bin/env python3 """ IsoZ CLI with Rich TUI -Command-line interface for managing maxval vectors, evolution gates, and swarm recursion. +Command-line interface for IsoZ intent vectors, evolution gates, and the [DEMO] evolution loop. """ import argparse @@ -87,7 +87,7 @@ def cmd_status(args): with open(map_path, 'r') as f: data = json.load(f) - table = Table(title=f"MaxVal Intent Vectors ({os.path.basename(target)})", show_header=True, header_style="bold magenta") + table = Table(title=f"Intent Vectors ({os.path.basename(target)})", show_header=True, header_style="bold magenta") table.add_column("Status") table.add_column("Feature") table.add_column("Intent Metric") @@ -107,7 +107,7 @@ def main(): subparsers = parser.add_subparsers(dest="command", required=True) # evolve - p_evolve = subparsers.add_parser('evolve', help="Boot the infinite recursive evolution matrix") + p_evolve = subparsers.add_parser('evolve', help="Run the [DEMO] evolution loop") p_evolve.add_argument('target', help="Target project directory") p_evolve.set_defaults(func=cmd_evolve) From db2ec33cd63a23caafff2735713cbec885955b81 Mon Sep 17 00:00:00 2001 From: ZuluYokohama Date: Sat, 6 Jun 2026 15:53:45 -0500 Subject: [PATCH 6/6] docs(isoz): drop hardcoded LOC from README truth_resolver claim CodeRabbit (re-review): "187-line" will drift stale -> capability wording. Aligns with the README's own anti-overclaim stance (an exact count is a claim that decays into a falsehood over time). Co-Authored-By: Claude Opus 4.8 (1M context) --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 49b443d..972149c 100644 --- a/README.md +++ b/README.md @@ -13,7 +13,7 @@ IsoZ is the honest, minimal, **running** seed of a larger theory — *Geometric - [`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 187-line deterministic gate that scores intent/context/value overlap; that is the real, shipped state. +**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