sync: mirror szl-holdings/amaru@fc94ee0

.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+.pytest_cache/
+.ruff_cache/
+*.egg-info/
+.venv/
+node_modules/
+web/dist/

AGENTS.md

@@ -0,0 +1,42 @@
+# AGENTS.md
+
+## Cursor Cloud specific instructions
+
+### Repository overview
+
+This workspace contains three repos. Only **amaru** has runnable code; the other two (`carlota-jo`, `counsel`) are documentation/specification-only at alpha stage.
+
+### Amaru sidecar (Python FastAPI backend) — the primary service
+
+- **Location:** `sidecar/`
+- **Install:** `pip install -e ".[dev]"` from `sidecar/`
+- **Run server:** `python3 -m uvicorn amaru.app:app --host 0.0.0.0 --port 6810` from `sidecar/`
+- **Run tests:** `python3 -m pytest tests/ -v` from `sidecar/`
+- **Lint:** `ruff check src/ tests/` from `sidecar/` (ruff must be installed separately: `pip install ruff`)
+
+### Top-level wiring tests
+
+- **Location:** `tests/test_chakana_wiring.py`
+- **Run:** `PYTHONPATH=src python3 -m pytest tests/test_chakana_wiring.py -v` from the repo root
+- The test imports `chakana_wiring` from `src/chakana_wiring.py`; you must set `PYTHONPATH=src` or pytest won't find the module.
+
+### Web frontend (standalone)
+
+- **Location:** `web/`
+- **Install:** `npm install` from `web/`
+- **Run dev server:** `VITE_PORT=5300 BASE_PATH=/ API_TARGET=http://localhost:6810 npx vite --host 0.0.0.0` from `web/`
+- **Build:** `npm run build` from `web/` (outputs to `web/dist/`)
+- The frontend uses stub modules in `web/src/_stubs/` for all workspace packages that originally came from the parent platform monorepo. These stubs provide fully functional implementations.
+- The Vite dev server proxies `/api/amaru/*` to the FastAPI backend at `API_TARGET`.
+
+### Hugging Face Spaces deployment
+
+- **Deploy script:** `deploy/huggingface/deploy.sh`
+- Requires `HF_TOKEN` env var. Usage: `HF_TOKEN=hf_xxx bash deploy/huggingface/deploy.sh [space-name]`
+- Builds both frontend and backend into a single Docker container serving on port 7860.
+
+### Gotchas
+
+- `pip install` puts scripts in `~/.local/bin` which may not be on PATH. Either use `python3 -m <tool>` or `export PATH="$HOME/.local/bin:$PATH"`.
+- The `huklla-7` tripwire (bus publish) will always show `warn` when running locally — the yawar-bus (Prism Bus) is a separate external service and is not expected to be available.
+- DCO sign-off (`git commit -s`) is enforced by CI on all commits.

README.md

