Add Decidron network simulator

Backend: deterministic decidron engine (models, network, engine, stats,
diagrams) under backend/app/decidron with a REST router at
/api/decidron; networkx dependency and patent-shaped seed network +
sample commands.

Frontend: DecidronSimulator view (vis-network diagram, sensor input,
command builder, results, stats, history) wired into App.js; api.js
rewritten for the Decidron endpoints; vis-network/vis-data added.

Docs/config: full README (patent context, start, UI workflow, command
schema, API curl reference, troubleshooting); trimmed .env.example and
docker-compose to the deterministic simulator.

Co-authored-by: Cursor <cursoragent@cursor.com>

.env.example

@@ -1,25 +1,11 @@
-# HANA API (Neon BrainForge)
-HANA_BASE_URL=https://hana.neonaialpha.com
-HANA_USERNAME=guest
-HANA_PASSWORD=password
-# BrainForge/Security (4090-x1-3): OpenAI-compatible API key for direct vLLM (same as HF Space API_KEY in brainforge-webapp).
-# NOT used for HANA /auth/login — see NeonGeckoCom/brainforge-webapp docker_overlay/config/config.yaml
-HANA_KLATCHAT_PASSWORD=sk_klatchat2024
-# Direct vLLM host (default matches demo 4090-x1-3)
-# NEON_SECURITY_VLLM_BASE_URL=https://4090-x1-3.neonaiservices2.com/vllm0
+# Decidron Network Simulator config.
+#
+# The deterministic simulator requires no API keys. The only settings
+# are CORS (for CRA dev on :3000 talking to the backend on :7860) and an
+# optional host port override for docker compose.
 
-# Neon vLLM direct access
-VLLM_API_KEY=sk_n30nn30n
+# Comma-separated allowed CORS origins.
+CORS_ORIGINS=http://localhost:3000,http://localhost:7860
 
-# Comparison providers
-FIREWORKS_API_KEY=your-fireworks-api-key-here
-TOGETHER_API_KEY=your-together-api-key-here
-OPENAI_API_KEY=your-openai-api-key-here
-GEMINI_API_KEY=your-gemini-api-key-here
-
-# Orchestrator LLM (used to monitor conversation endings)
-# Defaults to gpt-4o-mini via OpenAI if OPENAI_API_KEY is set
-ORCHESTRATOR_MODEL=gpt-4o-mini
-
-# App
-CORS_ORIGINS=http://localhost:3000
+# Host port to publish the container on (container always listens on 7860).
+# CCAI_HOST_PORT=7860

.gitignore

@@ -3,6 +3,7 @@ __pycache__/
 .env
 node_modules/
 frontend/build/
+backend/static/
 .DS_Store
 *.egg-info/
 dist/

README.md

