mishkan-harness 0.2.0 → 0.2.4

package/payload/mishkan/observability/watch/src/mishkan_watch/theme.tcss

@@ -40,7 +40,7 @@ Footer {
 
 #status-bar {
     dock: bottom;
-    height: 1;
+    height: 2;
     background: $color-muted;
     color: white 90%;
     padding: 0 1;
@@ -182,7 +182,7 @@ Tabs > Tab.-active {
 }
 
 #workflows-list {
-    width: 30%;
+    width: 38%;
     layout: vertical;
     border: solid $color-border-light;
     background: $color-surface;
@@ -190,7 +190,7 @@ Tabs > Tab.-active {
 }
 
 #workflows-detail {
-    width: 70%;
+    width: 62%;
     layout: vertical;
     border: solid $color-border-light;
     background: $color-surface;
@@ -199,6 +199,19 @@ Tabs > Tab.-active {
 
 #workflows-listview {
     height: 1fr;
+    overflow-y: scroll;
+}
+
+/* ListItem children (the Static we yield per row) are multi-line — name
+   on line 1, dim description on line 2. Without an explicit ListItem
+   height, Textual collapses each row to 1 line and the description (and
+   often the cursor highlight on long items) clips off. `height: auto`
+   tells the ListItem to size to its child's content height; `min-height: 3`
+   keeps the row tappable when the description happens to be empty. */
+#workflows-listview > ListItem {
+    height: auto;
+    min-height: 2;
+    padding: 0 1;
 }
 
 #workflows-tree {
@@ -213,7 +226,7 @@ Tabs > Tab.-active {
 }
 
 .cognee-card {
-    width: 50%;
+    width: 1fr;
     border: solid $color-border-light;
     background: $color-surface;
     padding: 1 2;
@@ -252,3 +265,64 @@ Tabs > Tab.-active {
     color: $color-dim;
     text-style: italic;
 }
+
+/* ─── Tab: Usage ───────────────────────────────────────────────── */
+
+#usage-row {
+    layout: horizontal;
+    height: 1fr;
+}
+
+#usage-totals {
+    width: 26%;
+    border: solid $color-border-light;
+    background: $color-surface;
+    padding: 1 2;
+}
+
+#usage-sessions {
+    width: 38%;
+    layout: vertical;
+    border: solid $color-border-light;
+    background: $color-surface;
+    padding: 0 1;
+}
+
+#usage-sessions-table {
+    height: 1fr;
+}
+
+#usage-detail {
+    width: 36%;
+    border: solid $color-border-light;
+    background: $color-surface;
+    padding: 1 2;
+}
+
+/* ─── Tab: Skills ──────────────────────────────────────────────── */
+
+#skills-row {
+    layout: horizontal;
+    height: 1fr;
+}
+
+#skills-tree {
+    width: 28%;
+    border: solid $color-border-light;
+    background: $color-surface;
+    padding: 0 1;
+}
+
+#skills-detail {
+    width: 44%;
+    border: solid $color-border-light;
+    background: $color-surface;
+    padding: 1 2;
+}
+
+#skills-adrs {
+    width: 28%;
+    border: solid $color-border-light;
+    background: $color-surface;
+    padding: 1 2;
+}

package/payload/mishkan/observability/watchd/src/mishkan_watchd/__main__.py

@@ -20,8 +20,9 @@ from pathlib import Path
 from .lifecycle import install_systemd_user_unit
 from .server import WatchdServer
 from .state import HarnessState
-from .sources import (bus_tail, cognee_poll, mcp_probe, session_discover,
-                       session_tail, subagent_tail, worktree_poll)
+from .sources import (bus_tail, cognee_poll, graphify_tail, mcp_probe,
+                       session_discover, session_tail, subagent_tail,
+                       worktree_poll)
 
 
 HOME = Path(os.path.expanduser("~"))
@@ -56,15 +57,42 @@ def _active_sessions_provider(state: HarnessState):
     return _provider
 
 
