leopold-driver 0.4.5 → 0.5.0

package/assets/VERSION

@@ -1 +1 @@
-0.4.5
+0.5.0

package/assets/extensions/ovmem/extension.json

@@ -4,5 +4,11 @@
   "summary": "Autonomous RAG long-term memory (OpenViking + 4 hooks). Provider + model picker (OpenAI / AWS Bedrock) with prices.",
   "homepage": "https://github.com/Jonhvmp/leopold",
   "license": "MIT",
-  "order": 30
+  "order": 30,
+  "dashboard": {
+    "label": "Memory",
+    "module": "~/.claude/ovmem/dashboard.py",
+    "view": "dashboard_view",
+    "search": "dashboard_search"
+  }
 }

package/assets/extensions/ovmem/install.sh

@@ -293,6 +293,7 @@ fi
 say "installing ovmem engine + hooks"
 mkdir -p "$OVMEM_DIR/state"
 cp "$PAYLOAD/ovmem.py" "$OVMEM_DIR/ovmem.py"; cp "$PAYLOAD/ovmem-cleanup.py" "$OVMEM_DIR/ovmem-cleanup.py"
+cp "$PAYLOAD/dashboard.py" "$OVMEM_DIR/dashboard.py" 2>/dev/null || true
 cp "$PAYLOAD/RUNTIME.md" "$OVMEM_DIR/README.md" 2>/dev/null || true
 [ -f "$SETTINGS" ] || echo '{}' > "$SETTINGS"; cp "$SETTINGS" "$SETTINGS.ovmem.bak"
 SS="python3 $OVMEM_DIR/ovmem.py --event session-start"; UP="python3 $OVMEM_DIR/ovmem.py --event user-prompt"

package/assets/extensions/ovmem/manage.sh

@@ -54,34 +54,42 @@ case "${1:-}" in
     echo "to purge those too: uv tool uninstall openviking ; rm -rf ~/.openviking"
     ;;
 
+  watch)
+    # open the standalone ovmem dashboard (http://127.0.0.1:1934)
+    [ -f "$OVMEM_DIR/dashboard.py" ] || { echo "dashboard not installed (run: manage.sh install)" >&2; exit 1; }
+    shift 2>/dev/null || true
+    exec python3 "$OVMEM_DIR/dashboard.py" "$@"
+    ;;
+
   doctor)
-    echo "engine:   $([ -f "$OVMEM_DIR/ovmem.py" ] && echo "$OVMEM_DIR/ovmem.py" || echo missing)"
-    echo "cleanup:  $([ -f "$OVMEM_DIR/ovmem-cleanup.py" ] && echo present || echo missing)"
-    echo "server:   $(server_up && echo "up (127.0.0.1:1933)" || echo "down")"
+    echo "engine:    $([ -f "$OVMEM_DIR/ovmem.py" ] && echo "$OVMEM_DIR/ovmem.py" || echo missing)"
+    echo "cleanup:   $([ -f "$OVMEM_DIR/ovmem-cleanup.py" ] && echo present || echo missing)"
+    echo "dashboard: $([ -f "$OVMEM_DIR/dashboard.py" ] && echo "present (127.0.0.1:1934)" || echo missing)"
+    echo "server:    $(server_up && echo "up (127.0.0.1:1933)" || echo "down")"
     if [ -f "$SETTINGS" ]; then
       local_hooks="$(grep -c 'ovmem.py --event' "$SETTINGS" 2>/dev/null || echo 0)"
-      echo "hooks:    $local_hooks/4 wired in settings.json"
+      echo "hooks:     $local_hooks/4 wired in settings.json"
     else
-      echo "hooks:    settings.json not found"
+      echo "hooks:     settings.json not found"
     fi
     if [ -f "$HOME/.openviking/ov.conf" ] && command -v jq >/dev/null 2>&1; then
       prov="$(jq -r '.vlm.provider // "?"' "$HOME/.openviking/ov.conf" 2>/dev/null)"
       chat="$(jq -r '.vlm.model // "?"' "$HOME/.openviking/ov.conf" 2>/dev/null)"
       emb="$(jq -r '.embedding.dense.model // "?"' "$HOME/.openviking/ov.conf" 2>/dev/null)"
       lang="$(jq -r '.output_language_override // "auto"' "$HOME/.openviking/ov.conf" 2>/dev/null)"
-      echo "provider: $prov"
-      echo "chat:     $chat"
-      echo "embed:    $emb"
-      echo "ov.conf:  present (lang=$lang)"
+      echo "provider:  $prov"
+      echo "chat:      $chat"
+      echo "embed:     $emb"
+      echo "ov.conf:   present (lang=$lang)"
     elif [ -f "$HOME/.openviking/ov.conf" ]; then
-      echo "ov.conf:  present"
+      echo "ov.conf:   present"
     else
-      echo "ov.conf:  missing"
+      echo "ov.conf:   missing"
     fi
     ;;
 
   *)
-    echo "usage: manage.sh {detect|status|install|update|remove|doctor}" >&2
+    echo "usage: manage.sh {detect|status|install|update|remove|doctor|watch}" >&2
     exit 2
     ;;
 esac

package/assets/extensions/ovmem/payload/dashboard.py

