leopold-driver 0.4.6 → 0.6.0

package/assets/VERSION

@@ -1 +1 @@
-0.4.6
+0.6.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/hooks/guard-irreversible.sh

@@ -149,8 +149,14 @@ case "$tool" in
                 deny "Leopold guard: 'git reset --hard' is forbidden in autonomous mode." ;;
       clean)  matches "$norm" '(--force|(^|[[:space:]])-[a-z]*f)' && \
                 deny "Leopold guard: 'git clean -f' is forbidden in autonomous mode." ;;
-      branch) matches "$norm" '(^|[[:space:]])-D([[:space:]]|$)' && \
-                deny "Leopold guard: 'git branch -D' is forbidden in autonomous mode." ;;
+      branch)
+        if matches "$norm" '(^|[[:space:]])-D([[:space:]]|$)'; then
+          # Exception: Leopold's own throwaway run-worktree branches are deletable
+          # (cleanup of `leopold/run-*`); every other forced branch delete stays denied.
+          matches "$norm" 'leopold/run-' || \
+            deny "Leopold guard: 'git branch -D' is forbidden in autonomous mode."
+        fi ;;
+      worktree) : ;;  # allowed: Leopold isolates a run in a dedicated git worktree
       push)
         matches "$norm" '(--force|--force-with-lease|(^|[[:space:]])-f([[:space:]]|$))' && \
           deny "Leopold guard: force-push is forbidden in autonomous mode."

package/assets/scripts/leopold-menu.sh

@@ -90,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

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/assets/skills/leopold-run/SKILL.md

@@ -65,8 +65,11 @@ in **parallel**, use a separate git worktree (one run per worktree):
 
     git worktree add ../<proj>-leopold-2 && cd ../<proj>-leopold-2
 
-Otherwise wait for the other run, or `/leopold-stop` it first. A run idle for
-over 10 minutes is treated as stale and may be taken over.
+The SDK driver automates this: `leopold-driver run --worktree` isolates the run in
+its own `leopold/run-<id>` worktree and, on the next start, reaps an orphaned prior
+run (a dead process that left `active:true`) and prunes its leftover worktree.
+Otherwise wait for the other run, or `/leopold-stop` it first. A run idle for over
+10 minutes is treated as stale and may be taken over.
 
 ## Step 1 — Activate the run
 

package/dist/config.js

@@ -43,12 +43,24 @@ export function initState(brief) {
         consecutive_failures: 0,
         max_failures: intFrom(brief.guardrails, "max_failures", 3),
         started_at: new Date().toISOString(),
+        orchestrator_pid: process.pid,
     };
     writeState(brief.leoDir, state);
     return state;
 }
+/** Persist run state by MERGING over what's already on disk. The bash skill and
+ *  Stop-hook write fields the driver's RunState doesn't model (session_id,
+ *  max_subagents, …); a full overwrite would drop them (and they'd drop ours).
+ *  Read-merge-write keeps both writers' fields intact. */
 export function writeState(leoDir, state) {
-    fs.writeFileSync(path.join(leoDir, "state.json"), JSON.stringify(state, null, 2));
+    const p = path.join(leoDir, "state.json");
+    let onDisk = {};
+    try {
+        if (fs.existsSync(p))
+            onDisk = JSON.parse(fs.readFileSync(p, "utf8"));
+    }
+    catch { /* corrupt/absent — fall back to a clean write */ }
+    fs.writeFileSync(p, JSON.stringify({ ...onDisk, ...state }, null, 2));
 }
 export function killSwitch(leoDir) {
     return fs.existsSync(path.join(leoDir, "STOP"));
@@ -70,5 +82,6 @@ export function loadConfig(argv) {
         maxTurnsPerItem: parseInt(process.env.LEOPOLD_MAX_TURNS_PER_ITEM ?? "40", 10),
         webhookUrl: process.env.LEOPOLD_WEBHOOK || undefined,
         dryRun: argv.includes("--dry-run"),
+        worktree: argv.includes("--worktree") || process.env.LEOPOLD_WORKTREE === "1",
     };
 }

package/dist/loop.js

@@ -1,11 +1,14 @@
 // The orchestration loop: the conductor burns down the plan, one fresh worker
 // per item, deciding from the charter, with git locked, until the plan is done
 // or a stop condition fires. It notifies the human on completion or escalation.
