feat: integrate Fabric (255 patterns) + Caveman (conciseness mode)

Two open-source projects wired in at the prompt level — no extra service to run.

FABRIC (danielmiessler/fabric): its 255 patterns are curated system-prompts, so
AIOS reads them straight from data/patterns/ and runs them through its OWN model
path (llm_chat) — no Go binary needed, and they use whatever provider you set,
including the Claude subscription via claude-code. Vendored trimmed to data/ +
README + LICENSE (2.2M, dropped ~40M of unused Go/web/docs). New: aios_tools
fabric_patterns()/fabric_pattern_system(), hub run_fabric(), 'fabric' chat target,
GET+POST /api/fabric, a Patterns dashboard view (filter -> pick -> run), and an
inline /p <pattern> <text> chat command.

CAVEMAN (JuliusBrussee/caveman): a system-prompt overlay that makes every agent
~65% terser while keeping code/commands/errors verbatim. Read from its own
SKILL.md so behaviour + levels (lite/full/ultra/wenyan-*) stay faithful. New:
tools.caveman_overlay(), hub caveman state (persisted to .aios/caveman.json) folded
into brain_system_prompt(), GET+POST /api/caveman, a composer toggle that cycles
off->lite->full->ultra->wenyan, and /caveman [level|off] chat command. Also mounted
as a skill into opencode/hermes/openclaw via mount_caveman() so they respect it too.

Verified on Windows: 254 patterns load with descriptions, pattern systems resolve,
caveman overlay reaches the Brain prompt and toggles on/off, dashboard Patterns +
Caveman render with zero console errors, all endpoints respond. The user's running
hub on :8787 was left untouched.

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

Author: ZD Studios

README.md

@@ -237,6 +237,13 @@ 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
+
+Two 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.
+
 **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.
 
 ## ⚙️ Configuration

aios.py

@@ -263,6 +263,10 @@ def resolve_root(*candidates) -> Path | None:
     # openclaw-os is the dashboard for openclaw (not a standalone agent).
     "openclaw_os": resolve_root("openclaw-os-main/openclaw-os-main", "openclaw-os-main", "openclaw-os"),
     "lifeos": resolve_root("LifeOS-main/LifeOS-main", "LifeOS-main", "LifeOS"),
+    # Prompt-level integrations (no service): fabric = 255 pattern prompts,
+    # caveman = a conciseness system-prompt overlay.
+    "fabric": resolve_root("fabric-main/fabric-main", "fabric-main", "fabric"),
+    "caveman": resolve_root("caveman-main/caveman-main", "caveman-main", "caveman"),
 }
 
 
@@ -799,6 +803,7 @@ def cmd_setup(args):
     # 6c) mount the bundled AI OS skills (skill-maker, mcp-maker, …) into the agents
     if cfg_get(cfg, "skills.mount", True):
         mount_aios_skills(cfg)
+        mount_caveman(cfg)  # caveman conciseness skill → every agent
 
     # 7) wire openclaw-os plugin (best-effort; needs openclaw runnable)
     if cfg_get(cfg, "services.openclaw_os.enabled", True) and not args.skip_wire:
@@ -1163,6 +1168,30 @@ def mount_aios_skills(cfg: dict):
     ok(f"mounted {len(names)} skills: {', '.join(names)}")
 
 
+def mount_caveman(cfg: dict):
+    """Mount JuliusBrussee/caveman's skills into every agent, so terser 'caveman
+    mode' is available not just to the hub Brain but to opencode/hermes/openclaw too."""
+    src = PROJECTS.get("caveman") or (ROOT / "caveman-main")
+    skdir = src / "skills"
+    if not skdir.exists():
+        return
+    head("Mounting Caveman skills")
+    names = [p.name for p in skdir.iterdir() if p.is_dir() and (p / "SKILL.md").exists()]
+    targets = [Path.home() / ".openclaw" / "skills", Path.home() / ".hermes" / "skills",
+               STATE / "skills"]
+    for t in targets:
+        for name in names:
+            try:
+                dst = t / name
+                if dst.exists():
+                    shutil.rmtree(dst)
+                dst.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copytree(skdir / name, dst)
+            except Exception as e:
+                warn(f"could not mount caveman/{name} → {t}: {e}")
+    ok(f"mounted {len(names)} caveman skills: {', '.join(names)}")
+
+
 def mount_openui(cfg: dict):
     """Mount OpenUI (generative-UI) context into every agent's skill dir so any
     agent can respond with OpenUI Lang that the openclaw-os dashboard renders."""

aios_hub.py

@@ -111,7 +111,7 @@ def read_system_prompt() -> str:
 
 
 # Chat "targets" the AIOS API exposes as OpenAI-style models.