@@ -0,0 +1,607 @@
+#!/usr/bin/env python3
+"""
+ovmem dashboard - local web panel to observe the RAG memory (OpenViking).
+
+Zero dependencies (stdlib only). Serves at http://127.0.0.1:1934:
+  /              -> HTML page (auto-refresh)
+  /api/stats     -> aggregated JSON: server, hooks, hotness, sessions, server-side usage
+  /api/search?q= -> live recall (POST /search/find on the OpenViking server)
+
+Everything is read-only. SQLite databases are opened mode=ro so they never compete
+with the server.
+
+It also exposes a small "dashboard provider" contract so a host dashboard (the
+leopold-watch tab system) can render a Memory tab without a second HTTP server:
+  dashboard_view()        -> {"cards": [...]}  declarative widget view
+  dashboard_search(query) -> {"hits": [...]}   live recall
+
+Usage:
+  python3 dashboard.py                 # serve the panel (port 1934, or the next free one)
+  python3 dashboard.py --port 9000     # fixed port
+  python3 dashboard.py --json          # print the aggregate and exit (no server)
+"""
+import json
+import os
+import sqlite3
+import sys
+import time
+import urllib.request
+import urllib.parse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+HOME = os.path.expanduser("~")
+OVMEM_DIR = os.path.join(HOME, ".claude", "ovmem")
+STATE_DIR = os.path.join(OVMEM_DIR, "state")
+LOG_PATH = os.path.join(OVMEM_DIR, "ovmem.log")
+CONF_PATH = os.path.join(HOME, ".openviking", "ov.conf")
+DATA_DIR = os.path.join(HOME, ".openviking", "data")
+AUDIT_DB = os.path.join(DATA_DIR, "_system", "usage_audit", "usage_audit.sqlite3")
+QUEUE_DB = os.path.join(DATA_DIR, "_system", "queue", "queue.db")
+
+
+# ---------- config ----------
+
+def load_conf():
+    host, port, key, lang, vlm, emb = "127.0.0.1", 1933, "ov-local-dev-key", "?", "?", "?"
+    try:
+        with open(CONF_PATH) as f:
+            c = json.load(f)
+        srv = c.get("server", {})
+        host = srv.get("host", host)
+        port = int(srv.get("port", port))
+        key = srv.get("root_api_key", key)
+        lang = c.get("output_language_override", "?")
+        vlm = (c.get("vlm") or {}).get("model", "?")
+        emb = ((c.get("embedding") or {}).get("dense") or {}).get("model", "?")
+    except Exception:
+        pass
+    return host, port, key, lang, vlm, emb
+
+
+HOST, PORT, API_KEY, LANG, VLM, EMB = load_conf()
+OV_BASE = "http://%s:%d" % (HOST, PORT)
+
+
+def ov_call(path, body=None, timeout=5):
+    url = OV_BASE + path
+    data = json.dumps(body).encode() if body is not None else None
+    req = urllib.request.Request(url, data=data, method="POST" if data else "GET")
+    req.add_header("x-api-key", API_KEY)
+    req.add_header("X-OpenViking-Account", "default")
+    req.add_header("X-OpenViking-User", os.environ.get("USER", "jonhvmp"))
+    req.add_header("X-OpenViking-Agent", "claude-code")
+    if data is not None:
+        req.add_header("Content-Type", "application/json")
+    with urllib.request.urlopen(req, timeout=timeout) as resp:
+        return json.loads(resp.read().decode())
+
+
+# ---------- collectors ----------
+
+def server_health():
+    out = {"up": False, "version": None, "auth_mode": None, "pid": None}
+    try:
+        out.update({k: v for k, v in ov_call("/health", timeout=2).items()
+                    if k in ("version", "auth_mode")})
+        out["up"] = True
+    except Exception:
+        pass
+    pidf = os.path.join(DATA_DIR, ".openviking.pid")
+    try:
+        with open(pidf) as f:
+            pid = int(f.read().strip())
+        os.kill(pid, 0)  # does not send a signal, just checks the process exists
+        out["pid"] = pid
+    except Exception:
+        pass
+    return out
+
+
+def hotness():
+    """Read access.json (local recall signal) -> top memories by frequency/recency."""
+    path = os.path.join(STATE_DIR, "access.json")
+    out = {"tracked": 0, "total_hits": 0, "last_access": None, "top": []}
+    try:
+        with open(path) as f:
+            d = json.load(f)
+    except Exception:
+        return out
+    out["tracked"] = len(d)
+    out["total_hits"] = sum(int(v.get("n", 0)) for v in d.values())
+    if d:
+        out["last_access"] = max(int(v.get("t", 0)) for v in d.values())
+    rows = sorted(d.items(), key=lambda kv: int(kv[1].get("n", 0)), reverse=True)
+    for uri, v in rows[:12]:
+        out["top"].append({
+            "name": uri.rstrip("/").split("/")[-1],
+            "uri": uri,
+            "n": int(v.get("n", 0)),
+            "t": int(v.get("t", 0)),
+        })
+    return out
+
+
+def sessions():
+    out = {"count": 0, "total_lines": 0, "recent": []}
+    try:
+        files = [f for f in os.listdir(STATE_DIR)
+                 if f.endswith(".json") and f != "access.json"]
+    except Exception:
+        return out
+    items = []
+    for f in files:
+        p = os.path.join(STATE_DIR, f)
+        try:
+            lines = json.load(open(p)).get("lines", 0)
+            items.append((f[:-5], int(lines), os.path.getmtime(p)))
+        except Exception:
+            continue
+    out["count"] = len(items)
+    out["total_lines"] = sum(i[1] for i in items)
+    for sid, lines, mt in sorted(items, key=lambda x: x[2], reverse=True)[:6]:
+        out["recent"].append({"id": sid[:8], "lines": lines, "mtime": int(mt)})
+    return out
+
+
+def _conn(db):
+    return sqlite3.connect("file:%s?mode=ro" % db, uri=True, timeout=3)
+
+
+def usage():
+    out = {"requests": 0, "by_route": [], "recent": [], "avg_ms": None,
+           "tokens": None, "retrievals": None, "errors": 0}
+    if not os.path.exists(AUDIT_DB):
+        return out
+    try:
+        c = _conn(AUDIT_DB)
+        out["requests"] = c.execute("select count(*) from request_audit").fetchone()[0]
+        out["errors"] = c.execute(
+            "select count(*) from request_audit where status_code >= 400").fetchone()[0]
+        avg = c.execute(
+            "select avg(duration_ms) from request_audit where duration_ms is not null"
+        ).fetchone()[0]
+        out["avg_ms"] = round(avg, 1) if avg is not None else None
+        for route, n in c.execute(
+                "select route, count(*) c from request_audit group by route "
+                "order by c desc limit 8"):
+            out["by_route"].append({"route": route, "n": n})
+        for row in c.execute(
+                "select route, status_code, duration_ms, created_at from request_audit "
+                "order by id desc limit 12"):
+            out["recent"].append({
+                "route": row[0], "status": row[1],
+                "ms": row[2], "at": str(row[3])[:19],
+            })
+        # tokens: dynamic sum of any column with 'token' in its name
+        try:
+            cols = [r[1] for r in c.execute("pragma table_info(usage_token_hourly)")]
+            tcols = [x for x in cols if "token" in x.lower()]
+            if tcols:
+                expr = "+".join("coalesce(sum(%s),0)" % x for x in tcols)
+                out["tokens"] = c.execute(
+                    "select %s from usage_token_hourly" % expr).fetchone()[0]
+        except Exception:
+            pass
+        try:
+            cols = [r[1] for r in c.execute("pragma table_info(usage_retrieval_hourly)")]
+            rcols = [x for x in cols if any(k in x.lower()
+                     for k in ("count", "retriev", "hits", "queries"))]
+            if rcols:
+                expr = "+".join("coalesce(sum(%s),0)" % x for x in rcols)
+                out["retrievals"] = c.execute(
+                    "select %s from usage_retrieval_hourly" % expr).fetchone()[0]
+        except Exception:
+            pass
+        c.close()
+    except Exception:
+        pass
+    return out
+
+
+def hook_log():
+    out = {"last_lines": [], "mtime": None}
+    try:
+        out["mtime"] = int(os.path.getmtime(LOG_PATH))
+        with open(LOG_PATH) as f:
+            out["last_lines"] = [l.rstrip("\n") for l in f.readlines()[-8:]]
+    except Exception:
+        pass
+    return out
+
+
+def collect_stats():
+    return {
+        "now": int(time.time()),
+        "config": {"host": HOST, "port": PORT, "lang": LANG, "vlm": VLM, "embedding": EMB},
+        "server": server_health(),
+        "hotness": hotness(),
+        "sessions": sessions(),
+        "usage": usage(),
+        "log": hook_log(),
+    }
+
+
+def live_search(q):
+    if not q:
+        return {"hits": []}
+    try:
+        r = ov_call("/api/v1/search/find", body={
+            "query": q,
+            "target_uri": ["viking://user/", "viking://session/"],
+            "limit": 8,
+        }, timeout=8)
+        res = r.get("result", {}) or {}
+        hits = []
+        for key in ("memories", "resources", "skills"):
+            hits += (res.get(key) or [])
+        hits.sort(key=lambda x: x.get("score", 0), reverse=True)
+        return {"hits": [{
+            "score": round(h.get("score", 0), 3),
+            "uri": h.get("uri", ""),
+            "text": (h.get("overview") or h.get("abstract") or "")[:300],
+        } for h in hits[:8]]}
+    except Exception as e:
+        return {"hits": [], "error": str(e)}
+
+
+# ---------- dashboard provider contract (for a host like leopold-watch) ----------
+
+def _fmt_age(now, t):
+    if not t:
+        return "-"
+    d = now - t
+    if d < 60:
+        return "%ds ago" % d
+    if d < 3600:
+        return "%dmin ago" % (d // 60)
+    if d < 86400:
+        return "%dh ago" % (d // 3600)
+    return "%dd ago" % (d // 86400)
+
+
+def _tone_age(now, t):
+    if not t:
+        return "warn"
+    return "good" if (now - t) < 86400 else "warn"
+
+
+def dashboard_view():
+    """Plugin contract: a declarative card/widget view for a host dashboard.
+
+    The host renders this with its own design system; we only describe data. Widget
+    kinds: kpis | bars | table | search | log. tone in good|warn|bad|none.
+    """
+    s = collect_stats()
+    now = s["now"]
+    srv, cfg, h, u, ses, lg = (s["server"], s["config"], s["hotness"],
+                               s["usage"], s["sessions"], s["log"])
+    cards = []
+
+    cards.append({"title": "OpenViking server", "widgets": [
+        {"kind": "kpis", "items": [
+            {"label": "status", "value": "online" if srv["up"] else "offline",
+             "tone": "good" if srv["up"] else "bad"},
+            {"label": "version", "value": srv.get("version") or "-"},
+            {"label": "port", "value": cfg["port"]},
+            {"label": "pid", "value": srv.get("pid") or "-"},
+            {"label": "vlm", "value": cfg["vlm"]},
+            {"label": "embedding", "value": cfg["embedding"]},
+        ]},
+    ]})
+
+    maxn = max([x["n"] for x in h["top"]] or [1])
+    cards.append({"title": "Recall (local hotness)", "widgets": [
+        {"kind": "kpis", "items": [
+            {"label": "memories", "value": h["tracked"],
+             "tone": "good" if h["tracked"] else "none"},
+            {"label": "total hits", "value": h["total_hits"]},
+            {"label": "last recall", "value": _fmt_age(now, h["last_access"]),
+             "tone": _tone_age(now, h["last_access"])},
+        ]},
+        {"kind": "bars", "items": [
+            {"label": x["name"], "value": x["n"], "max": maxn} for x in h["top"][:8]
+        ]},
+    ]})
+
+    cards.append({"title": "Server-side activity", "widgets": [
+        {"kind": "kpis", "items": [
+            {"label": "requests", "value": u["requests"]},
+            {"label": "avg latency",
+             "value": ("%sms" % u["avg_ms"]) if u["avg_ms"] is not None else "-"},
+            {"label": "errors", "value": u["errors"],
+             "tone": "warn" if u["errors"] else "none"},
+            {"label": "tokens", "value": u["tokens"] if u["tokens"] is not None else "-"},
+            {"label": "retrievals",
+             "value": u["retrievals"] if u["retrievals"] is not None else "-"},
+        ]},
+        {"kind": "table", "columns": ["route", "n"],
+         "rows": [[r["route"], r["n"]] for r in u["by_route"]]},
+    ]})
+
+    cards.append({"title": "Recent requests", "widgets": [
+        {"kind": "table", "columns": ["when", "route", "status", "ms"],
+         "rows": [[r["at"], r["route"], r["status"], r["ms"] if r["ms"] is not None else "-"]
+                  for r in u["recent"]]},
+    ]})
+
+    cards.append({"title": "Tracked sessions", "widgets": [
+        {"kind": "kpis", "items": [
+            {"label": "sessions", "value": ses["count"]},
+            {"label": "lines committed", "value": ses["total_lines"]},
+        ]},
+        {"kind": "table", "columns": ["id", "lines", "updated"],
+         "rows": [[x["id"], x["lines"], _fmt_age(now, x["mtime"])] for x in ses["recent"]]},
+    ]})
+
+    cards.append({"title": "Live memory search", "widgets": [
+        {"kind": "search", "placeholder": "e.g. ovmem project, user stack, deadline..."},
+    ]})
+
+    cards.append({"title": "Hook log", "widgets": [
+        {"kind": "log", "lines": lg["last_lines"] or ["no log (OVMEM_DEBUG off)"]},
+    ]})
+
+    return {"cards": cards, "ok": srv["up"]}
+
+
+def dashboard_search(q):
+    """Plugin contract: live recall for the host's search widget."""
+    return live_search(q)
+
+
+# ---------- HTML ----------
+
+PAGE = r"""<!doctype html>
+<html lang="en"><head>
+<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>ovmem dashboard</title>
+<style>
+  :root{
+    --bg:#0b0d10; --panel:#14181d; --panel2:#1b2027; --line:#262d36;
+    --txt:#e6edf3; --dim:#8b97a5; --acc:#5ad1a0; --warn:#e3b341; --bad:#f0746e;
+    --mono:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;
+  }
+  *{box-sizing:border-box}
+  body{margin:0;background:var(--bg);color:var(--txt);
+    font:14px/1.5 system-ui,-apple-system,Segoe UI,Roboto,sans-serif}
+  header{display:flex;align-items:center;gap:14px;padding:16px 22px;
+    border-bottom:1px solid var(--line);position:sticky;top:0;background:var(--bg);z-index:5}
+  header h1{font-size:16px;margin:0;font-weight:600;letter-spacing:.2px}
+  .dot{width:9px;height:9px;border-radius:50%;display:inline-block}
+  .up{background:var(--acc);box-shadow:0 0 8px var(--acc)}
+  .down{background:var(--bad);box-shadow:0 0 8px var(--bad)}
+  .pill{font:12px var(--mono);color:var(--dim);border:1px solid var(--line);
+    padding:2px 8px;border-radius:99px}
+  .spacer{flex:1}
+  #updated{font:11px var(--mono);color:var(--dim)}
+  main{padding:18px 22px;display:grid;gap:16px;
+    grid-template-columns:repeat(auto-fit,minmax(330px,1fr));max-width:1400px;margin:0 auto}
+  .card{background:var(--panel);border:1px solid var(--line);border-radius:12px;
+    padding:16px 18px;min-width:0}
+  .card.wide{grid-column:1/-1}
+  .card h2{font-size:11px;text-transform:uppercase;letter-spacing:1px;color:var(--dim);
+    margin:0 0 12px;font-weight:600}
+  .kpis{display:flex;gap:18px;flex-wrap:wrap}
+  .kpi .v{font:22px var(--mono);font-weight:600}
+  .kpi .l{font-size:11px;color:var(--dim)}
+  .v.acc{color:var(--acc)} .v.warn{color:var(--warn)} .v.bad{color:var(--bad)}
+  table{width:100%;border-collapse:collapse;font:12px var(--mono)}
+  td,th{text-align:left;padding:5px 6px;border-bottom:1px solid var(--line);
+    white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+  th{color:var(--dim);font-weight:500} tr:last-child td{border-bottom:none}
+  td.num{text-align:right;color:var(--acc)}
+  .name{max-width:0;width:100%}
+  .bar{height:5px;background:var(--panel2);border-radius:3px;overflow:hidden;margin-top:3px}
+  .bar>i{display:block;height:100%;background:var(--acc)}
+  .ok{color:var(--acc)} .err{color:var(--bad)} .muted{color:var(--dim)}
+  pre{margin:0;font:11px var(--mono);color:var(--dim);white-space:pre-wrap;
+    max-height:160px;overflow:auto}
+  .search{display:flex;gap:8px;margin-bottom:12px}
+  .search input{flex:1;background:var(--panel2);border:1px solid var(--line);color:var(--txt);
+    border-radius:8px;padding:8px 12px;font:13px var(--mono)}
+  .search button{background:var(--acc);color:#03130c;border:0;border-radius:8px;
+    padding:8px 16px;font-weight:600;cursor:pointer}
+  .hit{padding:8px 0;border-bottom:1px solid var(--line)}
+  .hit:last-child{border:none}
+  .hit .top{display:flex;gap:8px;align-items:baseline}
+  .hit .sc{font:12px var(--mono);color:var(--acc);font-weight:600}
+  .hit .u{font:11px var(--mono);color:var(--dim);overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+  .hit .tx{font-size:12px;color:var(--txt);margin-top:3px;opacity:.85}
+  .foot{padding:10px 22px;color:var(--dim);font:11px var(--mono);
+    border-top:1px solid var(--line)}
+</style></head>
+<body>
+<header>
+  <span id="dot" class="dot down"></span>
+  <h1>ovmem &middot; long-term memory</h1>
+  <span class="pill" id="srv">openviking ...</span>
+  <span class="pill" id="cfg"></span>
+  <span class="spacer"></span>
+  <span id="updated">connecting...</span>
+</header>
+<main id="grid">
+  <section class="card">
+    <h2>OpenViking server</h2>
+    <div class="kpis" id="k-server"></div>
+  </section>
+  <section class="card">
+    <h2>Recall (local hotness)</h2>
+    <div class="kpis" id="k-recall"></div>
+  </section>
+  <section class="card">
+    <h2>Server-side activity</h2>
+    <div class="kpis" id="k-usage"></div>
+  </section>
+  <section class="card wide">
+    <h2>Live memory search</h2>
+    <div class="search">
+      <input id="q" placeholder="e.g. ovmem project, user stack, deadline..." />
+      <button id="go">Search</button>
+    </div>
+    <div id="hits"><span class="muted">type a query and hit Enter</span></div>
+  </section>
+  <section class="card">
+    <h2>Hottest memories</h2>
+    <table><tbody id="t-hot"></tbody></table>
+  </section>
+  <section class="card">
+    <h2>Top routes</h2>
+    <table><tbody id="t-routes"></tbody></table>
+  </section>
+  <section class="card wide">
+    <h2>Recent requests</h2>
+    <table>
+      <thead><tr><th>when</th><th>route</th><th>status</th><th class="num">ms</th></tr></thead>
+      <tbody id="t-recent"></tbody>
+    </table>
+  </section>
+  <section class="card">
+    <h2>Tracked sessions</h2>
+    <table>
+      <thead><tr><th>id</th><th class="num">lines</th><th>updated</th></tr></thead>
+      <tbody id="t-sess"></tbody>
+    </table>
+  </section>
+  <section class="card">
+    <h2>Hook log</h2>
+    <pre id="log">no log (OVMEM_DEBUG off)</pre>
+  </section>
+</main>
+<div class="foot" id="foot"></div>
+<script>
+const $=s=>document.querySelector(s);
+const ago=ts=>{if(!ts)return "-";let d=Math.floor(Date.now()/1000)-ts;
+  if(d<60)return d+"s ago";if(d<3600)return Math.floor(d/60)+"min ago";
+  if(d<86400)return Math.floor(d/3600)+"h ago";return Math.floor(d/86400)+"d ago";};
+const esc=s=>(s||"").replace(/[&<>]/g,c=>({"&":"&amp;","<":"&lt;",">":"&gt;"}[c]));
+function kpi(v,l,cls){return `<div class="kpi"><div class="v ${cls||''}">${v}</div><div class="l">${l}</div></div>`;}
+
+async function refresh(){
+  let s;try{s=await (await fetch('/api/stats')).json();}catch(e){
+    $('#updated').textContent='dashboard server offline';return;}
+  const srvUp=s.server.up;
+  $('#dot').className='dot '+(srvUp?'up':'down');
+  $('#srv').textContent='openviking '+(s.server.version?('v'+s.server.version):'down')
+    +(s.server.pid?(' · pid '+s.server.pid):'');
+  $('#cfg').textContent=`lang:${s.config.lang} · vlm:${s.config.vlm} · emb:${s.config.embedding}`;
+
+  $('#k-server').innerHTML=
+    kpi(srvUp?'online':'offline','status',srvUp?'acc':'bad')
+    +kpi(s.config.port,'port')
+    +kpi(s.server.auth_mode||'-','auth');
+
+  const h=s.hotness;
+  $('#k-recall').innerHTML=
+    kpi(h.tracked,'memories','acc')
+    +kpi(h.total_hits,'total hits')
+    +kpi(ago(h.last_access),'last recall',(Date.now()/1000-h.last_access<86400)?'acc':'warn');
+
+  const u=s.usage;
+  $('#k-usage').innerHTML=
+    kpi(u.requests,'requests','acc')
+    +kpi(u.avg_ms!=null?u.avg_ms+'ms':'-','avg latency')
+    +kpi(u.errors,'errors 4xx/5xx',u.errors>0?'warn':'')
+    +(u.tokens!=null?kpi(u.tokens.toLocaleString(),'tokens (server)'):'');
+
+  const maxN=Math.max(1,...h.top.map(x=>x.n));
+  $('#t-hot').innerHTML=h.top.map(x=>`<tr>
+    <td class="name" title="${esc(x.uri)}">${esc(x.name)}
+      <div class="bar"><i style="width:${Math.round(100*x.n/maxN)}%"></i></div></td>
+    <td class="num">${x.n}</td></tr>`).join('')||'<tr><td class="muted">empty</td></tr>';
+
+  $('#t-routes').innerHTML=u.by_route.map(r=>`<tr>
+    <td class="name">${esc(r.route)}</td><td class="num">${r.n}</td></tr>`).join('')
+    ||'<tr><td class="muted">empty</td></tr>';
+
+  $('#t-recent').innerHTML=u.recent.map(r=>`<tr>
+    <td>${esc(r.at)}</td><td class="name">${esc(r.route)}</td>
+    <td class="${r.status>=400?'err':'ok'}">${r.status}</td>
+    <td class="num">${r.ms!=null?r.ms:'-'}</td></tr>`).join('')
+    ||'<tr><td class="muted">empty</td></tr>';
+
+  $('#t-sess').innerHTML=s.sessions.recent.map(x=>`<tr>
+    <td>${esc(x.id)}</td><td class="num">${x.lines}</td>
+    <td class="muted">${ago(x.mtime)}</td></tr>`).join('')
+    ||'<tr><td class="muted">empty</td></tr>';
+
+  if(s.log.last_lines.length)$('#log').textContent=s.log.last_lines.join('\n');
+  $('#updated').textContent='updated '+new Date().toLocaleTimeString();
+  $('#foot').textContent=`${s.sessions.count} sessions · ${s.sessions.total_lines} lines committed · `
+    +`retrievals: ${u.retrievals!=null?u.retrievals:'n/a'} · read-only dashboard`;
+}
+
+async function search(){
+  const q=$('#q').value.trim();if(!q)return;
+  $('#hits').innerHTML='<span class="muted">searching...</span>';
+  let r;try{r=await (await fetch('/api/search?q='+encodeURIComponent(q))).json();}
+  catch(e){$('#hits').innerHTML='<span class="err">failed</span>';return;}
+  if(r.error){$('#hits').innerHTML='<span class="err">'+esc(r.error)+'</span>';return;}
+  if(!r.hits.length){$('#hits').innerHTML='<span class="muted">no results</span>';return;}
+  $('#hits').innerHTML=r.hits.map(h=>`<div class="hit">
+    <div class="top"><span class="sc">${h.score.toFixed(3)}</span>
+      <span class="u" title="${esc(h.uri)}">${esc(h.uri)}</span></div>
+    <div class="tx">${esc(h.text)}</div></div>`).join('');
+}
+$('#go').onclick=search;
+$('#q').addEventListener('keydown',e=>{if(e.key==='Enter')search();});
+refresh();setInterval(refresh,5000);
+</script>
+</body></html>"""
+
+
+# ---------- http server ----------
+
+class Handler(BaseHTTPRequestHandler):
+    def _send(self, code, body, ctype):
+        data = body.encode() if isinstance(body, str) else body
+        self.send_response(code)
+        self.send_header("Content-Type", ctype)
+        self.send_header("Content-Length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    def do_GET(self):
+        parsed = urllib.parse.urlparse(self.path)
+        if parsed.path == "/":
+            self._send(200, PAGE, "text/html; charset=utf-8")
+        elif parsed.path == "/api/stats":
+            self._send(200, json.dumps(collect_stats()), "application/json")
+        elif parsed.path == "/api/search":
+            q = urllib.parse.parse_qs(parsed.query).get("q", [""])[0]
+            self._send(200, json.dumps(live_search(q)), "application/json")
+        else:
+            self._send(404, "not found", "text/plain")
+
+    def log_message(self, *a):
+        pass  # quiet
+
+
+def main():
+    if "--json" in sys.argv:
+        print(json.dumps(collect_stats(), indent=2, ensure_ascii=False))
+        return
+    port = 1934
+    if "--port" in sys.argv:
+        port = int(sys.argv[sys.argv.index("--port") + 1])
+    srv = None
+    for p in range(port, port + 10):
+        try:
+            srv = ThreadingHTTPServer(("127.0.0.1", p), Handler)
+            port = p
+            break
+        except OSError:
+            continue
+    if srv is None:
+        print("no free port in %d..%d" % (port, port + 9))
+        return
+    url = "http://127.0.0.1:%d" % port
+    print("ovmem dashboard  ->  %s" % url)
+    print("(Ctrl+C to stop)")
+    try:
+        srv.serve_forever()
+    except KeyboardInterrupt:
+        print("\nstopped")
+
+
+if __name__ == "__main__":
+    main()

package/assets/scripts/leopold-menu.sh

@@ -77,7 +77,8 @@ main_menu() {
       "$C_BOLD" "$i" "$C_RESET" "$C_BOLD" "$title" "$C_RESET" "$st" "$C_DIM" "$summary" "$C_RESET"
     i=$((i + 1))
   done < <(list_exts)
-  printf "   %sd%s) Doctor all     %sq%s) Quit\n\n" "$C_BOLD" "$C_RESET" "$C_BOLD" "$C_RESET"
+  printf "   %sd%s) Doctor all     %su%s) Uninstall     %sq%s) Quit\n\n" \
+    "$C_BOLD" "$C_RESET" "$C_BOLD" "$C_RESET" "$C_BOLD" "$C_RESET"
 }
 
 component_menu() {
@@ -89,13 +90,19 @@ component_menu() {
     ext_installed "$d" && st="installed${C_RESET} ${C_DIM}($(ext_status "$d"))"
     printf "  %s%s%s\n  status: %s%s\n\n" "$C_BOLD" "$title" "$C_RESET" "$C_GREEN" "$st"
     printf "  %s%s%s\n\n" "$C_DIM" "$(_jget "$d/extension.json" summary)" "$C_RESET"
-    printf "   1) Install    2) Update    3) Remove    4) Doctor    b) Back\n\n"
+    local has_dash=""; [ -n "$(_jget "$d/extension.json" dashboard)" ] && has_dash=1
+    if [ -n "$has_dash" ]; then
+      printf "   1) Install    2) Update    3) Remove    4) Doctor    w) Watch    b) Back\n\n"
+    else
+      printf "   1) Install    2) Update    3) Remove    4) Doctor    b) Back\n\n"
+    fi
     printf "select: "; read -r a || a="b"
     case "$a" in
       1) ext_run "$d" install || echo "${C_YELLOW}install returned non-zero${C_RESET}"; pause ;;
       2) ext_run "$d" update  || echo "${C_YELLOW}update returned non-zero${C_RESET}";  pause ;;
       3) ext_run "$d" remove  || echo "${C_YELLOW}remove returned non-zero${C_RESET}";  pause ;;
       4) ext_run "$d" doctor  || true; pause ;;
+      w|W) [ -n "$has_dash" ] && { ext_run "$d" watch || true; }; pause ;;
       b|B|"") return ;;
       *) ;;
     esac