+def _decode_project(p: str) -> str:
+    """Decode Claude Code's encoded project dir form (-home-ogu-...) to absolute.
+
+    session_discover sets sess.project to jsonl.parent.name which is the
+    Claude Code encoded form. Downstream consumers that open the path on
+    disk (worktree_poll, graphify_tail) must decode or they silently skip
+    every project. Idempotent on already-absolute paths.
+    """
+    if not p or p in ("", "unknown", "?"):
+        return p
+    if p.startswith("/"):
+        return p
+    if p.startswith("-"):
+        return p.replace("-", "/")
+    return p
+
+
 def _project_paths_provider(state: HarnessState):
-    """Return distinct project paths from active sessions, plus $PWD."""
+    """Return distinct project paths from active sessions, plus $PWD.
+
+    Decodes Claude Code's encoded project form so downstream sources can
+    actually open the project on disk.
+    """
     def _provider() -> list[Path]:
         seen: set[str] = set()
         out: list[Path] = []
         for s in state.sessions.values():
-            if s.project and s.project not in seen:
-                seen.add(s.project)
-                out.append(Path(s.project))
+            if not s.project or s.project in ("unknown", ""):
+                continue
+            decoded = _decode_project(s.project)
+            if decoded in seen:
+                continue
+            seen.add(decoded)
+            p = Path(decoded)
+            if p.is_dir():
+                out.append(p)
         try:
             cwd = os.getcwd()
             if cwd not in seen:
@@ -91,6 +119,8 @@ async def _run(log_dir: Path, projects_dir: Path, socket_path: Path) -> None:
         asyncio.create_task(cognee_poll.run(queue, projects_dir), name="cognee_poll"),
         asyncio.create_task(session_tail.run(queue, _active_sessions_provider(state)),
                             name="session_tail"),
+        asyncio.create_task(graphify_tail.run(queue, _project_paths_provider(state)),
+                            name="graphify_tail"),
         asyncio.create_task(subagent_tail.run(queue, _active_sessions_provider(state)),
                             name="subagent_tail"),
     ]

package/payload/mishkan/observability/watchd/src/mishkan_watchd/sources/bus_tail.py

@@ -74,14 +74,27 @@ class _TailHandler(FileSystemEventHandler):
 
 
 async def run(queue: asyncio.Queue[dict[str, Any]], log_dir: Path) -> None:
-    """Start a watchdog observer on log_dir. Backfills existing files first."""
+    """Start a watchdog observer on log_dir. Tails from EOF — no historical replay.
+
+    Why no backfill: hook log files accumulate session_ids from sessions
+    long gone. Replaying them on daemon start resurrected those sessions
+    as "phantoms" (project=unknown, stale agents_active) in the snapshot.
+    The daemon's source of truth for live sessions is session_discover,
+    which polls active JSONLs every 10s; bus_tail's job is only to forward
+    new hook events as they happen.
+    """
     log_dir.mkdir(parents=True, exist_ok=True)
     loop = asyncio.get_running_loop()
     handler = _TailHandler(queue, loop)
 
-    # Backfill: read each existing file from offset 0.
+    # Seek to EOF on each existing file. New writes after this point are
+    # emitted normally; everything before is treated as already-consumed
+    # by whichever daemon instance was alive at the time it was written.
     for f in log_dir.glob("*.jsonl"):
-        handler._drain(str(f))
+        try:
+            handler.offsets[str(f)] = os.path.getsize(str(f))
+        except OSError:
+            handler.offsets[str(f)] = 0
 
     observer = Observer()
     observer.schedule(handler, str(log_dir), recursive=False)

package/payload/mishkan/observability/watchd/src/mishkan_watchd/sources/graphify_tail.py

