mishkan-harness 0.2.4 → 0.2.6

package/README.md

@@ -14,7 +14,7 @@ MISHKAN turns Claude Code into a standing engineering organisation. Quality and
 
 It's personal, opinionated infrastructure built around one engineer's standards. To make it yours, replace `docs/engineer/profile.md` and re-sync — nothing else hardcodes the author.
 
-> **v0.2.4** — agent fleet, rules, hooks, installer are stable. Cognee knowledge stack ready to bring up locally. Observability stack (watchd + TUI) available as two `uv tool`-installable packages.
+> **v0.2.6** — agent fleet, rules, hooks, installer are stable. Cognee knowledge stack ready to bring up locally. Observability stack (watchd + TUI) available as two `uv tool`-installable packages.
 
 ---
 

package/docs/usage/01-installation.md

@@ -59,7 +59,7 @@ cd ~/path/to/harness
 node bin/mishkan.js install
 ```
 
-Or via npx (published from v0.2.0):
+Or via npx (published to npm):
 
 ```bash
 npx mishkan-harness install

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mishkan-harness",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "MISHKAN — a personal advanced SWE R&D harness for Claude Code: 45 biblically-named agents across six teams, deterministic rules + hooks, a shared research pipeline, dependency/supply-chain vetting, and a Cognee-backed knowledge graph. Installs into ~/.claude.",
   "type": "module",
   "bin": {

package/payload/mishkan/hooks/post-tool-observe.sh

@@ -6,7 +6,10 @@
 # all preserved) plus type-specific derived events:
 #
 #   - Write/Edit/MultiEdit    -> file_change (path + lines_added/removed)
-#   - Task                    -> agent_spawn (subagent_type + agentId)
+#   - Task                    -> agent_complete (subagent_type + tool_use_id)
+#                                (agent_spawn is emitted at PreToolUse by
+#                                pre-tool-trace.sh, when the agent starts)
+#   - Bash (graphify ...)     -> graphify_query / graphify_scan
 #   - Skill                   -> skill_invoke
 #   - ExitPlanMode            -> plan (exit + approved + excerpt)
 #   - WebFetch / WebSearch    -> web_query
@@ -138,15 +141,19 @@ case "$tool" in
     ;;
 
   Task|Agent)
+    # agent_spawn is emitted by pre-tool-trace.sh (PreToolUse) when the task
+    # starts. Here at PostToolUse we emit agent_complete so the daemon can
+    # decrement the active-agent count. Both events carry tool_use_id as the
+    # stable key so state.py can match spawn→complete even when two concurrent
+    # agents share the same subagent_type name.
     subagent="$(printf '%s' "$INPUT" | jq -r '.tool_input.subagent_type // empty' 2>/dev/null)"
-    desc="$(printf '%s' "$INPUT" | jq -r '.tool_input.description // empty' 2>/dev/null)"
-    model="$(printf '%s' "$INPUT" | jq -r '.tool_input.model // empty' 2>/dev/null)"
     agent_id="$(printf '%s' "$INPUT" | jq -r '.tool_response.agentId? // .tool_response.id? // empty' 2>/dev/null)"
-    if [ -n "$subagent" ]; then
+    if [ -n "$subagent" ] && [ -n "$tool_use_id" ]; then
       payload="$(jq -cn \
-        --arg s "$subagent" --arg d "$desc" --arg m "$model" \
-        '{subagent_type:$s} + (if $d=="" then {} else {description:$d} end) + (if $m=="" then {} else {model:$m} end)')"
-      bus_emit "$session" "agent_spawn" "$tool" "$outcome" "$payload" "$subagent" "$agent_id"
+        --arg s "$subagent" --arg tid "$tool_use_id" --arg aid "$agent_id" \
+        '{subagent_type:$s, tool_use_id:$tid}
+         + (if $aid=="" then {} else {agentId:$aid} end)')"
+      bus_emit "$session" "agent_complete" "$tool" "$outcome" "$payload" "$subagent" "$agent_id"
     fi
     ;;
 
@@ -212,6 +219,47 @@ case "$tool" in
     bus_emit "$session" "cron_event" "$tool" "$outcome" "$payload"
     ;;
 