@@ -113,6 +120,92 @@ doctor_all() {
   pause
 }
 
+# ---- uninstall (granular, data-safe) ---------------------------------------
+
+confirm() { # prompt -> 0 if yes
+  printf "%s [y/N] " "$1"
+  local a; read -r a || a=""
+  case "$a" in [yY]*) return 0 ;; *) echo "  skipped." ; return 1 ;; esac
+}
+ext_path() { [ -d "$EXT_DIR/$1" ] && printf "%s" "$EXT_DIR/$1"; }
+CLAUDE="${CLAUDE_HOME:-$HOME/.claude}"
+
+remove_core() {
+  local settings="$CLAUDE/settings.json" tmp d
+  if [ -f "$settings" ] && command -v jq >/dev/null 2>&1; then
+    cp "$settings" "$settings.leopold.bak"
+    tmp="$(mktemp)"
+    jq 'if .hooks then .hooks |= ( to_entries
+          | map(.value |= ( map(.hooks |= map(select((.command // "") | test("leopold/hooks/") | not)))
+                            | map(select((.hooks | length) > 0)) ))
+          | from_entries ) else . end' "$settings" > "$tmp" && mv "$tmp" "$settings"
+    echo "  unwired Leopold's Stop/PreToolUse hooks (backup at $settings.leopold.bak)"
+  fi
+  for d in "$CLAUDE"/skills/leopold-*; do [ -d "$d" ] && rm -rf "$d"; done
+  rm -rf "$CLAUDE/leopold" 2>/dev/null || true
+  echo "  removed the leopold-* skills and $CLAUDE/leopold"
+}
+
+remove_cli() {
+  if command -v npm >/dev/null 2>&1; then
+    npm uninstall -g leopold-driver >/dev/null 2>&1 \
+      && echo "  uninstalled the leopold CLI (npm)" \
+      || echo "  (leopold CLI not installed via npm, or it needs sudo)"
+  else
+    echo "  npm not found — nothing to do for the CLI"
+  fi
+}
+
+remove_ext() { # name
+  local d; d="$(ext_path "$1")"
+  [ -n "$d" ] && ext_run "$d" remove || echo "  ($1 extension not found in this build)"
+}
+
+remove_ovmem_data() {
+  printf "%s  This DELETES ~/.openviking — your ENTIRE long-term memory — and uninstalls\n" "$C_YELLOW"
+  printf "  the OpenViking server. There is no undo.%s\n" "$C_RESET"
+  printf "  Type %sDELETE%s to confirm: " "$C_BOLD" "$C_RESET"
+  local a; read -r a || a=""
+  [ "$a" = "DELETE" ] || { echo "  skipped (not confirmed)."; return; }
+  pkill -f "openviking-server" 2>/dev/null || true
+  command -v uv >/dev/null 2>&1 && uv tool uninstall openviking >/dev/null 2>&1 && echo "  uninstalled the openviking server" || true
+  rm -rf "$HOME/.openviking" 2>/dev/null && echo "  deleted ~/.openviking (long-term memory)" || true
+}
+
+uninstall_menu() {
+  header
+  printf "  %sUninstall Leopold%s — pick exactly what to remove.\n" "$C_BOLD" "$C_RESET"
+  printf "  %sYour data is KEPT unless you pick a DATA item; each pick is confirmed.%s\n\n" "$C_DIM" "$C_RESET"
+  printf "   1) Leopold core        skills + hooks + %s/leopold (the harness)\n" "$CLAUDE"
+  printf "   2) leopold CLI         npm uninstall -g leopold-driver\n"
+  printf "   3) serena              unregister MCP + unwire hooks (keeps the serena CLI)\n"
+  printf "   4) gstack              remove the skill suite\n"
+  printf "   5) ovmem               unwire hooks + remove engine %s(keeps your memory)%s\n" "$C_DIM" "$C_RESET"
+  printf "   6) %sovmem DATA + server   ~/.openviking + OpenViking — DELETES memory!%s\n\n" "$C_YELLOW" "$C_RESET"
+  printf "   a) everything except DATA (1-5)      q) cancel\n\n"
+  printf "pick (space-separated, e.g. \"1 2 5\"): "
+  local picks p; read -r picks || picks="q"
+  case "$picks" in q|Q|"") return ;; a|A) picks="1 2 3 4 5" ;; esac
+  echo
+  printf "%sSelected: %s%s\n" "$C_BOLD" "$picks" "$C_RESET"
+  confirm "Proceed with the removals above?" || { pause; return; }
+  echo
+  for p in $picks; do
+    case "$p" in
+      1) confirm "Remove Leopold core (skills + hooks)?"        && remove_core ;;
+      2) confirm "Uninstall the leopold CLI (npm -g)?"          && remove_cli ;;
+      3) confirm "Remove serena (MCP + hooks)?"                 && remove_ext serena ;;
+      4) confirm "Remove gstack?"                               && remove_ext gstack ;;
+      5) confirm "Remove ovmem engine (keeps your memory)?"     && remove_ext ovmem ;;
+      6) remove_ovmem_data ;;
+      *) echo "  ignored: '$p'" ;;
+    esac
+  done
+  echo
+  printf "%sUninstall done.%s\n" "$C_GREEN" "$C_RESET"
+  pause
+}
+
 # ---- main loop --------------------------------------------------------------
 
 while true; do
