feat: agents restyle the dashboard via API, OpenUI panels in the hub, colourful CLI

DASHBOARD CUSTOMIZATION API — agents can now change how the Control Room looks
without touching a line of code. All styling lives in one server-side JSON doc
(.aios/dashboard.json) the page applies on top of the active theme, so a bad
instruction can't break the UI and one reset undoes everything.

  GET/POST /api/dashboard — ops: set (vars/css/scale/density) · nav (hidden/order)
  · panel (add/del/clear) · reset (all|vars|css|panels|nav)

OPENUI IN THE HUB CHROME: panels are self-contained agent HTML rendered in the
same sandboxed iframes as chat widgets, placed in a top / chat / sidebar slot —
so generative UI is no longer confined to chat and the Canvas. Reusing a panel id
replaces it, which is how an agent live-updates a panel.

Input is refused rather than applied when hostile: CSS-escape attempts in variable
values ({ } < > ;), malformed keys, and CSS containing @import, </style> or a
remote url(http...) (which could beacon out) are rejected and reported in
"rejected". Every change is audited. Settings gains an "Agent-applied appearance"
card showing what's active with per-category reset buttons.

The new "dashboard-designer" skill teaches every agent the API, and the Brain's
system prompt now explicitly tells it to use the API and NOT edit dashboard.html.

Two bugs found and fixed while verifying:
- Overrides silently did nothing: applyTheme() sets the same CSS variables as
  INLINE styles on :root, which beat an injected stylesheet. Overrides now use
  setProperty the same way, applied after the theme (and re-applied on theme
  switch, so agent tweaks survive changing themes).
- reset restored the values it was meant to clear: dashboard_cfg() returned
  {**DASH_DEFAULT}, a shallow copy sharing the nested vars/nav dicts, so writing a
  variable mutated the module-level defaults. Now deepcopied.

CLI: "aios" help is grouped and colourised instead of argparse's flat 25-command
dump, and an unknown command gives "Did you mean doctor?" (difflib) rather than a
wall of choices — "aios docter" now suggests "doctor". Tagline corrected to eight
projects across CLI + README.