@@ -0,0 +1,220 @@
+"""Graphify daemon source — watch graphify-out/ for scans + queries.
+
+Graphify produces deterministic AST graphs under `<project>/graphify-out/`.
+This source watches every active session's project for changes in that
+directory and synthesises bus events that the Knowledge tab consumes.
+
+Two event types emitted:
+
+- graphify_scan  : `graph.json` mtime changed → a `graphify update <path>`
+                   completed. Payload: project path, node count, edge
+                   count, community count (parsed from manifest.json
+                   when present).
+- graphify_query : a new file under `graphify-out/memory/` → a
+                   `graphify query` was saved via `graphify save-result`.
+                   Payload: question, answer excerpt (200 chars).
+
+Fail-open per the daemon contract. Missing graphify-out/ is silent —
+many projects don't use Graphify and that's fine.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+
+def _iso(ts: float | None = None) -> str:
+    t = datetime.fromtimestamp(ts or time.time(), tz=timezone.utc)
+    return t.strftime("%Y-%m-%dT%H:%M:%S.") + f"{t.microsecond // 1000:03d}Z"
+
+
+class _ProjectWatcher:
+    """One watcher per project root that has a graphify-out/ dir."""
+
+    def __init__(self, project_path: Path, queue: asyncio.Queue[dict[str, Any]]) -> None:
+        self.project_path = project_path
+        self.queue = queue
+        self.graph_dir = project_path / "graphify-out"
+        self.graph_json = self.graph_dir / "graph.json"
+        self.manifest = self.graph_dir / "manifest.json"
+        self.memory_dir = self.graph_dir / "memory"
+        # Start at 0 so the first poll detects the current graph state and
+        # emits a graphify_scan event — otherwise the TUI shows "no scan"
+        # forever for projects whose graph predated the daemon. This costs
+        # one event per project per daemon restart; trivially cheap.
+        self.last_graph_mtime = 0.0
+        # Memory queries DO use seen-state to avoid replaying old queries
+        # on every restart (queries are append-only, replays would spam).
+        self.seen_memory: set[str] = set()
+        if self.memory_dir.is_dir():
+            try:
+                for f in self.memory_dir.iterdir():
+                    if f.is_file():
+                        self.seen_memory.add(f.name)
+            except OSError:
+                pass
+
+    async def step(self) -> None:
+        if not self.graph_dir.is_dir():
+            return
+        await self._check_graph()
+        await self._check_memory()
+
+    async def _check_graph(self) -> None:
+        try:
+            if not self.graph_json.exists():
+                return
+            mtime = self.graph_json.stat().st_mtime
+        except OSError:
+            return
+        if mtime <= self.last_graph_mtime:
+            return
+        self.last_graph_mtime = mtime
+        stats = self._read_graph_stats()
+        await self.queue.put({
+            "ts": _iso(),
+            "session": None,
+            "project": str(self.project_path),
+            "type": "graphify_scan",
+            "tool": None,
+            "outcome": "completed",
+            "payload": {
+                "op": "scan",
+                "project": str(self.project_path),
+                "nodes": stats.get("nodes"),
+                "edges": stats.get("edges"),
+                "communities": stats.get("communities"),
+                "scanned_at": _iso(mtime),
+            },
+        })
+
+    def _read_graph_stats(self) -> dict[str, Any]:
+        """Read node/edge/community counts from graph.json.
+
+        Graphify's manifest.json is a file→hash map, NOT a stats file —
+        we only read graph.json. The format is NetworkX node-link:
+          {nodes: [...], links: [...], hyperedges?: [...]}
+        Note: 'links' (NetworkX naming), not 'edges'. Communities are
+        not currently exported by Graphify, but we keep the field nullable
+        for future compatibility.
+        """
+        try:
+            g = json.loads(self.graph_json.read_text())
+        except Exception:
+            return {}
+        if not isinstance(g, dict):
+            return {}
+        nodes = g.get("nodes") or []
+        # Accept both 'links' (NetworkX, what Graphify writes) and 'edges'
+        # (alt convention) for forward-compat.
+        edges = g.get("links") or g.get("edges") or []
+        communities = g.get("communities") or g.get("hyperedges") or []
+        return {
+            "nodes": len(nodes) if isinstance(nodes, list) else None,
+            "edges": len(edges) if isinstance(edges, list) else None,
+            "communities": len(communities) if isinstance(communities, list) else None,
+        }
+
+    async def _check_memory(self) -> None:
+        if not self.memory_dir.is_dir():
+            return
+        try:
+            entries = [f for f in self.memory_dir.iterdir() if f.is_file()]
+        except OSError:
+            return
+        for f in entries:
+            if f.name in self.seen_memory:
+                continue
+            self.seen_memory.add(f.name)
+            payload = {"op": "query", "project": str(self.project_path), "file": f.name}
+            try:
+                data = json.loads(f.read_text())
+                if isinstance(data, dict):
+                    payload["question"] = (data.get("question") or "")[:200]
+                    answer = data.get("answer") or ""
+                    payload["answer_excerpt"] = answer[:200] if isinstance(answer, str) else ""
+                    payload["query_type"] = data.get("type") or data.get("query_type")
+            except Exception:
+                pass
+            await self.queue.put({
+                "ts": _iso(),
+                "session": None,
+                "project": str(self.project_path),
+                "type": "graphify_query",
+                "tool": None,
+                "outcome": "completed",
+                "payload": payload,
+            })
+
+
+def _decode_project(p: str) -> str:
+    """Decode Claude Code's encoded project dir name into an absolute path.
+
+    ~/.claude/projects encodes each working directory as its absolute path
+    with '/' replaced by '-' (e.g. -home-ogu-theY4NN-harness for
+    /home/ogu/theY4NN/harness). When the daemon's session_discover source
+    grabs the project from jsonl.parent.name, it gets this encoded form.
+    Sources that try to open the project on disk (graphify_tail,
+    worktree_poll) MUST decode first or every project is silently skipped.
+    """
+    if not p or p in ("", "unknown", "?"):
+        return p
+    if p.startswith("/"):
+        return p
+    if p.startswith("-"):
+        return p.replace("-", "/")
+    return p
+
+
+def _project_paths_from_state(state) -> list[Path]:
+    """Pull distinct project paths from the daemon's active sessions."""
+    seen: set[str] = set()
+    out: list[Path] = []
+    try:
+        for sess in (state.sessions or {}).values():
+            raw = sess.project if hasattr(sess, "project") else None
+            if not raw or raw in ("", "unknown"):
+                continue
+            p = _decode_project(raw)
+            if p in seen:
+                continue
+            seen.add(p)
+            if Path(p).is_dir():
+                out.append(Path(p))
+    except Exception:
+        pass
+    return out
+
+
+async def run(queue: asyncio.Queue[dict[str, Any]],
+              project_paths_provider, poll_interval: float = 5.0) -> None:
+    """Watch every project with a graphify-out/ dir.
+
+    project_paths_provider is a callable returning list[Path]. Re-evaluated
+    each poll so sessions discovered later are picked up automatically.
+    """
+    watchers: dict[Path, _ProjectWatcher] = {}
+    try:
+        while True:
+            try:
+                projects = project_paths_provider() or []
+            except Exception:
+                projects = []
+            for p in projects:
+                if p not in watchers and (p / "graphify-out").is_dir():
+                    watchers[p] = _ProjectWatcher(p, queue)
+            # Don't prune watchers whose graphify-out/ disappeared — same
+            # project may rebuild later; cheap to keep.
+            for w in list(watchers.values()):
+                try:
+                    await w.step()
+                except Exception:
+                    continue
+            await asyncio.sleep(poll_interval)
+    except asyncio.CancelledError:
+        return