-TARGETS = ["brain", "team", "opencode", "crewai", "claudecode", "all"]
+TARGETS = ["brain", "team", "opencode", "crewai", "claudecode", "fabric", "all"]
 
 MEMORY_FILE = ROOT / ".aios" / "memory.json"
 USAGE_FILE = ROOT / ".aios" / "usage.json"
@@ -373,6 +373,45 @@ def ask_claudecode(message: str, history: list | None = None) -> str:
         return f"⚠️ claude-code-api not reachable ({e}). Start it (`aios start claudecode`) and make sure the `claude` CLI is installed + authenticated."
 
 
+# --------------------------------------------------------------------------- #
+# Caveman mode — a system-prompt overlay (JuliusBrussee/caveman) that makes      #
+# every agent ~65% terser while keeping technical accuracy. State persists so    #
+# the toggle survives restarts; levels come from caveman's own SKILL.md.         #
+# --------------------------------------------------------------------------- #
+CAVEMAN_FILE = ROOT / ".aios" / "caveman.json"
+
+
+def caveman_state() -> dict:
+    return _load_json(CAVEMAN_FILE, {"enabled": False, "level": "full"})
+
+
+def set_caveman(enabled: bool, level: str = "full") -> dict:
+    lvl = level if level in tools.CAVEMAN_LEVELS else "full"
+    st = {"enabled": bool(enabled), "level": lvl}
+    _save_json(CAVEMAN_FILE, st)
+    return st
+
+
+def caveman_prompt_suffix() -> str:
+    st = caveman_state()
+    return tools.caveman_overlay(st["level"]) if st.get("enabled") else ""
+
+
+# --------------------------------------------------------------------------- #
+# Fabric — run any of the 255 danielmiessler/fabric patterns through AIOS's own  #
+# model path. A pattern is a system prompt; the user's text is the input.        #
+# --------------------------------------------------------------------------- #
+def run_fabric(pattern: str, text: str, target: str = "brain") -> str:
+    system = tools.fabric_pattern_system(pattern)
+    if system is None:
+        return f"⚠️ Unknown fabric pattern '{pattern}'. See the Patterns view for the full list."
+    system += caveman_prompt_suffix()
+    # Route through claude-code when the brain is on the subscription, else the LLM.
+    if target in ("claudecode", "claude-code"):
+        return ask_claudecode(text, [{"role": "system", "content": system}])
+    return llm_chat([{"role": "user", "content": text}], system=system)
+
+
 TOOL_PROTOCOL = (
     "\n\nFULL CONTROL: you control the computer AIOS is installed on. To run a shell "
     "command, emit a line of exactly this form:\n"
@@ -397,7 +436,8 @@ def brain_system_prompt(message: str) -> str:
              "OpenUI-style generative UI (https://www.openui.com).")
     if tools.full_control():
         sysp += TOOL_PROTOCOL
-    sysp += active_recall(message)  # Active Memory: relevant context, every turn
+    sysp += active_recall(message)      # Active Memory: relevant context, every turn
+    sysp += caveman_prompt_suffix()     # Caveman mode: terser output when toggled on
     return sysp
 
 
@@ -460,6 +500,12 @@ def route(target: str, message: str, history: list | None = None) -> str:
         return ask_opencode(message)
     if target in ("claudecode", "claude-code"):
         return ask_claudecode(message, history)
+    if target == "fabric":
+        # "pattern: text"  →  run that fabric pattern; else summarize by default.
+        pat, _, txt = message.partition(":")
+        if txt.strip():
+            return run_fabric(pat.strip(), txt.strip())
+        return run_fabric("summarize", message)
     if target in ("team", "auto", "merge"):
         return run_team(message, history)
     if target == "all":
@@ -1035,6 +1081,10 @@ def do_GET(self):
             self._send(200, {"channels": tools.channels()})
         elif self.path == "/api/skills":
             self._send(200, {"skills": tools.skills(), "learned": brain.skill_list()})
+        elif self.path == "/api/fabric":
+            self._send(200, {"patterns": tools.fabric_patterns(), "bin": bool(tools.fabric_bin())})
+        elif self.path == "/api/caveman":
+            self._send(200, {**caveman_state(), "levels": tools.CAVEMAN_LEVELS})
         elif self.path == "/api/tasks":
             self._send(200, {"tasks": brain.task_list()})
         elif self.path == "/api/task_runs":
@@ -1098,6 +1148,27 @@ def do_POST(self):
             target = payload.get("target") or payload.get("to") or "brain"
             message = payload.get("message", "")
             history = payload.get("history", [])