+import { randomUUID } from "node:crypto";
 import { loadBrief, initState, writeState, killSwitch, loadConfig, clearRunTokens } from "./config.js";
 import { runItem } from "./worker.js";
 import { decide } from "./conductor.js";
 import { logEvent, logDecision, markItemDone, openItems, nextOpenItem } from "./log.js";
 import { notify } from "./notify.js";
+import { createWorktree, cleanupWorktree } from "./worktree.js";
+import { reapOrphan } from "./reaper.js";
 export async function runDriver(cwd, argv) {
     const cfg = loadConfig(argv);
     const brief = loadBrief(cwd);
@@ -16,9 +19,25 @@ export async function runDriver(cwd, argv) {
         console.log("Next item: " + (nextOpenItem(brief.planPath) ?? "(none)"));
         return;
     }
+    // Preflight: reap a prior run that crashed leaving state.active === true.
+    reapOrphan(brief.root, brief.leoDir);
+    // Optional isolation: run inside a dedicated git worktree (the worker's cwd).
+    let worktree = null;
+    if (cfg.worktree) {
+        worktree = createWorktree(brief.root, brief.leoDir, randomUUID().slice(0, 8));
+        if (worktree) {
+            brief.worktreeRoot = worktree.path;
+            console.log(`Isolated in worktree: ${worktree.path}  (branch ${worktree.branch})`);
+        }
+    }
     const state = initState(brief);
+    if (worktree) {
+        state.worktree_path = worktree.path;
+        state.worktree_branch = worktree.branch;
+        writeState(brief.leoDir, state);
+    }
     const recent = [];
-    logEvent(brief.leoDir, { event: "run_start", conductor: cfg.conductorModel });
+    logEvent(brief.leoDir, { event: "run_start", conductor: cfg.conductorModel, worktree: worktree?.path ?? null });
     console.log(`Leopold is conducting "${brief.root}". Git is locked. touch .leopold/STOP to halt.\n`);
     const stop = (reason) => {
         state.active = false;
@@ -26,6 +45,8 @@ export async function runDriver(cwd, argv) {
         writeState(brief.leoDir, state);
         clearRunTokens(brief.leoDir);
         logEvent(brief.leoDir, { event: "stop", reason });
+        if (worktree)
+            cleanupWorktree(brief.root, worktree, brief.leoDir);
     };
     for (;;) {
         if (killSwitch(brief.leoDir)) {

package/dist/reaper.js

@@ -0,0 +1,59 @@
+// Orphan reaper: detect a prior run that crashed leaving state.active === true,
+// using a PID-liveness probe (the file's "active" flag is not proof of life).
+// Ported from paperclip's isZombieRun/reapOrphanedRuns, file-state edition.
+import fs from "node:fs";
+import path from "node:path";
+import { logEvent } from "./log.js";
+import { clearRunTokens } from "./config.js";
+import { cleanupWorktree } from "./worktree.js";
+/** True if a process with this pid is alive. `process.kill(pid, 0)` sends no
+ *  signal: it throws ESRCH if the pid is dead, EPERM if it's alive but not ours. */
+export function isProcessAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === "EPERM";
+    }
+}
+/** Best-effort preflight before a new run starts: if the previous run is still
+ *  flagged active but its orchestrator pid is dead, declare it orphaned — flip
+ *  inactive, log, clean its (clean) worktree, and clear stale run tokens.
+ *
+ *  Conservative on purpose: we only reap when there IS a pid AND it is dead.
+ *  An active state with no pid (e.g. a live in-session /leopold-run, which does
+ *  not persist orchestrator_pid) is left untouched — never clobber a live run. */
+export function reapOrphan(repoRoot, leoDir) {
+    const p = path.join(leoDir, "state.json");
+    if (!fs.existsSync(p))
+        return;
+    let prev;
+    try {
+        prev = JSON.parse(fs.readFileSync(p, "utf8"));
+    }
+    catch {
+        return;
+    }
+    if (prev.active !== true)
+        return;
+    const pid = typeof prev.orchestrator_pid === "number" ? prev.orchestrator_pid : undefined;
+    if (pid === undefined || isProcessAlive(pid))
+        return;
+    prev.active = false;
+    prev.stopped_reason = "reaped_orphan";
+    try {
+        fs.writeFileSync(p, JSON.stringify(prev, null, 2));
+    }
+    catch { /* ignore */ }
+    logEvent(leoDir, {
+        event: "run_reaped",
+        prior_pid: pid,
+        prior_started: prev.started_at ?? null,
+    });
+    const wtPath = typeof prev.worktree_path === "string" ? prev.worktree_path : undefined;
+    const wtBranch = typeof prev.worktree_branch === "string" ? prev.worktree_branch : undefined;
+    if (wtPath && wtBranch)
+        cleanupWorktree(repoRoot, { path: wtPath, branch: wtBranch }, leoDir);
+    clearRunTokens(leoDir);
+}

package/dist/worker.js

@@ -32,7 +32,7 @@ export async function runItem(opts) {
     const q = query({
         prompt: channel,
         options: {
-            cwd: brief.root,
+            cwd: brief.worktreeRoot ?? brief.root,
             maxTurns: cfg.maxTurnsPerItem,
             permissionMode: "default",
             canUseTool: guard,

package/dist/worktree.js

@@ -0,0 +1,87 @@
+// Git worktree isolation for a run (Path A / SDK driver). The orchestrator runs
+// git directly here — NOT through the worker's Bash tool — so the worker's git
+// lock is unaffected (the lock constrains the worker, not the orchestrator).
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { logEvent } from "./log.js";
+function git(cwd, args) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+}
+export function isGitRepo(dir) {
+    try {
+        return git(dir, ["rev-parse", "--is-inside-work-tree"]) === "true";
+    }
+    catch {
+        return false;
+    }
+}
+/** A worktree is "dirty" if it has staged, unstaged, or untracked changes.
+ *  Git is locked, so a run stages (git add) but never commits — dirty means
+ *  "there is work here the user should review", which we never destroy. */
+export function isDirty(worktreePath) {
+    try {
+        return git(worktreePath, ["status", "--porcelain"]).length > 0;
+    }
+    catch {
+        return false;
+    }
+}
+/** Provision an isolated worktree on a throwaway branch `leopold/run-<id>`,
+ *  as a sibling of the repo (matches the manual flow in docs/guardrails.md).
+ *  Returns null if the project is not a git repo — caller falls back to root. */
+export function createWorktree(repoRoot, leoDir, runId) {
+    if (!isGitRepo(repoRoot)) {
+        logEvent(leoDir, { event: "worktree_skipped", reason: "not_a_git_repo" });
+        return null;
+    }
+    const branch = `leopold/run-${runId}`;
+    // sibling of the repo, one level (matches `../<proj>-leopold-2` in the docs)
+    const dir = path.join(path.dirname(repoRoot), `${path.basename(repoRoot)}-leopold-${runId}`);
+    try {
+        git(repoRoot, ["worktree", "add", "-b", branch, dir, "HEAD"]);
+        logEvent(leoDir, { event: "worktree_created", path: dir, branch });
+        return { path: dir, branch };
+    }
+    catch (e) {
+        logEvent(leoDir, { event: "worktree_create_failed", error: String(e.message ?? e) });
+        return null;
+    }
+}
+/** Remove a run's worktree — but ONLY if it's clean. A worktree with work is
+ *  preserved (and logged) for the user to review/merge, since git is locked and
+ *  the run never committed. A clean worktree (or one already gone) is pruned. */
+export function cleanupWorktree(repoRoot, wt, leoDir) {
+    if (!fs.existsSync(wt.path)) {
+        try {
+            git(repoRoot, ["worktree", "prune"]);
+        }
+        catch { /* ignore */ }
+        try {
+            git(repoRoot, ["branch", "-D", wt.branch]);
+        }
+        catch { /* ignore */ }
+        return;
+    }
+    if (isDirty(wt.path)) {
+        logEvent(leoDir, {
+            event: "worktree_preserved",
+            path: wt.path,
+            branch: wt.branch,
+            reason: "uncommitted_changes",
+        });
+        return;
+    }
+    try {
+        git(repoRoot, ["worktree", "remove", "--force", wt.path]);
+        git(repoRoot, ["branch", "-D", wt.branch]);
+        logEvent(leoDir, { event: "worktree_removed", path: wt.path, branch: wt.branch });
+    }
+    catch (e) {
+        logEvent(leoDir, { event: "worktree_remove_failed", path: wt.path, error: String(e.message ?? e) });
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "leopold-driver",
-  "version": "0.4.6",
+  "version": "0.6.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": {
@@ -37,7 +37,7 @@
   "scripts": {
     "build": "tsc -p tsconfig.json && node scripts/copy-runtime.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "node --experimental-strip-types --test test/protocol.test.ts test/guard.test.ts",
+    "test": "node --import tsx --test test/protocol.test.ts test/guard.test.ts test/worktree.test.ts test/reaper.test.ts",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
     "prepublishOnly": "npm run build"