package/payload/mishkan/observability/watchd/src/mishkan_watchd/sources/worktree_poll.py

@@ -61,7 +61,11 @@ async def _poll_once(project_paths: list[Path], known: dict[str, dict[str, str]]
                 continue
             seen.add(path)
             if path not in known:
-                known[path] = wt
+                # Stamp the owner project so we only emit "remove" later
+                # if the OWNER was actually polled this round. Prevents the
+                # storm of phantom removes when project list temporarily
+                # drops (e.g. before session_discover's first confirmation).
+                known[path] = {**wt, "_project": str(proj)}
                 await queue.put({
                     "ts": _iso(),
                     "session": None,
@@ -72,13 +76,20 @@ async def _poll_once(project_paths: list[Path], known: dict[str, dict[str, str]]
                     "payload": {"op": "add", **wt},
                 })
 
+    polled_projects = {str(p) for p in project_paths}
     for path in list(known.keys()):
+        owner = known[path].get("_project", "")
+        if owner not in polled_projects:
+            # The project that owned this worktree wasn't polled this
+            # round — don't infer a removal from absence of evidence.
+            continue
         if path not in seen:
             wt = known.pop(path)
+            wt.pop("_project", None)
             await queue.put({
                 "ts": _iso(),
                 "session": None,
-                "project": "",
+                "project": owner,
                 "type": "worktree_change",
                 "tool": None,
                 "outcome": "completed",