@@ -121,6 +214,7 @@ while true; do
   case "$choice" in
     q|Q) echo; exit 0 ;;
     d|D) doctor_all ;;
+    u|U) uninstall_menu ;;
     ''|*[!0-9]*) ;;  # ignore non-numeric
     *)
       idx=$((choice - 1))

package/assets/scripts/leopold-watch.py

@@ -16,10 +16,12 @@ and uses no web fonts. Usage:
     python3 leopold-watch.py [--project DIR] [--port 4179] [--host 127.0.0.1]
 """
 import argparse
+import importlib.util
 import json
 import os
 import re
 import time
+import urllib.parse
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 
 LEO = ""          # set in main(): the project's .leopold dir
@@ -313,6 +315,77 @@ def snapshot():
     }
 
 
+# --------------------------------------------------------------------------- extension dashboards
+# A small plugin system: any installed extension whose extension.json carries a
+# `dashboard` block contributes a tab. The block names a Python module + a `view`
+# callable returning a declarative card/widget view ({"cards":[...]}), and an optional
+# `search` callable. The watch imports the module and renders the view with its own
+# design system. Any failure drops that extension silently — the tab just won't appear.
+_EXT_CACHE = None
+
+
+def _ext_dirs():
+    here = os.path.dirname(os.path.abspath(__file__))
+    out = []
+    for cand in (os.path.join(here, "..", "extensions"),
+                 os.path.expanduser("~/.claude/leopold/extensions")):
+        cand = os.path.abspath(cand)
+        if os.path.isdir(cand) and cand not in out:
+            out.append(cand)
+    return out
+
+
+def ext_dashboards():
+    """Discover installed extensions that contribute a dashboard tab (memoized)."""
+    global _EXT_CACHE
+    if _EXT_CACHE is not None:
+        return _EXT_CACHE
+    found, seen = [], set()
+    for base in _ext_dirs():
+        try:
+            names = sorted(os.listdir(base))
+        except OSError:
+            continue
+        for name in names:
+            meta = os.path.join(base, name, "extension.json")
+            if name in seen or not os.path.isfile(meta):
+                continue
+            try:
+                with open(meta, encoding="utf-8") as f:
+                    cfg = json.load(f)
+                dash = cfg.get("dashboard")
+                if not isinstance(dash, dict):
+                    continue
+                mod_path = os.path.expanduser(dash.get("module", ""))
+                if not mod_path or not os.path.isfile(mod_path):
+                    continue
+                spec = importlib.util.spec_from_file_location("ext_dash_%s" % name, mod_path)
+                mod = importlib.util.module_from_spec(spec)
+                spec.loader.exec_module(mod)
+                view_fn = getattr(mod, dash.get("view", "dashboard_view"), None)
+                if not callable(view_fn):
+                    continue
+                search_fn = getattr(mod, dash.get("search", ""), None)
+                found.append({
+                    "name": cfg.get("name", name),
+                    "label": dash.get("label", cfg.get("title", name)),
+                    "view": view_fn,
+                    "search": search_fn if callable(search_fn) else None,
+                })
+                seen.add(name)
+            except Exception:
+                continue
+    _EXT_CACHE = found
+    return found
+
+
+def ext_by_name(name):
+    for e in ext_dashboards():
+        if e["name"] == name:
+            return e
+    return None
+
+
 # --------------------------------------------------------------------------- page
 # Design system: warm cream (light) / near-black (dark), monochrome with semantic green/red
 # + severity tones; Geist / Geist Mono type stack (system fallback, no web fonts -> offline).
@@ -400,6 +473,31 @@ html,body{margin:0;background:var(--bg);color:var(--fg);font-family:var(--sans);
 .dec{background:var(--secondary);border:1px solid var(--hairline);border-radius:8px;padding:10px 12px;margin-bottom:8px;
  font-family:var(--mono);font-size:12px;white-space:pre-wrap;line-height:1.5}
 .empty{color:var(--muted-fg);padding:6px 0;font-size:12px}
+.tabs{display:flex;gap:6px;margin-bottom:16px;flex-wrap:wrap}
+.tab{background:transparent;border:1px solid var(--border);color:var(--muted-fg);border-radius:9999px;
+ height:28px;padding:0 14px;font-family:var(--mono);font-size:10px;letter-spacing:.12em;text-transform:uppercase;cursor:pointer}
+.tab:hover{color:var(--fg);border-color:var(--muted-fg)}
+.tab.active{color:var(--fg);border-color:var(--fg)}
+.kv{display:grid;grid-template-columns:repeat(auto-fit,minmax(120px,1fr));gap:12px}
+.kv .k{font-family:var(--mono);font-size:10px;letter-spacing:.08em;text-transform:uppercase;color:var(--muted-fg)}
+.kv .v{font-family:var(--mono);font-size:15px;font-variant-numeric:tabular-nums;margin-top:3px;word-break:break-word}
+.kv .v.good{color:var(--success)}.kv .v.bad{color:var(--destructive)}.kv .v.warn{color:var(--warnbar)}
+.xtab{width:100%;border-collapse:collapse;font-family:var(--mono);font-size:12px}
+.xtab th,.xtab td{text-align:left;padding:5px 6px;border-bottom:1px solid var(--hairline);
+ white-space:nowrap;overflow:hidden;text-overflow:ellipsis;max-width:340px}
+.xtab th{color:var(--muted-fg);font-weight:500;text-transform:uppercase;letter-spacing:.06em;font-size:10px}
+.xtab td.n{text-align:right;font-variant-numeric:tabular-nums}
+.xsearch{display:flex;gap:8px;margin-bottom:10px}
+.xsearch input{flex:1;background:var(--secondary);border:1px solid var(--border);color:var(--fg);
+ border-radius:6px;padding:7px 11px;font-family:var(--mono);font-size:12px}
+.xsearch button{background:var(--fg);color:var(--bg);border:0;border-radius:6px;padding:7px 14px;
+ font-family:var(--sans);font-weight:500;font-size:12px;cursor:pointer}
+.xhit{padding:7px 0;border-bottom:1px solid var(--hairline)}.xhit:last-child{border:0}
+.xhit .sc{font-family:var(--mono);font-size:11px;color:var(--success);font-weight:600}
+.xhit .u{font-family:var(--mono);font-size:10px;color:var(--muted-fg);margin-left:8px}
+.xhit .tx{font-size:12px;margin-top:3px;color:var(--fg);opacity:.85}
+.xlog{margin:0;font-family:var(--mono);font-size:11px;color:var(--muted-fg);white-space:pre-wrap;max-height:160px;overflow:auto}
+.hide{display:none}
 ::-webkit-scrollbar{width:10px;height:10px}::-webkit-scrollbar-track{background:transparent}
 ::-webkit-scrollbar-thumb{background:var(--hairline);border:2px solid var(--bg);border-radius:9999px}
 ::selection{background:var(--fg);color:var(--bg)}
@@ -411,6 +509,8 @@ html,body{margin:0;background:var(--bg);color:var(--fg);font-family:var(--sans);
   <span class="proj" id="proj"></span><span class="grow"></span>
   <button class="tgl" id="tgl">theme</button>
 </div>
+<div class="tabs" id="tabs"></div>
+<div id="tab-run">
 <div class="card">
   <div class="row">
     <span class="pill" id="status"><span class="dot" id="dot"></span><span id="stext">—</span></span>
@@ -424,6 +524,8 @@ html,body{margin:0;background:var(--bg);color:var(--fg);font-family:var(--sans);
 <div class="card"><div class="sectitle">Live events</div><div class="feed" id="feed"></div></div>
 <div class="card"><div class="sectitle">Plan</div><div id="plan" class="plan"></div></div>
 <div class="card"><div class="sectitle">Decisions · newest</div><div id="decisions"></div></div>
+</div><!-- /tab-run -->
+<div id="extviews"></div>
 <script>
 const $=s=>document.querySelector(s);
 function el(t,c,txt){const e=document.createElement(t);if(c)e.className=c;if(txt!=null)e.textContent=txt;return e;}
@@ -501,6 +603,86 @@ $("#tgl").addEventListener("click",()=>{
 fetch("/api/state").then(r=>r.json()).then(render).catch(()=>{});
 const es=new EventSource("/api/events");
 es.onmessage=ev=>{try{render(JSON.parse(ev.data))}catch(_){}};
+
+// ---- tabs: Run (SSE) + one per extension dashboard (polled) ----
+let curTab="run",extTimer=null;
+function setTab(name){
+  curTab=name;
+  document.querySelectorAll(".tab").forEach(b=>b.classList.toggle("active",b.dataset.tab===name));
+  $("#tab-run").classList.toggle("hide",name!=="run");
+  document.querySelectorAll("[data-extview]").forEach(v=>v.classList.toggle("hide",v.dataset.extview!==name));
+  try{localStorage.setItem("leo-tab",name)}catch(e){}
+  if(extTimer){clearInterval(extTimer);extTimer=null;}
+  if(name!=="run"){loadExt(name);extTimer=setInterval(()=>loadExt(name),5000);}
+}
+async function loadExt(name){
+  const host=document.querySelector('[data-extview="'+name+'"]');if(!host)return;
+  const inp=host.querySelector(".xsearch input");        // don't clobber an in-progress search
+  if(inp&&(inp===document.activeElement||inp.value.trim()))return;
+  let v;try{v=await (await fetch("/api/ext/"+encodeURIComponent(name)+"/stats")).json();}catch(e){return;}
+  renderView(host,name,v);
+}
+function widgetEl(name,w){
+  if(w.kind==="kpis"){
+    const g=el("div","kv");
+    (w.items||[]).forEach(it=>{const d=el("div");d.append(el("div","k",it.label));
+      const v=el("div","v"+(it.tone&&it.tone!=="none"?(" "+it.tone):""));v.textContent=it.value;d.append(v);g.append(d);});
+    return g;
+  }
+  if(w.kind==="bars"){
+    const wrap=el("div","meters"),items=w.items||[],mx=Math.max(1,...items.map(x=>x.max||x.value||0));
+    items.forEach(it=>{const m=el("div","meter"),top=el("div","top");
+      top.append(el("span","lbl",it.label),el("span","val tnum",""+it.value));
+      const bar=el("div","bar"),i=el("i");i.style.width=Math.round(100*(it.value||0)/(it.max||mx))+"%";bar.append(i);
+      m.append(top,bar);wrap.append(m);});
+    return wrap;
+  }
+  if(w.kind==="table"){
+    const t=el("table","xtab"),cols=w.columns||[],rows=w.rows||[];
+    if(cols.length){const tr=el("tr");cols.forEach((c,i)=>tr.append(el("th",i>0?"n":null,c)));
+      const th=el("thead");th.append(tr);t.append(th);}
+    const tb=el("tbody");
+    rows.forEach(row=>{const tr=el("tr");row.forEach((cell,i)=>{
+      const td=el("td",(i>0&&typeof cell==="number")?"n":null);td.textContent=cell;tr.append(td);});tb.append(tr);});
+    if(!rows.length){const tr=el("tr"),td=el("td","empty","empty");td.colSpan=Math.max(1,cols.length);tr.append(td);tb.append(tr);}
+    t.append(tb);return t;
+  }
+  if(w.kind==="search"){
+    const box=el("div"),row=el("div","xsearch"),inp=el("input"),btn=el("button",null,"Search"),res=el("div");
+    inp.placeholder=w.placeholder||"search…";
+    const go=async()=>{const q=inp.value.trim();if(!q)return;res.textContent="searching…";
+      let r;try{r=await (await fetch("/api/ext/"+encodeURIComponent(name)+"/search?q="+encodeURIComponent(q))).json();}
+      catch(e){res.textContent="failed";return;}
+      res.innerHTML="";if(r.error){res.append(el("div","empty",r.error));return;}
+      if(!(r.hits||[]).length){res.append(el("div","empty","no results"));return;}
+      r.hits.forEach(h=>{const d=el("div","xhit"),t=el("div");
+        t.append(el("span","sc",h.score!=null?h.score.toFixed(3):""),el("span","u",h.uri||""));
+        d.append(t);if(h.text)d.append(el("div","tx",h.text));res.append(d);});};
+    btn.onclick=go;inp.addEventListener("keydown",e=>{if(e.key==="Enter")go();});
+    row.append(inp,btn);box.append(row,res);return box;
+  }
+  if(w.kind==="log"){const pre=el("pre","xlog");pre.textContent=(w.lines||[]).join("\n");return pre;}
+  return el("div");
+}
+function renderView(host,name,v){
+  host.innerHTML="";
+  const cards=(v&&v.cards)||[];
+  if(v&&v.error){const c=el("div","card");c.append(el("div","empty","error: "+v.error));host.append(c);}
+  cards.forEach(card=>{const c=el("div","card");c.append(el("div","sectitle",card.title||""));
+    (card.widgets||[]).forEach(w=>c.append(widgetEl(name,w)));host.append(c);});
+  if(!cards.length&&!(v&&v.error)){const c=el("div","card");c.append(el("div","empty","no data"));host.append(c);}
+}
+(async()=>{
+  let exts=[];try{exts=await (await fetch("/api/ext")).json();}catch(e){}
+  const nav=$("#tabs"),views=$("#extviews");
+  const mk=(tab,label)=>{const b=el("button","tab",label);b.dataset.tab=tab;b.onclick=()=>setTab(tab);nav.append(b);};
+  mk("run","Run");
+  exts.forEach(e=>{mk(e.name,e.label);const v=el("div","hide");v.dataset.extview=e.name;views.append(v);});
+  if(!exts.length)nav.classList.add("hide");                // no extensions -> plain single page
+  let start="run";try{start=localStorage.getItem("leo-tab")||"run";}catch(e){}
+  if(start!=="run"&&!exts.some(e=>e.name===start))start="run";
+  setTab(start);
+})();
 </script></body></html>"""
 
 
