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
. Every change is audited. Settings gains an 'Agent-applied appearance'
card showing what's active with per-category reset buttons.

The new  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:  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 —  now suggests . 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":