+            # Inline commands: /caveman [level|off], /cave …
+            cmd = message.strip().lower()
+            if cmd.startswith(("/caveman", "/cave")):
+                arg = message.strip().split(None, 1)[1].strip().lower() if len(message.split()) > 1 else ""
+                if arg in ("off", "stop", "normal"):
+                    set_caveman(False)
+                    self._send(200, {"target": target, "reply": "Caveman mode **off** — normal replies.", "ran": []})
+                else:
+                    st = set_caveman(True, arg or caveman_state()["level"])
+                    self._send(200, {"target": target,
+                                     "reply": f"🗿 Caveman mode **on** · level **{st['level']}**. "
+                                     f"Every agent now replies terse. `/caveman off` to stop.", "ran": []})
+                return
+            # Inline fabric: /p <pattern> <text>  or  /pattern <name> <text>
+            if cmd.startswith(("/p ", "/pattern ")):
+                rest = message.split(None, 1)[1] if len(message.split()) > 1 else ""
+                pat, _, txt = rest.partition(" ")
+                reply = run_fabric(pat.strip(), txt.strip() or " ".join(m.get("content", "")
+                                   for m in history if m.get("role") == "user")[-4000:])
+                self._send(200, {"target": "fabric", "reply": reply, "ran": []})
+                return
             reply = route(target, message, history)
             ran = commands_this_turn()
             remember_async(message, reply)      # Active Memory: learn from every turn
@@ -1190,6 +1261,13 @@ def do_POST(self):
                                                     payload.get("content", "")))
             else:
                 self._send(400, {"error": "unknown op"})
+        elif self.path == "/api/fabric":
+            out = run_fabric(payload.get("pattern", "summarize"), payload.get("input", ""),
+                             target=payload.get("target", "brain"))
+            self._send(200, {"pattern": payload.get("pattern"), "output": out})
+        elif self.path == "/api/caveman":
+            st = set_caveman(payload.get("enabled", False), payload.get("level", "full"))
+            self._send(200, st)
         elif self.path == "/api/tasks":
             op = payload.get("op", "add")
             if op == "add":

aios_tools.py

@@ -19,6 +19,7 @@
 import json
 import os
 import platform
+import shutil
 import subprocess
 import time
 from pathlib import Path
@@ -205,8 +206,107 @@ def learn_skill(name: str, content: str, task: str = "") -> dict:
     return {"ok": True, "path": str(d.relative_to(ROOT))}
 
 
+# --------------------------------------------------------------------------- #
+# Fabric — danielmiessler/fabric. Its 255 "patterns" are just system prompts    #
+# (data/patterns/<name>/system.md), so we run them through AIOS's own LLM path:  #
+# no Go binary required, and they use whatever model you configured (including   #
+# your Claude subscription via claude-code). The real `fabric` CLI is optional   #
+# and only needed for its extras (--serve, youtube, scrape).                     #
+# --------------------------------------------------------------------------- #
+_FAB_CACHE: list | None = None
+
+
+def _fabric_dirs() -> list[Path]:
+    return [ROOT / "fabric-main" / "data" / "patterns",
+            Path.home() / ".config" / "fabric" / "patterns"]
+
+
+def _pattern_desc(system_md: str) -> str:
+    """A one-liner for the pattern: the 'You are …' identity line if present."""
+    for line in system_md.splitlines():
+        s = line.strip()
+        if s.lower().startswith(("you are", "you take", "you extract", "you're")):
+            return s[:200]
+    for line in system_md.splitlines():
+        s = line.strip()
+        if s and not s.startswith("#") and s.upper() not in ("IDENTITY", "INPUT:", "INPUT"):
+            return s[:200]
+    return ""
+
+
+def fabric_patterns() -> list[dict]:
+    global _FAB_CACHE
+    if _FAB_CACHE is None:
+        out, seen = [], set()
+        for base in _fabric_dirs():
+            if not base.exists():
+                continue
+            for d in sorted(base.iterdir()):
+                sysf = d / "system.md"
+                if d.is_dir() and sysf.exists() and d.name not in seen:
+                    seen.add(d.name)
+                    try:
+                        desc = _pattern_desc(sysf.read_text(encoding="utf-8", errors="replace"))
+                    except Exception:
+                        desc = ""
+                    out.append({"name": d.name, "description": desc})
+        _FAB_CACHE = out
+    return _FAB_CACHE
+
+
+def fabric_pattern_system(name: str) -> str | None:
+    slug = "".join(ch for ch in (name or "").strip().lower() if ch.isalnum() or ch in "-_")
+    for base in _fabric_dirs():
+        f = base / slug / "system.md"
+        if f.exists():
+            return f.read_text(encoding="utf-8", errors="replace")
+    return None
+
+
+def fabric_bin() -> str:
+    return shutil.which("fabric") or ""
+
+
+# --------------------------------------------------------------------------- #
+# Caveman — JuliusBrussee/caveman. A system-prompt OVERLAY that makes the agent  #
+# ~65% terser while keeping technical accuracy. We read its own SKILL.md so the  #
+# behaviour stays faithful, and expose the intensity levels it defines.          #
+# --------------------------------------------------------------------------- #
+CAVEMAN_LEVELS = ["lite", "full", "ultra", "wenyan-lite", "wenyan-full", "wenyan-ultra"]
+
+_CAVE_FALLBACK = (
+    "Respond terse like smart caveman. All technical substance stays; only fluff dies. "
+    "Drop articles (a/an/the), filler (just/really/basically), pleasantries, hedging. "
+    "Fragments OK. Short synonyms. No tool-call narration, no decorative tables/emoji. "
+    "Keep technical terms, code, API names, CLI commands and exact error strings verbatim. "
+    "Never invent abbreviations. Never announce the style.")
+
+
+def caveman_skill() -> str:
+    f = ROOT / "caveman-main" / "skills" / "caveman" / "SKILL.md"
+    if f.exists():
+        txt = f.read_text(encoding="utf-8", errors="replace")
+        # Strip the YAML front-matter; keep the behavioural body.
+        if txt.startswith("---"):
+            end = txt.find("---", 3)
+            if end > 0:
+                txt = txt[end + 3:].strip()
+        return txt
+    return _CAVE_FALLBACK
+
+
+def caveman_overlay(level: str = "full") -> str:
+    level = level if level in CAVEMAN_LEVELS else "full"
+    return (f"\n\n## CAVEMAN MODE — intensity: {level}\n"
+            "Apply this output style to every reply from now on (compress the STYLE, not the "
+            "content; keep code, commands, API names and error strings exact):\n\n"
+            + caveman_skill())
+
+
 if __name__ == "__main__":
     print(json.dumps({"full_control": full_control(), "guardrails": guardrails_on(),
-                      "channels": len(channels()), "skills": len(skills())}, indent=2))
+                      "channels": len(channels()), "skills": len(skills()),
+                      "fabric_patterns": len(fabric_patterns()), "fabric_bin": fabric_bin() or None,
+                      "caveman": bool(caveman_skill())}, indent=2))
     for c in channels():
         print(f"  {'[x]' if c['configured'] else '[ ]'} {c['id']:<20} {c['blurb'][:60]}")