Verified in-browser: agent restyle applies live (#caa63f -> #4f9dff, 16 -> 18.4px),
survives a theme switch, panel renders in a sandboxed iframe, nav hiding works,
reset returns every value to the theme default, Settings reports state accurately,
zero console errors.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: ZD Studios

README.md

@@ -2,7 +2,7 @@
 
 # 🧠 The AI OS
 
-### Five open-source AI agents. One operating system. One Control Room.
+### Eight open-source AI projects. One operating system. One Control Room.
 
 <p align="center">
   <a href="LICENSE"><img src="https://img.shields.io/badge/License-MIT-8B5CF6?style=for-the-badge" alt="MIT License"></a>
@@ -20,6 +20,9 @@
   <img src="https://img.shields.io/badge/LifeOS-shared_skills-8B5CF6?style=flat-square" alt="LifeOS">
   <img src="https://img.shields.io/badge/+_openclaw--os-dashboard-64748B?style=flat-square" alt="openclaw-os">
   <img src="https://img.shields.io/badge/+_OpenUI-generative_UI-10B981?style=flat-square" alt="OpenUI">
+  <img src="https://img.shields.io/badge/+_Fabric-255_patterns-0EA5E9?style=flat-square" alt="Fabric">
+  <img src="https://img.shields.io/badge/+_Caveman-say_less-A16207?style=flat-square" alt="Caveman">
+  <img src="https://img.shields.io/badge/+_Ponytail-build_less-DB2777?style=flat-square" alt="Ponytail">
 </p>
 
 **[Install](#-install-one-line)** · **[Control Room](#-the-control-room)** · **[Architecture](#️-architecture)** · **[Commands](#️-command-reference)** · **[Full docs](README.aios.md)** · **[Website](https://zdstudios.github.io/AIOS/)**
@@ -28,7 +31,7 @@
 
 ---
 
-**The AI OS** takes five independent open-source AI agents and makes them work as **one auto-configured
+**The AI OS** takes eight independent open-source AI projects and makes them work as **one auto-configured
 system** you drive from a single command — **`aios`** — and a single web **Control Room** where you can
 **talk to everything and have the agents talk to each other**.
 
@@ -38,7 +41,7 @@ together, mounts your shared skills, and adds **OpenUI** generative-UI context t
 
 > You can't fuse three runtimes and multiple package managers into a single file — that would just break
 > everything. So "one file" here means **one control surface** (`aios`) + **one dashboard** (the Hub) over
-> five real, unmodified projects. It installs, configures, wires, runs, tests, and debugs all of them.
+> eight real, unmodified projects. It installs, configures, wires, runs, tests, and debugs all of them.
 
 <div align="center">
 
@@ -92,7 +95,7 @@ aios url                 # open the Control Room
 - **Render generative UI (OpenUI) in the hub** — any agent can emit a ```ui``` block (self-contained HTML) that the hub renders **live and interactive** in chat (sandboxed, theme-aware). openclaw-os also renders OpenUI Lang natively.
 - **Shared Canvas any agent can edit** — agents `POST /api/ui` (CrewAI has a `build_dashboard_ui` tool) to pin widgets to a **Canvas** everyone sees. This is how "all agents edit the dashboard."
 
-## 🧩 The five agents
+## 🧩 The agents
 
 | Agent | Role in The AI OS | Port | Upstream |
 |---|---|---|---|
@@ -237,12 +240,35 @@ That is deliberately the "ambient authority" posture that made **OpenClaw's CVE-
 
 **Active Memory:** a memory sub-agent runs on **every** turn — recall is a free FTS5 query, fact-extraction is one small async call — so the agents actually learn your workflow over time instead of only reading memory at session start (`memory.active`).
 
-## 🧵 Fabric patterns & 🗿 Caveman mode
+## 🎨 Agents can redesign the dashboard (safely)
 
-Two more open-source projects, wired in at the prompt level (no extra service to run):
+Ask in chat — *"make the accent blue and the text bigger"*, *"hide Automations"*, *"put a
+deploy-status panel on the dashboard"* — and the agents do it **through the hub API, never by
+editing `dashboard.html`**. That's the point: styling lives in one server-side JSON document
+the page applies on top of your theme, so an agent can't break the UI by writing bad code, and
+**one Reset undoes everything** (Settings → *Agent-applied appearance*).
+
+| What they can change | How |
+|---|---|
+| Colours | any theme CSS variable — `--accent`, `--bg`, `--text`, `--border`… |
+| Text size / density | `scale` 0.7–1.6, `density` compact \| normal \| comfortable |
+| Custom CSS | appended last, for anything variables can't express |
+| Sidebar | hide or reorder any nav item |
+| **OpenUI panels** | self-contained agent HTML in sandboxed iframes, in the `top`, `chat` or `sidebar` slot |
+
+Changes appear within ~4s, survive a theme switch, and are audited. Hostile or careless input is
+refused, not applied: variable values containing `{ } < > ;`, malformed keys, and CSS with
+`@import`, `</style>` or a remote `url(http…)` (which could beacon out) are rejected and reported
+back. The agents learn this from the bundled **`dashboard-designer`** skill, and the endpoint is
+`GET`/`POST /api/dashboard` (ops: `set` · `nav` · `panel` · `reset`).
+
+## 🧵 Fabric patterns · 🗿 Caveman · 🎀 Ponytail
+
+Three more open-source projects, wired in at the prompt level (no extra service to run):
 
 - **[Fabric](https://github.com/danielmiessler/fabric) — 255 patterns.** Fabric's "patterns" are curated system-prompts (`summarize`, `extract_wisdom`, `analyze_claims`, `write_essay`, `create_quiz`…). AIOS reads them straight from `data/patterns/` and runs them **on your configured model** — including your Claude subscription — so there's no Go binary to install. Use them in the **Patterns** view (pick → paste → run) or inline in chat: `/p summarize <text>`. The `fabric` chat target also works: `fabric` with a message `pattern: your text`.
 - **[Caveman](https://github.com/JuliusBrussee/caveman) — conciseness mode.** A system-prompt overlay that makes every agent ~65% terser while keeping code, commands, and error strings exact. Toggle the **🗿 Caveman** button in the composer (cycles off → lite → full → ultra → wenyan), or type `/caveman [level]` / `/caveman off` in chat. It's also mounted as a skill into opencode/hermes/openclaw, so they respect it too. Levels come straight from Caveman's own SKILL.md.
+- **[Ponytail](https://github.com/DietrichGebert/ponytail) — build-less mode.** The same idea applied to *code* instead of prose: a "laziness ladder" that forces the simplest thing that works (~54% less code, YAGNI enforced, stdlib before dependencies). Toggle **🎀 Ponytail** in the composer or `/ponytail [lite|full|ultra]`. Caveman trims what an agent **says**; Ponytail trims what it **builds** — they compose, so you can run both.
 
 **On WSL?** `127.0.0.1:8787` often won't reach WSL from your Windows browser (localhost-forwarding is flaky). `aios start`/`aios url` now print your **WSL IP** URL — use that (e.g. `http://172.31.x.x:8787/`). The hub binds `0.0.0.0` so the WSL IP always works.
 

aios.py

@@ -14,6 +14,7 @@
 import argparse
 import json
 import os
+import re
 import shutil
 import socket
 import subprocess
@@ -2051,8 +2052,77 @@ def _print_urls(cfg):
 # --------------------------------------------------------------------------- #
 # CLI                                                                          #
 # --------------------------------------------------------------------------- #
+# Commands grouped for the help screen — argparse's flat alphabetical dump is
+# unreadable once you have 25 subcommands.
+HELP_GROUPS = [
+    ("Get started", ["setup", "start", "stop", "restart", "status", "url"]),
+    ("Everyday", ["logs", "doctor", "exec", "channels", "profile", "token"]),
+    ("Agents & updates", ["updates", "update", "claude-login", "attach", "migrate", "wire"]),
+    ("Advanced", ["test", "debug", "autostart", "install-cli", "bootstrap"]),
+]
+TAGLINE = "Eight open-source AI projects. One operating system."
+
+
+class AiosParser(argparse.ArgumentParser):
+    """Colourful grouped help, and 'did you mean …?' instead of a wall of choices."""
+
+    def format_help(self):
+        if self.prog != "aios":
+            return super().format_help()
+        # `add_parser(name, help=…)` stores the text on the subparsers action's
+        # pseudo-actions, not on the returned subparser — read it from there.
+        choices, helps = {}, {}
+        for a in (self._subparsers._group_actions if self._subparsers else []):
+            choices.update(getattr(a, "_name_parser_map", {}))
+            for ca in getattr(a, "_choices_actions", []):
+                helps[ca.dest] = ca.help or ""
+        L = []
+        L.append("")
+        L.append(f"  {C.B}{C.CYN}The AI OS{C.R}  {C.GRY}·{C.R}  {C.GRY}{TAGLINE}{C.R}")
+        L.append("")
+        L.append(f"  {C.GRY}usage:{C.R} {C.B}aios{C.R} {C.GRY}<command> [options]{C.R}")
+        L.append("")
+        seen = set()
+        for title, names in HELP_GROUPS:
+            rows = [(n, choices[n]) for n in names if n in choices]
+            if not rows:
+                continue
+            L.append(f"  {C.B}{title}{C.R}")
+            for n, _sp in rows:
+                seen.add(n)
+                L.append(f"    {C.CYN}{n:<15}{C.R}{C.GRY}{helps.get(n, '')[:64]}{C.R}")
+            L.append("")
+        extra = [n for n in choices if n not in seen]
+        if extra:
+            L.append(f"  {C.B}Other{C.R}")
+            for n in sorted(extra):
+                L.append(f"    {C.CYN}{n:<15}{C.R}")
+            L.append("")
+        L.append(f"  {C.GRY}aios <command> --help for details  ·  docs: "
+                 f"https://github.com/ZDStudios/AIOS{C.R}")
+        L.append("")
+        return "\n".join(L)
+
+    def error(self, message):
+        import difflib
+        m = re.search(r"invalid choice: '([^']+)'", message or "")
+        if m and self.prog == "aios":
+            bad = m.group(1)
+            names = []
+            for a in (self._subparsers._group_actions if self._subparsers else []):
+                names += list(getattr(a, "_name_parser_map", {}))
+            near = difflib.get_close_matches(bad, names, n=3, cutoff=0.55)
+            say(f"\n  {C.RED}✗{C.R} {C.B}{bad}{C.R} isn't an aios command.")
+            if near:
+                say(f"  {C.GRY}Did you mean{C.R} " +
+                    f"{C.GRY},{C.R} ".join(f"{C.CYN}{C.B}{n}{C.R}" for n in near) + "?")
+            say(f"  {C.GRY}Run{C.R} {C.B}aios{C.R} {C.GRY}to see every command.{C.R}\n")
+            sys.exit(2)
+        super().error(message)
+
+
 def build_parser():
-    p = argparse.ArgumentParser(prog="aios", description="The AI OS — one control surface for five agent projects")
+    p = AiosParser(prog="aios", description=f"The AI OS — {TAGLINE}")
     sub = p.add_subparsers(dest="cmd")
 
     s = sub.add_parser("setup", help="install toolchains+deps, create .env/config, render + wire")

aios_hub.py

@@ -12,8 +12,10 @@
 """
 from __future__ import annotations
 
+import copy
 import json
 import os
+import re
 import shutil
 import socket
 import subprocess
@@ -446,6 +448,17 @@ def brain_system_prompt(message: str) -> str:
              "OpenUI-style generative UI (https://www.openui.com).")
     if tools.full_control():
         sysp += TOOL_PROTOCOL
+        sysp += (
+            "\n\nRESTYLING THIS DASHBOARD: if the user asks to change how the Control Room "
+            f"looks — colours, text size, spacing/density, which sidebar items show, or adding "
+            f"a live panel — do it through the hub API, NEVER by editing docs/dashboard.html "
+            f"(editing the file can break the UI; the API cannot, and `reset` undoes it).\n"
+            f"  RUN: curl -s http://127.0.0.1:{PORT}/api/dashboard\n"
+            f"  RUN: curl -s -X POST http://127.0.0.1:{PORT}/api/dashboard -H 'Content-Type: application/json' "
+            "-d '{\"op\":\"set\",\"vars\":{\"--accent\":\"#4f9dff\"},\"scale\":1.1,\"density\":\"compact\"}'\n"
+            "Ops: set (vars/css/scale/density) · nav (hidden/order) · panel (add/del/clear, "
+            "slot top|chat|sidebar, self-contained HTML styled with var(--accent) etc.) · "
+            "reset (what: all|vars|css|panels|nav). Full reference: the `dashboard-designer` skill.")
     sysp += active_recall(message)      # Active Memory: relevant context, every turn
     sysp += modes_prompt_suffix()       # caveman / ponytail overlays when toggled on
     return sysp
@@ -693,6 +706,111 @@ def _watchdog_loop():
 # --------------------------------------------------------------------------- #
 # Claude login from the dashboard (interactive CLI session over HTTP)          #
 # --------------------------------------------------------------------------- #
+# --------------------------------------------------------------------------- #
+# Live dashboard customization — agents restyle the Control Room through an API, #
+# never by editing dashboard.html. Overrides live server-side in one JSON doc    #
+# the page applies on top of the active theme, so a bad instruction is undone    #
+# with `reset` instead of a broken file. Panels are OpenUI: arbitrary agent HTML #
+# rendered in the same sandboxed iframes the chat/canvas widgets use.            #
+# --------------------------------------------------------------------------- #
+DASH_FILE = ROOT / ".aios" / "dashboard.json"
+DASH_DEFAULT = {"vars": {}, "css": "", "scale": 1.0, "density": "normal",
+                "nav": {"hidden": [], "order": []}, "panels": [], "updated": 0}
+DASH_SLOTS = ["top", "chat", "sidebar"]
+
+_VAR_OK = re.compile(r"^--[A-Za-z0-9_-]{1,40}$")
+# CSS can't execute script in a <style>, but it CAN beacon out via url(http…) and
+# @import. Agents already own the machine, so this isn't a privilege boundary —
+# it's to stop a careless instruction from silently phoning home.
+_CSS_BAD = re.compile(r"</\s*style|@import|url\(\s*['\"]?\s*(https?:|//)", re.I)
+
+
+def dashboard_cfg() -> dict:
+    # deepcopy, not {**DASH_DEFAULT}: a shallow copy shares the nested `vars`/`nav`
+    # dicts with the module-level default, so writing a var would mutate the
+    # defaults themselves and `reset` would restore the very values it should clear.
+    cfg = copy.deepcopy(DASH_DEFAULT)
+    cfg.update(_load_json(DASH_FILE, {}))
+    for k, v in DASH_DEFAULT.items():  # heal older/partial files
+        cfg.setdefault(k, copy.deepcopy(v))
+    return cfg
+
+
+def _clean_var(k: str, v) -> tuple[str, str] | None:
+    k = str(k).strip()
+    if not k.startswith("--"):
+        k = "--" + k.lstrip("-")
+    if not _VAR_OK.match(k):
+        return None
+    val = str(v).strip()
+    # A value containing } or < would break out of the rule we inject it into.
+    if not val or len(val) > 200 or any(c in val for c in "}<>;{"):
+        return None
+    return k, val
+
+
+def dashboard_update(payload: dict) -> dict:
+    cfg = dashboard_cfg()
+    op = (payload.get("op") or "set").lower()
+    rejected = []
+
+    if op == "reset":
+        what = payload.get("what", "all")
+        if what == "all":
+            cfg = copy.deepcopy(DASH_DEFAULT)
+        else:
+            cfg[what] = copy.deepcopy(DASH_DEFAULT.get(what, ""))
+    elif op == "set":
+        for k, v in (payload.get("vars") or {}).items():
+            cleaned = _clean_var(k, v)
+            if cleaned:
+                cfg["vars"][cleaned[0]] = cleaned[1]
+            else:
+                rejected.append(str(k))
+        if "css" in payload:
+            css = str(payload["css"] or "")[:20000]
+            if _CSS_BAD.search(css):
+                rejected.append("css (contains @import, remote url(), or </style>)")
+            else:
+                cfg["css"] = css
+        if "scale" in payload:
+            try:
+                cfg["scale"] = max(0.7, min(1.6, float(payload["scale"])))
+            except (TypeError, ValueError):
+                rejected.append("scale")
+        if payload.get("density") in ("normal", "compact", "comfortable"):
+            cfg["density"] = payload["density"]
+    elif op == "nav":
+        if isinstance(payload.get("hidden"), list):
+            cfg["nav"]["hidden"] = [str(x)[:40] for x in payload["hidden"]][:40]
+        if isinstance(payload.get("order"), list):
+            cfg["nav"]["order"] = [str(x)[:40] for x in payload["order"]][:40]
+    elif op == "panel":
+        act = (payload.get("action") or "add").lower()
+        if act == "add":
+            pid = payload.get("id") or f"p{int(time.time() * 1000) % 10**9}"
+            panel = {"id": str(pid)[:40],
+                     "title": str(payload.get("title", "panel"))[:80],
+                     "html": str(payload.get("html", ""))[:200000],
+                     "slot": payload.get("slot") if payload.get("slot") in DASH_SLOTS else "top",
+                     "height": max(60, min(1200, int(payload.get("height", 220) or 220))),
+                     "by": str(payload.get("by", "agent"))[:40]}
+            cfg["panels"] = [p for p in cfg["panels"] if p["id"] != panel["id"]] + [panel]
+            cfg["panels"] = cfg["panels"][-24:]
+        elif act in ("del", "delete", "remove"):
+            cfg["panels"] = [p for p in cfg["panels"] if p["id"] != str(payload.get("id"))]
+        elif act == "clear":
+            cfg["panels"] = []
+    else:
+        return {"ok": False, "error": f"unknown op '{op}'", "config": cfg}
+
+    cfg["updated"] = time.time()
+    _save_json(DASH_FILE, cfg)
+    brain.audit(payload.get("by", "agent"), "dashboard." + op,
+                json.dumps({k: v for k, v in payload.items() if k != "html"})[:400])
+    return {"ok": True, "config": cfg, "rejected": rejected}
+
+
 # --------------------------------------------------------------------------- #
 # Supervised updates — watch every bundled project's upstream, have an AGENT     #
 # review what changed, then apply only what's safe (and roll back if the         #
@@ -1165,6 +1283,8 @@ def do_GET(self):
             self._send(200, {"patterns": tools.fabric_patterns(), "bin": bool(tools.fabric_bin())})
         elif self.path == "/api/modes":
             self._send(200, {"state": modes_state(), "modes": tools.agent_modes_meta()})
+        elif self.path == "/api/dashboard":
+            self._send(200, dashboard_cfg())
         elif self.path == "/api/updates":
             self._send(200, {"pending": pending_updates(), "pins": updates.pins(),
                              "reports": updates.reports()[:20],
@@ -1355,6 +1475,8 @@ def do_POST(self):
             st = set_mode(payload.get("mode", ""), payload.get("enabled", False),
                           payload.get("level", "full"))
             self._send(200, {"state": st})
+        elif self.path == "/api/dashboard":
+            self._send(200, dashboard_update(payload))
         elif self.path == "/api/updates":
             op = payload.get("op", "scan")
             if op == "scan":