+  Bash)
+    # Detect graphify CLI invocations so the daemon can count real queries
+    # and scans. Only emit on completed calls — errored/blocked calls did
+    # not produce a graph result, so they must not count.
+    if [ "$outcome" = "completed" ]; then
+      cmd="$(printf '%s' "$INPUT" | jq -r '.tool_input.command // empty' 2>/dev/null)"
+      project_dir="$(printf '%s' "$INPUT" | jq -r '.tool_input.cwd // empty' 2>/dev/null)"
+      [ -z "$project_dir" ] && project_dir="$(pwd 2>/dev/null || printf 'unknown')"
+
+      # Match graphify query (with or without npx prefix, with or without
+      # leading cd; capture the quoted question argument).
+      if printf '%s' "$cmd" | grep -qE '(^|&&|;|\|\|)\s*(npx\s+graphify|graphify)\s+.*\bquery\b'; then
+        # Extract the quoted question: first double- or single-quoted string
+        # after the word "query", or bare word(s) after it. Truncate to 200.
+        question="$(printf '%s' "$cmd" | \
+          sed -E 's/.*\bquery\b[[:space:]]*//' | \
+          sed -E 's/^"([^"]{0,200}).*/\1/;t;s/^'"'"'([^'"'"']{0,200}).*/\1/;t;s/^(.{0,200}).*/\1/' \
+          2>/dev/null || true)"
+        # Detect traversal flag for query_type.
+        query_type=""
+        if printf '%s' "$cmd" | grep -qE '\-\-dfs'; then
+          query_type="dfs"
+        elif printf '%s' "$cmd" | grep -qE '\-\-context'; then
+          query_type="context"
+        fi
+        payload="$(jq -cn \
+          --arg q "$question" \
+          --arg p "$project_dir" \
+          --arg qt "$query_type" \
+          '{project:$p}
+           + (if $q=="" then {} else {question:$q} end)
+           + (if $qt=="" then {} else {query_type:$qt} end)' 2>/dev/null)"
+        bus_emit "$session" "graphify_query" "$tool" "$outcome" "$payload"
+
+      elif printf '%s' "$cmd" | grep -qE '(^|&&|;|\|\|)\s*(npx\s+graphify|graphify)\s+.*(update|scan)\b'; then
+        payload="$(jq -cn --arg p "$project_dir" '{project:$p}' 2>/dev/null)"
+        bus_emit "$session" "graphify_scan" "$tool" "$outcome" "$payload"
+      fi
+    fi
+    ;;
+
   Workflow)
     wf_name="$(printf '%s' "$INPUT" | jq -r '.tool_input.name // empty' 2>/dev/null)"
     wf_script="$(printf '%s' "$INPUT" | jq -r '.tool_input.scriptPath // empty' 2>/dev/null)"

package/payload/mishkan/hooks/pre-tool-trace.sh

@@ -1,10 +1,14 @@
 #!/usr/bin/env bash
-# MISHKAN PreToolUse trace hook — records call-start timestamps so
-# post-tool-observe.sh can compute duration_ms per tool call.
+# MISHKAN PreToolUse trace hook — two responsibilities:
 #
-# Writes one line per (session, tool_use_id) pair to a tmpfile keyed by
-# session. The PostToolUse hook reads back, diffs against now, and the
-# tmpfile is pruned by the PostToolUse handler after consumption.
+# 1. Records call-start timestamps so post-tool-observe.sh can compute
+#    duration_ms per tool call. Writes one line per (session, tool_use_id)
+#    to a tmpfile keyed by session. PostToolUse reads back, diffs, prunes.
+#
+# 2. Emits agent_spawn for Task|Agent tool invocations so the daemon can
+#    track live agents from the moment they start (not when they finish).
+#    The spawn event carries tool_use_id as the stable correlation key so
+#    state.py can pair it with the agent_complete emitted by PostToolUse.
 #
 # Fail-open by contract: any parse / IO / format issue and we exit 0
 # silently. Never blocks a tool call.
@@ -18,11 +22,11 @@ fi
 INPUT="$(cat)"
 
 session="$(printf '%s' "$INPUT" | jq -r '.session_id // "unknown"' 2>/dev/null)"
+tool="$(printf '%s' "$INPUT" | jq -r '.tool_name // "unknown"' 2>/dev/null)"
 tool_use_id="$(printf '%s' "$INPUT" | jq -r '.tool_use_id // empty' 2>/dev/null)"
 
 # tool_use_id may be absent for some tool kinds — synthesize from name+timestamp.
 if [ -z "$tool_use_id" ]; then
-  tool="$(printf '%s' "$INPUT" | jq -r '.tool_name // "unknown"' 2>/dev/null)"
   tool_use_id="${tool}-$(date +%s%N 2>/dev/null || date +%s)"
 fi
 
@@ -40,4 +44,34 @@ fi
 printf '%s\t%s\n' "$tool_use_id" "$start_ms" \
   >> "${trace_dir}/mishkan-trace-${session}.tmp" 2>/dev/null
 
+# ---------------------------------------------------------------------------
+# agent_spawn — emitted here (PreToolUse) so the daemon sees the agent as
+# active from the START of a Task/Agent call, not after it completes.
+# tool_use_id is the correlation key used by both spawn and complete events.
+# agentId is not available yet at PreToolUse time — that's expected.
+# ---------------------------------------------------------------------------
+case "$tool" in
+  Task|Agent)
+    MISHKAN_HOME_RES="${MISHKAN_HOME:-$HOME/.claude/mishkan}"
+    # shellcheck disable=SC1091
+    source "${MISHKAN_HOME_RES}/observability/bus.sh" 2>/dev/null || exit 0
+
+    subagent="$(printf '%s' "$INPUT" | jq -r '.tool_input.subagent_type // empty' 2>/dev/null)"
+    desc="$(printf '%s' "$INPUT" | jq -r '.tool_input.description // empty' 2>/dev/null)"
+    model="$(printf '%s' "$INPUT" | jq -r '.tool_input.model // empty' 2>/dev/null)"
+
+    if [ -n "$subagent" ] && [ -n "$tool_use_id" ]; then
+      payload="$(jq -cn \
+        --arg s "$subagent" \
+        --arg d "$desc" \
+        --arg m "$model" \
+        --arg tid "$tool_use_id" \
+        '{subagent_type:$s, tool_use_id:$tid}
+         + (if $d=="" then {} else {description:$d} end)
+         + (if $m=="" then {} else {model:$m} end)' 2>/dev/null)"
+      bus_emit "$session" "agent_spawn" "$tool" "started" "$payload" "$subagent" ""
+    fi
+    ;;
+esac
+
 exit 0

package/payload/mishkan/observability/README.md

@@ -37,23 +37,26 @@ incrementally by the PostToolUse hook and pruned line-by-line.
 
 | Type | Source | Trigger |
 |---|---|---|
-| `tool_call` | post-tool-observe.sh | every tool call |
-| `file_change` | post-tool-observe.sh | Write / Edit / MultiEdit |
-| `agent_spawn` | post-tool-observe.sh | Task / Agent tool |
-| `skill_invoke` | post-tool-observe.sh | Skill tool |
-| `plan` | post-tool-observe.sh | ExitPlanMode |
-| `web_query` | post-tool-observe.sh | WebFetch / WebSearch |
-| `cron_event` | post-tool-observe.sh | CronCreate / CronDelete / CronList |
-| `error` | post-tool-observe.sh | outcome=errored OR blocked |
-| `hook_fire` | pre-tool-security.sh | Ira allow / deny |
-| `hook_fire` | model-route.py | model routing decision |
+| `tool_call` | post-tool-observe.sh (PostToolUse) | every tool call |
+| `file_change` | post-tool-observe.sh (PostToolUse) | Write / Edit / MultiEdit |
+| `agent_spawn` | pre-tool-trace.sh (PreToolUse) | Task / Agent tool starts — carries `tool_use_id` as stable correlation key |
+| `agent_complete` | post-tool-observe.sh (PostToolUse) | Task / Agent tool finishes — carries matching `tool_use_id` |
+| `skill_invoke` | post-tool-observe.sh (PostToolUse) | Skill tool |
+| `plan` | post-tool-observe.sh (PostToolUse) | ExitPlanMode |
+| `web_query` | post-tool-observe.sh (PostToolUse) | WebFetch / WebSearch |
+| `cron_event` | post-tool-observe.sh (PostToolUse) | CronCreate / CronDelete / CronList |
+| `graphify_query` | post-tool-observe.sh (PostToolUse, Bash branch) | `graphify query` CLI invocation detected in Bash tool_input.command |
+| `graphify_scan` (hook) | post-tool-observe.sh (PostToolUse, Bash branch) | `graphify update`/`graphify scan` CLI invocation detected |
+| `graphify_scan` (stats) | graphify_tail daemon source | graph.json mtime advance after daemon start — sets `stats_only=True`, updates node/edge counts only, does NOT increment scan counter |
+| `error` | post-tool-observe.sh (PostToolUse) | outcome=errored OR blocked |
+| `hook_fire` | pre-tool-security.sh (PreToolUse) | Ira allow / deny |
+| `hook_fire` | model-route.py (PreToolUse) | model routing decision |
 
 Deferred (next phases of the observability stack):
 
 - `token_usage` — Phase 1.5 (session JSONL `usage` block parser)
 - `inter_agent`, `compaction` — Phase 2 (daemon-side session JSONL tail)
-- `worktree_change`, `mcp_server`, `cognee_op`, `graphify_*`,
-  `workflow_*` — Phase 2/4 (daemon sources)
+- `worktree_change`, `mcp_server`, `cognee_op`, `workflow_*` — Phase 2/4 (daemon sources)
 
 ## Fail-open contract
 

package/payload/mishkan/observability/schema.json

@@ -67,9 +67,10 @@
         "properties": {
           "payload": {
             "type": "object",
-            "required": ["subagent_type"],
+            "required": ["subagent_type", "tool_use_id"],
             "properties": {
               "subagent_type": {"type": "string"},
+              "tool_use_id": {"type": "string", "description": "stable correlation key — matches the agent_complete event for this invocation"},
               "description": {"type": "string"},
               "model": {"type": "string"}
             }
@@ -77,6 +78,22 @@
         }
       }
     },
+    {
+      "if": {"properties": {"type": {"const": "agent_complete"}}},
+      "then": {
+        "properties": {
+          "payload": {
+            "type": "object",
+            "required": ["subagent_type", "tool_use_id"],
+            "properties": {
+              "subagent_type": {"type": "string"},
+              "tool_use_id": {"type": "string", "description": "matches the agent_spawn event for this invocation"},
+              "agentId": {"type": "string", "description": "Claude runtime agentId from tool_response, when present"}
+            }
+          }
+        }
+      }
+    },
     {
       "if": {"properties": {"type": {"const": "hook_fire"}}},
       "then": {

package/payload/mishkan/observability/watch/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "mishkan-watch"
-version = "0.1.0"
-description = "MISHKAN observability TUI — Textual client that reads the mishkan-watchd UNIX socket and renders the 5-tab dashboard."
+version = "0.2.6"
+description = "MISHKAN observability TUI — Textual client that reads the mishkan-watchd UNIX socket and renders the 8-tab dashboard."
 readme = "../README.md"
 requires-python = ">=3.11"
 license = {text = "MIT"}

package/payload/mishkan/observability/watch/src/mishkan_watch/__init__.py

@@ -1,3 +1,3 @@
 """MISHKAN observability TUI — mishkan-watch."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.6"

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

@@ -133,17 +133,36 @@ class AgentsTab(Container):
                     "agents_active": {},
                 }
             if etype == "agent_spawn" and sid:
-                name = ev.get("agent") or (ev.get("payload") or {}).get("subagent_type")
-                if name:
-                    sessions[sid].setdefault("agents_active", {})[name] = {
+                payload = ev.get("payload") or {}
+                name = ev.get("agent") or payload.get("subagent_type")
+                # Resolve the stable key: prefer tool_use_id from payload,
+                # then top-level subagent_id (older hook schema), then name.
+                key = payload.get("tool_use_id") or ev.get("subagent_id") or name
+                if name and key:
+                    agents = sessions[sid].setdefault("agents_active", {})
+                    # Remove any stale same-named entry under a different key
+                    # (key-scheme mismatch between snapshot and live delta).
+                    stale = [k for k, ag in agents.items()
+                             if ag.get("name") == name and k != key]
+                    for k in stale:
+                        del agents[k]
+                    agents[key] = {
                         "name": name,
                         "started": ev.get("ts"),
                         "status": "running",
                     }
             elif etype == "agent_complete" and sid:
-                name = ev.get("agent")
-                if name:
-                    sessions[sid].get("agents_active", {}).pop(name, None)
+                payload = ev.get("payload") or {}
+                key = payload.get("tool_use_id") or ev.get("subagent_id") or ev.get("agent")
+                if key:
+                    agents = sessions[sid].get("agents_active", {})
+                    agents.pop(key, None)
+                    # Sweep same-named ghosts left by a prior key-scheme mismatch.
+                    name = ev.get("agent") or (ev.get("payload") or {}).get("subagent_type")
+                    if name:
+                        for k in [k for k, ag in agents.items()
+                                  if ag.get("name") == name]:
+                            del agents[k]
         except Exception:
             return
 
@@ -205,7 +224,10 @@ class AgentsTab(Container):
                 sess_node.add_leaf(Text("(main only)", style="dim italic"),
                                    data={"kind": "agent", "sid": sid, "agent": "(main)"})
             else:
-                for name, ag in agents.items():
+                for _key, ag in agents.items():
+                    # Always display the stored name field, not the dict key
+                    # (which may be a tool_use_id from the daemon snapshot).
+                    name = ag.get("name") or _key
                     al = Text()
                     al.append("● ", style="#00D4AA")
                     al.append(name, style="bold")

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

@@ -86,12 +86,16 @@ class KnowledgeTab(Container):
             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
+                # stats_only=True comes from the tail-side periodic size probe
+                # (session:null). It updates the size display but is NOT a real
+                # scan triggered by a hook — do not increment the scan counter.
+                if not p.get("stats_only"):
+                    g["last_scan_project"] = p.get("project")
+                    g["last_scan_at"] = p.get("scanned_at") or ev.get("ts")
+                    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")

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

@@ -201,25 +201,48 @@ class LiveTab(Container):
                     "workflows_active": {},
                 }
             if etype == "agent_spawn" and sid:
-                name = ev.get("agent") or (ev.get("payload") or {}).get("subagent_type")
-                if name:
-                    sessions[sid].setdefault("agents_active", {})[name] = {
+                payload = ev.get("payload") or {}
+                name = ev.get("agent") or payload.get("subagent_type")
+                # Resolve the stable key: prefer tool_use_id from payload,
+                # then top-level subagent_id (older hook schema), then name.
+                key = payload.get("tool_use_id") or ev.get("subagent_id") or name
+                if name and key:
+                    agents = sessions[sid].setdefault("agents_active", {})
+                    # Avoid a ghost duplicate: if an entry with the same .name
+                    # already exists under a different key (key-scheme mismatch
+                    # between snapshot and delta), remove the stale entry first.
+                    stale = [k for k, ag in agents.items()
+                             if ag.get("name") == name and k != key]
+                    for k in stale:
+                        del agents[k]
+                    agents[key] = {
                         "name": name,
                         "started": ev.get("ts"),
                         "last_tool": ev.get("tool"),
                         "status": "running",
                     }
             elif etype == "agent_complete" and sid:
-                name = ev.get("agent")
-                if name:
-                    sessions[sid].get("agents_active", {}).pop(name, None)
+                payload = ev.get("payload") or {}
+                key = payload.get("tool_use_id") or ev.get("subagent_id") or ev.get("agent")
+                if key:
+                    agents = sessions[sid].get("agents_active", {})
+                    agents.pop(key, None)
+                    # Also sweep any same-named ghost entries left by a prior
+                    # key-scheme mismatch on spawn.
+                    name = ev.get("agent") or (ev.get("payload") or {}).get("subagent_type")
+                    if name:
+                        for k in [k for k, ag in agents.items()
+                                  if ag.get("name") == name]:
+                            del agents[k]
             elif etype == "tool_call" and sid:
                 name = ev.get("agent")
                 if name:
-                    ag = sessions[sid].get("agents_active", {}).get(name)
-                    if ag:
-                        ag["last_tool"] = ev.get("tool")
-                        ag["last_activity"] = ev.get("ts")
+                    # tool_call carries agent name, not tool_use_id; find by name
+                    for ag in sessions[sid].get("agents_active", {}).values():
+                        if ag.get("name") == name:
+                            ag["last_tool"] = ev.get("tool")
+                            ag["last_activity"] = ev.get("ts")
+                            break
             elif etype == "worktree_change":
                 p = ev.get("payload") or {}
                 path = p.get("path")
@@ -261,8 +284,10 @@ class LiveTab(Container):
                     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")
+                    # stats_only probes update size display but are not real scans
+                    if not p.get("stats_only"):
+                        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")
@@ -319,8 +344,12 @@ class LiveTab(Container):
         for sid, sess in sessions.items():
             if not self._session_matches_filter(sess):
                 continue
-            for name, ag in (sess.get("agents_active") or {}).items():
+            for _key, ag in (sess.get("agents_active") or {}).items():
                 any_agent = True
+                # Always use the stored name field — the key may be a tool_use_id
+                # (from daemon snapshot) or a legacy name; the name field is always
+                # the human-readable subagent_type.
+                name = ag.get("name") or _key
                 started = (ag.get("started") or "")[11:19]
                 last_tool = ag.get("last_tool") or "-"
                 status = ag.get("status") or "running"

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

@@ -155,7 +155,7 @@ class UsageTab(Container):
         nothing would refresh except on reconnect.
         """
         etype = ev.get("type")
-        sid = ev.get("session_id") or ev.get("sid")
+        sid = ev.get("session") or ev.get("session_id") or ev.get("sid")
         sessions = self._state.setdefault("sessions", {})
 
         if etype == "token_usage" and sid:
@@ -234,9 +234,16 @@ class UsageTab(Container):
         if sessions:
             best_pct = -1
             for sess in sessions:
-                tokens_in = int(sess.get("tokens_in") or 0)
+                # last_context_tokens is the most-recent turn's total input
+                # footprint (cache_read + cache_write + tokens_in for that
+                # turn), added by the daemon alongside Phase-4 token_usage
+                # events. It reflects what actually occupies the context window
+                # right now. Fall back to the cumulative tokens_in for old
+                # snapshots that predate the field — those will still under-
+                # report under caching, but gracefully rather than crashing.
+                ctx = int(sess.get("last_context_tokens") or sess.get("tokens_in") or 0)
                 window, label = _session_context_window(sess)
-                pct = int(100 * tokens_in / window) if window else 0
+                pct = int(100 * ctx / window) if window else 0
                 if pct > best_pct:
                     best_pct = pct
                     worst_label = label

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

@@ -239,12 +239,19 @@ class WorkflowsTab(Container):
         except Exception:
             return
         await lv.clear()
+        # Stable, index-based widget IDs. A run_id or workflow name can contain
+        # characters Textual rejects in an id (the "(unknown)" placeholder has
+        # parentheses; real names may have dots/spaces). Key list items by
+        # render position and map the position back to the real id/name on
+        # selection — never feed arbitrary data into a widget id.
+        self._wf_ids: list[str] = []
+        self._cat_ids: list[str] = []
         # ----- Recent runs (top) ---------------------------------------------
         if self._runs:
             head = Text()
             head.append("RECENT RUNS\n", style="bold #B794F4")
             lv.append(ListItem(Static(head)))
-            for run_id, run in list(self._runs.items())[-8:]:
+            for i, (run_id, run) in enumerate(list(self._runs.items())[-8:]):
                 t = Text()
                 mark = "║ " if self._selected == run_id else "  "
                 t.append(mark, style="#B794F4 bold")
@@ -257,14 +264,15 @@ class WorkflowsTab(Container):
                 cost = run.get("cost_usd") or 0.0
                 tok = run.get("tokens") or 0
                 t.append(f"   ${cost:.2f} · {tok/1000:.1f}k tok", style="#B794F4")
-                lv.append(ListItem(Static(t), id=f"wf-{run_id}"))
+                self._wf_ids.append(run_id)
+                lv.append(ListItem(Static(t), id=f"wf-{i}"))
         # ----- Catalogue (bottom) --------------------------------------------
         if self._catalogue:
             head = Text()
             head.append("AVAILABLE", style="bold #00D4AA")
             head.append(f"  ({len(self._catalogue)} workflows)", style="dim italic")
             lv.append(ListItem(Static(head)))
-            for entry in self._catalogue:
+            for i, entry in enumerate(self._catalogue):
                 name = entry.get("name", "?")
                 desc = entry.get("description") or ""
                 mark = "║ " if self._cat_selected == name else "  "
@@ -273,7 +281,8 @@ class WorkflowsTab(Container):
                 t.append(name[:30], style="bold")
                 if desc:
                     t.append(f"\n  {desc[:60]}", style="dim")
-                lv.append(ListItem(Static(t), id=f"cat-{name}"))
+                self._cat_ids.append(name)
+                lv.append(ListItem(Static(t), id=f"cat-{i}"))
         elif not self._runs:
             lv.append(ListItem(Static(Text(
                 "(no workflows installed and no runs yet)\n"
@@ -285,11 +294,21 @@ class WorkflowsTab(Container):
     def on_list_view_selected(self, event: ListView.Selected) -> None:
         node_id = event.item.id or ""
         if node_id.startswith("wf-"):
-            self._selected = node_id[3:]
+            try:
+                idx = int(node_id[3:])
+            except ValueError:
+                return
+            wf_ids = getattr(self, "_wf_ids", [])
+            self._selected = wf_ids[idx] if 0 <= idx < len(wf_ids) else None
             self._cat_selected = None
             self._render_tree()
         elif node_id.startswith("cat-"):
-            self._cat_selected = node_id[4:]
+            try:
+                idx = int(node_id[4:])
+            except ValueError:
+                return
+            cat_ids = getattr(self, "_cat_ids", [])
+            self._cat_selected = cat_ids[idx] if 0 <= idx < len(cat_ids) else None
             self._selected = None
             self._render_tree()
 

package/payload/mishkan/observability/watchd/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mishkan-watchd"
-version = "0.1.0"
+version = "0.2.6"
 description = "MISHKAN observability daemon — aggregates event bus + filesystem polls into a UNIX-socket snapshot+delta stream for mishkan-watch."
 readme = "../README.md"
 requires-python = ">=3.11"

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

@@ -1,3 +1,3 @@
 """MISHKAN observability daemon — mishkan-watchd."""
 
-__version__ = "0.1.0"
+__version__ = "0.2.6"

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

@@ -165,10 +165,34 @@ def _clear_pid() -> None:
         pass
 
 
+def _socket_is_live(socket_path: Path) -> bool:
+    """Return True if a daemon is already listening on socket_path."""
+    try:
+        with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as s:
+            s.settimeout(0.5)
+            s.connect(str(socket_path))
+        return True
+    except (OSError, socket.timeout):
+        return False
+
+
 def _cmd_start(args: argparse.Namespace) -> int:
+    # Check for a live daemon before writing the PID file or binding.
+    # The server.start() also performs this check, but the early exit here
+    # avoids overwriting a valid PID file with our own PID.
+    if args.socket.exists() and _socket_is_live(args.socket):
+        print("mishkan-watchd: daemon already running, nothing to do", file=sys.stderr)
+        return 0
     _write_pid()
     try:
         asyncio.run(_run(args.log_dir, args.projects_dir, args.socket))
+    except RuntimeError as e:
+        # server.start() raises RuntimeError when a live daemon is detected
+        # after the PID file was written (narrow race). Clean up and exit 0
+        # — another daemon is running, which is the desired state.
+        _clear_pid()
+        print(f"mishkan-watchd: {e}", file=sys.stderr)
+        return 0
     finally:
         _clear_pid()
     return 0
@@ -176,17 +200,41 @@ def _cmd_start(args: argparse.Namespace) -> int:
 
 def _cmd_stop(_args: argparse.Namespace) -> int:
     try:
-        pid = int(DEFAULT_PID.read_text().strip())
-    except Exception:
+        pid_text = DEFAULT_PID.read_text().strip()
+    except FileNotFoundError:
         print("mishkan-watchd: no PID file (daemon not running?)", file=sys.stderr)
+        return 0
+    except Exception as e:
+        print(f"mishkan-watchd: cannot read PID file: {e}", file=sys.stderr)
         return 1
+
     try:
-        os.kill(pid, signal.SIGTERM)
-        print(f"mishkan-watchd: sent SIGTERM to {pid}", file=sys.stderr)
+        pid = int(pid_text)
+    except ValueError:
+        print("mishkan-watchd: malformed PID file, clearing", file=sys.stderr)
+        _clear_pid()
+        return 1
+
+    # Verify the PID is actually a live mishkan-watchd process before killing.
+    try:
+        # os.kill with signal 0 checks existence without sending a signal.
+        os.kill(pid, 0)
     except ProcessLookupError:
         _clear_pid()
         print("mishkan-watchd: process not found, cleared stale PID", file=sys.stderr)
+        return 0
+    except PermissionError:
+        # Process exists but is owned by another user — not ours to kill.
+        print(f"mishkan-watchd: PID {pid} exists but is not owned by this user", file=sys.stderr)
+        _clear_pid()
         return 1
+
+    try:
+        os.kill(pid, signal.SIGTERM)
+        print(f"mishkan-watchd: sent SIGTERM to {pid}", file=sys.stderr)
+    except ProcessLookupError:
+        _clear_pid()
+        print("mishkan-watchd: process vanished before SIGTERM, cleared PID", file=sys.stderr)
     return 0