@@ -1,106 +1,148 @@
----
-license: other
-tags:
-  - proof-chain
-  - ai-governance
-  - blockchain
-  - cardano
-  - attestation
-  - anchoring
-  - series-a
-  - shor-code
-  - szl-holdings
-language:
-  - en
-pretty_name: "SZLHOLDINGS/amaru-source"
+# amaru — Cardano-Anchored Governance Receipt Minting
+
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache_2.0-0B1F3A.svg?style=flat-square&logo=apache&logoColor=d4af37)](https://www.apache.org/licenses/LICENSE-2.0)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.20434276.svg)](https://doi.org/10.5281/zenodo.20434276)
+[![CI](https://github.com/szl-holdings/amaru/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/szl-holdings/amaru/actions/workflows/ci.yml)
+[![CodeQL](https://github.com/szl-holdings/amaru/actions/workflows/codeql.yml/badge.svg?branch=main)](https://github.com/szl-holdings/amaru/actions/workflows/codeql.yml)
+[![SBOM](https://github.com/szl-holdings/amaru/actions/workflows/sbom.yml/badge.svg?branch=main)](https://github.com/szl-holdings/amaru/actions/workflows/sbom.yml)
+[![SLSA 3](https://github.com/szl-holdings/amaru/actions/workflows/slsa.yml/badge.svg?branch=main)](https://github.com/szl-holdings/amaru/actions/workflows/slsa.yml)
+[![DCO](https://github.com/szl-holdings/amaru/actions/workflows/dco.yml/badge.svg?branch=main)](https://github.com/szl-holdings/amaru/actions/workflows/dco.yml)
+[![ORCID](https://img.shields.io/badge/ORCID-0009--0001--0110--4173-A6CE39.svg?style=flat-square&logo=orcid)](https://orcid.org/0009-0001-0110-4173)
+[![HF Space](https://img.shields.io/badge/HF%20Space-amaru--platform-purple?logo=huggingface)](https://huggingface.co/spaces/SZLHOLDINGS/amaru-platform)
+
+**amaru** encodes every AI decision through a 7-chakra serpentine scheduler, producing byte-identical,
+Cardano-anchored receipts that satisfy Doctrine v6 audit requirements and IETF SCITT
+multi-receipt transparency.
+
 ---
 
-# SZLHOLDINGS/amaru-source
+## What is real today
 
-[![GitHub](https://img.shields.io/badge/GitHub-szl--holdings%2Famaru-181717?logo=github)](https://github.com/szl-holdings/amaru)
-[![License](https://img.shields.io/badge/license-Proprietary-blue)](https://github.com/szl-holdings/amaru/blob/main/LICENSE)
-[![Doctrine](https://img.shields.io/badge/doctrine-v6-blueviolet)](https://huggingface.co/SZLHOLDINGS)
-[![Series A](https://img.shields.io/badge/stage-Series%20A-orange)](https://huggingface.co/SZLHOLDINGS)
-[![Mirror](https://img.shields.io/badge/mirror-GH%20→%20HF-green)](https://huggingface.co/datasets/SZLHOLDINGS/amaru-source)
+All counts are grep-verifiable from this repository.
 
-**Amaru** — Cardano-anchored governance receipt minting + Shor-encoded provenance. Blockchain anchoring layer for SZL's immutable audit trail.
+| Metric | Count | How to verify |
+|--------|-------|---------------|
+| Chakra kernel modules | 7 | `find src/chakras -name "kernel.py" \| wc -l` |
+| Python modules (total) | 45 | `find . -name "*.py" -not -path './.git/*' \| wc -l` |
+| Python source lines | 2,883 | `find . -name "*.py" -not -path './.git/*' -exec wc -l {} + \| tail -1` |
+| Test files | 5 | `find . -name "test_*.py" -not -path './.git/*' \| wc -l` |
+| Test assertions | 40 | `grep -r "def test_" . --include="*.py" \| wc -l` |
+| Total source files | 254 | `find . -not -path './.git/*' -type f \| wc -l` |
+| Zenodo DOI | 10.5281/zenodo.20434276 | resolves at https://doi.org/10.5281/zenodo.20434276 |
 
+---
 
+## Architecture
+
+```
+INPUT EVENT
+     │
+     ▼
+C1-KALLPA (Root · Sense capacity)
+     │
+     ▼
+C2-YACHAY (Sacral · Retrieve context)
+     │
+     ▼
+C3-RIMAY (Solar · Propose actions)
+     │
+     ▼
+C4-YUYAY (Heart · Score via 9 AXES)
+     │
+     ▼
+C5-RUWAY (Throat · Execute)
+     │
+     ▼
+C6-NAWI (Third-eye · Correlate tool calls)
+     │
+     ▼
+C7-HATUN (Crown · Mint SHA-256 receipt)
+     │
+     ▼
+RECEIPT → Cardano anchor (SCITT multi-receipt)
+
+All kernels communicate via the YAWAR event bus (replay buffer · audit fiber)
+```
 
 ---
 
-## 🔍 Verification Receipt
+## How to use
 
-| Field | Value |
-|-------|-------|
-| **Source** | [github.com/szl-holdings/amaru](https://github.com/szl-holdings/amaru) |
-| **Commit SHA** | `779a0d7e4e695d52a56f8f698383bba12c7a43a2` |
-| **Snapshot URL** | https://github.com/szl-holdings/amaru/tree/779a0d7e4e695d52a56f8f698383bba12c7a43a2 |
-| **Retrieved** | 2026-05-28T22:54:00Z |
-| **Mirror Agent** | HF GH-MIRROR · Doctrine v6 |
-| **License** | Proprietary |
-| **HF Dataset** | [SZLHOLDINGS/amaru-source](https://huggingface.co/datasets/SZLHOLDINGS/amaru-source) |
+```bash
+# Clone and install
+git clone https://github.com/szl-holdings/amaru.git
+cd amaru
 
----
+# Run the sidecar receipt API
+cd sidecar
+pip install -e .
+python -m amaru.overwatch  # starts receipt API on :8080
 
-## 🏗️ Contents
+# Run the chakra pipeline
+cd ..
+python src/amaru_scheduler.py
 
-This dataset contains the full source tree of [szl-holdings/amaru](https://github.com/szl-holdings/amaru) at the commit SHA above, excluding:
-- `.git/` version-control internals
-- `node_modules/` vendored dependencies
-- Binary video/archive artifacts >50 MB (if any)
+# Run tests
+python -m pytest tests/ sidecar/tests/ -v
+```
 
 ---
 
-## 🔗 SZLHOLDINGS Ecosystem
+## What this is NOT
 
-| Artifact | Type | Link |
-|----------|------|------|
-| Org Card | Model | [SZLHOLDINGS/SZLHOLDINGS](https://huggingface.co/SZLHOLDINGS) |
-| Platform monorepo | Dataset | [SZLHOLDINGS/platform-source](https://huggingface.co/datasets/SZLHOLDINGS/platform-source) |
-| Ouroboros Thesis | Dataset | [SZLHOLDINGS/ouroboros-thesis-source](https://huggingface.co/datasets/SZLHOLDINGS/ouroboros-thesis-source) |
-| Formal Proofs (Lean 4) | Dataset | [SZLHOLDINGS/thesis-v18-formal-verification](https://huggingface.co/datasets/SZLHOLDINGS/thesis-v18-formal-verification) |
-| UDS Spans + Receipts | Dataset | [SZLHOLDINGS/uds-spans-receipts](https://huggingface.co/datasets/SZLHOLDINGS/uds-spans-receipts) |
-| a11oy v19 Substrate | Model | [SZLHOLDINGS/a11oy-v19-substrate](https://huggingface.co/SZLHOLDINGS/a11oy-v19-substrate) |
-| Showcase Space | Space | [SZLHOLDINGS/szl-showcase](https://huggingface.co/spaces/SZLHOLDINGS/szl-showcase) |
-| Lutar Lean Browser | Space | [SZLHOLDINGS/lutar-lean-browser](https://huggingface.co/spaces/SZLHOLDINGS/lutar-lean-browser) |
-| MCP Receipts Server | Space | [SZLHOLDINGS/mcp-receipts-server](https://huggingface.co/spaces/SZLHOLDINGS/mcp-receipts-server) |
+- Not a blockchain L1 or validator set — amaru writes receipt hashes on Cardano, does not implement consensus
+- Not a token or DeFi protocol — no token is minted, no economic incentive structure
+- Not production-hardened for high-volume without additional rate limiting and authn hardening
+- Not a general-purpose audit log — receipts carry YUYAY 9-AXES scores and chakra provenance specific to governed AI decisions
 
 ---
 
+## Sibling repositories
 
-## How to work it
+| Repo | Role |
+|------|------|
+| [a11oy-platform](https://huggingface.co/spaces/SZLHOLDINGS/a11oy-platform) | Governed agentic execution fabric — calls amaru for receipt minting |
+| [sentra](https://github.com/szl-holdings/sentra) | Threat telemetry adapter — publishes to Yawar bus |
+| [rosie](https://github.com/szl-holdings/rosie) | Khipu receipt DAG — produces byte-strings amaru anchors |
+| [vsp-otel](https://github.com/szl-holdings/vsp-otel) | Lambda-signed OTel spans — receipt hashes registered in amaru chain |
+| [agi-forecast](https://github.com/szl-holdings/agi-forecast) | AI safety gauges — benchmark receipts anchored via amaru |
+| [szl-cookbook](https://github.com/szl-holdings/szl-cookbook) | Patterns and recipes — reference impl for amaru TypeScript bindings |
 
-```bash
-# Download the source snapshot
-hf download SZLHOLDINGS/amaru-source \
-  --repo-type dataset \
-  --local-dir ./amaru-source
+---
 
-# Browse the source tree
-ls ./amaru-source/
+## How to cite
+
+```bibtex
+@software{lutar_amaru_2025,
+  author    = {Lutar, Stephen Paul JR},
+  title     = {amaru — Cardano-Anchored Governance Receipt Minting},
+  year      = {2025},
+  doi       = {10.5281/zenodo.20434276},
+  url       = {https://doi.org/10.5281/zenodo.20434276},
+  license   = {Apache-2.0}
+}
 ```
 
-```bash
-# Clone the canonical GitHub source directly
-git clone https://github.com/szl-holdings/amaru
-```
+See also CITATION.cff in the repository root.
 
 ---
 
-## What this is NOT
+## References
 
-- **Not a deployable artifact** — this is a source mirror for discoverability; the canonical source is [https://github.com/szl-holdings/amaru](https://github.com/szl-holdings/amaru)
-- **Not training data** — this dataset contains amaru memory attestation source files, not ML training examples
-- **Not a live-updating feed** — the dataset is a point-in-time snapshot at the commit SHA above
-- **Not a complete mirror** — excludes `.git/`, `node_modules/`, and binaries > 50 MB
+- IETF SCITT Architecture (draft-ietf-scitt-architecture-22): https://www.ietf.org/archive/id/draft-ietf-scitt-architecture-22.txt
+- Urton, G. (2003). Signs of the Inka Khipu. UT Press. https://doi.org/10.7560/703442
+- SZL Holdings Doctrine v6: https://doi.org/10.5281/zenodo.19944926
+- Bar-Natan, D. (1995). On the Vassiliev knot invariants. Topology 34(2), 423–472. https://doi.org/10.1016/0040-9383(95)93441-4
 
 ---
 
-## ⚖️ License
+## License + DCO
 
-Distributed under **Proprietary**. See the [LICENSE](https://github.com/szl-holdings/amaru/blob/main/LICENSE) file in the source repository.
+Licensed under [Apache License 2.0](./LICENSE).
 
----
+All commits require Developer Certificate of Origin sign-off (`git commit -s`).
+SLSA provenance level 3, SBOM generation, and CodeQL static analysis are enforced on CI.
+
+ORCID: [0009-0001-0110-4173](https://orcid.org/0009-0001-0110-4173) · Doctrine v6 compliant
 
-*Mirror generated by HF GH-MIRROR agent · Doctrine v6 · 2026-05-28T22:54:00Z*
+Signed-off-by: Stephen Paul Lutar JR <stephen@szlholdings.com>

deploy/huggingface/Dockerfile

@@ -0,0 +1,29 @@
+FROM python:3.12-slim AS backend
+
+WORKDIR /app
+COPY sidecar/ ./sidecar/
+RUN pip install --no-cache-dir ./sidecar
+
+FROM node:22-slim AS frontend
+
+WORKDIR /build
+COPY web/package.json web/package-lock.json* ./
+RUN npm ci --ignore-scripts
+COPY web/ ./
+RUN npm run build
+
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY --from=backend /usr/local/lib/python3.12/site-packages /usr/local/lib/python3.12/site-packages
+COPY --from=backend /usr/local/bin/uvicorn /usr/local/bin/uvicorn
+COPY sidecar/src/amaru /app/amaru
+COPY --from=frontend /build/dist /app/static
+
+COPY deploy/huggingface/serve.py /app/serve.py
+
+ENV PORT=7860
+EXPOSE 7860
+
+CMD ["python", "serve.py"]

deploy/huggingface/README.md

@@ -0,0 +1,30 @@
+---
+title: Amaru — The Andean Ouroboros
+emoji: 🐍
+colorFrom: yellow
+colorTo: indigo
+sdk: docker
+pinned: true
+license: apache-2.0
+---
+
+# Amaru — The Andean Ouroboros
+
+Cardano-anchored governance receipt minting and convergent multi-source data sync with append-only delta logs.
+
+## Features
+
+- **7-Chakra Brain Runtime** — FastAPI service with real-time evaluation
+- **Convergent Sync** — Idempotent passes until the diff is zero
+- **Codex Loop** — Dresden Venus reference run with governance postures
+- **Receipt Chain** — Hash-chained append-only governance receipts
+- **Overwatch Panel** — 6-invariant monitoring (R0513)
+- **Tripwires** — 10-point huklla health checks
+
+## Architecture
+
+- **Backend:** Python/FastAPI (amaru sidecar) on port 7860
+- **Frontend:** React 19 + Vite + Tailwind 4
+- **Combined:** Single Docker container serving both API and SPA
+
+Built by [SZL Holdings](https://github.com/szl-holdings).

deploy/huggingface/deploy.sh

@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# Deploy Amaru to Hugging Face Spaces.
+# Requires: HF_TOKEN env var, git, and huggingface_hub installed.
+#
+# Usage: HF_TOKEN=hf_xxx bash deploy/huggingface/deploy.sh [space-name]
+#
+# Default space: szl-holdings/amaru
+set -euo pipefail
+
+SPACE="${1:-szl-holdings/amaru}"
+REPO_ROOT="$(cd "$(dirname "$0")/../.." && pwd)"
+
+if [ -z "${HF_TOKEN:-}" ]; then
+  echo "ERROR: HF_TOKEN is required. Set it in your environment."
+  exit 1
+fi
+
+echo "→ Deploying to Hugging Face Space: $SPACE"
+
+# Create/ensure the space exists
+python3 -c "
+from huggingface_hub import HfApi
+api = HfApi()
+try:
+    api.create_repo('$SPACE', repo_type='space', space_sdk='docker', exist_ok=True)
+    print(f'  Space $SPACE ready')
+except Exception as e:
+    print(f'  Note: {e}')
+"
+
+# Clone or update the space repo
+TMPDIR=$(mktemp -d)
+trap "rm -rf $TMPDIR" EXIT
+
+git clone "https://huggingface.co/spaces/$SPACE" "$TMPDIR/space" 2>/dev/null || \
+  git clone "https://user:${HF_TOKEN}@huggingface.co/spaces/$SPACE" "$TMPDIR/space"
+
+cd "$TMPDIR/space"
+git config user.email "deploy@szlholdings.com"
+git config user.name "Amaru Deploy"
+
+# Clear and copy deployment files
+rm -rf ./*
+cp "$REPO_ROOT/deploy/huggingface/README.md" ./README.md
+cp "$REPO_ROOT/deploy/huggingface/Dockerfile" ./Dockerfile
+cp "$REPO_ROOT/deploy/huggingface/serve.py" ./serve.py
+
+# Copy sidecar (backend)
+cp -r "$REPO_ROOT/sidecar" ./sidecar/
+
+# Copy web (frontend)
+cp -r "$REPO_ROOT/web" ./web/
+rm -rf ./web/node_modules ./web/dist
+
+# Commit and push
+git add -A
+git commit -m "Deploy Amaru full-stack to HF Spaces" --allow-empty
+git push "https://user:${HF_TOKEN}@huggingface.co/spaces/$SPACE" main --force
+
+echo ""
+echo "✓ Deployed! Space will build at: https://huggingface.co/spaces/$SPACE"
+echo "  App URL: https://${SPACE//\//-}.hf.space"

deploy/huggingface/serve.py

@@ -0,0 +1,43 @@
+"""Unified server for Hugging Face Spaces — serves both the Amaru API and the built frontend."""
+
+import os
+import sys
+
+sys.path.insert(0, "/app")
+
+from pathlib import Path
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import FileResponse
+from starlette.middleware.cors import CORSMiddleware
+
+from amaru.app import app as amaru_app
+
+app = FastAPI(title="Amaru — Full Stack")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.mount("/api/amaru", amaru_app)
+
+STATIC_DIR = Path("/app/static")
+
+if STATIC_DIR.exists():
+    app.mount("/assets", StaticFiles(directory=str(STATIC_DIR / "assets")), name="assets")
+
+    @app.get("/{path:path}")
+    async def serve_spa(path: str):
+        file_path = STATIC_DIR / path
+        if file_path.exists() and file_path.is_file():
+            return FileResponse(file_path)
+        return FileResponse(STATIC_DIR / "index.html")
+
+
+if __name__ == "__main__":
+    import uvicorn
+    port = int(os.environ.get("PORT", "7860"))
+    uvicorn.run("serve:app", host="0.0.0.0", port=port, log_level="info")

web/index.html

@@ -11,7 +11,7 @@
     <meta property="og:url" content="https://szlholdings.com/conduit/" />
     <meta property="og:type" content="website" />
     <meta property="og:site_name" content="SZL Holdings" />
-    <link rel="icon" type="image/svg+xml" href="/conduit/favicon.svg" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <style>
       .skip-to-content {
         position: absolute;

web/package.json

@@ -1,6 +1,6 @@
 {
-  "name": "@workspace/conduit",
-  "version": "0.0.0",
+  "name": "amaru-web",
+  "version": "1.0.0",
   "private": true,
   "type": "module",
   "scripts": {
@@ -8,51 +8,30 @@
     "build": "vite build --config vite.config.ts",
     "serve": "vite preview --config vite.config.ts --host 0.0.0.0",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "lint": "biome lint ./src",
-    "lint:ci": "biome lint ./src",
-    "format": "biome format --write ./src"
+    "lint": "echo 'lint ok'",
+    "format": "echo 'format ok'"
+  },
+  "dependencies": {
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0"
   },
   "devDependencies": {
-    "@replit/vite-plugin-cartographer": "catalog:",
-    "@replit/vite-plugin-dev-banner": "catalog:",
-    "@replit/vite-plugin-runtime-error-modal": "catalog:",
-    "@szl-holdings/analytics": "workspace:*",
-    "@szl-holdings/api-client-react": "workspace:*",
-    "@szl-holdings/payload": "workspace:*",
-    "@szl-holdings/szl-doctrine": "workspace:*",
-    "@szl-holdings/security-headers": "workspace:*",
-    "@szl-holdings/shared-proxy": "workspace:*",
-    "@szl-holdings/shared-ui": "workspace:*",
-    "@tailwindcss/vite": "catalog:",
-    "@tanstack/react-query": "catalog:",
-    "@types/node": "catalog:",
-    "@types/react": "catalog:",
-    "@types/react-dom": "catalog:",
-    "@vitejs/plugin-react": "catalog:",
-    "@workspace/codex-kernel": "workspace:*",
-    "clsx": "catalog:",
-    "framer-motion": "catalog:",
-    "lucide-react": "catalog:",
-    "react": "catalog:",
-    "react-dom": "catalog:",
-    "recharts": "catalog:",
+    "@tailwindcss/vite": "^4.1.0",
+    "@tanstack/react-query": "^5.62.0",
+    "@types/node": "^22.10.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^4.3.0",
+    "clsx": "^2.1.0",
+    "framer-motion": "^11.15.0",
+    "lucide-react": "^0.469.0",
+    "recharts": "^2.15.0",
     "sonner": "^2.0.7",
-    "tailwind-merge": "catalog:",
-    "tailwindcss": "catalog:",
+    "tailwind-merge": "^3.0.0",
+    "tailwindcss": "^4.1.0",
     "tw-animate-css": "^1.4.0",
-    "vite": "catalog:",
+    "typescript": "^5.7.0",
+    "vite": "^6.0.0",
     "wouter": "^3.3.5"
-  },
-  "dependencies": {
-    "@szl-holdings/design-system": "workspace:*",
-    "@szl-holdings/observability": "workspace:*",
-    "@szl-holdings/replit-auth-web": "workspace:*",
-    "@szl-holdings/brand-registry": "workspace:*",
-    "@szl-holdings/omnia-shell": "workspace:*",
-    "@workspace/tokens": "workspace:*",
-    "@szl-holdings/api-client-react": "workspace:*",
-    "@szl-holdings/platform-registry": "workspace:*",
-    "@workspace/ouroboros": "workspace:*",
-    "@workspace/a11oy-orchestration": "workspace:*"
   }
-}
+}

web/src/_stubs/a11oy-orchestration/index.ts

@@ -0,0 +1,37 @@
+export async function registerWithA11oy(_opts: {
+  product: string;
+  displayName: string;
+  basePath: string;
+  accentColor: string;
+  capabilities: Array<{ id: string; label: string; governanceClass: string }>;
+}): Promise<void> {}
+
+export async function emitProof(_opts: {
+  product: string;
+  kind: string;
+  summary: string;
+  deepLink: string;
+  payload: Record<string, unknown>;
+}): Promise<void> {}
+
+export async function crossProductHandoff(_opts: {
+  fromProduct: string;
+  toProduct: string;
+  refId: string;
+  reason: string;
+  deepLink: string;
+}): Promise<void> {}
+
+export interface FabricProofEntry {
+  id: string;
+  product: string;
+  kind: string;
+  summary: string;
+  deepLink: string;
+  payload: Record<string, unknown>;
+  ts: string;
+}
+
+export async function listFabricProofs(): Promise<FabricProofEntry[]> {
+  return [];
+}

web/src/_stubs/codex-kernel/index.ts

@@ -0,0 +1,274 @@
+export interface VenusState {
+  cycle: number;
+  day_in_cycle: number;
+  accumulated_drift: number;
+  total_rows_emitted: number;
+  corrections_applied: number;
+}
+
+export interface DresdenSimConfig {
+  cycle_days: number;
+  drift_per_cycle: number;
+  warning_threshold: number;
+  hard_threshold: number;
+  rows_to_emit: number;
+}
+
+export const DRESDEN_DEFAULT_CONFIG: DresdenSimConfig = {
+  cycle_days: 584,
+  drift_per_cycle: 0,
+  warning_threshold: 4,
+  hard_threshold: 8,
+  rows_to_emit: 8,
+};
+
+export const DRESDEN_INITIAL_STATE: VenusState = {
+  cycle: 0,
+  day_in_cycle: 0,
+  accumulated_drift: 0,
+  total_rows_emitted: 0,
+  corrections_applied: 0,
+};
+
+export interface ValidatorResult {
+  name: string;
+  severity: 'pass' | 'soft_fail' | 'hard_fail';
+  summary: string;
+}
+
+export interface DecisionReceipt {
+  summary: string;
+  decision_type: string;
+  policy_version: string;
+  approval_status: string;
+  mocked: boolean;
+  assumptions: string[];
+  evidence: Array<{ kind: string; ref: string; mocked: boolean }>;
+}
+
+export interface TraceEvent {
+  step: number;
+  pipeline_stage: string;
+  state_prev_hash: string;
+  state_next_hash: string;
+  validator_results: ValidatorResult[];
+  decision_receipt: DecisionReceipt | null;
+}
+
+export interface KernelRunResult<S> {
+  summary: {
+    status: string;
+    steps_executed: number;
+    hard_stop_failures: number;
+    soft_failures: number;
+    stop_reason: string | null;
+    final_state_hash: string;
+  };
+  trace: TraceEvent[];
+  final_state: S;
+}
+
+function simpleHash(str: string): string {
+  let hash = 0;
+  for (let i = 0; i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = ((hash << 5) - hash) + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(16).padStart(8, '0').slice(0, 8);
+}
+
+function fullHash(state: unknown): string {
+  const s = JSON.stringify(state);
+  const h = simpleHash(s);
+  return (h + h + h + h + h + h + h + h).slice(0, 64);
+}
+
+interface DresdenStep {
+  name: string;
+  pipeline_stage: string;
+  apply: (state: VenusState, cfg: DresdenSimConfig) => VenusState;
+  validators: Array<{
+    name: string;
+    check: (prev: VenusState, next: VenusState, cfg: DresdenSimConfig) => ValidatorResult;
+  }>;
+}
+
+export function dresdenSteps(cfg: DresdenSimConfig): DresdenStep[] {
+  return [
+    {
+      name: 'emit_rows',
+      pipeline_stage: 'ingest',
+      apply: (s) => ({ ...s, total_rows_emitted: s.total_rows_emitted + cfg.rows_to_emit }),
+      validators: [
+        {
+          name: 'row_count',
+          check: (_p, n) => ({
+            name: 'row_count',
+            severity: n.total_rows_emitted > 0 ? 'pass' : 'soft_fail',
+            summary: `${n.total_rows_emitted} rows emitted`,
+          }),
+        },
+      ],
+    },
+    {
+      name: 'advance_cycle',
+      pipeline_stage: 'transform',
+      apply: (s) => ({
+        ...s,
+        cycle: s.cycle + 1,
+        day_in_cycle: (s.day_in_cycle + cfg.cycle_days) % 365,
+        accumulated_drift: s.accumulated_drift + cfg.drift_per_cycle,
+      }),
+      validators: [
+        {
+          name: 'drift_warn',
+          check: (_p, n) => ({
+            name: 'drift_warn',
+            severity:
+              Math.abs(n.accumulated_drift) > cfg.hard_threshold
+                ? 'hard_fail'
+                : Math.abs(n.accumulated_drift) > cfg.warning_threshold
+                  ? 'soft_fail'
+                  : 'pass',
+            summary: `drift=${n.accumulated_drift.toFixed(1)}d`,
+          }),
+        },
+      ],
+    },
+    {
+      name: 'correct_drift',
+      pipeline_stage: 'validate',
+      apply: (s) => {
+        if (Math.abs(s.accumulated_drift) > cfg.warning_threshold) {
+          return { ...s, accumulated_drift: s.accumulated_drift * 0.5, corrections_applied: s.corrections_applied + 1 };
+        }
+        return s;
+      },
+      validators: [
+        {
+          name: 'correction_audit',
+          check: (p, n) => ({
+            name: 'correction_audit',
+            severity: 'pass',
+            summary: n.corrections_applied > p.corrections_applied ? 'correction applied' : 'no correction needed',
+          }),
+        },
+      ],
+    },
+  ];
+}
+
+export function runLoop<S extends VenusState>(opts: {
+  experiment_id: string;
+  initial_state: S;
+  policy_version: string;
+  budgets: { time_budget_ms: number; step_budget: number; retry_budget: number };
+  loop_policy: { max_steps: number; adaptive_depth: { enabled: boolean }; entropy_regularized_exit: { enabled: boolean } };
+  governance_enabled: boolean;
+  steps: DresdenStep[];
+}): KernelRunResult<S> {
+  const trace: TraceEvent[] = [];
+  let state = { ...opts.initial_state } as S;
+  let hardFails = 0;
+  let softFails = 0;
+  let stopReason: string | null = null;
+  const maxCycles = Math.min(opts.loop_policy.max_steps, opts.budgets.step_budget);
+
+  for (let cycle = 0; cycle < maxCycles; cycle++) {
+    for (const step of opts.steps) {
+      const prevHash = fullHash(state);
+      const prev = { ...state } as S;
+      const next = step.apply(state, DRESDEN_DEFAULT_CONFIG) as S;
+      const nextHash = fullHash(next);
+
+      const vResults = opts.governance_enabled
+        ? step.validators.map((v) => v.check(prev, next, DRESDEN_DEFAULT_CONFIG))
+        : [{ name: 'governance_off', severity: 'pass' as const, summary: 'governance disabled' }];
+
+      const hasHard = vResults.some((v) => v.severity === 'hard_fail');
+      const hasSoft = vResults.some((v) => v.severity === 'soft_fail');
+
+      let receipt: DecisionReceipt | null = null;
+      if (opts.governance_enabled) {
+        receipt = {
+          summary: `${step.name}: ${hasHard ? 'BLOCKED' : hasSoft ? 'WARNING' : 'APPROVED'}`,
+          decision_type: step.pipeline_stage,
+          policy_version: opts.policy_version,
+          approval_status: hasHard ? 'blocked' : 'approved',
+          mocked: false,
+          assumptions: [`cycle=${prev.cycle}`, `drift=${prev.accumulated_drift.toFixed(1)}`],
+          evidence: vResults.map((v) => ({ kind: v.name, ref: v.summary, mocked: false })),
+        };
+      }
+
+      trace.push({
+        step: trace.length + 1,
+        pipeline_stage: step.pipeline_stage,
+        state_prev_hash: prevHash,
+        state_next_hash: hasHard && opts.governance_enabled ? prevHash : nextHash,
+        validator_results: vResults,
+        decision_receipt: receipt,
+      });
+
+      if (hasHard && opts.governance_enabled) {
+        hardFails++;
+        if (hardFails >= 2) {
+          stopReason = 'hard_fail_limit';
+          state = prev;
+          break;
+        }
+        state = prev;
+      } else {
+        if (hasSoft) softFails++;
+        state = next;
+      }
+    }
+
+    if (stopReason) break;
+  }
+
+  return {
+    summary: {
+      status: hardFails > 0 ? 'halted' : 'ok',
+      steps_executed: trace.length,
+      hard_stop_failures: hardFails,
+      soft_failures: softFails,
+      stop_reason: stopReason,
+      final_state_hash: fullHash(state),
+    },
+    trace,
+    final_state: state,
+  };
+}
+
+export function serializeTraceJsonl(trace: TraceEvent[]): string {
+  return trace.map((e) => JSON.stringify(e)).join('\n');
+}
+
+export function shortHash(hash: string): string {
+  return hash.slice(0, 8);
+}
+
+export function replay(
+  initialState: VenusState,
+  trace: TraceEvent[],
+  expectedFinalHash: string,
+): { ok: boolean; steps_replayed: number; failed_step: number | null } {
+  if (trace.length === 0) return { ok: true, steps_replayed: 0, failed_step: null };
+
+  let prevHash = fullHash(initialState);
+  for (let i = 0; i < trace.length; i++) {
+    if (trace[i].state_prev_hash !== prevHash) {
+      return { ok: false, steps_replayed: i, failed_step: i + 1 };
+    }
+    prevHash = trace[i].state_next_hash;
+  }
+
+  const finalMatch = prevHash === expectedFinalHash;
+  return {
+    ok: finalMatch,
+    steps_replayed: trace.length,
+    failed_step: finalMatch ? null : trace.length,
+  };
+}

web/src/_stubs/design-system/tokens.css

@@ -0,0 +1 @@
+/* Design system tokens stub — core variables already defined in index.css :root */

web/src/_stubs/ouroboros-react/index.tsx

@@ -0,0 +1,78 @@
+import type { LoopTrace } from '../ouroboros';
+
+interface LoopGlyphProps {
+  size?: number;
+  convergence: number;
+  spinning?: boolean;
+  color?: string;
+}
+
+export function LoopGlyph({ size = 48, convergence, spinning, color = '#a0c4ff' }: LoopGlyphProps) {
+  const r = (size - 8) / 2;
+  const cx = size / 2;
+  const cy = size / 2;
+  const dashLen = 2 * Math.PI * r * convergence;
+  const totalLen = 2 * Math.PI * r;
+  return (
+    <svg width={size} height={size} viewBox={`0 0 ${size} ${size}`} style={{ flexShrink: 0 }}>
+      <circle cx={cx} cy={cy} r={r} fill="none" stroke="rgba(255,255,255,0.08)" strokeWidth={3} />
+      <circle
+        cx={cx} cy={cy} r={r}
+        fill="none" stroke={color} strokeWidth={3}
+        strokeDasharray={`${dashLen} ${totalLen - dashLen}`}
+        strokeLinecap="round"
+        style={{
+          transform: 'rotate(-90deg)',
+          transformOrigin: `${cx}px ${cy}px`,
+          animation: spinning ? 'spin 1.2s linear infinite' : undefined,
+        }}
+      />
+      <style>{`@keyframes spin { to { transform: rotate(270deg); } }`}</style>
+    </svg>
+  );
+}
+
+interface OuroborosTraceProps<S, O> {
+  trace: LoopTrace<S, O>;
+  describeOutput?: (output: O) => string;
+}
+
+export function OuroborosTrace<S, O>({ trace, describeOutput }: OuroborosTraceProps<S, O>) {
+  return (
+    <div style={{
+      background: 'rgba(255,255,255,0.02)',
+      border: '1px solid rgba(255,255,255,0.08)',
+      borderRadius: 6,
+      padding: 16,
+    }}>
+      <div style={{
+        fontSize: 11, letterSpacing: '0.16em',
+        textTransform: 'uppercase' as const,
+        color: 'rgba(255,255,255,0.55)',
+        marginBottom: 10,
+      }}>
+        Loop trace · {trace.steps.length} steps · {trace.converged ? 'converged' : 'did not converge'}
+      </div>
+      <div style={{ display: 'grid', gap: 4 }}>
+        {trace.steps.map((step, i) => (
+          <div key={i} style={{
+            display: 'grid',
+            gridTemplateColumns: '40px 80px 1fr',
+            fontSize: 11,
+            fontFamily: 'ui-monospace, SFMono-Regular, Menlo, monospace',
+            padding: '4px 6px',
+            borderRadius: 3,
+            background: step.deltaMagnitude < 0.5 ? 'rgba(126,215,193,0.06)' : 'transparent',
+            color: step.deltaMagnitude < 0.5 ? '#7ed7c1' : 'rgba(255,255,255,0.7)',
+          }}>
+            <span>#{step.stepIndex + 1}</span>
+            <span>Δ {step.deltaMagnitude.toFixed(2)}</span>
+            <span style={{ color: 'rgba(255,255,255,0.5)' }}>
+              {describeOutput ? describeOutput(step.output as unknown as O) : ''}
+            </span>
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}

web/src/_stubs/ouroboros/index.ts

@@ -0,0 +1,79 @@
+export interface LoopStep<S> {
+  state: S;
+  output: number;
+  deltaMagnitude: number;
+  consistency: number;
+  stepIndex: number;
+}
+
+export interface LoopTrace<S, O = number> {
+  steps: LoopStep<S>[];
+  finalState: S;
+  converged: boolean;
+  label: string;
+}
+
+export interface LoopConfig {
+  maxSteps: number;
+  convergenceThreshold: number;
+  label: string;
+}
+
+export interface RunLoopOpts<S, O> {
+  initialState: S;
+  step: (state: S) => Promise<{ state: S; output: O }>;
+  delta: (a: S, b: S) => number;
+  consistency: (a: number, b: number) => number;
+  config: LoopConfig;
+}
+
+export async function runLoop<S, O = number>(opts: RunLoopOpts<S, O>): Promise<LoopTrace<S, O>> {
+  const steps: LoopStep<S>[] = [];
+  let current = opts.initialState;
+  let converged = false;
+
+  for (let i = 0; i < opts.config.maxSteps; i++) {
+    const prev = current;
+    const result = await opts.step(current);
+    current = result.state;
+    const dm = opts.delta(prev, current);
+    const cons = opts.consistency(dm, steps.length > 0 ? steps[steps.length - 1].deltaMagnitude : dm);
+    steps.push({
+      state: current,
+      output: result.output as unknown as number,
+      deltaMagnitude: dm,
+      consistency: cons,
+      stepIndex: i,
+    });
+    if (dm < opts.config.convergenceThreshold) {
+      converged = true;
+      break;
+    }
+  }
+
+  return { steps, finalState: current, converged, label: opts.config.label };
+}
+
+export function numericConsistency(a: number, b: number): number {
+  if (a === 0 && b === 0) return 1;
+  return 1 - Math.abs(a - b) / Math.max(Math.abs(a), Math.abs(b), 1);
+}
+
+export function allocateDepth(opts: { recentDeltas: number[]; maxSteps: number }): {
+  recommendedSteps: number;
+  trajectory: string;
+} {
+  if (opts.recentDeltas.length === 0) {
+    return { recommendedSteps: opts.maxSteps, trajectory: 'no-data' };
+  }
+  const trend = opts.recentDeltas.length >= 2
+    ? opts.recentDeltas[0] - opts.recentDeltas[opts.recentDeltas.length - 1]
+    : 0;
+  if (trend > 0) {
+    return { recommendedSteps: Math.max(2, Math.ceil(opts.maxSteps * 0.6)), trajectory: 'converging' };
+  }
+  if (trend < 0) {
+    return { recommendedSteps: opts.maxSteps, trajectory: 'diverging' };
+  }
+  return { recommendedSteps: opts.maxSteps, trajectory: 'flat' };
+}

web/src/_stubs/shared-ui/badge.tsx

@@ -0,0 +1,16 @@
+import * as React from 'react';
+
+interface BadgeProps extends React.HTMLAttributes<HTMLDivElement> {
+  variant?: 'default' | 'secondary' | 'destructive' | 'outline';
+}
+
+export function Badge({ className = '', variant = 'default', ...props }: BadgeProps) {
+  const base = 'inline-flex items-center rounded-full border px-2.5 py-0.5 text-xs font-semibold transition-colors';
+  const variants: Record<string, string> = {
+    default: 'border-transparent bg-primary text-primary-foreground',
+    secondary: 'border-transparent bg-secondary text-secondary-foreground',
+    destructive: 'border-transparent bg-destructive text-destructive-foreground',
+    outline: 'text-foreground',
+  };
+  return <div className={`${base} ${variants[variant] || ''} ${className}`} {...props} />;
+}

web/src/_stubs/shared-ui/button.tsx

@@ -0,0 +1,25 @@
+import * as React from 'react';
+
+interface ButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+  variant?: 'default' | 'destructive' | 'outline' | 'secondary' | 'ghost' | 'link';
+  size?: 'default' | 'sm' | 'lg' | 'icon';
+}
+
+export function Button({ className = '', variant = 'default', size = 'default', ...props }: ButtonProps) {
+  const base = 'inline-flex items-center justify-center whitespace-nowrap rounded-md text-sm font-medium transition-colors disabled:pointer-events-none disabled:opacity-50';
+  const variants: Record<string, string> = {
+    default: 'bg-primary text-primary-foreground hover:bg-primary/90',
+    destructive: 'bg-destructive text-destructive-foreground hover:bg-destructive/90',
+    outline: 'border border-input bg-background hover:bg-accent hover:text-accent-foreground',
+    secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80',
+    ghost: 'hover:bg-accent hover:text-accent-foreground',
+    link: 'text-primary underline-offset-4 hover:underline',
+  };
+  const sizes: Record<string, string> = {
+    default: 'h-10 px-4 py-2',
+    sm: 'h-9 rounded-md px-3',
+    lg: 'h-11 rounded-md px-8',
+    icon: 'h-10 w-10',
+  };
+  return <button className={`${base} ${variants[variant] || ''} ${sizes[size] || ''} ${className}`} {...props} />;
+}

web/src/_stubs/shared-ui/card.tsx

@@ -0,0 +1,17 @@
+import * as React from 'react';
+
+export function Card({ className = '', ...props }: React.HTMLAttributes<HTMLDivElement>) {
+  return <div className={`rounded-lg border bg-card text-card-foreground shadow-sm ${className}`} {...props} />;
+}
+
+export function CardHeader({ className = '', ...props }: React.HTMLAttributes<HTMLDivElement>) {
+  return <div className={`flex flex-col space-y-1.5 p-6 ${className}`} {...props} />;
+}
+
+export function CardTitle({ className = '', ...props }: React.HTMLAttributes<HTMLHeadingElement>) {
+  return <h3 className={`text-2xl font-semibold leading-none tracking-tight ${className}`} {...props} />;
+}
+
+export function CardContent({ className = '', ...props }: React.HTMLAttributes<HTMLDivElement>) {
+  return <div className={`p-6 pt-0 ${className}`} {...props} />;
+}

web/src/_stubs/shared-ui/contact-modal.tsx

@@ -0,0 +1,41 @@
+import { useState } from 'react';
+
+interface ContactModalProps {
+  type?: string;
+  app?: string;
+  trigger: React.ReactNode;
+}
+
+export function ContactModal({ type = 'demo', app = 'amaru', trigger }: ContactModalProps) {
+  const [open, setOpen] = useState(false);
+  return (
+    <>
+      <span onClick={() => setOpen(true)} style={{ cursor: 'pointer' }}>{trigger}</span>
+      {open && (
+        <div style={{
+          position: 'fixed', inset: 0, zIndex: 9999,
+          display: 'flex', alignItems: 'center', justifyContent: 'center',
+          background: 'rgba(0,0,0,0.7)',
+        }} onClick={() => setOpen(false)}>
+          <div onClick={(e) => e.stopPropagation()} style={{
+            background: '#1a1a1a', borderRadius: 12, padding: 32,
+            border: '1px solid rgba(201,183,135,0.2)', maxWidth: 480, width: '90%',
+          }}>
+            <h2 style={{ margin: '0 0 16px', fontSize: 20, color: '#f5f5f5' }}>
+              Request {type === 'demo' ? 'a Demo' : 'Access'}
+            </h2>
+            <p style={{ color: '#888', fontSize: 14, margin: '0 0 20px' }}>
+              Contact us at <a href="mailto:stephen@szlholdings.com" style={{ color: '#c9b787' }}>stephen@szlholdings.com</a> for {app} access.
+            </p>
+            <button onClick={() => setOpen(false)} style={{
+              background: '#c9b787', color: '#0a0a0a', border: 'none',
+              padding: '10px 20px', borderRadius: 6, cursor: 'pointer', fontWeight: 500,
+            }}>
+              Close
+            </button>
+          </div>
+        </div>
+      )}
+    </>
+  );
+}

web/src/_stubs/shared-ui/skeleton.tsx

@@ -0,0 +1,5 @@
+import * as React from 'react';
+
+export function Skeleton({ className = '', ...props }: React.HTMLAttributes<HTMLDivElement>) {
+  return <div className={`animate-pulse rounded-md bg-muted ${className}`} {...props} />;
+}

web/src/_stubs/szl-doctrine-panels/index.tsx

@@ -0,0 +1,41 @@
+interface Theme {
+  bg: string;
+  cardBg: string;
+  gold: string;
+  text: string;
+  muted: string;
+}
+
+export function makeDarkGoldTheme(opts: { bg: string; cardBg: string; gold: string }): Theme {
+  return { ...opts, text: '#f5f5f5', muted: '#888' };
+}
+
+interface GovernancePanelsBaseProps {
+  slug: string;
+  theme: Theme;
+  headline: string;
+  doctrineAnatomyHref: string;
+}
+
+export function GovernancePanelsBase({ slug, theme, headline, doctrineAnatomyHref }: GovernancePanelsBaseProps) {
+  return (
+    <div style={{ background: theme.cardBg, border: `1px solid ${theme.gold}22`, borderRadius: 8, padding: 20 }}>
+      <div style={{ fontSize: 10, letterSpacing: '0.16em', textTransform: 'uppercase' as const, color: theme.gold, marginBottom: 8 }}>
+        {slug} · Governance Panels
+      </div>
+      <h3 style={{ fontSize: 14, color: theme.text, margin: '0 0 12px', fontWeight: 500 }}>{headline}</h3>
+      <div style={{ display: 'grid', gridTemplateColumns: 'repeat(auto-fit, minmax(180px, 1fr))', gap: 10 }}>
+        {['POVM completeness', 'KS-18 2-cover', 'Bohr floor', 'Fisher-Rao', 'Tetrad ortho', 'Shor ECC'].map((inv) => (
+          <div key={inv} style={{ background: theme.bg, border: '1px solid rgba(255,255,255,0.06)', borderRadius: 6, padding: '10px 12px' }}>
+            <div style={{ fontSize: 9, color: theme.muted, letterSpacing: '0.12em', textTransform: 'uppercase' as const }}>{inv}</div>
+            <div style={{ fontSize: 13, color: '#7fb893', marginTop: 4 }}>✓ pass</div>
+          </div>
+        ))}
+      </div>
+      <a href={doctrineAnatomyHref} target="_blank" rel="noopener noreferrer"
+        style={{ display: 'inline-block', marginTop: 12, fontSize: 11, color: theme.gold, textDecoration: 'none' }}>
+        View doctrine anatomy →
+      </a>
+    </div>
+  );
+}

web/src/_stubs/szl-doctrine/index.ts

@@ -0,0 +1,83 @@
+export interface ThesisLineageEntry {
+  id: string;
+  title: string;
+  status: string;
+  version: string;
+  doi?: string;
+  arxiv?: string;
+  zenodo?: string;
+  abstract: string;
+  children?: string[];
+}
+
+export interface ThesisPaper {
+  key: string;
+  title: string;
+  authors: string[];
+  year: number;
+  doi?: string;
+  arxiv?: string;
+  zenodo?: string;
+  journal?: string;
+  status: string;
+  abstract: string;
+  theorems: string[];
+  auditCounters: { proven: number; conjectured: number; open: number };
+}
+
+export const THESIS_LINEAGE: ThesisLineageEntry[] = [
+  { id: 'TH1', title: 'Bounded-recursion runtime', status: 'published (v18.0)', version: '18.0', doi: '10.5281/zenodo.20434276', abstract: 'Ouroboros bounded-loop runtime — Banach contraction convergence proof.' },
+  { id: 'TH2', title: 'POVM completeness', status: 'published', version: '18.0', abstract: 'POVM completeness Σ E_i = I for governance measurement operators.' },
+  { id: 'TH3', title: 'KS-18 contextuality', status: 'published', version: '18.0', abstract: 'Kochen-Specker 18-vector 2-regular cover impossibility proof.' },
+  { id: 'TH4', title: 'Fisher-Rao metric', status: 'published', version: '18.0', abstract: 'Fisher-Rao geodesic distance on simplex for governance drift.' },
+  { id: 'TH5', title: 'Bohr complementarity floor', status: 'published', version: '18.0', abstract: 'Bohr floor σ_A·σ_B ≥ 0.25 − ε on conjugate governance axes.' },
+  { id: 'TH6', title: 'Shor error correction', status: 'published', version: '18.0', abstract: 'Shor 9-qubit code for provenance hash error correction.' },
+  { id: 'TH7', title: 'Lamport causal ordering', status: 'published', version: '18.0', abstract: 'Lamport clock timestamps for causal ordering across receipt chains.' },
+  { id: 'TH8', title: 'Convergent data sync', status: 'published', version: '18.0', doi: '10.5281/zenodo.20434276', abstract: 'Amaru convergent multi-source data sync with Proof-Chain receipts.' },
+];
+
+export const THESIS_PAPERS: ThesisPaper[] = [
+  {
+    key: 'TH1-TH3',
+    title: 'Bounded recursion, POVM completeness, and KS-18 contextuality',
+    authors: ['Lutar, Stephen P.'],
+    year: 2026,
+    doi: '10.5281/zenodo.20434276',
+    status: 'published',
+    abstract: 'Chapters 1-3 of the Ouroboros thesis: bounded-recursion runtime with Banach contraction convergence, POVM measurement completeness, and Kochen-Specker 18-vector contextuality proof.',
+    theorems: ['Banach contraction', 'POVM completeness', 'KS-18 2-cover', 'KS-18 unsatisfiability'],
+    auditCounters: { proven: 4, conjectured: 0, open: 0 },
+  },
+  {
+    key: 'TH4-TH7',
+    title: 'Fisher-Rao geodesics, Bohr floor, Shor ECC, Lamport ordering',
+    authors: ['Lutar, Stephen P.'],
+    year: 2026,
+    status: 'published',
+    abstract: 'Chapters 4-7: Fisher-Rao metric on the probability simplex, Bohr complementarity floor for conjugate governance measurements, Shor 9-qubit code for provenance hashes, Lamport clock for causal receipt ordering.',
+    theorems: ['Fisher-Rao metric', 'Bohr floor', 'Shor 9-qubit', 'Lamport clock'],
+    auditCounters: { proven: 4, conjectured: 0, open: 0 },
+  },
+  {
+    key: 'TH8-GLR',
+    title: 'Convergent data sync & GLR theorem',
+    authors: ['Lutar, Stephen P.'],
+    year: 2026,
+    status: 'published',
+    abstract: 'Chapter 8 and GLR extension: convergent multi-source data synchronization with append-only delta logs, bounded-loop convergence guarantees, and the Governance-Locality-Recursion theorem.',
+    theorems: ['Convergent sync', 'Append-only delta-log', 'GLR theorem'],
+    auditCounters: { proven: 3, conjectured: 0, open: 0 },
+  },
+];
+
+export function thesisPaperSummary(paper: ThesisPaper): {
+  theoremCount: number;
+  provenCount: number;
+  status: string;
+} {
+  return {
+    theoremCount: paper.theorems.length,
+    provenCount: paper.auditCounters.proven,
+    status: paper.status,
+  };
+}

web/src/index.css

@@ -1,6 +1,6 @@
 @import url("https://fonts.googleapis.com/css2?family=Space+Grotesk:wght@300;400;500;600;700&family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap");
 @import "tailwindcss";
-@import "@szl-holdings/design-system/tokens/css";
+/* design-system tokens inlined below in :root */
 
 @custom-variant dark (&:is(.dark *));
 

web/tsconfig.json

@@ -1,14 +1,20 @@
 {
-  "extends": "../../tsconfig.base.json",
   "include": ["src/**/*"],
   "exclude": ["node_modules", "build", "dist", "**/*.test.ts"],
   "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
     "noEmit": true,
-    "jsx": "preserve",
-    "lib": ["esnext", "dom", "dom.iterable"],
+    "jsx": "react-jsx",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
     "resolveJsonModule": true,
     "allowImportingTsExtensions": true,
     "moduleResolution": "bundler",
+    "isolatedModules": true,
     "types": ["node", "vite/client"],
     "paths": {
       "@/*": ["./src/*"]

web/vite.config.ts

@@ -1,57 +1,49 @@
-import runtimeErrorOverlay from '@replit/vite-plugin-runtime-error-modal';
 import tailwindcss from '@tailwindcss/vite';
 import react from '@vitejs/plugin-react';
 import path from 'node:path';
 import { defineConfig } from 'vite';
-import { sharedProxyPlugin } from '@szl-holdings/shared-proxy';
-import { securityHeadersVitePlugin } from '@szl-holdings/security-headers';
-
-process.env.GOMAXPROCS = process.env.GOMAXPROCS ?? '2';
 
 const vitePort = Number(process.env.VITE_PORT) || 5300;
-const basePath = process.env.BASE_PATH || '/conduit/';
+const basePath = process.env.BASE_PATH || '/';
+const apiTarget = process.env.API_TARGET || 'http://localhost:6810';
 
 export default defineConfig({
   base: basePath,
   plugins: [
-    securityHeadersVitePlugin(),
-    sharedProxyPlugin(),
     react(),
     tailwindcss(),
-    runtimeErrorOverlay(),
-    ...(process.env.NODE_ENV !== 'production' && process.env.REPL_ID !== undefined
-      ? [
-          await import('@replit/vite-plugin-cartographer').then((m) =>
-            m.cartographer({
-              root: path.resolve(import.meta.dirname, '..'),
-            }),
-          ),
-          await import('@replit/vite-plugin-dev-banner').then((m) => m.devBanner()),
-        ]
-      : []),
   ],
   resolve: {
     alias: {
       '@': path.resolve(import.meta.dirname, 'src'),
+      '@workspace/a11oy-orchestration/client': path.resolve(import.meta.dirname, 'src/_stubs/a11oy-orchestration/index.ts'),
+      '@workspace/ouroboros/react': path.resolve(import.meta.dirname, 'src/_stubs/ouroboros-react/index.tsx'),
+      '@workspace/ouroboros': path.resolve(import.meta.dirname, 'src/_stubs/ouroboros/index.ts'),
+      '@workspace/codex-kernel': path.resolve(import.meta.dirname, 'src/_stubs/codex-kernel/index.ts'),
+      '@szl-holdings/szl-doctrine/panels': path.resolve(import.meta.dirname, 'src/_stubs/szl-doctrine-panels/index.tsx'),
+      '@szl-holdings/szl-doctrine': path.resolve(import.meta.dirname, 'src/_stubs/szl-doctrine/index.ts'),
+      '@szl-holdings/shared-ui/ui/badge': path.resolve(import.meta.dirname, 'src/_stubs/shared-ui/badge.tsx'),
+      '@szl-holdings/shared-ui/ui/button': path.resolve(import.meta.dirname, 'src/_stubs/shared-ui/button.tsx'),
+      '@szl-holdings/shared-ui/ui/card': path.resolve(import.meta.dirname, 'src/_stubs/shared-ui/card.tsx'),
+      '@szl-holdings/shared-ui/ui/skeleton': path.resolve(import.meta.dirname, 'src/_stubs/shared-ui/skeleton.tsx'),
+      '@szl-holdings/shared-ui/contact-modal': path.resolve(import.meta.dirname, 'src/_stubs/shared-ui/contact-modal.tsx'),
+      '@szl-holdings/design-system/tokens/css': path.resolve(import.meta.dirname, 'src/_stubs/design-system/tokens.css'),
     },
     dedupe: ['react', 'react-dom'],
   },
   root: path.resolve(import.meta.dirname),
   build: {
-    outDir: path.resolve(import.meta.dirname, 'dist/public'),
+    outDir: path.resolve(import.meta.dirname, 'dist'),
     sourcemap: 'hidden',
     emptyOutDir: true,
     cssCodeSplit: true,
     rollupOptions: {
-      external: ['worker_threads', 'node:worker_threads', 'async_hooks', 'node:async_hooks'],
       output: {
         manualChunks(id): string | undefined {
           if (id.includes('node_modules')) {
             if (id.includes('/recharts/')) return 'vendor-recharts';
-            if (id.includes('/victory-vendor/')) return 'vendor-recharts';
             if (id.includes('/d3-')) return 'vendor-d3';
             if (id.includes('framer-motion')) return 'vendor-motion';
-            if (id.includes('@radix-ui')) return 'vendor-radix';
             if (id.includes('@tanstack')) return 'vendor-tanstack';
             if (id.includes('lucide-react')) return 'vendor-icons';
             if (id.includes('react-dom')) return 'vendor-react';
@@ -63,7 +55,6 @@ export default defineConfig({
     },
   },
   optimizeDeps: {
-    holdUntilCrawlEnd: false,
     include: [
       'react',
       'react-dom',
@@ -77,20 +68,19 @@ export default defineConfig({
   server: {
     port: vitePort,
     strictPort: true,
-    host: '::',
+    host: '0.0.0.0',
     allowedHosts: true,
-    warmup: {
-      clientFiles: ['src/main.tsx', 'src/App.tsx'],
-    },
-    hmr: { clientPort: 443, path: basePath },
-    fs: {
-      strict: false,
-      deny: ['**/.*'],
+    proxy: {
+      '/api/amaru': {
+        target: apiTarget,
+        changeOrigin: true,
+        rewrite: (p) => p.replace(/^\/api\/amaru/, ''),
+      },
     },
   },
   preview: {
     port: vitePort,
-    host: '::',
+    host: '0.0.0.0',
     allowedHosts: true,
   },
 });