caveman-main/.claude-plugin/marketplace.json

@@ -0,0 +1,17 @@
+{
+  "$schema": "https://anthropic.com/claude-code/marketplace.schema.json",
+  "name": "caveman",
+  "description": "Ultra-compressed communication mode for Claude Code. Cuts 65% of output tokens (measured) while keeping full technical accuracy.",
+  "owner": {
+    "name": "Julius Brussee",
+    "url": "https://github.com/JuliusBrussee"
+  },
+  "plugins": [
+    {
+      "name": "caveman",
+      "description": "Talk like caveman. Cut 65% output tokens (measured). Keep all technical accuracy.",
+      "source": "./",
+      "category": "productivity"
+    }
+  ]
+}

caveman-main/.claude-plugin/plugin.json

@@ -0,0 +1,34 @@
+{
+  "name": "caveman",
+  "description": "Ultra-compressed communication mode. Cuts 65% of output tokens (measured) while keeping full technical accuracy by speaking like a caveman.",
+  "author": {
+    "name": "Julius Brussee",
+    "url": "https://github.com/JuliusBrussee"
+  },
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/src/hooks/caveman-activate.js\"",
+            "timeout": 5,
+            "statusMessage": "Loading caveman mode..."
+          }
+        ]
+      }
+    ],
+    "UserPromptSubmit": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/src/hooks/caveman-mode-tracker.js\"",
+            "timeout": 5,
+            "statusMessage": "Tracking caveman mode..."
+          }
+        ]
+      }
+    ]
+  }
+}

caveman-main/.codex/config.toml

@@ -0,0 +1,2 @@
+[features]
+hooks = true

caveman-main/.codex/hooks.json

@@ -0,0 +1,17 @@
+{
+  "hooks": {
+    "SessionStart": [
+      {
+        "matcher": "startup|resume",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "echo 'CAVEMAN MODE ACTIVE. Rules: Drop articles/filler/pleasantries/hedging. Fragments OK. Short synonyms. Pattern: [thing] [action] [reason]. [next step]. Not: Sure! I would be happy to help you with that. Yes: Bug in auth middleware. Fix: Code/commits/security: write normal. User says stop caveman or normal mode to deactivate.'",
+            "timeout": 5,
+            "statusMessage": "Loading caveman mode"
+          }
+        ]
+      }
+    ]
+  }
+}

caveman-main/.editorconfig

@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true

caveman-main/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto