mishkan-harness 0.2.0 → 0.2.3

package/payload/mishkan/observability/watch/src/mishkan_watch/tabs/knowledge.py

@@ -21,13 +21,14 @@ class KnowledgeTab(Container):
 
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
-        self._state: dict[str, Any] = {"mcp_servers": {}, "cognee": {}}
+        self._state: dict[str, Any] = {"mcp_servers": {}, "cognee": {}, "graphify": {}}
         self._recent_ops: deque[dict[str, Any]] = deque(maxlen=30)
 
     def compose(self) -> ComposeResult:
         with Horizontal(id="knowledge-stores"):
             yield Static("", id="knowledge-work", classes="cognee-card")
             yield Static("", id="knowledge-curated", classes="cognee-card")
+            yield Static("", id="knowledge-graphify", classes="cognee-card")
         with Container(id="knowledge-ops"):
             yield Static("RECENT OPS", classes="panel-title")
             yield DataTable(id="knowledge-ops-table", cursor_type="row",
@@ -40,7 +41,7 @@ class KnowledgeTab(Container):
     def on_mount(self) -> None:
         try:
             ops = self.query_one("#knowledge-ops-table", DataTable)
-            ops.add_columns("time", "store", "op", "query/path", "ms")
+            ops.add_columns("time", "store", "op", "detail", "metric")
             mcp = self.query_one("#knowledge-mcp-table", DataTable)
             mcp.add_columns("server", "status", "since", "last event")
         except Exception:
@@ -64,11 +65,65 @@ class KnowledgeTab(Container):
         if etype in ("cognee_op", "graphify_query", "graphify_scan"):
             self._recent_ops.append(ev)
             self._render_ops()
+        if etype == "cognee_op":
+            self._mutate_cognee(ev)
+            self._render_cards()
+        if etype in ("graphify_scan", "graphify_query"):
+            self._mutate_graphify(ev)
+            self._render_cards()
         if etype == "mcp_server":
             self._mutate_mcp(ev)
             self._render_mcp()
             self._render_cards()
 
+    def _mutate_graphify(self, ev: dict[str, Any]) -> None:
+        """Update self._state['graphify'] from graphify_scan / graphify_query.
+
+        Aggregates: latest scan (nodes/edges/project/ts) + query counter.
+        """
+        try:
+            p = ev.get("payload") or {}
+            etype = ev.get("type")
+            g = self._state.setdefault("graphify", {})
+            if etype == "graphify_scan":
+                g["last_scan_project"] = p.get("project")
+                g["last_scan_at"] = p.get("scanned_at") or ev.get("ts")
+                g["nodes"] = p.get("nodes")
+                g["edges"] = p.get("edges")
+                g["communities"] = p.get("communities")
+                g["scans"] = (g.get("scans") or 0) + 1
+            elif etype == "graphify_query":
+                g["last_query_project"] = p.get("project")
+                g["last_query_at"] = ev.get("ts")
+                g["last_query_text"] = p.get("question") or p.get("file")
+                g["queries"] = (g.get("queries") or 0) + 1
+        except Exception:
+            return
+
+    def _mutate_cognee(self, ev: dict[str, Any]) -> None:
+        """Update self._state['cognee'][store] from a cognee_op probe event.
+
+        Without this, _render_cards keeps reading an empty dict and the
+        top work/curated cards stay at zero even though the daemon is
+        emitting healthy probe events every 30s.
+        """
+        try:
+            p = ev.get("payload") or {}
+            store = p.get("store")
+            if not store:
+                return
+            cognee = self._state.setdefault("cognee", {})
+            entry = cognee.setdefault(store, {})
+            entry["up"] = bool(p.get("up"))
+            entry["url"] = p.get("url") or entry.get("url", "")
+            if "nodes" in p:
+                entry["nodes"] = p.get("nodes")
+            entry["last_event"] = ev.get("ts")
+            if p.get("status_changed"):
+                entry["since"] = ev.get("ts")
+        except Exception:
+            return
+
     def _mutate_mcp(self, ev: dict[str, Any]) -> None:
         try:
             p = ev.get("payload") or {}
@@ -97,6 +152,7 @@ class KnowledgeTab(Container):
         try:
             work_panel = self.query_one("#knowledge-work", Static)
             cur_panel = self.query_one("#knowledge-curated", Static)
+            graphify_panel = self.query_one("#knowledge-graphify", Static)
         except Exception:
             return
         mcps = self._state.get("mcp_servers") or {}
@@ -106,6 +162,40 @@ class KnowledgeTab(Container):
         cur_entry = cognee_state.get("curated") or self._mcp_match(mcps, "cognee", ("curated", "7730"))
         work_panel.update(self._card_for("work :7777", work_entry))
         cur_panel.update(self._card_for("curated :7730", cur_entry))
+        graphify_panel.update(self._graphify_card(self._state.get("graphify") or {}))
+
+    def _graphify_card(self, g: dict[str, Any]) -> Text:
+        text = Text()
+        has_data = bool(g.get("last_scan_at") or g.get("last_query_at"))
+        dot = "●" if has_data else "○"
+        color = "#00D4AA" if has_data else "#F6AD55"
+        text.append(f"{dot} ", style=color)
+        text.append("graphify", style="bold")
+        text.append("  (code-graph)\n", style="dim")
+        text.append("\n")
+        nodes = g.get("nodes")
+        edges = g.get("edges")
+        if nodes is not None:
+            text.append(f"{nodes:>6}", style="bold")
+            text.append(" nodes  ", style="dim")
+            if edges is not None:
+                text.append(f"{edges:,}", style="bold")
+                text.append(" edges", style="dim")
+            text.append("\n")
+        scans = g.get("scans") or 0
+        queries = g.get("queries") or 0
+        text.append(f"{scans:>6}", style="bold")
+        text.append(" scans  ", style="dim")
+        text.append(f"{queries}", style="bold")
+        text.append(" queries\n", style="dim")
+        last_scan = g.get("last_scan_at")
+        if last_scan and len(str(last_scan)) > 19:
+            text.append("scan ", style="dim")
+            text.append(str(last_scan)[11:19], style="white")
+            text.append("\n")
+        if not has_data:
+            text.append("(no scan emitted yet)\n", style="dim italic")
+        return text
 
     def _mcp_match(self, mcps: dict[str, Any], must_have: str,
                    prefer_tokens: tuple[str, ...]) -> dict[str, Any] | None:
@@ -151,18 +241,37 @@ class KnowledgeTab(Container):
         table.clear()
         for ev in list(self._recent_ops)[-20:]:
             ts = (ev.get("ts") or "")[11:19]
+            etype = ev.get("type") or ""
             p = ev.get("payload") or {}
-            store = p.get("store") or ("graphify" if ev.get("type", "").startswith("graphify") else "?")
-            op = p.get("op") or ev.get("type", "").replace("graphify_", "g:")
-            query = (p.get("query") or p.get("path") or "")[:40]
-            dur = ev.get("duration_ms") or p.get("duration_ms") or 0
-            style = "#F687B3" if "cognee" in (ev.get("type") or "") else "#B794F4"
+            store = p.get("store") or ("graphify" if etype.startswith("graphify") else "?")
+            op = p.get("op") or etype.replace("graphify_", "g:")
+            # Each event family fills the "query/path" + "ms" columns
+            # with the most useful field it carries:
+            #   cognee_op       → up/down status, nodes count
+            #   graphify_scan   → project basename, nodes/edges
+            #   graphify_query  → question excerpt or filename
+            if etype == "cognee_op":
+                detail = ("up " if p.get("up") else "down ") + str(p.get("url") or "")
+                n = p.get("nodes")
+                metric = f"{n} nodes" if n is not None else "-"
+            elif etype == "graphify_scan":
+                detail = (p.get("project") or "").rsplit("/", 1)[-1] or "(?)"
+                nodes = p.get("nodes")
+                edges = p.get("edges")
+                metric = f"{nodes}n {edges}e" if nodes is not None and edges is not None else "-"
+            elif etype == "graphify_query":
+                detail = (p.get("question") or p.get("file") or "")[:40]
+                metric = p.get("query_type") or "query"
+            else:
+                detail = (p.get("query") or p.get("path") or "")[:40]
+                metric = f"{ev.get('duration_ms') or 0}ms"
+            style = "#F687B3" if "cognee" in etype else "#B794F4"
             table.add_row(
                 Text(ts, style="dim"),
                 Text(str(store)[:10], style=style),
                 Text(str(op)[:10]),
-                Text(query),
-                Text(f"{dur}ms" if dur else "-", style="dim"),
+                Text(detail[:50]),
+                Text(metric, style="dim"),
             )
 
     def _render_mcp(self) -> None:

package/payload/mishkan/observability/watch/src/mishkan_watch/tabs/live.py

@@ -16,6 +16,27 @@ from textual.containers import Container, Horizontal, Vertical
 from textual.widgets import RichLog, Static
 from rich.text import Text
 
+# Module-level cache for the alias→role lookup (org.json is static).
+_ROLE_CACHE: dict[str, str | None] | None = None
+
+
+def _role_for(alias: str) -> str | None:
+    global _ROLE_CACHE
+    if _ROLE_CACHE is None:
+        try:
+            from ..org_data import load_org
+            org = load_org()
+            cache: dict[str, str | None] = {}
+            for grp in org.get("groups", []):
+                for ag in grp.get("agents", []):
+                    a = (ag.get("alias") or "").lower()
+                    if a:
+                        cache[a] = ag.get("short") or ag.get("role")
+            _ROLE_CACHE = cache
+        except Exception:
+            _ROLE_CACHE = {}
+    return _ROLE_CACHE.get((alias or "").lower())
+
 
 MAX_FEED_LINES = 200
 
@@ -116,6 +137,9 @@ class LiveTab(Container):
     def __init__(self, **kwargs) -> None:
         super().__init__(**kwargs)
         self._state: dict[str, Any] = {}
+        # Project filter — None means show all; a Path means filter to that project.
+        # Toggled by the app via set_project_filter() in response to the 'p' key.
+        self._project_filter: Any = None
         self._feed_buf: deque[Text] = deque(maxlen=MAX_FEED_LINES)
 
     def compose(self) -> ComposeResult:
@@ -159,7 +183,7 @@ class LiveTab(Container):
             self._render_active(self._state)
         if etype == "worktree_change":
             self._render_worktrees(self._state)
-        if etype in ("mcp_server", "cognee_op"):
+        if etype in ("mcp_server", "cognee_op", "graphify_scan", "graphify_query"):
             self._render_knowledge(self._state)
 
     def _mutate_state(self, ev: dict[str, Any]) -> None:
@@ -219,6 +243,29 @@ class LiveTab(Container):
                     existing["status"] = p.get("status") or existing.get("status", "?")
                     existing["last_event"] = ev.get("ts")
                     mcps[name] = existing
+            elif etype == "cognee_op":
+                p = ev.get("payload") or {}
+                store = p.get("store")
+                if store:
+                    cognee = self._state.setdefault("cognee", {})
+                    entry = cognee.setdefault(store, {})
+                    entry["up"] = bool(p.get("up"))
+                    entry["url"] = p.get("url") or entry.get("url", "")
+                    if "nodes" in p:
+                        entry["nodes"] = p.get("nodes")
+                    entry["last_event"] = ev.get("ts")
+            elif etype in ("graphify_scan", "graphify_query"):
+                p = ev.get("payload") or {}
+                g = self._state.setdefault("graphify", {})
+                if etype == "graphify_scan":
+                    g["nodes"] = p.get("nodes")
+                    g["edges"] = p.get("edges")
+                    g["communities"] = p.get("communities")
+                    g["scans"] = (g.get("scans") or 0) + 1
+                    g["last_scan_at"] = p.get("scanned_at") or ev.get("ts")
+                else:
+                    g["queries"] = (g.get("queries") or 0) + 1
+                    g["last_query_at"] = ev.get("ts")
             elif etype == "session_stop" and sid:
                 sessions.pop(sid, None)
         except Exception:
@@ -226,6 +273,38 @@ class LiveTab(Container):
 
     # ----- panel renderers ---------------------------------------------------
 
+    def set_project_filter(self, project: Any) -> None:
+        """Called by the app when the user toggles the project filter (key 'p')."""
+        self._project_filter = project
+        self._render_active(self._state)
+        self._render_worktrees(self._state)
+
+    def _session_matches_filter(self, sess: dict[str, Any]) -> bool:
+        """Match a session to the active project filter, tolerating both
+        absolute paths and Claude Code's encoded dir form.
+
+        Claude Code stores sessions under ~/.claude/projects/<encoded>/...
+        where <encoded> is the absolute project path with '/' replaced by
+        '-' (e.g. -home-ogu-theY4NN-harness). The daemon's session.project
+        field carries this encoded form. The filter target is an absolute
+        Path. We compare both:
+          - absolute  →  encoded     (replace '/' with '-')
+          - encoded   →  basename match (last segment)
+        """
+        flt = getattr(self, "_project_filter", None)
+        if not flt:
+            return True
+        proj = (sess.get("project") or "").rstrip("/")
+        if not proj:
+            return False
+        target_abs = str(flt).rstrip("/")
+        # Encoded form: leading dash + path with '/' → '-'.
+        target_encoded = target_abs.replace("/", "-")
+        if proj == target_abs or proj == target_encoded:
+            return True
+        # Last-segment fallback (covers both encoded and absolute forms).
+        return proj.rsplit("-", 1)[-1] == target_abs.rsplit("/", 1)[-1]
+
     def _render_active(self, state: dict[str, Any]) -> None:
         try:
             panel = self.query_one("#live-active", Static)
@@ -233,9 +312,13 @@ class LiveTab(Container):
             return
         sessions = (state or {}).get("sessions") or {}
         text = Text()
-        text.append("ACTIVE\n", style="bold dim")
+        flt = getattr(self, "_project_filter", None)
+        title = "ACTIVE" if not flt else f"ACTIVE  ·  {str(flt).split('/')[-1]} only (p to toggle)"
+        text.append(title + "\n", style="bold dim")
         any_agent = False
         for sid, sess in sessions.items():
+            if not self._session_matches_filter(sess):
+                continue
             for name, ag in (sess.get("agents_active") or {}).items():
                 any_agent = True
                 started = (ag.get("started") or "")[11:19]
@@ -245,6 +328,9 @@ class LiveTab(Container):
                 style = _style_for_type("agent_spawn") if status == "running" else "dim"
                 text.append(f"{dot} ", style=style)
                 text.append(f"{name:14}", style="bold")
+                role = _role_for(name)
+                if role:
+                    text.append(f" · {role:18}", style="dim")
                 text.append(f"  {started}  {last_tool}\n", style="dim")
         if not any_agent:
             text.append("(no active agents)\n", style="dim italic")
@@ -295,6 +381,20 @@ class LiveTab(Container):
             text.append(f"{nodes:>6} nodes\n", style="white")
         if not cognee:
             text.append("(cognee not yet probed)\n", style="dim italic")
+        g = (state or {}).get("graphify") or {}
+        if g:
+            nodes = g.get("nodes")
+            edges = g.get("edges")
+            scans = g.get("scans") or 0
+            queries = g.get("queries") or 0
+            text.append("● ", style="#00D4AA")
+            text.append(f"{'graphify':12} ", style="bold")
+            if nodes is not None:
+                text.append(f"{nodes:>6} nodes", style="white")
+                if edges is not None:
+                    text.append(f" / {edges:,} edges", style="dim")
+                text.append("\n")
+            text.append(f"  {scans} scans · {queries} queries\n", style="dim")
         mcp = (state or {}).get("mcp_servers") or {}
         if mcp:
             text.append("\nMCP\n", style="bold dim")

package/payload/mishkan/observability/watch/src/mishkan_watch/tabs/org.py

@@ -0,0 +1,139 @@
+"""Org tab — MISHKAN organisation reference.
+
+Read-only browser of the 45-agent org chart. Tree on the left
+(groups → agents), details panel on the right (role + description +
+source). Static data: loaded from org.json via org_data.load_org(),
+never depends on the bus.
+
+Purpose: small recalls until the org is memorised.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.widgets import Static, Tree
+
+from ..org_data import load_org as _load_org
+
+
+class OrgTab(Container):
+    """Org reference tab."""
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._org = _load_org()
+        self._selected: tuple[str, str] | None = None  # (group_id, alias)
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="org-row"):
+            yield Tree("MISHKAN", id="org-tree")
+            with Container(id="org-detail"):
+                yield Static("(select an agent)", id="org-detail-body")
+
+    def on_mount(self) -> None:
+        self._build_tree()
+
+    def _build_tree(self) -> None:
+        try:
+            tree = self.query_one("#org-tree", Tree)
+        except Exception:
+            return
+        tree.root.expand()
+        for grp in self._org.get("groups", []):
+            label = Text()
+            label.append(grp["label"], style="bold")
+            domain = grp.get("domain")
+            if domain:
+                label.append(f"  · {domain}", style="#00D4AA")
+            label.append(f"  ({len(grp.get('agents', []))})", style="dim")
+            node = tree.root.add(label, data={"kind": "group", "id": grp["id"]})
+            node.expand()
+            for ag in grp.get("agents", []):
+                al = Text()
+                al.append("● ", style="#00D4AA")
+                al.append(ag["alias"].capitalize(), style="bold")
+                al.append(f"  · {ag['role']}", style="dim")
+                node.add_leaf(al, data={"kind": "agent", "group": grp["id"], "alias": ag["alias"]})
+
+    def on_tree_node_selected(self, event: Tree.NodeSelected) -> None:
+        data = event.node.data or {}
+        kind = data.get("kind")
+        if kind == "agent":
+            self._render_agent_detail(data["group"], data["alias"])
+        elif kind == "group":
+            self._render_group_detail(data["id"])
+
+    def _render_group_detail(self, gid: str) -> None:
+        try:
+            panel = self.query_one("#org-detail-body", Static)
+        except Exception:
+            return
+        grp = next((g for g in self._org.get("groups", []) if g["id"] == gid), None)
+        if not grp:
+            return
+        t = Text()
+        t.append(grp["label"], style="bold #B794F4")
+        if grp.get("domain"):
+            t.append(f"  ·  {grp['domain']}", style="bold #00D4AA")
+        t.append("\n")
+        if grp.get("hebrew"):
+            t.append(grp["hebrew"], style="cyan")
+            if grp.get("hebrew_meaning"):
+                t.append(f"  —  {grp['hebrew_meaning']}", style="dim italic")
+            t.append("\n")
+        t.append("\n")
+        if grp.get("mission"):
+            t.append("mission\n", style="dim")
+            t.append(grp["mission"], style="white")
+            t.append("\n\n")
+        if grp.get("charter"):
+            t.append("charter\n", style="dim")
+            t.append(grp["charter"], style="white")
+            t.append("\n\n")
+        if grp.get("relationships"):
+            t.append("relationships\n", style="dim")
+            t.append(grp["relationships"], style="white")
+            t.append("\n\n")
+        t.append(f"{len(grp.get('agents', []))} agents — select one for role detail.", style="dim italic")
+        panel.update(t)
+
+    def _render_agent_detail(self, gid: str, alias: str) -> None:
+        try:
+            panel = self.query_one("#org-detail-body", Static)
+        except Exception:
+            return
+        grp = next((g for g in self._org.get("groups", []) if g["id"] == gid), None)
+        if not grp:
+            return
+        ag = next((a for a in grp.get("agents", []) if a["alias"] == alias), None)
+        if not ag:
+            return
+        t = Text()
+        t.append(ag["alias"].capitalize(), style="bold #B794F4")
+        t.append(f"  ·  {grp['label']}", style="bold")
+        if grp.get("domain"):
+            t.append(f"  ·  {grp['domain']}", style="#00D4AA")
+        t.append("\n\n")
+        t.append("role  ", style="dim")
+        t.append(ag["role"], style="cyan")
+        t.append("\n")
+        if ag.get("short"):
+            t.append("short  ", style="dim")
+            t.append(ag["short"], style="white")
+            t.append("\n")
+        t.append("source  ", style="dim")
+        t.append(ag.get("source", "—"), style="dim italic")
+        t.append("\n\n")
+        t.append(ag.get("description", ""), style="white")
+        panel.update(t)
+
+    # ----- API expected by app.py (no-op since static data) -----------------
+
+    def apply_snapshot(self, state: dict[str, Any]) -> None:
+        return
+
+    def apply_event(self, ev: dict[str, Any]) -> None:
+        return

package/payload/mishkan/observability/watch/src/mishkan_watch/tabs/skills.py

@@ -0,0 +1,187 @@
+"""Tab 8 — Skills.
+
+3-column browser of every installed skill on the user's Claude Code
+instance, with cross-reference to the CTO decisions (ADRs) where each
+skill is mentioned.
+
+Layout:
+  - LEFT (28%)  : tree grouped by origin (MISHKAN / user / plugin)
+                  then by category. Selecting a leaf loads detail.
+  - CENTER (44%): selected skill's full metadata — origin, source path,
+                  category, description, triggers ("Use when..." lines).
+  - RIGHT (28%) : ADRs that mention this skill, with section bodies
+                  truncated for at-a-glance reading.
+
+Data via skills_data.load_skills() (prefers the indexer output if
+Bezalel's index.json exists; otherwise scans paths directly).
+"""
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any
+
+from rich.text import Text
+from textual.app import ComposeResult
+from textual.containers import Container, Horizontal
+from textual.widgets import Static, Tree
+
+from ..skills_data import load_skills
+
+
+class SkillsTab(Container):
+    DEFAULT_CSS = ""
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self._skills: list[dict[str, Any]] = []
+        self._selected_name: str | None = None
+
+    def compose(self) -> ComposeResult:
+        with Horizontal(id="skills-row"):
+            yield Tree("Skills", id="skills-tree")
+            with Container(id="skills-detail"):
+                yield Static("", id="skills-detail-body")
+            with Container(id="skills-adrs"):
+                yield Static("", id="skills-adrs-body")
+
+    def on_mount(self) -> None:
+        try:
+            self._skills = load_skills()
+        except Exception:
+            self._skills = []
+        self._rebuild_tree()
+        self._render_detail()
+        self._render_adrs()
+
+    def _rebuild_tree(self) -> None:
+        try:
+            tree = self.query_one("#skills-tree", Tree)
+        except Exception:
+            return
+        tree.clear()
+        root = tree.root
+        root.expand()
+        # Group origin → category → entries.
+        groups: dict[str, dict[str, list[dict[str, Any]]]] = defaultdict(
+            lambda: defaultdict(list))
+        for s in self._skills:
+            groups[s.get("origin") or "?"][s.get("category") or "?"].append(s)
+        origin_labels = {
+            "mishkan": "MISHKAN craft",
+            "user":    "Community",
+            "plugin":  "Plugins",
+            "project": "Project-local",
+            "builtin": "Built-in",
+        }
+        # Render in fixed order so MISHKAN is always first.
+        for origin in ("mishkan", "user", "plugin", "project", "builtin"):
+            if origin not in groups:
+                continue
+            cats = groups[origin]
+            total = sum(len(v) for v in cats.values())
+            label = Text()
+            label.append(origin_labels.get(origin, origin), style="bold")
+            label.append(f"  ({total})", style="dim")
+            on = root.add(label, data={"kind": "origin"})
+            on.expand()
+            for cat in sorted(cats.keys()):
+                entries = cats[cat]
+                cl = Text()
+                cl.append(cat, style="bold #00D4AA")
+                cl.append(f"  ({len(entries)})", style="dim")
+                cn = on.add(cl, data={"kind": "category"})
+                for entry in sorted(entries, key=lambda e: e.get("name") or ""):
+                    sl = Text()
+                    sl.append("● ", style="#B794F4")
+                    sl.append(entry.get("name") or "?", style="white")
+                    if entry.get("adrs"):
+                        sl.append(f"  · {','.join(entry['adrs'])}", style="#F6AD55 italic")
+                    cn.add_leaf(sl, data={"kind": "skill", "name": entry.get("name")})
+
+    def on_tree_node_selected(self, event: Tree.NodeSelected) -> None:
+        data = event.node.data or {}
+        if data.get("kind") == "skill":
+            self._selected_name = data.get("name")
+            self._render_detail()
+            self._render_adrs()
+
+    def _render_detail(self) -> None:
+        try:
+            panel = self.query_one("#skills-detail-body", Static)
+        except Exception:
+            return
+        if not self._selected_name:
+            panel.update(Text("(select a skill on the left)\n\n"
+                              f"{len(self._skills)} skills installed",
+                              style="dim italic"))
+            return
+        entry = next((s for s in self._skills if s.get("name") == self._selected_name), None)
+        if not entry:
+            panel.update(Text("(skill no longer in index)", style="dim italic"))
+            return
+        t = Text()
+        t.append(entry["name"], style="bold #B794F4")
+        t.append("\n\n")
+        t.append("origin   ", style="dim")
+        t.append(entry.get("origin") or "?", style="cyan")
+        t.append("\n")
+        t.append("category ", style="dim")
+        t.append(entry.get("category") or "?", style="cyan")
+        t.append("\n")
+        t.append("source   ", style="dim")
+        t.append(str(entry.get("source_path") or "?")[-60:], style="dim italic")
+        t.append("\n\n")
+        desc = entry.get("description") or "(no description)"
+        t.append("description\n", style="bold dim")
+        t.append(desc + "\n", style="white")
+        triggers = entry.get("triggers") or []
+        if triggers:
+            t.append("\nuse when\n", style="bold dim")
+            for tr in triggers[:4]:
+                t.append(f"  · {tr[:80]}\n", style="white")
+        # Frontmatter dump for the curious.
+        fm = entry.get("frontmatter") or {}
+        if fm:
+            t.append("\nfrontmatter\n", style="bold dim")
+            for k, v in list(fm.items())[:6]:
+                if k in ("name", "description"):
+                    continue
+                t.append(f"  {k}: ", style="dim")
+                t.append(str(v)[:60] + "\n", style="white")
+        panel.update(t)
+
+    def _render_adrs(self) -> None:
+        try:
+            panel = self.query_one("#skills-adrs-body", Static)
+        except Exception:
+            return
+        t = Text()
+        t.append("CTO decisions\n", style="bold #B794F4")
+        if not self._selected_name:
+            t.append("\n(select a skill to see linked ADRs)", style="dim italic")
+            panel.update(t)
+            return
+        entry = next((s for s in self._skills if s.get("name") == self._selected_name), None)
+        adrs = (entry or {}).get("adrs") or []
+        if not adrs:
+            t.append("\n(no ADR mentions this skill)\n", style="dim italic")
+            t.append("\nADRs live in docs/design/MISHKAN_decisions.md", style="dim")
+            panel.update(t)
+            return
+        t.append(f"\n{len(adrs)} ADR mention(s):\n\n", style="dim")
+        for adr_id in adrs:
+            t.append(f"  ● {adr_id}\n", style="#F6AD55 bold")
+        t.append("\nFull text:\n", style="bold dim")
+        t.append("  docs/design/MISHKAN_decisions.md\n", style="dim italic")
+        panel.update(t)
+
+    # ----- API expected by app.py -------------------------------------------
+
+    def apply_snapshot(self, state: dict[str, Any]) -> None:
+        return  # static data, no daemon dependency
+
+    def apply_event(self, ev: dict[str, Any]) -> None:
+        return
+
+    def set_project_filter(self, project: Any) -> None:
+        return