@@ -1,128 +1,229 @@
----
-title: Collaborative Conversational AI (CCAI) Demo
-emoji: 🤝
-colorFrom: blue
-colorTo: purple
-sdk: docker
-app_port: 7860
-hf_oauth: true
-hf_oauth_scopes:
-  - read-repos
-pinned: false
----
-
-# Collaborative Conversational AI (CCAI) Demo
-
-A demo of **Collaborative Conversational AI (CCAI)** - Neon.ai's patented
-group-discussion technology. Up to 9 participants (any mix of AI personas,
-human-defined "expert" personas, or - in the future - real humans, agents,
-tools, or sensors) hold a structured group conversation facilitated by a
-neutral **Orchestrator**, with the goal of reaching a real group decision
-the way a thoughtful human meeting would.
-
-This repo descends from
-[NeonClary/LLMChats3](https://github.com/NeonClary/LLMChats3) and reuses
-its color scheme, branding, settings menu structure, and chat formatting
-verbatim. The CCAI multi-participant orchestration, expert-persona modal,
-participant sidebar, and table view are layered on top.
-
-## Architecture (one-pager)
-
-- **Frontend** (React 19, react-markdown, lucide-react) - lives in
-  `frontend/`. Talks SSE to the backend.
-- **Backend** (FastAPI, httpx) - lives in `backend/`. Routes:
-  - `GET /api/personas` — Neon HANA personas (vanilla/RAG filtered),
-    bundled extra personas, and (echoed) expert personas.
-  - `GET /api/demo-questions` — the bank of 10 long-context demo prompts.
-  - `POST /api/chat/start` — kicks off a CCAI session and returns SSE.
-  - `POST /api/chat/{id}/continue?reason=…` — resumes a paused session.
-  - `GET  /api/chat/{id}/export?fmt=txt|md|csv-table` — exports.
-  - `GET  /api/chat/{id}/table` — JSON for the table view.
-- **Orchestrator state machine** — six phases (Initial Opinions,
-  Critique x2, Status Assessment, Finalization, Consensus, Closure)
-  with two failsafes (60+20 messages, 100+50 orchestrator calls) and
-  per-participant on-demand context summarization.
-
-## CCAI Phase Overview
-
-1. **Initial Opinions.** Each participant offers an independent first
-   opinion. The orchestrator builds a per-participant **Credential
-   Summary** in the background.
-2. **Critique x 2.** Each participant gets two turns to critique
-   others, ask follow-ups, and revise. After Phase 2 the Credential
-   Summary is refreshed.
-3. **Status Assessment.** The orchestrator either proceeds or runs
-   targeted follow-ups (max 3 iterations).
-4. **Finalization.** Each participant either revises their own opinion
-   or endorses another's.
-5. **Consensus Gathering.** Allied participants advocate, solo
-   participants seek allies / switch / propose compromises. The
-   orchestrator routes addressed-to messages.
-6. **Closure.** Majority-report (with weighted dissent), or
-   unaddressed-factor probe + retry, or no-consensus report.
-
-Thinking traces (`<think>`, `<reasoning>`, etc.) are stripped from every
-LLM response in `backend/app/utils/sanitize.py` before being stored,
-displayed, or fed back to the orchestrator/summarizer/Credential builder.
-
-## Quick Start (local development)
+# Decidron Network Simulator
+
+A deterministic, browser-based simulator for **Decidron networks** — the
+coupled machine-learning decision units described in US Patent
+[US11989636B1](https://patents.google.com/patent/US11989636B1/en)
+("System and method for persuadable collaborative conversational AI",
+Gasper & Leeds).
+
+You define simulated **sensor inputs** and **processing commands**
+(IF a sensor matches THEN emit an output / drive an actuator / modify the
+network), run the simulation, and watch the **network diagram**,
+**performance statistics**, and **topology-change history** update live.
+
+> This project started from Neon.ai's private `CCAI-Vibe-Demo` app and
+> reuses its FastAPI + React scaffold, Docker setup, and visual branding.
+> The CCAI multi-LLM orchestration was intentionally removed — v1 of the
+> simulator is purely rule-based and needs no API keys or LLM. See
+> [Relationship to CCAI](#relationship-to-ccai-and-the-patent).
+
+## Patent context (brief)
+
+A **Decidron** is a machine-learning unit (MLU) with collaborative
+protocols that can be **coupled/networked** with other Decidrons. The
+patent highlights that "a MLU network coupled with real-time sensors and
+actuators can operate industrial controls ... and increased reliability
+through parallel pathways." A Decidron records its **experience**, fires
+**actions**, scores **results**, and can **modify its own topology**.
+
+This simulator models those concepts deterministically:
+
+| Patent concept | Simulator |
+| --- | --- |
+| Coupled MLU node / coupling | `decidron` node / directed edge |
+| Sensors and actuators | `sensor` / `actuator` nodes |
+| Experience Chains (ECDS) | per-node experience log (sensor received → rule fired → actuator acted) |
+| Select & perform action, results scored | command output (+ optional actuator) + performance stats |
+| Dynamic/extensible topology | `network_ops` applied when a command fires |
+| Parallel pathways / reliability | redundant couplings in the seed network |
+
+## Prerequisites
+
+- **Docker** (recommended), or
+- **Python 3.12+** and **Node 22+** for local dev.
+
+## Start the application
+
+### Docker (recommended)
 
 ```bash
-cp .env.example .env
-# Edit .env with your API keys
+cp .env.example .env        # no secrets needed; defaults are fine
+docker compose up --build
+# open http://localhost:7860
+```
+
+The container builds the React frontend, serves it as static files from
+FastAPI, and listens on port 7860. Override the host port with
+`CCAI_HOST_PORT` in `.env` if 7860 is taken.
+
+### Local development
 
-# Backend
+Backend (FastAPI on :7860):
+
+```bash
 cd backend
+python -m venv .venv
+.venv/Scripts/activate      # Windows; use source .venv/bin/activate on macOS/Linux
 pip install -r requirements.txt
-uvicorn app.main:app --reload --port 8000
+uvicorn app.main:app --reload --port 7860
+```
+
+Frontend (CRA dev server on :3000, proxying to the backend):
 
-# Frontend (separate terminal)
+```bash
 cd frontend
 npm install
+# point the dev server at the backend:
+echo "REACT_APP_API_URL=http://localhost:7860" > .env.development
 npm start
 ```
 
-## Docker
+## Web UI workflow
+
+1. **View the initial network diagram** — sensors (blue boxes) feed
+   coupled Decidrons (purple hexagons) that drive actuators (green
+   triangles).
+2. **Enter a simulated sensor input** — pick a channel (e.g.
+   `Temperature Sensor`), enter a value (e.g. `97`), and click **Queue**.
+3. **Create processing commands** — define IF (sensor + match) THEN
+   (output, optional actuator). The match is an `operator:value` rule.
+4. **Run the simulation** — click **Run Simulation**; queued inputs are
+   evaluated against all commands.
+5. **Read the results and statistics** — matched commands, emitted
+   outputs, and per-sensor/command/output metrics appear on the right.
+6. **Review the network-change diagram** — if a command applied
+   `network_ops`, a new version is snapshotted; select any version in the
+   **Network Modification History** to view that topology in the diagram.
+
+## Processing command format
+
+A command is JSON:
+
+```json
+{
+  "name": "HighTempAlert",
+  "sensor": "temperature",
+  "match": "gte:85",
+  "output": "Trigger failsafe review",
+  "actuator": "actuator-1",
+  "network_ops": [
+    { "op": "add_node", "node": { "id": "D3", "label": "Decidron D3", "type": "decidron" } },
+    { "op": "add_edge", "from": "temperature", "to": "D3" },
+    { "op": "remove_edge", "from": "D1", "to": "D2" }
+  ]
+}
+```
+
+- `sensor` — the sensor channel/node id this command listens to.
+- `match` — `operator:value`, where operator is one of `contains`,
+  `equals`, `startswith`, `endswith`, `regex`, `gt`, `gte`, `lt`, `lte`.
+  A bare value (no operator) is treated as `contains`.
+- `output` — text emitted when the rule fires.
+- `actuator` *(optional)* — id of an actuator node to drive.
+- `network_ops` *(optional)* — topology changes: `add_node`, `add_edge`,
+  `remove_edge` (edges use `from`/`to`).
+
+## API reference
+
+All endpoints are under `/api/decidron`.
+
+| Method | Path | Purpose |
+| --- | --- | --- |
+| GET | `/api/decidron/network` | Current network + vis-network diagram JSON |
+| POST | `/api/decidron/sensors/input` | Queue a simulated sensor input |
+| GET | `/api/decidron/commands` | List processing commands |
+| POST | `/api/decidron/commands` | Create a processing command |
+| POST | `/api/decidron/run` | Process queued (or supplied) inputs |
+| GET | `/api/decidron/stats` | Performance statistics |
+| GET | `/api/decidron/history` | Topology-change snapshots |
+| POST | `/api/decidron/reset` | Reset to the seed network |
+
+### curl examples
 
 ```bash
-cp .env.example .env
-# Edit .env with your API keys
-docker compose up --build
-# Open http://localhost:7860
+# View the initial network
+curl http://localhost:7860/api/decidron/network
+
+# Queue a sensor reading and run
+curl -X POST http://localhost:7860/api/decidron/sensors/input \
+  -H 'Content-Type: application/json' \
+  -d '{"channel":"temperature","value":"97"}'
+
+curl -X POST http://localhost:7860/api/decidron/run \
+  -H 'Content-Type: application/json' -d '{}'
+
+# Create a command
+curl -X POST http://localhost:7860/api/decidron/commands \
+  -H 'Content-Type: application/json' \
+  -d '{"name":"LowTemp","sensor":"temperature","match":"lt:0","output":"Freeze warning"}'
+
+# Run with inline inputs (bypasses the queue)
+curl -X POST http://localhost:7860/api/decidron/run \
+  -H 'Content-Type: application/json' \
+  -d '{"inputs":[{"channel":"temperature","value":"-5"}]}'
+
+# Stats and history
+curl http://localhost:7860/api/decidron/stats
+curl http://localhost:7860/api/decidron/history
 ```
 
-## HuggingFace Spaces Deployment
-
-Deployed as a Docker Space (`app_port: 7860`).
-
-Required Space Secrets:
-
-- `HANA_USERNAME`, `HANA_PASSWORD` — Neon HANA credentials.
-- `HANA_KLATCHAT_PASSWORD` (optional) — BrainForge/Security vLLM access.
-- Provider keys: `OPENAI_API_KEY`, `GEMINI_API_KEY`, `FIREWORKS_API_KEY`,
-  `TOGETHER_API_KEY`, `MISTRAL_API_KEY`.
-- `HF_RATE_LIMIT_DAILY=30` — daily per-IP cap (defaults to 30; org
-  members are unlimited).
-- `HF_RATE_LIMIT_ORG=neongeckocom` — bypass org name.
-- `SESSION_SECRET` — cookie session secret for OAuth.
-
-## Features
-
-- **Participant dropdown** in the header with three sections (Neon /
-  Extra / Expert) and a `Create Expert Persona...` shortcut.
-- **Participant sidebar** with on/off slider per participant; flipping
-  off does not deselect, and a `Remove` button appears for actually
-  dropping someone from the conversation.
-- **Settings menu** with searchable orchestrator-model and summarizer-
-  model pickers (summarizer defaults to "Same as Orchestrator"),
-  a 3-9 max-participants stepper, per-participant model overrides, and
-  the same display-options + downloads structure as LLMChats3.
-- **Two failsafes** with explicit Continue buttons (60+20 messages,
-  100+50 orchestrator calls).
-- **Exports**: `.txt`, `.md`, RFC-4180 `.csv` table, JSON API log.
-- **Table view** of the whole conversation with per-participant first /
-  contribution / revised / final columns.
-- **localStorage persistence** for expert personas, participant
-  selection, on/off state, model assignments, orchestrator/summarizer
-  picks, and max-participants.
-- **HuggingFace OAuth** with `neongeckocom` org bypass.
+## Config & seed files
+
+- [`backend/app/config.py`](backend/app/config.py) — minimal settings
+  (`CORS_ORIGINS`).
+- [`backend/app/data/decidron/default_network.json`](backend/app/data/decidron/default_network.json)
+  — the starter network (sensor → coupled Decidrons → actuator, with a
+  redundant coupling).
+- [`backend/app/data/decidron/sample_commands.json`](backend/app/data/decidron/sample_commands.json)
+  — example commands (one drives an actuator, one reconfigures the
+  topology). Edit these to change the simulation's starting state.
+
+## Adding files in Cursor
+
+- **Open the repo as a workspace**: File → Open Folder → `decidron-simulator`.
+- **New file**: right-click a folder in the Explorer → New File.
+- **Drag & drop** files from your file manager into the Explorer.
+- **Ask Cursor in chat**: e.g. "Add `backend/app/decidron/alerts.py`".
+- **Terminal**: `New-Item backend/app/decidron/alerts.py` (PowerShell) or
+  `touch backend/app/decidron/alerts.py` (bash).
+
+## Relationship to CCAI and the patent
+
+v1 deliberately omits the patent's full pipeline: ECDS context/memory
+augmentation, the embedded CCAI per Decidron, Theory-of-Mind,
+persuadability, and action-reinforcement learning. A future version
+could make Decidrons LLM-driven by porting the orchestration and LLM
+clients from the `CCAI-Vibe-Demo` reference app. The simulator's logic is
+isolated under `backend/app/decidron/` and
+`frontend/src/components/decidron/` to keep that door open.
+
+## Project layout
+
+```
+backend/
+  app/
+    main.py                 # FastAPI app: CORS, /api/health, SPA serving
+    config.py               # minimal settings
+    api/decidron.py         # REST router
+    decidron/               # simulation engine (models, network, engine, stats, diagrams)
+    data/decidron/          # seed network + sample commands
+frontend/
+  src/
+    App.js                  # shell
+    components/Header.js     # branded header
+    components/decidron/     # simulator UI (diagram, forms, tables, history)
+    utils/api.js             # API client
+    styles/                  # branding + simulator CSS
+Dockerfile, docker-compose.yml
+```
+
+## Troubleshooting
+
+- **Port 7860 in use** — set `CCAI_HOST_PORT` in `.env`, or run uvicorn
+  on another port.
+- **Frontend can't reach the API in dev** — ensure
+  `REACT_APP_API_URL=http://localhost:7860` is set in
+  `frontend/.env.development` and the backend is running.
+- **CORS errors** — add your origin to `CORS_ORIGINS` in `.env`.
+- **Diagram doesn't render** — vis-network needs the bundled assets from
+  `npm install`; re-run it if you cloned without building.

backend/app/api/decidron.py

@@ -0,0 +1,88 @@
+"""REST API for the Decidron network simulator."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter
+from pydantic import BaseModel
+
+from app.decidron.engine import engine
+from app.decidron.diagrams import to_vis_network
+from app.decidron.models import ProcessingCommand, RunResult, SensorInput
+
+router = APIRouter(prefix="/decidron", tags=["decidron"])
+
+
+def _network_payload() -> dict:
+    nodes = engine.network.nodes_list()
+    return {
+        "version": engine.network.version,
+        "nodes": [n.model_dump() for n in nodes],
+        "edges": [e.model_dump(by_alias=True) for e in engine.network.edges],
+        "diagram": to_vis_network(nodes, engine.network.edges),
+    }
+
+
+@router.get("/network")
+async def get_network() -> dict:
+    return _network_payload()
+
+
+@router.post("/sensors/input")
+async def submit_sensor_input(sensor_input: SensorInput) -> dict:
+    engine.add_sensor_input(sensor_input)
+    return {
+        "queued": sensor_input.model_dump(),
+        "pending_count": len(engine.pending_inputs),
+    }
+
+
+@router.get("/commands")
+async def list_commands() -> list[ProcessingCommand]:
+    return engine.list_commands()
+
+
+@router.post("/commands")
+async def create_command(command: ProcessingCommand) -> ProcessingCommand:
+    return engine.add_command(command)
+
+
+class RunRequest(BaseModel):
+    inputs: list[SensorInput] | None = None
+
+
+@router.post("/run")
+async def run_simulation(req: RunRequest | None = None) -> dict:
+    inputs = req.inputs if req else None
+    results: list[RunResult] = engine.run(inputs)
+    return {
+        "results": [r.model_dump() for r in results],
+        "matches": sum(1 for r in results if r.matched),
+        "network": _network_payload(),
+    }
+
+
+@router.get("/stats")
+async def get_stats() -> dict:
+    return engine.stats.as_dict()
+
+
+@router.get("/history")
+async def get_history() -> dict:
+    return {
+        "version": engine.network.version,
+        "snapshots": [
+            {
+                "version": s.version,
+                "reason": s.reason,
+                "timestamp": s.timestamp,
+                "diagram": to_vis_network(s.nodes, s.edges),
+            }
+            for s in engine.network.history
+        ],
+    }
+
+
+@router.post("/reset")
+async def reset_simulation() -> dict:
+    engine.reset()
+    return _network_payload()

backend/app/data/decidron/default_network.json

@@ -0,0 +1,16 @@
+{
+  "nodes": [
+    { "id": "temperature", "label": "Temperature Sensor", "type": "sensor" },
+    { "id": "D1", "label": "Decidron D1", "type": "decidron" },
+    { "id": "D2", "label": "Decidron D2", "type": "decidron" },
+    { "id": "actuator-1", "label": "Failsafe Actuator", "type": "actuator" }
+  ],
+  "edges": [
+    { "from": "temperature", "to": "D1", "label": "senses" },
+    { "from": "temperature", "to": "D2", "label": "senses (redundant)" },
+    { "from": "D1", "to": "D2", "label": "coupling" },
+    { "from": "D2", "to": "D1", "label": "coupling" },
+    { "from": "D1", "to": "actuator-1", "label": "drives" },
+    { "from": "D2", "to": "actuator-1", "label": "drives (redundant)" }
+  ]
+}

backend/app/data/decidron/sample_commands.json

@@ -0,0 +1,20 @@
+[
+  {
+    "name": "HighTempAlert",
+    "sensor": "temperature",
+    "match": "gte:85",
+    "output": "Trigger failsafe review",
+    "actuator": "actuator-1"
+  },
+  {
+    "name": "CriticalTempReconfigure",
+    "sensor": "temperature",
+    "match": "gte:95",
+    "output": "Spin up redundant Decidron D3 and couple it to the failsafe actuator",
+    "network_ops": [
+      { "op": "add_node", "node": { "id": "D3", "label": "Decidron D3", "type": "decidron" } },
+      { "op": "add_edge", "from": "temperature", "to": "D3" },
+      { "op": "add_edge", "from": "D3", "to": "actuator-1" }
+    ]
+  }
+]

backend/app/decidron/__init__.py

@@ -0,0 +1,7 @@
+"""Decidron network simulator package.
+
+A deterministic, LLM-free simulation of the patent's (US11989636B1)
+Decidron network: machine-learning decision units (Decidrons) coupled
+with sensors and actuators, that record experience, fire rule-based
+actions, and can modify their own topology.
+"""

backend/app/decidron/diagrams.py

@@ -0,0 +1,48 @@
+"""Convert Decidron network state into vis-network diagram JSON.
+
+Uses ``networkx`` as the server-side graph representation and emits
+``{nodes, edges}`` shaped for the vis-network frontend, styled by node
+type (sensor / decidron / actuator).
+"""
+
+from __future__ import annotations
+
+import networkx as nx
+
+from .models import DecidronNode, Edge
+
+_GROUP_STYLE = {
+    "sensor": {"shape": "box", "color": "#3b82f6"},
+    "decidron": {"shape": "hexagon", "color": "#8b5cf6"},
+    "actuator": {"shape": "triangle", "color": "#10b981"},
+}
+
+
+def build_graph(nodes: list[DecidronNode], edges: list[Edge]) -> nx.DiGraph:
+    g = nx.DiGraph()
+    for n in nodes:
+        g.add_node(n.id, label=n.label, type=n.type, experience=len(n.experience))
+    for e in edges:
+        g.add_edge(e.source, e.target, label=e.label or "")
+    return g
+
+
+def to_vis_network(nodes: list[DecidronNode], edges: list[Edge]) -> dict:
+    """Return a vis-network ``{nodes, edges}`` payload."""
+    g = build_graph(nodes, edges)
+    vis_nodes = []
+    for node_id, data in g.nodes(data=True):
+        ntype = data.get("type", "decidron")
+        style = _GROUP_STYLE.get(ntype, {})
+        vis_nodes.append({
+            "id": node_id,
+            "label": data.get("label", node_id),
+            "group": ntype,
+            "title": f"{ntype} - {data.get('experience', 0)} experience events",
+            **style,
+        })
+    vis_edges = [
+        {"from": s, "to": t, "label": d.get("label", ""), "arrows": "to"}
+        for s, t, d in g.edges(data=True)
+    ]
+    return {"nodes": vis_nodes, "edges": vis_edges}

backend/app/decidron/engine.py

@@ -0,0 +1,207 @@
+"""Deterministic Decidron processing engine.
+
+Ties the network topology, statistics, user commands, and queued sensor
+inputs together. On each run it matches commands against sensor inputs
+and, for every match:
+
+1. records ECDS-like experience events on the involved nodes
+   (sensor received -> decidron fired -> actuator acted),
+2. emits the command output and drives the target actuator (if any),
+3. applies topology ``network_ops`` (snapshotting history),
+4. updates performance statistics.
+
+No LLM is involved -- v1 is purely rule-based.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+import time
+from pathlib import Path
+
+from .models import (
+    ExperienceEvent,
+    ProcessingCommand,
+    RunResult,
+    SensorInput,
+)
+from .network import NetworkStore
+from .stats import StatsCollector
+
+_DATA_DIR = Path(__file__).resolve().parent.parent / "data" / "decidron"
+_SAMPLE_COMMANDS = _DATA_DIR / "sample_commands.json"
+
+
+def _matches(rule: str, value: str) -> bool:
+    """Evaluate an ``operator:value`` match rule against a sensor value."""
+    if ":" in rule:
+        op, _, target = rule.partition(":")
+        op = op.strip().lower()
+        target = target.strip()
+    else:
+        op, target = "contains", rule.strip()
+
+    v = value.strip()
+
+    def _nums():
+        try:
+            return float(v), float(target)
+        except (TypeError, ValueError):
+            return None, None
+
+    if op == "contains":
+        return target.lower() in v.lower()
+    if op == "equals":
+        return v.lower() == target.lower()
+    if op == "startswith":
+        return v.lower().startswith(target.lower())
+    if op == "endswith":
+        return v.lower().endswith(target.lower())
+    if op == "regex":
+        try:
+            return re.search(target, v) is not None
+        except re.error:
+            return False
+    if op in {"gt", "lt", "gte", "lte"}:
+        a, b = _nums()
+        if a is None:
+            return False
+        return {
+            "gt": a > b,
+            "lt": a < b,
+            "gte": a >= b,
+            "lte": a <= b,
+        }[op]
+    # Unknown operator -> no match.
+    return False
+
+
+class DecidronEngine:
+    def __init__(self) -> None:
+        self.network = NetworkStore()
+        self.stats = StatsCollector()
+        self.commands: dict[str, ProcessingCommand] = {}
+        self.pending_inputs: list[SensorInput] = []
+        self.input_log: list[SensorInput] = []
+        self.run_results: list[RunResult] = []
+        self._load_sample_commands()
+
+    def _load_sample_commands(self) -> None:
+        if _SAMPLE_COMMANDS.is_file():
+            for c in json.loads(_SAMPLE_COMMANDS.read_text(encoding="utf-8")):
+                cmd = ProcessingCommand(**c)
+                self.commands[cmd.name] = cmd
+
+    # -- commands --------------------------------------------------------
+
+    def list_commands(self) -> list[ProcessingCommand]:
+        return list(self.commands.values())
+
+    def add_command(self, command: ProcessingCommand) -> ProcessingCommand:
+        self.commands[command.name] = command
+        return command
+
+    # -- sensor inputs ---------------------------------------------------
+
+    def add_sensor_input(self, sensor_input: SensorInput) -> SensorInput:
+        self.pending_inputs.append(sensor_input)
+        return sensor_input
+
+    # -- experience (ECDS-like) -----------------------------------------
+
+    def _record(self, node_id: str, event: ExperienceEvent) -> None:
+        node = self.network.nodes.get(node_id)
+        if node is not None:
+            node.experience.append(event)
+
+    def _decidrons_for_sensor(self, sensor_node_id: str | None) -> list[str]:
+        """Decidron nodes coupled downstream of a sensor (fallback: all)."""
+        if sensor_node_id is not None:
+            coupled = [
+                nid for nid in self.network.neighbors_out(sensor_node_id)
+                if self.network.nodes.get(nid) and self.network.nodes[nid].type == "decidron"
+            ]
+            if coupled:
+                return coupled
+        return [n.id for n in self.network.nodes_list() if n.type == "decidron"]
+
+    # -- run -------------------------------------------------------------
+
+    def run(self, inputs: list[SensorInput] | None = None) -> list[RunResult]:
+        batch = inputs if inputs is not None else list(self.pending_inputs)
+        results: list[RunResult] = []
+
+        for si in batch:
+            sensor_node = self.network.find_sensor_node(si.channel)
+            if sensor_node is not None:
+                self._record(sensor_node.id, ExperienceEvent(
+                    kind="sensor_received",
+                    detail=f"received '{si.value}' on channel '{si.channel}'",
+                    sensor=si.channel,
+                    value=si.value,
+                ))
+
+            for cmd in self.commands.values():
+                if cmd.sensor.lower() != si.channel.lower():
+                    continue
+                start = time.perf_counter()
+                matched = _matches(cmd.match, si.value)
+                ops_applied = 0
+                output = None
+                actuator = None
+
+                if matched:
+                    output = cmd.output
+                    for nid in self._decidrons_for_sensor(
+                        sensor_node.id if sensor_node else None
+                    ):
+                        self._record(nid, ExperienceEvent(
+                            kind="rule_fired",
+                            detail=f"command '{cmd.name}' fired -> {cmd.output}",
+                            command=cmd.name,
+                            sensor=si.channel,
+                            value=si.value,
+                        ))
+                    if cmd.actuator and cmd.actuator in self.network.nodes:
+                        actuator = cmd.actuator
+                        self._record(cmd.actuator, ExperienceEvent(
+                            kind="actuator_acted",
+                            detail=f"actuated by '{cmd.name}': {cmd.output}",
+                            command=cmd.name,
+                        ))
+                    if cmd.network_ops:
+                        ops_applied = self.network.apply_ops(
+                            cmd.network_ops, reason=f"command '{cmd.name}' fired"
+                        )
+
+                latency_ms = (time.perf_counter() - start) * 1000.0
+                self.stats.record(si.channel, cmd.name, output, matched, latency_ms)
+                result = RunResult(
+                    command=cmd.name,
+                    sensor=si.channel,
+                    value=si.value,
+                    matched=matched,
+                    output=output,
+                    actuator=actuator,
+                    network_ops_applied=ops_applied,
+                    latency_ms=round(latency_ms, 4),
+                )
+                results.append(result)
+
+            self.input_log.append(si)
+
+        if inputs is None:
+            self.pending_inputs.clear()
+        self.run_results.extend(results)
+        return results
+
+    def reset(self) -> None:
+        self.network.reset()
+        self.stats.reset()
+        self.pending_inputs.clear()
+        self.input_log.clear()
+        self.run_results.clear()
+
+
+engine = DecidronEngine()

backend/app/decidron/models.py

@@ -0,0 +1,106 @@
+"""Pydantic schemas for the Decidron simulator.
+
+These model the patent's core objects in a deliberately simplified,
+deterministic form:
+
+- ``DecidronNode``  -> a coupled MLU node (decidron) or a sensor/actuator.
+- ``Edge``          -> a coupling between nodes.
+- ``ExperienceEvent`` -> a simplified ECDS entry recorded on a node.
+- ``ProcessingCommand`` -> a user-defined IF (sensor matches) THEN
+  (emit output / drive actuator / modify network) rule.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import Literal, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+NodeType = Literal["decidron", "sensor", "actuator"]
+NetworkOpType = Literal["add_edge", "remove_edge", "add_node"]
+ExperienceKind = Literal["sensor_received", "rule_fired", "actuator_acted"]
+
+
+class ExperienceEvent(BaseModel):
+    """A simplified ECDS (Experience Chain Data Structure) entry.
+
+    The patent's signature behavior is that each unit records its
+    experience; in v1 we capture the salient facts of each run.
+    """
+
+    kind: ExperienceKind
+    detail: str
+    command: Optional[str] = None
+    sensor: Optional[str] = None
+    value: Optional[str] = None
+    timestamp: float = Field(default_factory=time.time)
+
+
+class DecidronNode(BaseModel):
+    id: str
+    label: str
+    type: NodeType = "decidron"
+    experience: list[ExperienceEvent] = Field(default_factory=list)
+
+
+class Edge(BaseModel):
+    """A directed coupling between two nodes (``from`` -> ``to``)."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    source: str = Field(alias="from")
+    target: str = Field(alias="to")
+    label: Optional[str] = None
+
+
+class NetworkOp(BaseModel):
+    """A topology modification applied when a command fires."""
+
+    model_config = ConfigDict(populate_by_name=True)
+
+    op: NetworkOpType
+    source: Optional[str] = Field(default=None, alias="from")
+    target: Optional[str] = Field(default=None, alias="to")
+    node: Optional[DecidronNode] = None
+
+
+class SensorInput(BaseModel):
+    channel: str
+    value: str
+    timestamp: float = Field(default_factory=time.time)
+
+
+class ProcessingCommand(BaseModel):
+    """A user-defined processing rule.
+
+    ``match`` is an ``operator:value`` string, e.g. ``contains:85``,
+    ``equals:on``, ``gt:80``. A bare value is treated as ``contains``.
+    """
+
+    name: str
+    sensor: str
+    match: str
+    output: str
+    actuator: Optional[str] = None
+    network_ops: list[NetworkOp] = Field(default_factory=list)
+
+
+class NetworkSnapshot(BaseModel):
+    version: int
+    reason: str
+    nodes: list[DecidronNode]
+    edges: list[Edge]
+    timestamp: float = Field(default_factory=time.time)
+
+
+class RunResult(BaseModel):
+    command: str
+    sensor: str
+    value: str
+    matched: bool
+    output: Optional[str] = None
+    actuator: Optional[str] = None
+    network_ops_applied: int = 0
+    latency_ms: float = 0.0
+    timestamp: float = Field(default_factory=time.time)

backend/app/decidron/network.py

@@ -0,0 +1,101 @@
+"""In-memory Decidron network state with version history.
+
+Holds the live topology (nodes + directed couplings), applies topology
+modifications, and snapshots the network whenever it changes so the UI
+can show before/after diagrams.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .models import DecidronNode, Edge, NetworkOp, NetworkSnapshot
+
+_DATA_DIR = Path(__file__).resolve().parent.parent / "data" / "decidron"
+_DEFAULT_NETWORK = _DATA_DIR / "default_network.json"
+
+
+class NetworkStore:
+    def __init__(self) -> None:
+        self.nodes: dict[str, DecidronNode] = {}
+        self.edges: list[Edge] = []
+        self.version: int = 0
+        self.history: list[NetworkSnapshot] = []
+        self.load_default()
+
+    def load_default(self) -> None:
+        raw = json.loads(_DEFAULT_NETWORK.read_text(encoding="utf-8"))
+        self.nodes = {n["id"]: DecidronNode(**n) for n in raw.get("nodes", [])}
+        self.edges = [Edge(**e) for e in raw.get("edges", [])]
+        self.version = 0
+        self.history = []
+        self._snapshot("initial network")
+
+    def reset(self) -> None:
+        self.load_default()
+
+    # -- queries ---------------------------------------------------------
+
+    def neighbors_out(self, node_id: str) -> list[str]:
+        """Nodes reachable from ``node_id`` via an outgoing coupling."""
+        return [e.target for e in self.edges if e.source == node_id]
+
+    def nodes_list(self) -> list[DecidronNode]:
+        return list(self.nodes.values())
+
+    def find_sensor_node(self, channel: str) -> DecidronNode | None:
+        """Match a sensor channel to a sensor node by id or label."""
+        for node in self.nodes.values():
+            if node.type != "sensor":
+                continue
+            if node.id == channel or node.label.lower() == channel.lower():
+                return node
+        return None
+
+    # -- mutations -------------------------------------------------------
+
+    def _snapshot(self, reason: str) -> None:
+        self.history.append(
+            NetworkSnapshot(
+                version=self.version,
+                reason=reason,
+                nodes=[n.model_copy(deep=True) for n in self.nodes.values()],
+                edges=[e.model_copy(deep=True) for e in self.edges],
+            )
+        )
+
+    def _edge_exists(self, source: str, target: str) -> bool:
+        return any(e.source == source and e.target == target for e in self.edges)
+
+    def apply_op(self, op: NetworkOp) -> bool:
+        """Apply a single topology op. Returns True if the graph changed."""
+        if op.op == "add_node" and op.node is not None:
+            if op.node.id not in self.nodes:
+                self.nodes[op.node.id] = op.node
+                return True
+            return False
+        if op.op == "add_edge" and op.source and op.target:
+            if not self._edge_exists(op.source, op.target):
+                self.edges.append(Edge(source=op.source, target=op.target))
+                return True
+            return False
+        if op.op == "remove_edge" and op.source and op.target:
+            before = len(self.edges)
+            self.edges = [
+                e for e in self.edges
+                if not (e.source == op.source and e.target == op.target)
+            ]
+            return len(self.edges) != before
+        return False
+
+    def apply_ops(self, ops: list[NetworkOp], reason: str) -> int:
+        """Apply ops, snapshotting once if anything changed. Returns count."""
+        changed = 0
+        for op in ops:
+            if self.apply_op(op):
+                changed += 1
+        if changed:
+            self.version += 1
+            self._snapshot(reason)
+        return changed

backend/app/decidron/stats.py

@@ -0,0 +1,62 @@
+"""Performance statistics for the Decidron simulator.
+
+Aggregates per-sensor, per-command, and per-output counts plus latency
+and last-run timestamps -- a deterministic stand-in for the patent's
+"results determined and scored" step.
+"""
+
+from __future__ import annotations
+
+import time
+from collections import defaultdict
+
+
+class StatsCollector:
+    def __init__(self) -> None:
+        self.sensors: dict[str, dict] = defaultdict(self._blank)
+        self.commands: dict[str, dict] = defaultdict(self._blank)
+        self.outputs: dict[str, dict] = defaultdict(self._blank)
+        self.total_runs: int = 0
+        self.total_matches: int = 0
+
+    @staticmethod
+    def _blank() -> dict:
+        return {"count": 0, "matches": 0, "last_run": None, "avg_latency_ms": 0.0}
+
+    @staticmethod
+    def _update(bucket: dict, matched: bool, latency_ms: float) -> None:
+        n = bucket["count"]
+        bucket["count"] = n + 1
+        if matched:
+            bucket["matches"] += 1
+        # incremental average latency
+        bucket["avg_latency_ms"] = (bucket["avg_latency_ms"] * n + latency_ms) / (n + 1)
+        bucket["last_run"] = time.time()
+
+    def record(
+        self,
+        sensor: str,
+        command: str,
+        output: str | None,
+        matched: bool,
+        latency_ms: float,
+    ) -> None:
+        self.total_runs += 1
+        if matched:
+            self.total_matches += 1
+        self._update(self.sensors[sensor], matched, latency_ms)
+        self._update(self.commands[command], matched, latency_ms)
+        if matched and output:
+            self._update(self.outputs[output], True, latency_ms)
+
+    def reset(self) -> None:
+        self.__init__()
+
+    def as_dict(self) -> dict:
+        return {
+            "total_runs": self.total_runs,
+            "total_matches": self.total_matches,
+            "per_sensor": dict(self.sensors),
+            "per_command": dict(self.commands),
+            "per_output": dict(self.outputs),
+        }

backend/app/main.py

@@ -7,6 +7,7 @@ from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 
 from app.config import settings
+from app.api import decidron
 
 logging.basicConfig(level=logging.INFO)
 LOG = logging.getLogger(__name__)
@@ -26,6 +27,9 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+app.include_router(decidron.router, prefix="/api")
+
+
 @app.get("/api/health")
 async def health():
     return {"status": "ok"}

backend/requirements.txt

@@ -2,4 +2,5 @@ fastapi>=0.115.0
 uvicorn[standard]>=0.32.0
 pydantic-settings>=2.6.0
 python-dotenv>=1.0.0
+networkx>=3.3
 pytest>=8.0.0

docker-compose.yml

@@ -10,5 +10,4 @@ services:
       - .env
     environment:
       CORS_ORIGINS: "http://localhost:7860,http://localhost:3000"
-      HF_RATE_LIMIT_DAILY: "30"
     restart: unless-stopped

frontend/package-lock.json

@@ -11,7 +11,9 @@
         "lucide-react": "^0.577.0",
         "react": "^19.2.4",
         "react-dom": "^19.2.4",
-        "react-scripts": "5.0.1"
+        "react-scripts": "5.0.1",
+        "vis-data": "^7.1.9",
+        "vis-network": "^9.1.9"
       }
     },
     "node_modules/@alloc/quick-lru": {
@@ -2386,6 +2388,19 @@
         "postcss-selector-parser": "^6.0.10"
       }
     },
+    "node_modules/@egjs/hammerjs": {
+      "version": "2.0.17",
+      "resolved": "https://registry.npmjs.org/@egjs/hammerjs/-/hammerjs-2.0.17.tgz",
+      "integrity": "sha512-XQsZgjm2EcVUiZQf11UBJQfmZeEmOW8DpI1gsFeln6w0ae0ii4dMQEQ0kjl6DspdWX1aGY1/loyXnP0JS06e/A==",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/hammerjs": "^2.0.36"
+      },
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
     "node_modules/@eslint-community/eslint-utils": {
       "version": "4.9.1",
       "resolved": "https://registry.npmjs.org/@eslint-community/eslint-utils/-/eslint-utils-4.9.1.tgz",
@@ -3499,6 +3514,13 @@
         "@types/node": "*"
       }
     },
+    "node_modules/@types/hammerjs": {
+      "version": "2.0.46",
+      "resolved": "https://registry.npmjs.org/@types/hammerjs/-/hammerjs-2.0.46.tgz",
+      "integrity": "sha512-ynRvcq6wvqexJ9brDMS4BnBLzmr0e14d6ZJTEShTBWKymQiHwlAyGu0ZPEFI2Fh1U53F7tN9ufClWM5KvqkKOw==",
+      "license": "MIT",
+      "peer": true
+    },
     "node_modules/@types/html-minifier-terser": {
       "version": "6.1.0",
       "resolved": "https://registry.npmjs.org/@types/html-minifier-terser/-/html-minifier-terser-6.1.0.tgz",
@@ -5626,6 +5648,19 @@
       "integrity": "sha512-W9pAhw0ja1Edb5GVdIF1mjZw/ASI0AlShXM83UUGe2DVr5TdAPEA1OA8m/g8zWp9x6On7gqufY+FatDbC3MDQg==",
       "license": "MIT"
     },
+    "node_modules/component-emitter": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/component-emitter/-/component-emitter-2.0.0.tgz",
+      "integrity": "sha512-4m5s3Me2xxlVKG9PkZpQqHQR7bgpnN7joDMJ4yvVkVXngjoITG76IaZmzmywSeRTeTpc6N6r3H3+KyUurV8OYw==",
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/compressible": {
       "version": "2.0.18",
       "resolved": "https://registry.npmjs.org/compressible/-/compressible-2.0.18.tgz",
@@ -10794,6 +10829,13 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/keycharm": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/keycharm/-/keycharm-0.4.0.tgz",
+      "integrity": "sha512-TyQTtsabOVv3MeOpR92sIKk/br9wxS+zGj4BG7CR8YbK4jM3tyIBaF0zhzeBUMx36/Q/iQLOKKOT+3jOQtemRQ==",
+      "license": "(Apache-2.0 OR MIT)",
+      "peer": true
+    },
     "node_modules/keyv": {
       "version": "4.5.4",
       "resolved": "https://registry.npmjs.org/keyv/-/keyv-4.5.4.tgz",
@@ -16204,6 +16246,56 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/vis-data": {
+      "version": "7.1.10",
+      "resolved": "https://registry.npmjs.org/vis-data/-/vis-data-7.1.10.tgz",
+      "integrity": "sha512-23juM9tdCaHTX5vyIQ7XBzsfZU0Hny+gSTwniLrfFcmw9DOm7pi3+h9iEBsoZMp5rX6KNqWwc1MF0fkAmWVuoQ==",
+      "license": "(Apache-2.0 OR MIT)",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/visjs"
+      },
+      "peerDependencies": {
+        "uuid": "^3.4.0 || ^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0 || ^11.0.0",
+        "vis-util": "^5.0.1"
+      }
+    },
+    "node_modules/vis-network": {
+      "version": "9.1.13",
+      "resolved": "https://registry.npmjs.org/vis-network/-/vis-network-9.1.13.tgz",
+      "integrity": "sha512-HLeHd5KZS92qzO1kC59qMh1/FWAZxMUEwUWBwDMoj6RKj/Ajkrgy/heEYo0Zc8SZNQ2J+u6omvK2+a28GX1QuQ==",
+      "license": "(Apache-2.0 OR MIT)",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/visjs"
+      },
+      "peerDependencies": {
+        "@egjs/hammerjs": "^2.0.0",
+        "component-emitter": "^1.3.0 || ^2.0.0",
+        "keycharm": "^0.2.0 || ^0.3.0 || ^0.4.0",
+        "uuid": "^3.4.0 || ^7.0.0 || ^8.0.0 || ^9.0.0 || ^10.0.0 || ^11.0.0",
+        "vis-data": "^6.3.0 || ^7.0.0",
+        "vis-util": "^5.0.1"
+      }
+    },
+    "node_modules/vis-util": {
+      "version": "5.0.7",
+      "resolved": "https://registry.npmjs.org/vis-util/-/vis-util-5.0.7.tgz",
+      "integrity": "sha512-E3L03G3+trvc/X4LXvBfih3YIHcKS2WrP0XTdZefr6W6Qi/2nNCqZfe4JFfJU6DcQLm6Gxqj2Pfl+02859oL5A==",
+      "license": "(Apache-2.0 OR MIT)",
+      "peer": true,
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/visjs"
+      },
+      "peerDependencies": {
+        "@egjs/hammerjs": "^2.0.0",
+        "component-emitter": "^1.3.0 || ^2.0.0"
+      }
+    },
     "node_modules/w3c-hr-time": {
       "version": "1.0.2",
       "resolved": "https://registry.npmjs.org/w3c-hr-time/-/w3c-hr-time-1.0.2.tgz",

frontend/package.json

@@ -6,7 +6,9 @@
     "lucide-react": "^0.577.0",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
-    "react-scripts": "5.0.1"
+    "react-scripts": "5.0.1",
+    "vis-data": "^7.1.9",
+    "vis-network": "^9.1.9"
   },
   "scripts": {
     "start": "react-scripts start",

frontend/src/App.js

@@ -1,5 +1,6 @@
 import React, { useState, useEffect } from 'react';
 import Header from './components/Header';
+import DecidronSimulator from './components/decidron/DecidronSimulator';
 import './styles/variables.css';
 import './styles/layout.css';
 import './styles/components.css';
@@ -24,9 +25,7 @@ export default function App() {
     <div className="app">
       <Header theme={theme} onToggleTheme={toggleTheme} />
       <main className="app-main">
-        <p style={{ padding: '2rem', opacity: 0.7 }}>
-          Decidron Network Simulator — UI loading…
-        </p>
+        <DecidronSimulator />
       </main>
     </div>
   );

frontend/src/components/decidron/CommandBuilder.js

@@ -0,0 +1,102 @@
+import React, { useState } from 'react';
+import { Plus } from 'lucide-react';
+
+const MATCH_OPS = ['contains', 'equals', 'gt', 'gte', 'lt', 'lte', 'startswith', 'endswith', 'regex'];
+
+export default function CommandBuilder({ commands, sensors, nodes, onCreate }) {
+  const [name, setName] = useState('');
+  const [sensor, setSensor] = useState('');
+  const [op, setOp] = useState('gte');
+  const [matchValue, setMatchValue] = useState('');
+  const [output, setOutput] = useState('');
+  const [actuator, setActuator] = useState('');
+  const [error, setError] = useState(null);
+
+  const actuators = nodes.filter((n) => n.type === 'actuator');
+
+  const submit = async (e) => {
+    e.preventDefault();
+    setError(null);
+    if (!name || !sensor || matchValue === '' || !output) {
+      setError('Name, sensor, match value, and output are required.');
+      return;
+    }
+    try {
+      await onCreate({
+        name,
+        sensor,
+        match: `${op}:${matchValue}`,
+        output,
+        actuator: actuator || null,
+      });
+      setName(''); setMatchValue(''); setOutput(''); setActuator('');
+    } catch (err) {
+      setError(err.message);
+    }
+  };
+
+  return (
+    <div className="decidron-panel">
+      <h2>Processing Commands</h2>
+      <p className="panel-hint">
+        Define IF (sensor matches) THEN (emit output, optionally drive an
+        actuator). Commands fire when you run the simulation.
+      </p>
+
+      {error && <div className="decidron-error">{error}</div>}
+
+      <form onSubmit={submit}>
+        <div className="decidron-row">
+          <div className="decidron-field" style={{ flex: 1 }}>
+            <label>Name</label>
+            <input value={name} onChange={(e) => setName(e.target.value)} placeholder="HighTempAlert" />
+          </div>
+          <div className="decidron-field" style={{ flex: 1 }}>
+            <label>Sensor</label>
+            <select value={sensor} onChange={(e) => setSensor(e.target.value)}>
+              <option value="">Select…</option>
+              {sensors.map((s) => <option key={s.id} value={s.id}>{s.label}</option>)}
+            </select>
+          </div>
+        </div>
+        <div className="decidron-row">
+          <div className="decidron-field" style={{ width: 120 }}>
+            <label>Match</label>
+            <select value={op} onChange={(e) => setOp(e.target.value)}>
+              {MATCH_OPS.map((o) => <option key={o} value={o}>{o}</option>)}
+            </select>
+          </div>
+          <div className="decidron-field" style={{ flex: 1 }}>
+            <label>Value</label>
+            <input value={matchValue} onChange={(e) => setMatchValue(e.target.value)} placeholder="85" />
+          </div>
+          <div className="decidron-field" style={{ flex: 1 }}>
+            <label>Actuator (optional)</label>
+            <select value={actuator} onChange={(e) => setActuator(e.target.value)}>
+              <option value="">None</option>
+              {actuators.map((a) => <option key={a.id} value={a.id}>{a.label}</option>)}
+            </select>
+          </div>
+        </div>
+        <div className="decidron-field">
+          <label>Output</label>
+          <input value={output} onChange={(e) => setOutput(e.target.value)} placeholder="Trigger failsafe review" />
+        </div>
+        <button type="submit" className="decidron-btn">
+          <Plus size={14} style={{ marginRight: 4, verticalAlign: 'middle' }} />
+          Add Command
+        </button>
+      </form>
+
+      <div style={{ marginTop: '0.75rem' }}>
+        {commands.map((c) => (
+          <div className="decidron-cmd" key={c.name}>
+            <strong>{c.name}</strong>: IF <code>{c.sensor}</code> <code>{c.match}</code> THEN {c.output}
+            {c.actuator && <> → drives <code>{c.actuator}</code></>}
+            {c.network_ops && c.network_ops.length > 0 && <> <span className="decidron-chip">{c.network_ops.length} network op(s)</span></>}
+          </div>
+        ))}
+      </div>
+    </div>
+  );
+}

frontend/src/components/decidron/DecidronSimulator.js

@@ -0,0 +1,149 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import { RotateCcw } from 'lucide-react';
+import NetworkDiagram from './NetworkDiagram';
+import SensorInputForm from './SensorInputForm';
+import CommandBuilder from './CommandBuilder';
+import ResultsPanel from './ResultsPanel';
+import StatsTable from './StatsTable';
+import HistoryTimeline from './HistoryTimeline';
+import {
+  getNetwork, getCommands, getStats, getHistory,
+  submitSensorInput, runSimulation, createCommand, resetSimulation,
+} from '../../utils/api';
+import '../../styles/decidron.css';
+
+export default function DecidronSimulator() {
+  const [network, setNetwork] = useState(null);
+  const [commands, setCommands] = useState([]);
+  const [stats, setStats] = useState(null);
+  const [history, setHistory] = useState([]);
+  const [results, setResults] = useState([]);
+  const [pending, setPending] = useState([]);
+  const [selected, setSelected] = useState(null); // null = live network
+  const [running, setRunning] = useState(false);
+  const [error, setError] = useState(null);
+
+  const refreshAll = useCallback(async () => {
+    try {
+      const [net, cmds, st, hist] = await Promise.all([
+        getNetwork(), getCommands(), getStats(), getHistory(),
+      ]);
+      setNetwork(net);
+      setCommands(cmds);
+      setStats(st);
+      setHistory(hist.snapshots);
+    } catch (err) {
+      setError(err.message);
+    }
+  }, []);
+
+  useEffect(() => { refreshAll(); }, [refreshAll]);
+
+  const handleQueue = async (channel, value) => {
+    setError(null);
+    try {
+      await submitSensorInput(channel, value);
+      setPending((prev) => [...prev, { channel, value }]);
+    } catch (err) {
+      setError(err.message);
+    }
+  };
+
+  const handleRun = async () => {
+    setRunning(true);
+    setError(null);
+    try {
+      const resp = await runSimulation();
+      setResults(resp.results);
+      setNetwork(resp.network);
+      setSelected(null);
+      setPending([]);
+      const [st, hist] = await Promise.all([getStats(), getHistory()]);
+      setStats(st);
+      setHistory(hist.snapshots);
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setRunning(false);
+    }
+  };
+
+  const handleCreate = async (cmd) => {
+    await createCommand(cmd);
+    setCommands(await getCommands());
+  };
+
+  const handleReset = async () => {
+    setError(null);
+    try {
+      await resetSimulation();
+      setResults([]);
+      setPending([]);
+      setSelected(null);
+      await refreshAll();
+    } catch (err) {
+      setError(err.message);
+    }
+  };
+
+  if (!network) {
+    return (
+      <div className="decidron-app">
+        {error ? <div className="decidron-error">{error}</div> : <p>Loading…</p>}
+      </div>
+    );
+  }
+
+  const sensors = network.nodes.filter((n) => n.type === 'sensor');
+  const shownDiagram = selected ? selected.diagram : network.diagram;
+  const shownVersion = selected ? selected.version : network.version;
+
+  return (
+    <div className="decidron-app">
+      {error && <div className="decidron-error">{error}</div>}
+      <div className="decidron-grid">
+        <div>
+          <div className="decidron-panel">
+            <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+              <h2>Decidron Network (v{shownVersion}{selected ? ' — historical' : ' — live'})</h2>
+              <button type="button" className="decidron-btn secondary" onClick={handleReset}>
+                <RotateCcw size={13} style={{ marginRight: 4, verticalAlign: 'middle' }} />
+                Reset
+              </button>
+            </div>
+            <p className="panel-hint">
+              Sensors (blue) feed coupled Decidrons (purple) that drive
+              actuators (green). Commands can modify this topology.
+            </p>
+            <NetworkDiagram data={shownDiagram} />
+          </div>
+          <HistoryTimeline
+            snapshots={history}
+            selectedVersion={selected ? selected.version : null}
+            onSelect={(s) => setSelected(
+              s.version === network.version ? null : s
+            )}
+          />
+        </div>
+
+        <div>
+          <SensorInputForm
+            sensors={sensors}
+            pending={pending}
+            onQueue={handleQueue}
+            onRun={handleRun}
+            running={running}
+          />
+          <CommandBuilder
+            commands={commands}
+            sensors={sensors}
+            nodes={network.nodes}
+            onCreate={handleCreate}
+          />
+          <ResultsPanel results={results} />
+          <StatsTable stats={stats} />
+        </div>
+      </div>
+    </div>
+  );
+}

frontend/src/components/decidron/HistoryTimeline.js

@@ -0,0 +1,29 @@
+import React from 'react';
+
+export default function HistoryTimeline({ snapshots, selectedVersion, onSelect }) {
+  return (
+    <div className="decidron-panel">
+      <h2>Network Modification History</h2>
+      <p className="panel-hint">
+        Each topology change is snapshotted. Select a version to view that
+        network state in the diagram above.
+      </p>
+      {(!snapshots || snapshots.length === 0) ? (
+        <p className="panel-hint">No snapshots yet.</p>
+      ) : (
+        snapshots.map((s) => (
+          <div
+            key={s.version}
+            className={`decidron-history-item ${s.version === selectedVersion ? 'active' : ''}`}
+            onClick={() => onSelect(s)}
+          >
+            <strong>v{s.version}</strong> — {s.reason}
+            <span style={{ float: 'right', opacity: 0.6 }}>
+              {new Date(s.timestamp * 1000).toLocaleTimeString()}
+            </span>
+          </div>
+        ))
+      )}
+    </div>
+  );
+}

frontend/src/components/decidron/NetworkDiagram.js

@@ -0,0 +1,54 @@
+import React, { useEffect, useRef } from 'react';
+import { Network } from 'vis-network/standalone';
+
+const OPTIONS = {
+  autoResize: true,
+  nodes: {
+    borderWidth: 2,
+    font: { color: '#ffffff', size: 14 },
+  },
+  edges: {
+    arrows: 'to',
+    color: { color: '#9aa3b2', highlight: '#6366F1' },
+    font: { size: 10, color: '#9aa3b2', strokeWidth: 0, align: 'middle' },
+    smooth: { type: 'cubicBezier', roundness: 0.4 },
+  },
+  groups: {
+    sensor: { shape: 'box', color: { background: '#3b82f6', border: '#1d4ed8' } },
+    decidron: { shape: 'hexagon', color: { background: '#8b5cf6', border: '#6d28d9' } },
+    actuator: { shape: 'triangle', color: { background: '#10b981', border: '#047857' } },
+  },
+  physics: {
+    stabilization: { iterations: 150 },
+    barnesHut: { springLength: 150, gravitationalConstant: -6000 },
+  },
+  interaction: { hover: true, tooltipDelay: 120 },
+};
+
+export default function NetworkDiagram({ data, height = 380 }) {
+  const containerRef = useRef(null);
+  const networkRef = useRef(null);
+
+  useEffect(() => {
+    if (!containerRef.current) return undefined;
+    networkRef.current = new Network(
+      containerRef.current,
+      data || { nodes: [], edges: [] },
+      OPTIONS,
+    );
+    return () => {
+      if (networkRef.current) {
+        networkRef.current.destroy();
+        networkRef.current = null;
+      }
+    };
+  }, [data]);
+
+  return (
+    <div
+      ref={containerRef}
+      className="decidron-diagram"
+      style={{ height, width: '100%' }}
+    />
+  );
+}

frontend/src/components/decidron/ResultsPanel.js

@@ -0,0 +1,41 @@
+import React from 'react';
+
+export default function ResultsPanel({ results }) {
+  return (
+    <div className="decidron-panel">
+      <h2>Latest Run Results</h2>
+      {(!results || results.length === 0) ? (
+        <p className="panel-hint">No runs yet. Queue a sensor input and run the simulation.</p>
+      ) : (
+        <table className="decidron-table">
+          <thead>
+            <tr>
+              <th>Command</th>
+              <th>Sensor</th>
+              <th>Value</th>
+              <th>Result</th>
+              <th>Output</th>
+              <th>Net ops</th>
+            </tr>
+          </thead>
+          <tbody>
+            {results.map((r, i) => (
+              <tr key={i}>
+                <td>{r.command}</td>
+                <td>{r.sensor}</td>
+                <td>{r.value}</td>
+                <td>
+                  <span className={`decidron-chip ${r.matched ? 'match' : 'nomatch'}`}>
+                    {r.matched ? 'matched' : 'no match'}
+                  </span>
+                </td>
+                <td>{r.output || '—'}{r.actuator ? ` → ${r.actuator}` : ''}</td>
+                <td>{r.network_ops_applied}</td>
+              </tr>
+            ))}
+          </tbody>
+        </table>
+      )}
+    </div>
+  );
+}

frontend/src/components/decidron/SensorInputForm.js

@@ -0,0 +1,73 @@
+import React, { useState, useEffect } from 'react';
+import { Activity, Play } from 'lucide-react';
+
+export default function SensorInputForm({ sensors, pending, onQueue, onRun, running }) {
+  const [channel, setChannel] = useState('');
+  const [value, setValue] = useState('');
+
+  useEffect(() => {
+    if (!channel && sensors.length) setChannel(sensors[0].id);
+  }, [sensors, channel]);
+
+  const handleQueue = (e) => {
+    e.preventDefault();
+    if (!channel || value === '') return;
+    onQueue(channel, value);
+    setValue('');
+  };
+
+  return (
+    <div className="decidron-panel">
+      <h2>Sensor Input</h2>
+      <p className="panel-hint">
+        Simulate a sensor reading, then run the network to process queued
+        inputs against your processing commands.
+      </p>
+      <form onSubmit={handleQueue}>
+        <div className="decidron-row">
+          <div className="decidron-field" style={{ flex: 1 }}>
+            <label>Channel</label>
+            <select value={channel} onChange={(e) => setChannel(e.target.value)}>
+              {sensors.map((s) => (
+                <option key={s.id} value={s.id}>{s.label}</option>
+              ))}
+            </select>
+          </div>
+          <div className="decidron-field" style={{ flex: 1 }}>
+            <label>Value</label>
+            <input
+              type="text"
+              value={value}
+              placeholder="e.g. 97"
+              onChange={(e) => setValue(e.target.value)}
+            />
+          </div>
+          <button type="submit" className="decidron-btn secondary">
+            <Activity size={14} style={{ marginRight: 4, verticalAlign: 'middle' }} />
+            Queue
+          </button>
+        </div>
+      </form>
+
+      {pending.length > 0 && (
+        <ul className="decidron-pending">
+          {pending.map((p, i) => (
+            <li key={i}>{p.channel}: {p.value}</li>
+          ))}
+        </ul>
+      )}
+
+      <div className="decidron-row" style={{ marginTop: '0.5rem' }}>
+        <button
+          type="button"
+          className="decidron-btn"
+          onClick={onRun}
+          disabled={running || pending.length === 0}
+        >
+          <Play size={14} style={{ marginRight: 4, verticalAlign: 'middle' }} />
+          {running ? 'Running…' : `Run Simulation (${pending.length})`}
+        </button>
+      </div>
+    </div>
+  );
+}

frontend/src/components/decidron/StatsTable.js

@@ -0,0 +1,47 @@
+import React from 'react';
+
+function Section({ title, data }) {
+  const rows = Object.entries(data || {});
+  if (rows.length === 0) return null;
+  return (
+    <>
+      <tr><th colSpan={4} style={{ paddingTop: '0.6rem' }}>{title}</th></tr>
+      {rows.map(([key, s]) => (
+        <tr key={title + key}>
+          <td>{key}</td>
+          <td>{s.count}</td>
+          <td>{s.matches}</td>
+          <td>{s.avg_latency_ms != null ? s.avg_latency_ms.toFixed(3) : '—'}</td>
+        </tr>
+      ))}
+    </>
+  );
+}
+
+export default function StatsTable({ stats }) {
+  const empty = !stats || stats.total_runs === 0;
+  return (
+    <div className="decidron-panel">
+      <h2>Performance Statistics</h2>
+      {empty ? (
+        <p className="panel-hint">Run the simulation to collect statistics.</p>
+      ) : (
+        <>
+          <p className="panel-hint">
+            {stats.total_runs} command evaluation(s), {stats.total_matches} match(es).
+          </p>
+          <table className="decidron-table">
+            <thead>
+              <tr><th>Key</th><th>Runs</th><th>Matches</th><th>Avg ms</th></tr>
+            </thead>
+            <tbody>
+              <Section title="Per Sensor" data={stats.per_sensor} />
+              <Section title="Per Command" data={stats.per_command} />
+              <Section title="Per Output" data={stats.per_output} />
+            </tbody>
+          </table>
+        </>
+      )}
+    </div>
+  );
+}

frontend/src/styles/decidron.css

@@ -0,0 +1,178 @@
+.decidron-app {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 1rem 1.25rem 3rem;
+}
+
+.decidron-grid {
+  display: grid;
+  grid-template-columns: minmax(0, 1.4fr) minmax(0, 1fr);
+  gap: 1rem;
+}
+
+@media (max-width: 980px) {
+  .decidron-grid { grid-template-columns: 1fr; }
+}
+
+.decidron-panel {
+  background: var(--card-bg);
+  border: 1px solid var(--border-primary);
+  border-radius: 12px;
+  box-shadow: var(--shadow-sm);
+  padding: 1rem;
+  margin-bottom: 1rem;
+}
+
+.decidron-panel h2 {
+  font-size: 0.95rem;
+  font-weight: 700;
+  color: var(--text-primary);
+  margin-bottom: 0.25rem;
+}
+
+.decidron-panel .panel-hint {
+  font-size: 0.78rem;
+  color: var(--text-tertiary);
+  margin-bottom: 0.75rem;
+}
+
+.decidron-diagram {
+  background: var(--bg-secondary);
+  border: 1px solid var(--border-primary);
+  border-radius: 10px;
+}
+
+.decidron-field {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+  margin-bottom: 0.6rem;
+}
+
+.decidron-field label {
+  font-size: 0.75rem;
+  font-weight: 600;
+  color: var(--text-secondary);
+}
+
+.decidron-field input,
+.decidron-field select {
+  padding: 0.45rem 0.55rem;
+  border: 1px solid var(--border-primary);
+  border-radius: 8px;
+  background: var(--bg-primary);
+  color: var(--text-primary);
+  font-size: 0.85rem;
+}
+
+.decidron-row {
+  display: flex;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+  align-items: flex-end;
+}
+
+.decidron-btn {
+  padding: 0.5rem 0.9rem;
+  border: none;
+  border-radius: 8px;
+  background: var(--accent-gradient);
+  color: #fff;
+  font-size: 0.85rem;
+  font-weight: 600;
+}
+
+.decidron-btn:disabled { opacity: 0.5; cursor: not-allowed; }
+
+.decidron-btn.secondary {
+  background: transparent;
+  color: var(--text-secondary);
+  border: 1px solid var(--border-primary);
+}
+
+.decidron-table {
+  width: 100%;
+  border-collapse: collapse;
+  font-size: 0.8rem;
+}
+
+.decidron-table th,
+.decidron-table td {
+  text-align: left;
+  padding: 0.4rem 0.5rem;
+  border-bottom: 1px solid var(--border-muted);
+  color: var(--text-secondary);
+}
+
+.decidron-table th { color: var(--text-tertiary); font-weight: 600; }
+
+.decidron-chip {
+  display: inline-block;
+  padding: 0.1rem 0.45rem;
+  border-radius: 999px;
+  font-size: 0.7rem;
+  font-weight: 600;
+  background: var(--accent-light);
+  color: var(--accent-primary);
+}
+
+.decidron-chip.match { background: var(--speaker-b-bg); color: var(--speaker-b-color); }
+.decidron-chip.nomatch { background: var(--bg-tertiary); color: var(--text-tertiary); }
+
+.decidron-pending {
+  list-style: none;
+  display: flex;
+  flex-wrap: wrap;
+  gap: 0.35rem;
+  margin: 0.4rem 0;
+}
+
+.decidron-pending li {
+  font-size: 0.75rem;
+  padding: 0.15rem 0.5rem;
+  border-radius: 6px;
+  background: var(--comp-bg);
+  border: 1px solid var(--comp-border);
+  color: var(--text-secondary);
+}
+
+.decidron-history-item {
+  padding: 0.5rem 0.6rem;
+  border: 1px solid var(--border-primary);
+  border-radius: 8px;
+  margin-bottom: 0.4rem;
+  cursor: pointer;
+  font-size: 0.8rem;
+  color: var(--text-secondary);
+}
+
+.decidron-history-item.active {
+  border-color: var(--accent-primary);
+  background: var(--accent-light);
+}
+
+.decidron-error {
+  background: var(--error-bg);
+  border: 1px solid var(--error-border);
+  color: var(--error-text);
+  padding: 0.5rem 0.75rem;
+  border-radius: 8px;
+  font-size: 0.82rem;
+  margin-bottom: 0.75rem;
+}
+
+.decidron-cmd {
+  border: 1px solid var(--border-primary);
+  border-radius: 8px;
+  padding: 0.5rem 0.6rem;
+  margin-bottom: 0.4rem;
+  font-size: 0.8rem;
+  color: var(--text-secondary);
+}
+
+.decidron-cmd code {
+  background: var(--bg-tertiary);
+  padding: 0.05rem 0.3rem;
+  border-radius: 4px;
+  font-size: 0.75rem;
+}

frontend/src/utils/api.js

@@ -1,385 +1,62 @@
-// Default to '' (relative URLs) so any production-style build - whether
-// done inside Docker (Dockerfile sets REACT_APP_API_URL=) or on the host
-// without that env var - hits the same origin that served the page. This
-// avoids the cross-origin trap where a `npm run build` on the host
-// without REACT_APP_API_URL would silently bake `http://localhost:8000`
-// into the bundle and break every API call from a Docker deployment.
+// API client for the Decidron network simulator.
 //
-// If you want the CRA dev server (`npm start` on :3000) to talk to a
-// FastAPI backend on :8000, set REACT_APP_API_URL=http://localhost:8000
-// in `frontend/.env.development` or your shell.
+// Defaults to relative URLs so a production build served by the FastAPI
+// container hits the same origin. For CRA dev (`npm start` on :3000),
+// set REACT_APP_API_URL=http://localhost:7860 in frontend/.env.development.
 const API_BASE = process.env.REACT_APP_API_URL !== undefined
   ? process.env.REACT_APP_API_URL
   : '';
 
-export async function fetchModels() {
-  const resp = await fetch(`${API_BASE}/api/models`, { cache: 'no-store' });
-  if (!resp.ok) throw new Error(`Failed to fetch models: ${resp.status}`);
-  return resp.json();
-}
-
-export async function fetchPersonas() {
-  const resp = await fetch(`${API_BASE}/api/personas`, { cache: 'no-store' });
-  if (!resp.ok) throw new Error(`Failed to fetch personas: ${resp.status}`);
-  return resp.json();
-}
-
-export async function fetchDemoQuestions() {
-  const resp = await fetch(`${API_BASE}/api/demo-questions`, { cache: 'no-store' });
-  if (!resp.ok) throw new Error(`Failed to fetch demo questions: ${resp.status}`);
-  return resp.json();
-}
-
-export async function generateRole({ model_id, name, profile, identity, samples, role_style }) {
-  const resp = await fetch(`${API_BASE}/api/chat/generate-role`, {
-    method: 'POST',
+async function jsonFetch(path, options = {}) {
+  const resp = await fetch(`${API_BASE}${path}`, {
     headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ model_id, name, profile, identity, samples, role_style }),
+    cache: 'no-store',
+    ...options,
   });
   if (!resp.ok) {
     const err = await resp.json().catch(() => ({ detail: resp.statusText }));
-    throw new Error(err.detail || 'Role generation failed');
-  }
-  return resp.json();
-}
-
-export async function generateRoleFreeform({ model_id, name, text, role_style }) {
-  const resp = await fetch(`${API_BASE}/api/chat/generate-role-freeform`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ model_id, name, text, role_style }),
-  });
-  if (!resp.ok) {
-    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
-    throw new Error(err.detail || 'Role generation failed');
-  }
-  return resp.json();
-}
-
-/**
- * Start a CCAI conversation and consume the SSE stream.
- *
- * Body: { question, participants[], expert_personas[], model_assignments,
- *         orchestrator_model_id, summarizer_model_id, max_participants }
- */
-export async function startChat(body, handlers, abortSignal) {
-  const resp = await fetch(`${API_BASE}/api/chat/start`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(body),
-    signal: abortSignal,
-  });
-
-  if (!resp.ok) {
-    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
-    throw new Error(err.detail || 'Chat start failed');
+    throw new Error(err.detail || `Request failed: ${resp.status}`);
   }
-
-  const reader = resp.body.getReader();
-  const decoder = new TextDecoder();
-  let buffer = '';
-
-  try {
-    while (true) {
-      if (abortSignal?.aborted) break;
-      const { value, done } = await reader.read();
-      if (done) break;
-      buffer += decoder.decode(value, { stream: true });
-
-      const parts = buffer.split('\n\n');
-      buffer = parts.pop();
-
-      for (const part of parts) {
-        const lines = part.trim().split('\n');
-        let eventType = 'message';
-        let data = '';
-        for (const line of lines) {
-          if (line.startsWith('event: ')) eventType = line.slice(7).trim();
-          else if (line.startsWith('data: ')) data = line.slice(6);
-        }
-        if (!data) continue;
-        try {
-          const parsed = JSON.parse(data);
-          const handler = handlers[eventHandlerKey(eventType)];
-          if (handler) handler(parsed);
-        } catch (e) {
-          console.warn('SSE parse error', e, data);
-        }
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  handlers.onDone?.();
-}
-
-function eventHandlerKey(eventType) {
-  switch (eventType) {
-    case 'session': return 'onSession';
-    case 'message': return 'onMessage';
-    case 'message_stream_start': return 'onMessageStreamStart';
-    case 'message_delta': return 'onMessageDelta';
-    case 'orchestrator': return 'onOrchestrator';
-    case 'system': return 'onSystem';
-    case 'status': return 'onStatus';
-    case 'error': return 'onError';
-    case 'done': return 'onDone';
-    case 'failsafe_pause': return 'onFailsafePause';
-    case 'orchestrator_cap_pause': return 'onOrchestratorCapPause';
-    case 'participant_error': return 'onParticipantError';
-    case 'participant_substituted': return 'onParticipantSubstituted';
-    case 'participant_replaced': return 'onParticipantReplaced';
-    case 'vote_cast': return 'onVoteCast';
-    case 'vote_tally': return 'onVoteTally';
-    case 'credentials_updated': return 'onCredentialsUpdated';
-    case 'human_turn_needed': return 'onHumanTurnNeeded';
-    case 'human_turn_cleared': return 'onHumanTurnCleared';
-    default: return null;
-  }
-}
-
-export async function continueChat(sessionId, reason) {
-  const resp = await fetch(
-    `${API_BASE}/api/chat/${sessionId}/continue?reason=${encodeURIComponent(reason)}`,
-    { method: 'POST' },
-  );
-  if (!resp.ok) throw new Error('Continue failed');
   return resp.json();
 }
 
-export async function getOrchestrator() {
-  const resp = await fetch(`${API_BASE}/api/chat/orchestrator`);
-  if (!resp.ok) throw new Error('Failed to get orchestrator');
-  return resp.json();
+export function getNetwork() {
+  return jsonFetch('/api/decidron/network');
 }
 
-export async function setOrchestrator(modelId) {
-  const resp = await fetch(`${API_BASE}/api/chat/orchestrator`, {
-    method: 'PUT',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ model_id: modelId }),
-  });
-  if (!resp.ok) throw new Error('Failed to set orchestrator');
-  return resp.json();
+export function getCommands() {
+  return jsonFetch('/api/decidron/commands');
 }
 
-export async function getSpeedPriority() {
-  const resp = await fetch(`${API_BASE}/api/chat/speed-priority`);
-  if (!resp.ok) throw new Error('Failed to get speed priority');
-  return resp.json();
-}
-
-export async function setSpeedPriority(enabled) {
-  const resp = await fetch(`${API_BASE}/api/chat/speed-priority`, {
-    method: 'PUT',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ enabled }),
-  });
-  if (!resp.ok) throw new Error('Failed to set speed priority');
-  return resp.json();
-}
-
-/**
- * Fetch the catalog of available conversation structures and
- * decision-making methods. The Settings menu's "Conversation format"
- * accordion populates from this so adding a new plugin server-side
- * doesn't require frontend code changes.
- *
- * Returns: { structures: [{id, name, description}, ...],
- *            decisions: [{id, name, description}, ...],
- *            default_structure_id, default_decision_id }
- */
-export async function fetchConversationFormats() {
-  const resp = await fetch(`${API_BASE}/api/chat/conversation-formats`, { cache: 'no-store' });
-  if (!resp.ok) throw new Error('Failed to fetch conversation formats');
-  return resp.json();
-}
-
-export async function exportChat(sessionId, fmt = 'txt') {
-  const resp = await fetch(`${API_BASE}/api/chat/${sessionId}/export?fmt=${fmt}`);
-  if (!resp.ok) throw new Error('Export failed');
-  return resp.json();
-}
-
-export async function exportApiLog(sessionId) {
-  const resp = await fetch(`${API_BASE}/api/chat/${sessionId}/api-log`);
-  if (!resp.ok) throw new Error('API log export failed');
-  return resp.json();
-}
-
-export async function fetchTableView(sessionId) {
-  const resp = await fetch(`${API_BASE}/api/chat/${sessionId}/table`);
-  if (!resp.ok) throw new Error('Table view fetch failed');
-  return resp.json();
-}
-
-/**
- * Fetch the catalog of every prompt template the orchestrator and
- * participants use, grouped by phase and annotated with purpose and
- * runtime variables. Backs the "View current chat prompts" modal.
- */
-export async function fetchPromptCatalog() {
-  const resp = await fetch(`${API_BASE}/api/chat/prompts/catalog`, { cache: 'no-store' });
-  if (!resp.ok) throw new Error('Failed to fetch prompt catalog');
-  return resp.json();
-}
-
-/**
- * Ask the backend to pick the top `count` participants from the
- * candidate pool by relevance to the question. Used by the
- * "Select N Automatically" toggle in the participants dropdown.
- *
- * Returns: { selected: [participant_id, ...], rationale: "..." }
- */
-export async function autoSelectParticipants({ question, count, candidates, orchestrator_model_id }) {
-  const resp = await fetch(`${API_BASE}/api/chat/auto-select-participants`, {
+export function createCommand(command) {
+  return jsonFetch('/api/decidron/commands', {
     method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ question, count, candidates, orchestrator_model_id }),
+    body: JSON.stringify(command),
   });
-  if (!resp.ok) {
-    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
-    throw new Error(err.detail || 'Auto-select failed');
-  }
-  return resp.json();
 }
 
-/**
- * Fetch the user-tunable conversation-limit defaults, bounds, and
- * descriptions. The frontend uses this to render the "Conversation
- * limits" settings modal entirely from the server schema, so adding
- * a new knob in the backend doesn't require a frontend change.
- *
- * Shape: { defaults: {field: int}, bounds: {field: {min, max}},
- *          descriptions: {field: {group, label, help}} }
- */
-export async function fetchConversationLimitsDefaults() {
-  const resp = await fetch(`${API_BASE}/api/chat/limits/defaults`, { cache: 'no-store' });
-  if (!resp.ok) throw new Error('Failed to fetch conversation-limit defaults');
-  return resp.json();
-}
-
-export async function fetchCredentials(sessionId) {
-  const resp = await fetch(
-    `${API_BASE}/api/chat/${sessionId}/credentials`,
-    { cache: 'no-store' },
-  );
-  if (!resp.ok) throw new Error('Credentials fetch failed');
-  return resp.json();
-}
-
-/**
- * Submit the human participant's response to the orchestrator for the
- * currently pending turn. `skip=true` flips the turn into a "declined
- * to comment" note rather than a message.
- */
-export async function submitHumanResponse(sessionId, { text, skip = false } = {}) {
-  const resp = await fetch(`${API_BASE}/api/chat/${sessionId}/human-response`, {
+export function submitSensorInput(channel, value) {
+  return jsonFetch('/api/decidron/sensors/input', {
     method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ text: text || '', skip: !!skip }),
+    body: JSON.stringify({ channel, value }),
   });
-  if (!resp.ok) {
-    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
-    throw new Error(err.detail || 'Submit failed');
-  }
-  return resp.json();
 }
 
-/**
- * Patch the in-the-loop human's credential summary. Used by the
- * CredentialSummaryModal's edit affordance on the human's row. The
- * backend rejects fields it doesn't know about; we send only the
- * fields the user actually changed (sparse patch).
- */
-export async function patchHumanCredential(sessionId, patch) {
-  const resp = await fetch(`${API_BASE}/api/chat/${sessionId}/credentials/human`, {
-    method: 'PATCH',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(patch),
-  });
-  if (!resp.ok) {
-    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
-    throw new Error(err.detail || 'Edit failed');
-  }
-  return resp.json();
-}
-
-/**
- * Start the AI-assisted credential intake Q&A flow. Returns either a
- * first question or (rarely) a final summary if the LLM bails. The
- * draft_id is needed for subsequent /answer calls.
- */
-/**
- * Generate a structured credential summary from a human's freeform
- * profile text (experience, personality, etc.). Uses the orchestrator
- * the same way it assesses an LLM participant's role prompt.
- */
-export async function generateHumanCredentialFromProfile({
-  name, question, profile_text, participant_id, orchestrator_model_id,
-}) {
-  const resp = await fetch(`${API_BASE}/api/chat/credentials/from-profile`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({
-      name,
-      question,
-      profile_text,
-      participant_id: participant_id || '',
-      orchestrator_model_id: orchestrator_model_id || null,
-    }),
-  });
-  if (!resp.ok) {
-    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
-    throw new Error(err.detail || 'Credential generation failed');
-  }
-  return resp.json();
-}
-
-export async function startCredentialDraft({
-  name, question, max_questions = 6, orchestrator_model_id = null,
-}) {
-  const resp = await fetch(`${API_BASE}/api/chat/credentials/draft`, {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ name, question, max_questions, orchestrator_model_id }),
-  });
-  if (!resp.ok) {
-    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
-    throw new Error(err.detail || 'Credential draft start failed');
-  }
-  return resp.json();
-}
-
-export async function answerCredentialDraft(draftId, answer) {
-  const resp = await fetch(`${API_BASE}/api/chat/credentials/draft/${draftId}/answer`, {
+export function runSimulation(inputs = null) {
+  return jsonFetch('/api/decidron/run', {
     method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ answer: answer || '' }),
+    body: JSON.stringify(inputs ? { inputs } : {}),
   });
-  if (!resp.ok) {
-    const err = await resp.json().catch(() => ({ detail: resp.statusText }));
-    throw new Error(err.detail || 'Credential draft answer failed');
-  }
-  return resp.json();
 }
 
-export async function cancelCredentialDraft(draftId) {
-  try {
-    await fetch(`${API_BASE}/api/chat/credentials/draft/${draftId}`, {
-      method: 'DELETE',
-    });
-  } catch (_) { /* fire-and-forget cleanup; ignore */ }
+export function getStats() {
+  return jsonFetch('/api/decidron/stats');
 }
 
-export async function getAuthStatus() {
-  const resp = await fetch(`${API_BASE}/api/auth/status`, { credentials: 'include' });
-  if (!resp.ok) return { logged_in: false, remaining_conversations: -1 };
-  return resp.json();
+export function getHistory() {
+  return jsonFetch('/api/decidron/history');
 }
 
-export async function getRateLimitStatus() {
-  const resp = await fetch(`${API_BASE}/api/rate-limit/status`, { credentials: 'include' });
-  if (!resp.ok) return { remaining: -1, daily_limit: 30 };
-  return resp.json();
+export function resetSimulation() {
+  return jsonFetch('/api/decidron/reset', { method: 'POST' });
 }

frontend/src/utils/storage.js

@@ -1,135 +0,0 @@
-/**
- * Tiny localStorage shim for the CCAI demo.
- *
- * Single namespace `ccai-vibe-demo` so we never collide with anything else
- * the host page is doing. Schema-versioned so we can migrate if/when the
- * shape changes.
- */
-
-const NS = 'ccai-vibe-demo';
-const SCHEMA_VERSION = 1;
-
-const DEFAULTS = {
-  schema_version: SCHEMA_VERSION,
-  expert_personas: [],
-  participants_selected: [],
-  participants_enabled: {},
-  model_assignments: {},
-  orchestrator_model_id: null,
-  summarizer_model_id: null,
-  max_participants: 5,
-  theme: null,
-  // Sparse map of user overrides to ConversationLimits fields. Empty
-  // map = "use server defaults". The server clamps anything we send,
-  // so storing whatever the user typed (including stale values from
-  // an earlier session) is safe.
-  conversation_limits: {},
-  // When true, the participants dropdown shows "Select N Automatically"
-  // as the active mode and the per-persona checkboxes are hidden.
-  // The auto-select happens just before /chat/start.
-  auto_select_mode: false,
-  // In-the-loop human participant. null when no human is configured.
-  // Shape when set:
-  //   { participant_id, name, profile_text,
-  //     credential_summary: {
-  //       name, expertise, personality,
-  //       credibility_for_question, bias_to_watch
-  //     } }
-  // Persisted across page reloads so the user doesn't have to re-author
-  // their summary every session. Cleared from storage when the user
-  // removes the human via the sidebar.
-  human_participant: null,
-  // Conversation-format plugin choices (see backend
-  // /api/chat/conversation-formats). null means "use server default"
-  // — the backend returns `default_structure_id` / `default_decision_id`
-  // alongside the catalog so the UI can highlight them.
-  conversation_structure_id: null,
-  decision_method_id: null,
-};
-
-function readAll() {
-  try {
-    const raw = window.localStorage.getItem(NS);
-    if (!raw) return { ...DEFAULTS };
-    const parsed = JSON.parse(raw);
-    if (parsed.schema_version !== SCHEMA_VERSION) {
-      // Future-proofing: migrate or wipe. For v1 we just merge with defaults.
-      return { ...DEFAULTS, ...parsed, schema_version: SCHEMA_VERSION };
-    }
-    return { ...DEFAULTS, ...parsed };
-  } catch (err) {
-    console.warn('localStorage read failed:', err);
-    return { ...DEFAULTS };
-  }
-}
-
-function writeAll(state) {
-  try {
-    window.localStorage.setItem(NS, JSON.stringify(state));
-  } catch (err) {
-    console.warn('localStorage write failed:', err);
-  }
-}
-
-export function loadState() {
-  return readAll();
-}
-
-export function patchState(patch) {
-  const current = readAll();
-  const next = { ...current, ...patch };
-  writeAll(next);
-  return next;
-}
-
-export function setExpertPersonas(list) {
-  return patchState({ expert_personas: list });
-}
-
-export function setParticipantsSelected(ids) {
-  return patchState({ participants_selected: ids });
-}
-
-export function setParticipantsEnabled(map) {
-  return patchState({ participants_enabled: map });
-}
-
-export function setModelAssignments(map) {
-  return patchState({ model_assignments: map });
-}
-
-export function setOrchestratorModelId(modelId) {
-  return patchState({ orchestrator_model_id: modelId });
-}
-
-export function setSummarizerModelId(modelId) {
-  return patchState({ summarizer_model_id: modelId });
-}
-
-export function setMaxParticipants(n) {
-  return patchState({ max_participants: n });
-}
-
-export function setTheme(theme) {
-  return patchState({ theme });
-}
-
-export function setConversationLimits(limitsMap) {
-  return patchState({ conversation_limits: limitsMap || {} });
-}
-
-export function setAutoSelectMode(on) {
-  return patchState({ auto_select_mode: !!on });
-}
-
-export function setHumanParticipant(humanOrNull) {
-  return patchState({ human_participant: humanOrNull || null });
-}
-
-export function setConversationStructureId(id) {
-  return patchState({ conversation_structure_id: id || null });
-}
-
-export function setDecisionMethodId(id) {
-  return patchState({ decision_method_id: id || null });
-}