@@ -525,6 +707,43 @@ class Handler(BaseHTTPRequestHandler):
             self._send(200, "application/json", json.dumps(snapshot()).encode())
         elif path == "/api/events":
             self._sse()
+        elif path == "/api/ext":
+            tabs = [{"name": e["name"], "label": e["label"], "search": bool(e["search"])}
+                    for e in ext_dashboards()]
+            self._send(200, "application/json", json.dumps(tabs).encode())
+        elif path.startswith("/api/ext/"):
+            self._ext_route(path)
+        else:
+            self._send(404, "text/plain", b"not found")
+
+    def _ext_route(self, path):
+        parts = path.split("/")  # ['', 'api', 'ext', '<name>', 'stats'|'search']
+        if len(parts) != 5:
+            self._send(404, "text/plain", b"not found")
+            return
+        name, action = urllib.parse.unquote(parts[3]), parts[4]
+        e = ext_by_name(name)
+        if not e:
+            self._send(404, "application/json", b'{"error":"unknown extension"}')
+            return
+        if action == "stats":
+            try:
+                body = json.dumps(e["view"]())
+            except Exception as ex:
+                body = json.dumps({"cards": [], "error": str(ex)})
+            self._send(200, "application/json", body.encode())
+        elif action == "search":
+            if not e["search"]:
+                self._send(404, "application/json", b'{"hits":[]}')
+                return
+            q = ""
+            if "?" in self.path:
+                q = urllib.parse.parse_qs(self.path.split("?", 1)[1]).get("q", [""])[0]
+            try:
+                body = json.dumps(e["search"](q))
+            except Exception as ex:
+                body = json.dumps({"hits": [], "error": str(ex)})
+            self._send(200, "application/json", body.encode())
         else:
             self._send(404, "text/plain", b"not found")
 
@@ -575,6 +794,9 @@ def main():
     url = "http://%s:%d" % (args.host, args.port)
     print("Leopold watch -> %s   (project: %s)" % (url, args.project))
     print("Reading: %s + the session transcript   ·   Ctrl-C to stop" % LEO)
+    tabs = ext_dashboards()  # warm the cache once (single-threaded) + surface what's wired
+    if tabs:
+        print("Extension tabs: %s" % ", ".join(e["label"] for e in tabs))
     try:
         httpd.serve_forever()
     except KeyboardInterrupt:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leopold-driver",
-  "version": "0.4.5",
+  "version": "0.5.0",
   "description": "Leopold SDK driver: a persistent conductor that orchestrates fresh Claude Code workers per task, decides from your charter, and notifies you. Uses your Claude Code auth. Git stays locked.",
   "type": "module",
   "bin": {