Sync ctx 6f02987

GitHub commit: 6f029879196b75d112d71b975be0411821897d4d

.github/workflows/publish.yml

@@ -242,17 +242,17 @@ jobs:
             --min-edges 2000000 \
             --min-skills-sh-nodes 89000 \
             --min-semantic-edges 1000000 \
-            --expected-nodes 102718 \
-            --expected-edges 2911220 \
-            --expected-semantic-edges 1683265 \
-            --expected-harness-nodes 14 \
+            --expected-nodes 102717 \
+            --expected-edges 2911162 \
+            --expected-semantic-edges 1683182 \
+            --expected-harness-nodes 15 \
             --expected-skills-sh-nodes 89463 \
             --expected-skills-sh-catalog-entries 89463 \
             --expected-skills-sh-converted 89463 \
-            --expected-skill-pages 91450 \
+            --expected-skill-pages 91448 \
             --expected-agent-pages 467 \
             --expected-mcp-pages 10787 \
-            --expected-harness-pages 14 \
+            --expected-harness-pages 15 \
             --line-threshold 180 \
             --max-stage-lines 40
 

.github/workflows/test.yml

@@ -400,17 +400,17 @@ jobs:
             --min-edges 2000000 \
             --min-skills-sh-nodes 89000 \
             --min-semantic-edges 1000000 \
-            --expected-nodes 102718 \
-            --expected-edges 2911220 \
-            --expected-semantic-edges 1683265 \
-            --expected-harness-nodes 14 \
+            --expected-nodes 102717 \
+            --expected-edges 2911162 \
+            --expected-semantic-edges 1683182 \
+            --expected-harness-nodes 15 \
             --expected-skills-sh-nodes 89463 \
             --expected-skills-sh-catalog-entries 89463 \
             --expected-skills-sh-converted 89463 \
-            --expected-skill-pages 91450 \
+            --expected-skill-pages 91448 \
             --expected-agent-pages 467 \
             --expected-mcp-pages 10787 \
-            --expected-harness-pages 14 \
+            --expected-harness-pages 15 \
             --line-threshold 180 \
             --max-stage-lines 40
 

CHANGELOG.md

@@ -7,6 +7,30 @@ Format loosely follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 - No unreleased changes yet.
 
+## [1.0.6] - 2026-05-14
+
+### Fixed
+
+- Promoted Mirage, CodeGraph, and `codegraph-agentic-codebase-analysis` from
+  graph overlay-only records into first-class shipped LLM-wiki pages in
+  `graph/wiki-graph.tar.gz`; the fast runtime archive now carries the Mirage
+  harness page for custom/API/local model onboarding.
+- Regenerated graph preview HTML from the refreshed graph export and updated
+  exact graph artifact validation counts to 102,717 nodes, 2,911,162 edges,
+  91,448 skill pages, 467 agent pages, 10,787 MCP pages, and 15 harness pages.
+- Added a compact dashboard neighborhood index to the shipped runtime/full
+  graph archives so dashboard graph lookup does not parse the 604 MB
+  `graph.json` on the first request.
+- Fixed `ctx-init --graph --graph-url ...` so an explicit remote graph URL is
+  verified and downloaded instead of being silently shadowed by any local
+  source-checkout archive.
+- Fixed dashboard entity deletion queue jobs so the worker no longer fails by
+  trying to read an entity page that the dashboard already removed; deletes now
+  queue a full graph-only refresh.
+- Fixed cross-source MCP canonical merges so the queued wiki refresh and
+  canonical index use the existing target slug/path instead of the incoming
+  alias slug.
+
 ## [1.0.5] - 2026-05-14
 
 ### Fixed
@@ -1524,6 +1548,7 @@ pass. Full test suite: **1316 passed, 2 skipped**.
 - 5 dead imports removed (`os`, `Mapping`, `timedelta` from
   `ctx_lifecycle`; `Path` from `intake_gate`, `intake_pipeline`).
 
+[1.0.6]: https://github.com/stevesolun/ctx/releases/tag/v1.0.6
 [1.0.5]: https://github.com/stevesolun/ctx/releases/tag/v1.0.5
 [1.0.4]: https://github.com/stevesolun/ctx/releases/tag/v1.0.4
 [1.0.3]: https://github.com/stevesolun/ctx/releases/tag/v1.0.3

README.md

@@ -18,11 +18,11 @@ tags:
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](LICENSE)
 [![Python 3.11+](https://img.shields.io/badge/Python-3.11+-green.svg)](https://python.org)
 [![PyPI](https://img.shields.io/pypi/v/claude-ctx.svg)](https://pypi.org/project/claude-ctx/)
-[![Tests](https://img.shields.io/badge/Tests-3797_collected-brightgreen.svg)](#)
-[![Graph](https://img.shields.io/badge/Graph-102%2C718_nodes_/_2.9M_edges-red.svg)](graph/)
+[![Tests](https://img.shields.io/badge/Tests-3818_collected-brightgreen.svg)](#)
+[![Graph](https://img.shields.io/badge/Graph-102%2C717_nodes_/_2.9M_edges-red.svg)](graph/)
 [![Docs](https://img.shields.io/badge/docs-MkDocs_Material-blue.svg)](https://stevesolun.github.io/ctx/)
 
-ctx watches what you are building, walks a **102,718-node** graph, and
+ctx watches what you are building, walks a **102,717-node** graph, and
 recommends a small, top-scored bundle of skills, agents, and MCP servers for
 the current task. If you use your own local/API model instead of Claude Code,
 ctx has a separate harness catalog flow: tell it the model and goal, review the
@@ -30,15 +30,15 @@ recommended harness, then install with dry-run/update/uninstall controls.
 
 Current shipped snapshot:
 
-- **91,450 skills**: 1,987 curated/imported skills plus **89,463 body-backed Skills.sh skills**.
-- **467 agents**, **10,787 MCP servers**, and **14 cataloged harnesses**.
+- **91,448 skills**: 1,985 curated/imported skills plus **89,463 body-backed Skills.sh skills**.
+- **467 agents**, **10,787 MCP servers**, and **15 cataloged harnesses**.
 - **2.9M graph edges** across semantic similarity, tags, slug tokens, source overlap, direct links, quality, usage, type affinity, and graph structure.
 - **89,463 hydrated `SKILL.md` bodies** in the shipped LLM-wiki; long entries are converted through the micro-skill gate instead of loading raw long prompts.
 - Entity updates for skills, agents, MCPs, and harnesses print benefits/risks and skip replacement unless you explicitly approve the update.
 
 ## Why it exists
 
-- **Discovery** — with 91K+ skill nodes, 460+ agents, 10K+ MCP servers, and 14 cataloged harnesses, you can't possibly know which exist or which apply to your current work.
+- **Discovery** — with 91K+ skill nodes, 460+ agents, 10K+ MCP servers, and 15 cataloged harnesses, you can't possibly know which exist or which apply to your current work.
 - **Context budget** — loading everything wastes tokens and degrades quality. You need the right 10–15 per session.
 - **Skill rot** — skills you installed months ago and never used are cluttering context. Stale ones should be flagged automatically.
 
@@ -61,7 +61,7 @@ Graph-backed recommendations need the pre-built graph. By default, `ctx-init
 --graph` installs the fast runtime artifact: `graph/wiki-graph-runtime.tar.gz`
 in source checkouts, or the matching GitHub release asset from pip installs.
 It contains `graphify-out/*` plus the external Skills.sh catalog needed for
-recommendations and the 13 cataloged harness pages needed by
+recommendations and the 15 cataloged harness pages needed by
 `ctx-harness-install`:
 
 ```bash
@@ -78,7 +78,7 @@ ctx-init --graph --graph-install-mode full
 The full `wiki-graph.tar.gz` includes `external-catalogs/skills-sh/catalog.json`,
 89,463 body-backed Skills.sh skill pages under `entities/skills/skills-sh-*.md`,
 89,463 hydrated installable Skills.sh `SKILL.md` files under
-`converted/skills-sh-*/`, and 13 cataloged harness pages under
+`converted/skills-sh-*/`, and 15 cataloged harness pages under
 `entities/harnesses/`.
 
 > **Windows:** PowerShell's built-in `tar.exe` does not support

docs/huggingface-publish.md

@@ -36,7 +36,7 @@ current process, and clear it after the upload.
 ```powershell
 python -m pip install --upgrade huggingface_hub
 git lfs install
-git lfs pull --include="graph/wiki-graph.tar.gz,graph/wiki-graph-runtime.tar.gz,graph/skills-sh-catalog.json.gz"
+git lfs pull --include="graph/wiki-graph.tar.gz,graph/wiki-graph-runtime.tar.gz"
 
 $secureToken = Read-Host "HF write token" -AsSecureString
 $tokenPtr = [Runtime.InteropServices.Marshal]::SecureStringToBSTR($secureToken)

docs/index.md

@@ -5,8 +5,8 @@ hide:
 
 # ctx — Skill, Agent, MCP & Harness Catalog
 
-Watches what you develop, walks a knowledge graph of **91,450 skills, 467
-agents, 10,787 MCP servers, and 14 cataloged harnesses**, and recommends the
+Watches what you develop, walks a knowledge graph of **91,448 skills, 467
+agents, 10,787 MCP servers, and 15 cataloged harnesses**, and recommends the
 right execution bundle on the fly. The live execution bundle is skills,
 agents, and MCP servers only; custom/API/local model users get a separate
 harness-catalog recommendation based on model choice and task goal. You decide
@@ -42,7 +42,7 @@ Claude Code skills, agents, MCP servers, and model harness profiles are
 powerful, but at scale they become unmanageable:
 
 - **Discovery problem** — with 91K+ skills, 460+ agents, 10,000+
-  MCP servers, and 14 cataloged harnesses, how do you know which
+  MCP servers, and 15 cataloged harnesses, how do you know which
   ones exist and which are relevant to your current project?
 - **Context budget** — loading every installable entity wastes tokens and
   degrades quality. You need exactly the right skills, agents, and MCP
@@ -76,12 +76,12 @@ graph-based discovery:
 
 - A Karpathy 3-layer wiki at `~/.claude/skill-wiki/` is the single source
   of truth.
-- **102,718 entity pages/nodes** for the shipped skill/agent/MCP/harness
+- **102,717 entity pages/nodes** for the shipped skill/agent/MCP/harness
   inventory, including 89,463 body-backed Skills.sh skill pages
-  and 13 cataloged harness pages under `entities/harnesses/`.
+  and 15 cataloged harness pages under `entities/harnesses/`.
   Each page tracks tags, status, provenance, and usage where it applies.
-- A **knowledge graph** (102,718 nodes, 2,911,220 edges) built from a
-  13,233-node curated core plus 89,463 body-backed Skills.sh `skill`
+- A **knowledge graph** (102,717 nodes, 2,911,162 edges) built from a
+  13,254-node curated core plus 89,463 body-backed Skills.sh `skill`
   nodes. The graph has 52 Louvain communities and blends semantic cosine,
   tag overlap, and slug-token overlap; 89,463 hydrated Skills.sh bodies are
   shipped as installable `SKILL.md` files. Entries over the configured line
@@ -117,9 +117,9 @@ ones are flagged. New ones self-ingest.
 
     ---
 
-    102,718 shipped graph nodes: 13,255 curated skill/agent/MCP/harness
+    102,717 shipped graph nodes: 13,254 curated skill/agent/MCP/harness
     nodes plus 89,463 body-backed Skills.sh skill nodes. The graph has
-    2,911,220 weighted edges and 52 Louvain communities.
+    2,911,162 weighted edges and 52 Louvain communities.
     Ships pre-built in `graph/wiki-graph.tar.gz` and powers the
     graph-aware recommendations + the pre-ship `ctx-dedup-check` gate.
 
@@ -188,14 +188,14 @@ ones are flagged. New ones self-ingest.
 
     ---
 
-    **v1.0.5** — MIT, CI-matrixed (Ubuntu + Windows × Python 3.11/3.12),
-    3,797 tests collected. Ships console scripts including `ctx-init`,
+    **v1.0.6** — MIT, CI-matrixed (Ubuntu 3.12 plus Windows/macOS 3.11/3.12),
+    3,818 tests collected. Ships console scripts including `ctx-init`,
     `ctx-monitor` (local dashboard with graph + wiki + load/unload for
     skills, agents, and MCP servers, plus Harness Setup for user-owned LLMs),
     `ctx-incremental-attach`, `ctx-incremental-shadow`, `ctx-dedup-check`
     (pre-ship near-duplicate gate), and
     `ctx-tag-backfill` (catalog hygiene), plus a fast runtime graph artifact
-    and the full ~334 MiB wiki tarball with **102,718 nodes / 2,911,220
+    and the full ~390 MiB wiki tarball with **102,717 nodes / 2,911,162
     edges / 52 Louvain communities**.
 
     [:octicons-arrow-right-24: CHANGELOG](https://github.com/stevesolun/ctx/blob/main/CHANGELOG.md) ·

docs/knowledge-graph.md

@@ -13,8 +13,8 @@ agents, and MCP servers.
 ## What's in it
 
 Authoritative numbers from the shipped tarball. The curated-core snapshot
-is **13,255 nodes** (1,987 curated skills + 467 agents + 10,787 MCP servers
-+ 14 harnesses). Harness pages under `entities/harnesses/` are ingested into
+is **13,254 nodes** (1,985 curated skills + 467 agents + 10,787 MCP servers
++ 15 harnesses). Harness pages under `entities/harnesses/` are ingested into
 local rebuilds and the separate harness-catalog recommendation path. The
 tarball also carries **89,463 body-backed Skills.sh `skill` nodes**,
 matching skill pages under `entities/skills/skills-sh-*.md`. **89,463**
@@ -27,18 +27,18 @@ are omitted from the shipped tarball.
 
 | | Count |
 |---|---:|
-| Total nodes | **102,718** |
-| Curated core nodes | **13,255** (1,987 skills + 467 agents + 10,787 MCP servers + 14 harnesses) |
+| Total nodes | **102,717** |
+| Curated core nodes | **13,254** (1,985 skills + 467 agents + 10,787 MCP servers + 15 harnesses) |
 | Remote-cataloged Skills.sh skill nodes | **89,463** (`skill`, `status=remote-cataloged`, body-backed) |
-| Total edges | **2,911,220** |
-| Skills.sh incident edges | **2,605,992** |
-| Skills.sh semantic incident edges | **1,500,706** |
+| Total edges | **2,911,162** |
+| Skills.sh incident edges | **2,605,979** |
+| Skills.sh semantic incident edges | **1,500,693** |
 | Communities | **52** (Louvain) |
-| Edge sources (overlap-deduped) | semantic 1,682,846 - tag 891,739 - token 433,074 |
-| Cross-type edges (skill <-> agent) | ~65K |
+| Edge sources (overlap-deduped) | semantic 1,683,182 - tag 894,935 - token 433,252 |
+| Cross-type edges (skill <-> agent) | ~67K |
 | Cross-type edges (skill <-> MCP) | ~41K |
 | Cross-type edges (agent <-> MCP) | ~223 |
-| Harness edges | **3,289** |
+| Harness edges | **3,632** |
 | Skills.sh catalog | **89,463** observed body-backed entries (`external-catalogs/skills-sh/catalog.json` + `entities/skills/skills-sh-*.md`) |
 
 ## Install
@@ -170,7 +170,7 @@ raw = json.loads(
 edges_key = "links" if "links" in raw else "edges"
 G = node_link_graph(raw, edges=edges_key)
 
-# 102,718 nodes, 2,911,220 edges
+# 102,717 nodes, 2,911,162 edges
 print(G.number_of_nodes(), G.number_of_edges())
 
 # Find entities related to 'fastapi-pro' by edge weight
@@ -330,8 +330,10 @@ next run rebuilds instead of trusting mixed graph files.
 | 2026-05-04 body-backed Skills.sh prune | **2,900,834** | Removed 1,383 Skills.sh records that had no packaged `SKILL.md` body and no parseable Skills.sh prose body. Remaining Skills.sh catalog entries, graph nodes, entity pages, and converted `SKILL.md` bodies are all **89,463**. |
 | 2026-05-05 artifact hygiene refresh | **2,900,834** | Repacked `graph/wiki-graph.tar.gz` to remove transient `.lock` files from the shipped LLM-wiki. Topology unchanged. |
 | 2026-05-10 v1.0.0 release prep | **2,900,834** | Refreshed shipped HTML previews from the current export, validated their export IDs in CI, and removed stale PNG previews. Topology unchanged. |
-| 2026-05-13 external source overlay | **2,911,220** | Added AGENTS.md, lat.md, OptiLLM, Matt Pocock refresh deltas, and Julius caveman entities through the safe overlay path (+21 nodes, +10,310 edges) while preserving the saturated Skills.sh topology. Current tar members: **598,192**. |
 | 2026-05-12 book-to-skill + queue hygiene | **2,900,910** | Added `book-to-skill` as a curated skill entity (+1 node, +76 edges), restored the missing converted Skills.sh body for `skills-sh-yaklang-hack-skills-csv-formula-injection`, and repacked `graph/wiki-graph.tar.gz` to omit `.ctx/` queue state. Tar members: **598,154**. |
+| 2026-05-13 external source overlay | **2,911,220** | Added AGENTS.md, lat.md, OptiLLM, Matt Pocock refresh deltas, and Julius caveman entities through the safe overlay path (+21 nodes, +10,310 edges) while preserving the saturated Skills.sh topology. Tar members at that pass: **598,192**. |
+| 2026-05-14 Matt Pocock upstream refresh | **2,911,126** | Pinned `mattpocock/skills` to `e74f0061bb67222181640effa98c675bdb2fdaa7`, removed three stale legacy alias skill pages/nodes (`mattpocock-domain-model`, `mattpocock-github-triage`, `mattpocock-triage-issue`), refreshed `mattpocock-grill-with-docs`, and pruned 94 incident edges plus stale wiki references. Current tar members: **598,189**. |
+| 2026-05-14 Mirage + CodeGraph first-class wiki pass | **2,911,162** | Added Mirage as a shipped harness wiki/runtime page, added the CodeGraph MCP markdown page and `codegraph-agentic-codebase-analysis` skill page/body to the full LLM-wiki, added the compact dashboard neighborhood index, regenerated graph preview HTML from the current export, and refreshed exact validation counts. Current tar members: **598,193**. |
 
 The full audit history lives in `CHANGELOG.md`. The current build is
 fully reproducible from the wiki content.

graph/README.md

@@ -4,13 +4,13 @@ This directory ships the pre-built ctx LLM-wiki and knowledge graph.
 
 Current snapshot:
 
-- **102,718 graph nodes**
-- **2,911,220 graph edges**
+- **102,717 graph nodes**
+- **2,911,162 graph edges**
 - **52 Louvain communities**
-- **91,450 skill entity pages**: 1,987 curated/imported skills plus 89,463 body-backed Skills.sh skills
+- **91,448 skill entity pages**: 1,985 curated/imported skills plus 89,463 body-backed Skills.sh skills
 - **467 agent pages**
 - **10,787 MCP server pages**
-- **14 harness pages**
+- **15 harness pages**
 - **89,463 hydrated Skills.sh `SKILL.md` bodies**
 - **28,612 long Skills.sh bodies converted through the micro-skill gate**
 
@@ -23,10 +23,11 @@ The runtime recommendation paths use this graph in two ways:
 
 | File | Contents |
 |---|---|
-| `wiki-graph-runtime.tar.gz` | Fast install artifact used by default `ctx-init --graph`: `graphify-out/*`, the external Skills.sh catalog, 14 harness pages, wiki index files, and Obsidian metadata needed for recommendations and harness dry-runs without expanding every entity page |
+| `wiki-graph-runtime.tar.gz` | Fast install artifact used by default `ctx-init --graph`: `graphify-out/*`, the external Skills.sh catalog, 15 harness pages, wiki index files, and Obsidian metadata needed for recommendations and harness dry-runs without expanding every entity page |
 | `wiki-graph.tar.gz` | Full LLM-wiki: entity pages, converted skill bodies, mirrored agent bodies, concept pages, `graphify-out/graph.json`, `graph-delta.json`, export manifest, communities, external catalogs, and Obsidian metadata |
 | `skills-sh-catalog.json.gz` | Compressed Skills.sh catalog for the 89,463 body-backed entries shipped in the wiki |
 | `communities.json` | Current Louvain community export |
+| `graphify-out/dashboard-neighborhoods.sqlite3` inside both tarballs | Compact top-neighbor index used by `ctx-monitor` so `/api/graph/<slug>.json` does not cold-parse the 604 MB NetworkX graph |
 | `viz-overview.html` | Plotly overview of the graph |
 | `viz-python.html` | Python-focused graph view |
 | `viz-security.html` | Security-focused graph view |
@@ -109,17 +110,17 @@ For release-count validation, pin the exact snapshot numbers:
 
 ```bash
 python src/validate_graph_artifacts.py --deep \
-  --expected-nodes 102718 \
-  --expected-edges 2911220 \
-  --expected-semantic-edges 1683265 \
-  --expected-harness-nodes 14 \
+  --expected-nodes 102717 \
+  --expected-edges 2911162 \
+  --expected-semantic-edges 1683182 \
+  --expected-harness-nodes 15 \
   --expected-skills-sh-nodes 89463 \
   --expected-skills-sh-catalog-entries 89463 \
   --expected-skills-sh-converted 89463 \
-  --expected-skill-pages 91450 \
+  --expected-skill-pages 91448 \
   --expected-agent-pages 467 \
   --expected-mcp-pages 10787 \
-  --expected-harness-pages 14
+  --expected-harness-pages 15
 ```
 
 Manual sanity checks:

graph/communities.json

@@ -15960,7 +15960,8 @@
         "skill:verification-before-completion",
         "skill:verification-loop",
         "skill:vibe-code-auditor",
-        "skill:vibers-code-review"
+        "skill:vibers-code-review",
+        "skill:codegraph-agentic-codebase-analysis"
       ]
     },
     "12": {
@@ -30631,7 +30632,8 @@
         "harness:optillm",
         "skill:mattpocock-review",
         "skill:mattpocock-setup-matt-pocock-skills",
-        "skill:mattpocock-triage"
+        "skill:mattpocock-triage",
+        "harness:mirage"
       ]
     },
     "16": {
@@ -50473,10 +50475,8 @@
         "skill:laravel-security",
         "skill:mattpocock-caveman",
         "skill:mattpocock-design-an-interface",
-        "skill:mattpocock-domain-model",
         "skill:mattpocock-edit-article",
         "skill:mattpocock-git-guardrails-claude-code",
-        "skill:mattpocock-github-triage",
         "skill:mattpocock-grill-me",
         "skill:mattpocock-improve-codebase-architecture",
         "skill:mattpocock-migrate-to-shoehorn",
@@ -50488,7 +50488,6 @@
         "skill:mattpocock-tdd",
         "skill:mattpocock-to-issues",
         "skill:mattpocock-to-prd",
-        "skill:mattpocock-triage-issue",
         "skill:mattpocock-ubiquitous-language",
         "skill:mattpocock-write-a-skill",
         "skill:mattpocock-zoom-out",
@@ -102980,6 +102979,6 @@
     }
   },
   "total_communities": 52,
-  "generated": "20260513T150939Z",
-  "export_id": "ctx-graph-overlay-20260513T150939Z-102718-2911220"
+  "generated": "20260514T163846Z",
+  "export_id": "ctx-graph-overlay-20260514T163846Z-102717-2911162"
 }

graph/skills-sh-catalog.json.gz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:e85a1940234667ae4f2347a3ae61fd47f22ad843e36bdffa3c47cc6def8812d5
-size 11656331
+oid sha256:8a664233f08b724d20a459a5fc7da722cab98741abaea1c36bfc2488af70b62a
+size 11656727

graph/wiki-graph-runtime.tar.gz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:84634152dea0f7c8881bc717eaefcce5bfe1b97c4cee90b3202a2ee48b95dd8c
-size 74522806
+oid sha256:27cd757cabaf7209d864b460d14b0755e258cc9bcf93581cacf987e1a7ef1e21
+size 159737046

graph/wiki-graph.tar.gz

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a3968445d6ef9a27d5a684d30019b5730e9c40c62ba7fcd1b66e8567baa756b6
-size 350655613
+oid sha256:57974831189e6fa6c828f3dc2b6b54ebff50879dcc301ed749d20fa9cc495414
+size 408620019

imported-skills/mattpocock/ATTRIBUTION.md

@@ -1,116 +1,110 @@
-# Mattpocock Skills Import — Attribution & Usage
-
-This directory mirrors Matt Pocock's personal `.claude/` skill set — opinionated
-agent skills covering TDD, domain modelling, codebase architecture review,
-github triage, and meta-workflows for working with Claude Code.
-
-## Provenance
-
-| Field | Value |
-|---|---|
-| Upstream repo | https://github.com/mattpocock/skills |
-| Revision | `f304057d61d3df3c9fd992ac2b6e3833cb9325fb` |
-| Revision date | 2026-05-12 |
-| Upstream license | MIT (see `LICENSE`) |
-| Imported on | 2026-04-27 |
-| Skill count | 31 total: 28 current upstream skills plus 3 legacy aliases preserved for compatibility |
-
-## What's in here
-
-Each top-level directory is one skill, with `SKILL.md` as the entry point and
-optional supporting `.md` / `.sh` files alongside it (e.g. `tdd/deep-modules.md`,
-`domain-model/ADR-FORMAT.md`, `git-guardrails-claude-code/scripts/block-dangerous-git.sh`).
-
-`domain-model`, `github-triage`, and `triage-issue` are retained as legacy
-ctx aliases. The current upstream equivalents are `grill-with-docs` and
-`triage`.
-
-| Skill | Purpose |
-|---|---|
-| `tdd` | Red-green-refactor TDD discipline (with deep-modules / mocking / refactoring sidecars) |
-| `qa` | Interactive QA conversation that files GitHub issues using project domain language |
-| `caveman` | Ultra-compressed communication mode (~75% token reduction) |
-| `domain-model` | Stress-test plans against existing domain model + ADRs (with `ADR-FORMAT.md` + `CONTEXT-FORMAT.md`) |
-| `ubiquitous-language` | DDD-style shared vocabulary discipline |
-| `design-an-interface` | Generate multiple radically different API designs via parallel sub-agents |
-| `improve-codebase-architecture` | Architecture review playbook (with `DEEPENING.md`, `INTERFACE-DESIGN.md`, `LANGUAGE.md` sidecars) |
-| `github-triage` | Triage GitHub issues with agent-brief + out-of-scope guardrails |
-| `triage-issue` | Single-issue triage workflow |
-| `diagnose` | Disciplined reproduce/minimize/hypothesize/instrument/fix loop |
-| `grill-with-docs` | Plan interrogation backed by `CONTEXT.md` and ADRs |
-| `handoff` | Compact a session into a continuation handoff |
-| `prototype` | Throwaway logic/UI prototypes before committing to a design |
-| `review` | Standards/spec two-axis review against a fixed point |
-| `setup-matt-pocock-skills` | Per-repo setup for issue tracker, triage labels, and domain docs |
-| `to-issues` | Convert plans/notes into well-formed issues |
-| `to-prd` | Convert sketches into a product requirements document |
-| `request-refactor-plan` | Plan a refactor before touching code |
-| `migrate-to-shoehorn` | Migration playbook to the `shoehorn` library |
-| `setup-pre-commit` | Pre-commit hook bootstrap |
-| `scaffold-exercises` | Scaffold programming exercises |
-| `git-guardrails-claude-code` | Block dangerous git ops in Claude Code (with hook script) |
-| `obsidian-vault` | Obsidian vault management workflow |
-| `edit-article` | Editing pass for article drafts |
-| `grill-me` | Adversarial questioning to stress-test a plan |
-| `write-a-skill` | Meta: how to write a skill |
-| `writing-beats` | Build an article beat by beat from raw material |
-| `writing-fragments` | Capture raw article fragments through a grilling session |
-| `writing-shape` | Shape a pile of notes into a publishable article |
-| `zoom-out` | Force a higher-altitude review of current work |
-
-## License compliance
-
-Per the MIT license:
-- Upstream `LICENSE` text is preserved alongside the imported files.
-- Files are imported verbatim. The deployed copies (under `~/.claude/skills/`) prepend
-  an HTML-comment attribution header before the original `---` frontmatter so
-  provenance is visible inline; the original content below is unmodified.
-
-## How to integrate
-
-Skills are staged in this directory and **not** deployed to `~/.claude/skills/`
-until you run the importer:
-
-```bash
-python imported-skills/mattpocock/build_manifest.py    # rebuild MANIFEST.json
-python src/import_mattpocock_skills.py --dry-run       # preview
-python src/import_mattpocock_skills.py --install       # deploy as mattpocock-<slug>
-```
-
-Each skill lands as `~/.claude/skills/mattpocock-<slug>/` with all its support
-files copied alongside `SKILL.md`. Directory namespacing prevents collisions
-with same-named skills already in the wiki (e.g. existing `tdd-orchestrator`
-agent + `python-testing` skill coexist with `mattpocock-tdd`).
-
-After install, refresh the wiki + graph:
-
-```bash
-python src/catalog_builder.py
-python src/wiki_batch_entities.py --all
-python -m ctx.core.wiki.wiki_graphify
-```
-
-## Why this set
-
-mattpocock's skills are short, opinionated, and prose-style — closer to
-checklists or playbooks than reference manuals. They complement the larger
-catalogue (which leans dense + comprehensive) by providing crisp,
-single-purpose workflows for everyday engineering tasks.
-
-The `tdd`, `domain-model`, `ubiquitous-language`, and
-`improve-codebase-architecture` set in particular form a cohesive DDD-leaning
-toolkit. The `caveman`, `grill-me`, `zoom-out` set are useful behavioural
-modes for steering a Claude Code session.
-
-## Limitations
-
-- **Frontmatter format** — uses YAML frontmatter with `name:` + `description:`;
-  some entries use `disable-model-invocation: true` (Claude Code reads this).
-  The importer preserves these fields as-is.
-- **Tool assumptions** — `git-guardrails-claude-code` ships a `block-dangerous-git.sh`
-  hook that expects POSIX `bash` on PATH; on Windows it requires Git-Bash or
-  WSL. The hook is copied but not wired into your Claude Code settings — wire
-  manually if you want it active.
-- **Opinionated** — these reflect one engineer's workflow. Treat them as
-  starting points; nothing here is universally correct (e.g. `grill-me`'s
-  adversarial style isn't right for every team).
+# Mattpocock Skills Import — Attribution & Usage
+
+This directory mirrors Matt Pocock's personal `.claude/` skill set — opinionated
+agent skills covering TDD, domain modelling, codebase architecture review,
+github triage, and meta-workflows for working with Claude Code.
+
+## Provenance
+
+| Field | Value |
+|---|---|
+| Upstream repo | https://github.com/mattpocock/skills |
+| Revision | `e74f0061bb67222181640effa98c675bdb2fdaa7` |
+| Revision date | 2026-05-14 |
+| Upstream license | MIT (see `LICENSE`) |
+| Imported on | 2026-04-27 |
+| Skill count | 28 current upstream skills |
+
+## What's in here
+
+Each top-level directory is one skill, with `SKILL.md` as the entry point and
+optional supporting `.md` / `.sh` files alongside it (e.g. `tdd/deep-modules.md`,
+`grill-with-docs/ADR-FORMAT.md`, `git-guardrails-claude-code/scripts/block-dangerous-git.sh`).
+
+| Skill | Purpose |
+|---|---|
+| `tdd` | Red-green-refactor TDD discipline (with deep-modules / mocking / refactoring sidecars) |
+| `qa` | Interactive QA conversation that files GitHub issues using project domain language |
+| `caveman` | Ultra-compressed communication mode (~75% token reduction) |
+| `ubiquitous-language` | DDD-style shared vocabulary discipline |
+| `design-an-interface` | Generate multiple radically different API designs via parallel sub-agents |
+| `improve-codebase-architecture` | Architecture review playbook (with `DEEPENING.md`, `INTERFACE-DESIGN.md`, `LANGUAGE.md` sidecars) |
+| `triage` | Triage issues with agent-brief + out-of-scope guardrails |
+| `diagnose` | Disciplined reproduce/minimize/hypothesize/instrument/fix loop |
+| `grill-with-docs` | Plan interrogation backed by `CONTEXT.md` and ADRs |
+| `handoff` | Compact a session into a continuation handoff |
+| `prototype` | Throwaway logic/UI prototypes before committing to a design |
+| `review` | Standards/spec two-axis review against a fixed point |
+| `setup-matt-pocock-skills` | Per-repo setup for issue tracker, triage labels, and domain docs |
+| `to-issues` | Convert plans/notes into well-formed issues |
+| `to-prd` | Convert sketches into a product requirements document |
+| `request-refactor-plan` | Plan a refactor before touching code |
+| `migrate-to-shoehorn` | Migration playbook to the `shoehorn` library |
+| `setup-pre-commit` | Pre-commit hook bootstrap |
+| `scaffold-exercises` | Scaffold programming exercises |
+| `git-guardrails-claude-code` | Block dangerous git ops in Claude Code (with hook script) |
+| `obsidian-vault` | Obsidian vault management workflow |
+| `edit-article` | Editing pass for article drafts |
+| `grill-me` | Adversarial questioning to stress-test a plan |
+| `write-a-skill` | Meta: how to write a skill |
+| `writing-beats` | Build an article beat by beat from raw material |
+| `writing-fragments` | Capture raw article fragments through a grilling session |
+| `writing-shape` | Shape a pile of notes into a publishable article |
+| `zoom-out` | Force a higher-altitude review of current work |
+
+## License compliance
+
+Per the MIT license:
+- Upstream `LICENSE` text is preserved alongside the imported files.
+- Files are imported verbatim. The deployed copies (under `~/.claude/skills/`) prepend
+  an HTML-comment attribution header before the original `---` frontmatter so
+  provenance is visible inline; the original content below is unmodified.
+
+## How to integrate
+
+Skills are staged in this directory and **not** deployed to `~/.claude/skills/`
+until you run the importer:
+
+```bash
+python imported-skills/mattpocock/build_manifest.py    # rebuild MANIFEST.json
+python src/import_mattpocock_skills.py --dry-run       # preview
+python src/import_mattpocock_skills.py --install       # deploy as mattpocock-<slug>
+```
+
+Each skill lands as `~/.claude/skills/mattpocock-<slug>/` with all its support
+files copied alongside `SKILL.md`. Directory namespacing prevents collisions
+with same-named skills already in the wiki (e.g. existing `tdd-orchestrator`
+agent + `python-testing` skill coexist with `mattpocock-tdd`).
+
+After install, refresh the wiki + graph:
+
+```bash
+python src/catalog_builder.py
+python src/wiki_batch_entities.py --all
+python -m ctx.core.wiki.wiki_graphify
+```
+
+## Why this set
+
+mattpocock's skills are short, opinionated, and prose-style — closer to
+checklists or playbooks than reference manuals. They complement the larger
+catalogue (which leans dense + comprehensive) by providing crisp,
+single-purpose workflows for everyday engineering tasks.
+
+The `tdd`, `grill-with-docs`, `ubiquitous-language`, and
+`improve-codebase-architecture` set in particular form a cohesive DDD-leaning
+toolkit. The `caveman`, `grill-me`, `zoom-out` set are useful behavioural
+modes for steering a Claude Code session.
+
+## Limitations
+
+- **Frontmatter format** — uses YAML frontmatter with `name:` + `description:`;
+  some entries use `disable-model-invocation: true` (Claude Code reads this).
+  The importer preserves these fields as-is.
+- **Tool assumptions** — `git-guardrails-claude-code` ships a `block-dangerous-git.sh`
+  hook that expects POSIX `bash` on PATH; on Windows it requires Git-Bash or
+  WSL. The hook is copied but not wired into your Claude Code settings — wire
+  manually if you want it active.
+- **Opinionated** — these reflect one engineer's workflow. Treat them as
+  starting points; nothing here is universally correct (e.g. `grill-me`'s
+  adversarial style isn't right for every team).

imported-skills/mattpocock/MANIFEST.json

@@ -1,9 +1,9 @@
 {
   "upstream": "https://github.com/mattpocock/skills",
-  "upstream_revision": "f304057d61d3df3c9fd992ac2b6e3833cb9325fb",
+  "upstream_revision": "e74f0061bb67222181640effa98c675bdb2fdaa7",
   "license": "MIT",
   "namespace": "mattpocock",
-  "total": 31,
+  "total": 28,
   "entries": [
     {
       "name": "caveman",
@@ -31,17 +31,6 @@
       ],
       "lines": 117
     },
-    {
-      "name": "domain-model",
-      "description": "Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.",
-      "slug": "domain-model",
-      "source_path": "domain-model/SKILL.md",
-      "support_files": [
-        "ADR-FORMAT.md",
-        "CONTEXT-FORMAT.md"
-      ],
-      "lines": 81
-    },
     {
       "name": "edit-article",
       "description": "Edit and improve articles by restructuring sections, improving clarity, and tightening prose. Use when user wants to edit, revise, or improve an article draft.",
@@ -60,17 +49,6 @@
       ],
       "lines": 95
     },
-    {
-      "name": "github-triage",
-      "description": "Triage GitHub issues through a label-based state machine. Use when user wants to create an issue, triage issues, review incoming bugs or feature requests, prepare issues for an AFK agent, or manage issue workflow.",
-      "slug": "github-triage",
-      "source_path": "github-triage/SKILL.md",
-      "support_files": [
-        "AGENT-BRIEF.md",
-        "OUT-OF-SCOPE.md"
-      ],
-      "lines": 168
-    },
     {
       "name": "grill-me",
       "description": "Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions \"grill me\".",
@@ -232,14 +210,6 @@
       ],
       "lines": 103
     },
-    {
-      "name": "triage-issue",
-      "description": "Triage a bug or issue by exploring the codebase to find root cause, then create a GitHub issue with a TDD-based fix plan. Use when user reports a bug, wants to file an issue, mentions \"triage\", or wants to investigate and plan a fix for a problem.",
-      "slug": "triage-issue",
-      "source_path": "triage-issue/SKILL.md",
-      "support_files": [],
-      "lines": 102
-    },
     {
       "name": "ubiquitous-language",
       "description": "Extract a DDD-style ubiquitous language glossary from the current conversation, flagging ambiguities and proposing canonical terms. Saves to UBIQUITOUS_LANGUAGE.md. Use when user wants to define domain terms, build a glossary, harden terminology, create a ubiquitous language, or mentions \"domain model\" or \"DDD\".",

imported-skills/mattpocock/README.md

@@ -1,55 +1,49 @@
-# Matt Pocock Skills
-
-Local mirror of [mattpocock/skills](https://github.com/mattpocock/skills), pinned
-at `f304057d61d3df3c9fd992ac2b6e3833cb9325fb`.
-
-This directory contains 31 ctx-staged entries: 28 current upstream skills plus
-3 legacy aliases (`domain-model`, `github-triage`, `triage-issue`) kept so older
-ctx graph/wiki references do not break.
-
-Run `python imported-skills/mattpocock/build_manifest.py` after edits, then
-`python src/import_mattpocock_skills.py --dry-run` before installing.
-
-## Current Upstream Skills
-
-Engineering:
-
-- `diagnose`
-- `grill-with-docs`
-- `improve-codebase-architecture`
-- `prototype`
-- `setup-matt-pocock-skills`
-- `tdd`
-- `to-issues`
-- `to-prd`
-- `triage`
-- `zoom-out`
-
-Productivity:
-
-- `caveman`
-- `grill-me`
-- `handoff`
-- `write-a-skill`
-
-Writing/personal/misc:
-
-- `design-an-interface`
-- `edit-article`
-- `git-guardrails-claude-code`
-- `migrate-to-shoehorn`
-- `obsidian-vault`
-- `qa`
-- `request-refactor-plan`
-- `scaffold-exercises`
-- `setup-pre-commit`
-- `ubiquitous-language`
-- `writing-beats`
-- `writing-fragments`
-- `writing-shape`
-
-## Legacy Aliases
-
-- `domain-model` -> superseded upstream by `grill-with-docs`
-- `github-triage` -> superseded upstream by `triage`
-- `triage-issue` -> superseded upstream by `triage`
+# Matt Pocock Skills
+
+Local mirror of [mattpocock/skills](https://github.com/mattpocock/skills), pinned
+at `e74f0061bb67222181640effa98c675bdb2fdaa7`.
+
+This directory contains 28 ctx-staged entries from the current upstream skill
+directories. Removed upstream aliases are not retained here; ctx graph/wiki
+artifacts should prune stale alias nodes during the next artifact refresh.
+
+Run `python imported-skills/mattpocock/build_manifest.py` after edits, then
+`python src/import_mattpocock_skills.py --dry-run` before installing.
+
+## Current Upstream Skills
+
+Engineering:
+
+- `diagnose`
+- `grill-with-docs`
+- `improve-codebase-architecture`
+- `prototype`
+- `setup-matt-pocock-skills`
+- `tdd`
+- `to-issues`
+- `to-prd`
+- `triage`
+- `zoom-out`
+
+Productivity:
+
+- `caveman`
+- `grill-me`
+- `handoff`
+- `write-a-skill`
+
+Writing/personal/misc:
+
+- `design-an-interface`
+- `edit-article`
+- `git-guardrails-claude-code`
+- `migrate-to-shoehorn`
+- `obsidian-vault`
+- `qa`
+- `request-refactor-plan`
+- `scaffold-exercises`
+- `setup-pre-commit`
+- `ubiquitous-language`
+- `writing-beats`
+- `writing-fragments`
+- `writing-shape`

imported-skills/mattpocock/UPSTREAM_REVISION

@@ -1 +1 @@
-f304057d61d3df3c9fd992ac2b6e3833cb9325fb
+e74f0061bb67222181640effa98c675bdb2fdaa7

imported-skills/mattpocock/domain-model/ADR-FORMAT.md

@@ -1,47 +0,0 @@
-# ADR Format
-
-ADRs live in `docs/adr/` and use sequential numbering: `0001-slug.md`, `0002-slug.md`, etc.
-
-Create the `docs/adr/` directory lazily — only when the first ADR is needed.
-
-## Template
-
-```md
-# {Short title of the decision}
-
-{1-3 sentences: what's the context, what did we decide, and why.}
-```
-
-That's it. An ADR can be a single paragraph. The value is in recording *that* a decision was made and *why* — not in filling out sections.
-
-## Optional sections
-
-Only include these when they add genuine value. Most ADRs won't need them.
-
-- **Status** frontmatter (`proposed | accepted | deprecated | superseded by ADR-NNNN`) — useful when decisions are revisited
-- **Considered Options** — only when the rejected alternatives are worth remembering
-- **Consequences** — only when non-obvious downstream effects need to be called out
-
-## Numbering
-
-Scan `docs/adr/` for the highest existing number and increment by one.
-
-## When to offer an ADR
-
-All three of these must be true:
-
-1. **Hard to reverse** — the cost of changing your mind later is meaningful
-2. **Surprising without context** — a future reader will look at the code and wonder "why on earth did they do it this way?"
-3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
-
-If a decision is easy to reverse, skip it — you'll just reverse it. If it's not surprising, nobody will wonder why. If there was no real alternative, there's nothing to record beyond "we did the obvious thing."
-
-### What qualifies
-
-- **Architectural shape.** "We're using a monorepo." "The write model is event-sourced, the read model is projected into Postgres."
-- **Integration patterns between contexts.** "Ordering and Billing communicate via domain events, not synchronous HTTP."
-- **Technology choices that carry lock-in.** Database, message bus, auth provider, deployment target. Not every library — just the ones that would take a quarter to swap out.
-- **Boundary and scope decisions.** "Customer data is owned by the Customer context; other contexts reference it by ID only." The explicit no-s are as valuable as the yes-s.
-- **Deliberate deviations from the obvious path.** "We're using manual SQL instead of an ORM because X." Anything where a reasonable reader would assume the opposite. These stop the next engineer from "fixing" something that was deliberate.
-- **Constraints not visible in the code.** "We can't use AWS because of compliance requirements." "Response times must be under 200ms because of the partner API contract."
-- **Rejected alternatives when the rejection is non-obvious.** If you considered GraphQL and picked REST for subtle reasons, record it — otherwise someone will suggest GraphQL again in six months.

imported-skills/mattpocock/domain-model/CONTEXT-FORMAT.md

@@ -1,77 +0,0 @@
-# CONTEXT.md Format
-
-## Structure
-
-```md
-# {Context Name}
-
-{One or two sentence description of what this context is and why it exists.}
-
-## Language
-
-**Order**:
-{A concise description of the term}
-_Avoid_: Purchase, transaction
-
-**Invoice**:
-A request for payment sent to a customer after delivery.
-_Avoid_: Bill, payment request
-
-**Customer**:
-A person or organization that places orders.
-_Avoid_: Client, buyer, account
-
-## Relationships
-
-- An **Order** produces one or more **Invoices**
-- An **Invoice** belongs to exactly one **Customer**
-
-## Example dialogue
-
-> **Dev:** "When a **Customer** places an **Order**, do we create the **Invoice** immediately?"
-> **Domain expert:** "No — an **Invoice** is only generated once a **Fulfillment** is confirmed."
-
-## Flagged ambiguities
-
-- "account" was used to mean both **Customer** and **User** — resolved: these are distinct concepts.
-```
-
-## Rules
-
-- **Be opinionated.** When multiple words exist for the same concept, pick the best one and list the others as aliases to avoid.
-- **Flag conflicts explicitly.** If a term is used ambiguously, call it out in "Flagged ambiguities" with a clear resolution.
-- **Keep definitions tight.** One sentence max. Define what it IS, not what it does.
-- **Show relationships.** Use bold term names and express cardinality where obvious.
-- **Only include terms specific to this project's context.** General programming concepts (timeouts, error types, utility patterns) don't belong even if the project uses them extensively. Before adding a term, ask: is this a concept unique to this context, or a general programming concept? Only the former belongs.
-- **Group terms under subheadings** when natural clusters emerge. If all terms belong to a single cohesive area, a flat list is fine.
-- **Write an example dialogue.** A conversation between a dev and a domain expert that demonstrates how the terms interact naturally and clarifies boundaries between related concepts.
-
-## Single vs multi-context repos
-
-**Single context (most repos):** One `CONTEXT.md` at the repo root.
-
-**Multiple contexts:** A `CONTEXT-MAP.md` at the repo root lists the contexts, where they live, and how they relate to each other:
-
-```md
-# Context Map
-
-## Contexts
-
-- [Ordering](./src/ordering/CONTEXT.md) — receives and tracks customer orders
-- [Billing](./src/billing/CONTEXT.md) — generates invoices and processes payments
-- [Fulfillment](./src/fulfillment/CONTEXT.md) — manages warehouse picking and shipping
-
-## Relationships
-
-- **Ordering → Fulfillment**: Ordering emits `OrderPlaced` events; Fulfillment consumes them to start picking
-- **Fulfillment → Billing**: Fulfillment emits `ShipmentDispatched` events; Billing consumes them to generate invoices
-- **Ordering ↔ Billing**: Shared types for `CustomerId` and `Money`
-```
-
-The skill infers which structure applies:
-
-- If `CONTEXT-MAP.md` exists, read it to find contexts
-- If only a root `CONTEXT.md` exists, single context
-- If neither exists, create a root `CONTEXT.md` lazily when the first term is resolved
-
-When multiple contexts exist, infer which one the current topic relates to. If unclear, ask.

imported-skills/mattpocock/domain-model/SKILL.md

@@ -1,81 +0,0 @@
----
-name: domain-model
-description: Grilling session that challenges your plan against the existing domain model, sharpens terminology, and updates documentation (CONTEXT.md, ADRs) inline as decisions crystallise. Use when user wants to stress-test a plan against their project's language and documented decisions.
-disable-model-invocation: true
----
-
-Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
-
-Ask the questions one at a time, waiting for feedback on each question before continuing.
-
-If a question can be answered by exploring the codebase, explore the codebase instead.
-
-## Domain awareness
-
-During codebase exploration, also look for existing documentation:
-
-### File structure
-
-Most repos have a single context:
-
-```
-/
-├── CONTEXT.md
-├── docs/
-│   └── adr/
-│       ├── 0001-event-sourced-orders.md
-│       └── 0002-postgres-for-write-model.md
-└── src/
-```
-
-If a `CONTEXT-MAP.md` exists at the root, the repo has multiple contexts. The map points to where each one lives:
-
-```
-/
-├── CONTEXT-MAP.md
-├── docs/
-│   └── adr/                          ← system-wide decisions
-├── src/
-│   ├── ordering/
-│   │   ├── CONTEXT.md
-│   │   └── docs/adr/                 ← context-specific decisions
-│   └── billing/
-│       ├── CONTEXT.md
-│       └── docs/adr/
-```
-
-Create files lazily — only when you have something to write. If no `CONTEXT.md` exists, create one when the first term is resolved. If no `docs/adr/` exists, create it when the first ADR is needed.
-
-## During the session
-
-### Challenge against the glossary
-
-When the user uses a term that conflicts with the existing language in `CONTEXT.md`, call it out immediately. "Your glossary defines 'cancellation' as X, but you seem to mean Y — which is it?"
-
-### Sharpen fuzzy language
-
-When the user uses vague or overloaded terms, propose a precise canonical term. "You're saying 'account' — do you mean the Customer or the User? Those are different things."
-
-### Discuss concrete scenarios
-
-When domain relationships are being discussed, stress-test them with specific scenarios. Invent scenarios that probe edge cases and force the user to be precise about the boundaries between concepts.
-
-### Cross-reference with code
-
-When the user states how something works, check whether the code agrees. If you find a contradiction, surface it: "Your code cancels entire Orders, but you just said partial cancellation is possible — which is right?"
-
-### Update CONTEXT.md inline
-
-When a term is resolved, update `CONTEXT.md` right there. Don't batch these up — capture them as they happen. Use the format in [CONTEXT-FORMAT.md](./CONTEXT-FORMAT.md).
-
-Don't couple `CONTEXT.md` to implementation details. Only include terms that are meaningful to domain experts.
-
-### Offer ADRs sparingly
-
-Only offer to create an ADR when all three are true:
-
-1. **Hard to reverse** — the cost of changing your mind later is meaningful
-2. **Surprising without context** — a future reader will wonder "why did they do it this way?"
-3. **The result of a real trade-off** — there were genuine alternatives and you picked one for specific reasons
-
-If any of the three is missing, skip the ADR. Use the format in [ADR-FORMAT.md](./ADR-FORMAT.md).

imported-skills/mattpocock/github-triage/AGENT-BRIEF.md

@@ -1,168 +0,0 @@
-# Writing Agent Briefs
-
-An agent brief is a structured comment posted on a GitHub issue when it moves to `ready-for-agent`. It is the authoritative specification that an AFK agent will work from. The original issue body and discussion are context — the agent brief is the contract.
-
-## Principles
-
-### Durability over precision
-
-The issue may sit in `ready-for-agent` for days or weeks. The codebase will change in the meantime. Write the brief so it stays useful even as files are renamed, moved, or refactored.
-
-- **Do** describe interfaces, types, and behavioral contracts
-- **Do** name specific types, function signatures, or config shapes that the agent should look for or modify
-- **Don't** reference file paths — they go stale
-- **Don't** reference line numbers
-- **Don't** assume the current implementation structure will remain the same
-
-### Behavioral, not procedural
-
-Describe **what** the system should do, not **how** to implement it. The agent will explore the codebase fresh and make its own implementation decisions.
-
-- **Good:** "The `SkillConfig` type should accept an optional `schedule` field of type `CronExpression`"
-- **Bad:** "Open src/types/skill.ts and add a schedule field on line 42"
-- **Good:** "When a user runs `/triage` with no arguments, they should see a summary of issues needing attention"
-- **Bad:** "Add a switch statement in the main handler function"
-
-### Complete acceptance criteria
-
-The agent needs to know when it's done. Every agent brief must have concrete, testable acceptance criteria. Each criterion should be independently verifiable.
-
-- **Good:** "Running `gh issue list --label needs-triage` returns issues that have been through initial classification"
-- **Bad:** "Triage should work correctly"
-
-### Explicit scope boundaries
-
-State what is out of scope. This prevents the agent from gold-plating or making assumptions about adjacent features.
-
-## Template
-
-```markdown
-## Agent Brief
-
-**Category:** bug / enhancement
-**Summary:** one-line description of what needs to happen
-
-**Current behavior:**
-Describe what happens now. For bugs, this is the broken behavior.
-For enhancements, this is the status quo the feature builds on.
-
-**Desired behavior:**
-Describe what should happen after the agent's work is complete.
-Be specific about edge cases and error conditions.
-
-**Key interfaces:**
-- `TypeName` — what needs to change and why
-- `functionName()` return type — what it currently returns vs what it should return
-- Config shape — any new configuration options needed
-
-**Acceptance criteria:**
-- [ ] Specific, testable criterion 1
-- [ ] Specific, testable criterion 2
-- [ ] Specific, testable criterion 3
-
-**Out of scope:**
-- Thing that should NOT be changed or addressed in this issue
-- Adjacent feature that might seem related but is separate
-```
-
-## Examples
-
-### Good agent brief (bug)
-
-```markdown
-## Agent Brief
-
-**Category:** bug
-**Summary:** Skill description truncation drops mid-word, producing broken output
-
-**Current behavior:**
-When a skill description exceeds 1024 characters, it is truncated at exactly
-1024 characters regardless of word boundaries. This produces descriptions
-that end mid-word (e.g. "Use when the user wants to confi").
-
-**Desired behavior:**
-Truncation should break at the last word boundary before 1024 characters
-and append "..." to indicate truncation.
-
-**Key interfaces:**
-- The `SkillMetadata` type's `description` field — no type change needed,
-  but the validation/processing logic that populates it needs to respect
-  word boundaries
-- Any function that reads SKILL.md frontmatter and extracts the description
-
-**Acceptance criteria:**
-- [ ] Descriptions under 1024 chars are unchanged
-- [ ] Descriptions over 1024 chars are truncated at the last word boundary
-      before 1024 chars
-- [ ] Truncated descriptions end with "..."
-- [ ] The total length including "..." does not exceed 1024 chars
-
-**Out of scope:**
-- Changing the 1024 char limit itself
-- Multi-line description support
-```
-
-### Good agent brief (enhancement)
-
-```markdown
-## Agent Brief
-
-**Category:** enhancement
-**Summary:** Add `.out-of-scope/` directory support for tracking rejected feature requests
-
-**Current behavior:**
-When a feature request is rejected, the issue is closed with a `wontfix` label
-and a comment. There is no persistent record of the decision or reasoning.
-Future similar requests require the maintainer to recall or search for the
-prior discussion.
-
-**Desired behavior:**
-Rejected feature requests should be documented in `.out-of-scope/<concept>.md`
-files that capture the decision, reasoning, and links to all issues that
-requested the feature. When triaging new issues, these files should be
-checked for matches.
-
-**Key interfaces:**
-- Markdown file format in `.out-of-scope/` — each file should have a
-  `# Concept Name` heading, a `**Decision:**` line, a `**Reason:**` line,
-  and a `**Prior requests:**` list with issue links
-- The triage workflow should read all `.out-of-scope/*.md` files early
-  and match incoming issues against them by concept similarity
-
-**Acceptance criteria:**
-- [ ] Closing a feature as wontfix creates/updates a file in `.out-of-scope/`
-- [ ] The file includes the decision, reasoning, and link to the closed issue
-- [ ] If a matching `.out-of-scope/` file already exists, the new issue is
-      appended to its "Prior requests" list rather than creating a duplicate
-- [ ] During triage, existing `.out-of-scope/` files are checked and surfaced
-      when a new issue matches a prior rejection
-
-**Out of scope:**
-- Automated matching (human confirms the match)
-- Reopening previously rejected features
-- Bug reports (only enhancement rejections go to `.out-of-scope/`)
-```
-
-### Bad agent brief
-
-```markdown
-## Agent Brief
-
-**Summary:** Fix the triage bug
-
-**What to do:**
-The triage thing is broken. Look at the main file and fix it.
-The function around line 150 has the issue.
-
-**Files to change:**
-- src/triage/handler.ts (line 150)
-- src/types.ts (line 42)
-```
-
-This is bad because:
-- No category
-- Vague description ("the triage thing is broken")
-- References file paths and line numbers that will go stale
-- No acceptance criteria
-- No scope boundaries
-- No description of current vs desired behavior

imported-skills/mattpocock/github-triage/OUT-OF-SCOPE.md

@@ -1,101 +0,0 @@
-# Out-of-Scope Knowledge Base
-
-The `.out-of-scope/` directory in a repo stores persistent records of rejected feature requests. It serves two purposes:
-
-1. **Institutional memory** — why a feature was rejected, so the reasoning isn't lost when the issue is closed
-2. **Deduplication** — when a new issue comes in that matches a prior rejection, the skill can surface the previous decision instead of re-litigating it
-
-## Directory structure
-
-```
-.out-of-scope/
-├── dark-mode.md
-├── plugin-system.md
-└── graphql-api.md
-```
-
-One file per **concept**, not per issue. Multiple issues requesting the same thing are grouped under one file.
-
-## File format
-
-The file should be written in a relaxed, readable style — more like a short design document than a database entry. Use paragraphs, code samples, and examples to make the reasoning clear and useful to someone encountering it for the first time.
-
-```markdown
-# Dark Mode
-
-This project does not support dark mode or user-facing theming.
-
-## Why this is out of scope
-
-The rendering pipeline assumes a single color palette defined in
-`ThemeConfig`. Supporting multiple themes would require:
-
-- A theme context provider wrapping the entire component tree
-- Per-component theme-aware style resolution
-- A persistence layer for user theme preferences
-
-This is a significant architectural change that doesn't align with the
-project's focus on content authoring. Theming is a concern for downstream
-consumers who embed or redistribute the output.
-
-```ts
-// The current ThemeConfig interface is not designed for runtime switching:
-interface ThemeConfig {
-  colors: ColorPalette; // single palette, resolved at build time
-  fonts: FontStack;
-}
-```
-
-## Prior requests
-
-- #42 — "Add dark mode support"
-- #87 — "Night theme for accessibility"
-- #134 — "Dark theme option"
-```
-
-### Naming the file
-
-Use a short, descriptive kebab-case name for the concept: `dark-mode.md`, `plugin-system.md`, `graphql-api.md`. The name should be recognizable enough that someone browsing the directory understands what was rejected without opening the file.
-
-### Writing the reason
-
-The reason should be substantive — not "we don't want this" but why. Good reasons reference:
-
-- Project scope or philosophy ("This project focuses on X; theming is a downstream concern")
-- Technical constraints ("Supporting this would require Y, which conflicts with our Z architecture")
-- Strategic decisions ("We chose to use A instead of B because...")
-
-The reason should be durable. Avoid referencing temporary circumstances ("we're too busy right now") — those aren't real rejections, they're deferrals.
-
-## When to check `.out-of-scope/`
-
-During triage (Step 1: Gather context), read all files in `.out-of-scope/`. When evaluating a new issue:
-
-- Check if the request matches an existing out-of-scope concept
-- Matching is by concept similarity, not keyword — "night theme" matches `dark-mode.md`
-- If there's a match, surface it to the maintainer: "This is similar to `.out-of-scope/dark-mode.md` — we rejected this before because [reason]. Do you still feel the same way?"
-
-The maintainer may:
-
-- **Confirm** — the new issue gets added to the existing file's "Prior requests" list, then closed
-- **Reconsider** — the out-of-scope file gets deleted or updated, and the issue proceeds through normal triage
-- **Disagree** — the issues are related but distinct, proceed with normal triage
-
-## When to write to `.out-of-scope/`
-
-Only when an **enhancement** (not a bug) is rejected as `wontfix`. The flow:
-
-1. Maintainer decides a feature request is out of scope
-2. Check if a matching `.out-of-scope/` file already exists
-3. If yes: append the new issue to the "Prior requests" list
-4. If no: create a new file with the concept name, decision, reason, and first prior request
-5. Post a comment on the issue explaining the decision and mentioning the `.out-of-scope/` file
-6. Close the issue with the `wontfix` label
-
-## Updating or removing out-of-scope files
-
-If the maintainer changes their mind about a previously rejected concept:
-
-- Delete the `.out-of-scope/` file
-- The skill does not need to reopen old issues — they're historical records
-- The new issue that triggered the reconsideration proceeds through normal triage

imported-skills/mattpocock/github-triage/SKILL.md

@@ -1,168 +0,0 @@
----
-name: github-triage
-description: Triage GitHub issues through a label-based state machine. Use when user wants to create an issue, triage issues, review incoming bugs or feature requests, prepare issues for an AFK agent, or manage issue workflow.
----
-
-# GitHub Issue Triage
-
-Triage issues in the current repo using a label-based state machine. Infer the repo from `git remote`. Use `gh` for all GitHub operations.
-
-## AI Disclaimer
-
-Every comment or issue posted to GitHub during triage **must** include the following disclaimer at the top of the comment body, before any other content:
-
-```
-> *This was generated by AI during triage.*
-```
-
-## Reference docs
-
-- [AGENT-BRIEF.md](AGENT-BRIEF.md) — how to write durable agent briefs
-- [OUT-OF-SCOPE.md](OUT-OF-SCOPE.md) — how the `.out-of-scope/` knowledge base works
-
-## Labels
-
-| Label             | Type     | Description                              |
-| ----------------- | -------- | ---------------------------------------- |
-| `bug`             | Category | Something is broken                      |
-| `enhancement`     | Category | New feature or improvement               |
-| `needs-triage`    | State    | Maintainer needs to evaluate this issue  |
-| `needs-info`      | State    | Waiting on reporter for more information |
-| `ready-for-agent` | State    | Fully specified, ready for AFK agent     |
-| `ready-for-human` | State    | Requires human implementation            |
-| `wontfix`         | State    | Will not be actioned                     |
-
-Every issue should have exactly **one** state label and **one** category label. If an issue has conflicting state labels (e.g. both `needs-triage` and `ready-for-agent`), flag the conflict and ask the maintainer which state is correct before doing anything else. Provide a recommendation.
-
-## State Machine
-
-| Current State  | Can transition to | Who triggers it        | What happens                                                                                                         |
-| -------------- | ----------------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------- |
-| `unlabeled`    | `needs-triage`    | Skill (on first look)  | Issue needs maintainer evaluation. Skill applies label after presenting recommendation.                              |
-| `unlabeled`    | `ready-for-agent` | Maintainer (via skill) | Issue is already well-specified and agent-suitable. Skill writes agent brief comment, applies label.                 |
-| `unlabeled`    | `ready-for-human` | Maintainer (via skill) | Issue requires human implementation. Skill writes a brief comment summarizing the task, applies label.               |
-| `unlabeled`    | `wontfix`         | Maintainer (via skill) | Issue is spam, duplicate, or out of scope. Skill closes with comment (and writes `.out-of-scope/` for enhancements). |
-| `needs-triage` | `needs-info`      | Maintainer (via skill) | Issue is underspecified. Skill posts triage notes capturing progress so far + questions for reporter.                |
-| `needs-triage` | `ready-for-agent` | Maintainer (via skill) | Grilling session complete, agent-suitable. Skill writes agent brief comment, applies label.                          |
-| `needs-triage` | `ready-for-human` | Maintainer (via skill) | Grilling session complete, needs human. Skill writes a brief comment summarizing the task, applies label.            |
-| `needs-triage` | `wontfix`         | Maintainer (via skill) | Maintainer decides not to action. Skill closes with comment (and writes `.out-of-scope/` for enhancements).          |
-| `needs-info`   | `needs-triage`    | Skill (detects reply)  | Reporter has replied. Skill surfaces to maintainer for re-evaluation.                                                |
-
-An issue can only move along these transitions. The maintainer can override any state directly (see Quick State Override below), but the skill should flag if the transition is unusual.
-
-## Invocation
-
-The maintainer invokes `/github-triage` then describes what they want in natural language. The skill interprets the request and takes the appropriate action.
-
-Example requests:
-
-- "Show me anything that needs my attention"
-- "Let's look at #42"
-- "Move #42 to ready-for-agent"
-- "What's ready for agents to pick up?"
-- "Are there any unlabeled issues?"
-
-## Workflow: Show What Needs Attention
-
-When the maintainer asks for an overview, query GitHub and present a summary grouped into three buckets:
-
-1. **Unlabeled issues** — new, no labels at all. These have never been triaged.
-2. **`needs-triage` issues** — maintainer needs to evaluate or continue evaluating.
-3. **`needs-info` issues with new activity** — the reporter has commented since the last triage notes comment. Check comment timestamps to determine this.
-
-Display counts per group. Within each group, show issues oldest first (longest-waiting gets attention first). For each issue, show: number, title, age, and a one-line summary of the issue body.
-
-Let the maintainer pick which issue to dive into.
-
-## Workflow: Triage a Specific Issue
-
-### Step 1: Gather context
-
-Before presenting anything to the maintainer:
-
-- Read the full issue: body, all comments, all labels, who reported it, when
-- If there are prior triage notes comments (from previous sessions), parse them to understand what has already been established
-- Explore the codebase to build context — understand the domain, relevant interfaces, and existing behavior related to the issue
-- Read `.out-of-scope/*.md` files and check if this issue matches or is similar to a previously rejected concept
-
-### Step 2: Present a recommendation
-
-Tell the maintainer:
-
-- **Category recommendation:** bug or enhancement, with reasoning
-- **State recommendation:** where this issue should go, with reasoning
-- If it matches a prior out-of-scope rejection, surface that: "This is similar to `.out-of-scope/concept-name.md` — we rejected this before because X. Do you still feel the same way?"
-- A brief summary of what you found in the codebase that's relevant
-
-Then wait for the maintainer's direction. They may:
-
-- Agree and ask you to apply labels → do it
-- Want to flesh it out → start a /domain-model session
-- Override with a different state → apply their choice
-- Want to discuss → have a conversation
-
-### Step 3: Bug reproduction (bugs only)
-
-If the issue is categorized as a bug, attempt to reproduce it before starting a /domain-model session. This will vary by codebase, but do your best:
-
-- Read the reporter's reproduction steps (if provided)
-- Explore the codebase to understand the relevant code paths
-- Try to reproduce the bug: run tests, execute commands, or trace the logic to confirm the reported behavior
-- If reproduction succeeds, report what you found to the maintainer — include the specific behavior you observed and where in the code it originates
-- If reproduction fails, report that too — the bug may be environment-specific, already fixed, or the report may be inaccurate
-- If the report lacks enough detail to attempt reproduction, note that — this is a strong signal the issue should move to `needs-info`
-
-The reproduction attempt informs the /domain-model session and the agent brief. A confirmed reproduction with a known code path makes for a much stronger brief.
-
-### Step 4: /domain-model session (if needed)
-
-If the issue needs to be fleshed out before it's ready for an agent, interview the maintainer to build a complete specification. Use the /domain-model skill.
-
-### Step 5: Apply the outcome
-
-Depending on the outcome:
-
-- **ready-for-agent** — post an agent brief comment (see [AGENT-BRIEF.md](AGENT-BRIEF.md))
-- **ready-for-human** — post a comment summarizing the task, what was established during triage, and why it needs human implementation. Use the same structure as an agent brief but note the reason it can't be delegated to an agent (e.g. requires judgment calls, external system access, design decisions, or manual testing).
-- **needs-info** — post triage notes with progress so far and questions for the reporter (see Needs Info Output below)
-- **wontfix (bug)** — post a polite comment explaining why, then close the issue
-- **wontfix (enhancement)** — write to `.out-of-scope/`, post a comment linking to it, then close the issue (see [OUT-OF-SCOPE.md](OUT-OF-SCOPE.md))
-- **needs-triage** — apply the label. Optionally leave a comment if there's partial progress to capture.
-
-## Workflow: Quick State Override
-
-When the maintainer explicitly tells you to move an issue to a specific state (e.g. "move #42 to ready-for-agent"), trust their judgment and apply the label directly.
-
-Still show a confirmation of what you're about to do: which labels will be added/removed, and whether you'll post a comment or close the issue. But skip the /domain-model session entirely.
-
-If moving to `ready-for-agent` without a /domain-model session, ask the maintainer if they want to write a brief agent brief comment or skip it.
-
-## Needs Info Output
-
-When moving an issue to `needs-info`, post a comment that captures the interview progress and tells the reporter what's needed:
-
-```markdown
-## Triage Notes
-
-**What we've established so far:**
-
-- point 1
-- point 2
-
-**What we still need from you (@reporter):**
-
-- question 1
-- question 2
-```
-
-Include everything resolved during the /domain-model session in "established so far" — this work should not be lost. The questions for the reporter should be specific and actionable, not vague ("please provide more info").
-
-## Resuming Previous Sessions
-
-When triaging an issue that already has triage notes from a previous session:
-
-1. Read all comments to find prior triage notes
-2. Parse what was already established
-3. Check if the reporter has answered any outstanding questions
-4. Present the maintainer with an updated picture: "Here's where we left off, and here's what the reporter has said since"
-5. Continue the /domain-model session from where it stopped — do not re-ask resolved questions

imported-skills/mattpocock/grill-with-docs/SKILL.md

@@ -73,7 +73,7 @@ When the user states how something works, check whether the code agrees. If you
 
 When a term is resolved, update `CONTEXT.md` right there. Don't batch these up — capture them as they happen. Use the format in [CONTEXT-FORMAT.md](./CONTEXT-FORMAT.md).
 
-Don't couple `CONTEXT.md` to implementation details. Only include terms that are meaningful to domain experts.
+`CONTEXT.md` should be totally devoid of implementation details. Do not treat `CONTEXT.md` as a spec, a scratch pad, or a repository for implementation decisions. It is a glossary and nothing else.
 
 ### Offer ADRs sparingly
 

imported-skills/mattpocock/triage-issue/SKILL.md

@@ -1,102 +0,0 @@
----
-name: triage-issue
-description: Triage a bug or issue by exploring the codebase to find root cause, then create a GitHub issue with a TDD-based fix plan. Use when user reports a bug, wants to file an issue, mentions "triage", or wants to investigate and plan a fix for a problem.
----
-
-# Triage Issue
-
-Investigate a reported problem, find its root cause, and create a GitHub issue with a TDD fix plan. This is a mostly hands-off workflow - minimize questions to the user.
-
-## Process
-
-### 1. Capture the problem
-
-Get a brief description of the issue from the user. If they haven't provided one, ask ONE question: "What's the problem you're seeing?"
-
-Do NOT ask follow-up questions yet. Start investigating immediately.
-
-### 2. Explore and diagnose
-
-Use the Agent tool with subagent_type=Explore to deeply investigate the codebase. Your goal is to find:
-
-- **Where** the bug manifests (entry points, UI, API responses)
-- **What** code path is involved (trace the flow)
-- **Why** it fails (the root cause, not just the symptom)
-- **What** related code exists (similar patterns, tests, adjacent modules)
-
-Look at:
-- Related source files and their dependencies
-- Existing tests (what's tested, what's missing)
-- Recent changes to affected files (`git log` on relevant files)
-- Error handling in the code path
-- Similar patterns elsewhere in the codebase that work correctly
-
-### 3. Identify the fix approach
-
-Based on your investigation, determine:
-
-- The minimal change needed to fix the root cause
-- Which modules/interfaces are affected
-- What behaviors need to be verified via tests
-- Whether this is a regression, missing feature, or design flaw
-
-### 4. Design TDD fix plan
-
-Create a concrete, ordered list of RED-GREEN cycles. Each cycle is one vertical slice:
-
-- **RED**: Describe a specific test that captures the broken/missing behavior
-- **GREEN**: Describe the minimal code change to make that test pass
-
-Rules:
-- Tests verify behavior through public interfaces, not implementation details
-- One test at a time, vertical slices (NOT all tests first, then all code)
-- Each test should survive internal refactors
-- Include a final refactor step if needed
-- **Durability**: Only suggest fixes that would survive radical codebase changes. Describe behaviors and contracts, not internal structure. Tests assert on observable outcomes (API responses, UI state, user-visible effects), not internal state. A good suggestion reads like a spec; a bad one reads like a diff.
-
-### 5. Create the GitHub issue
-
-Create a GitHub issue using `gh issue create` with the template below. Do NOT ask the user to review before creating - just create it and share the URL.
-
-<issue-template>
-
-## Problem
-
-A clear description of the bug or issue, including:
-- What happens (actual behavior)
-- What should happen (expected behavior)
-- How to reproduce (if applicable)
-
-## Root Cause Analysis
-
-Describe what you found during investigation:
-- The code path involved
-- Why the current code fails
-- Any contributing factors
-
-Do NOT include specific file paths, line numbers, or implementation details that couple to current code layout. Describe modules, behaviors, and contracts instead. The issue should remain useful even after major refactors.
-
-## TDD Fix Plan
-
-A numbered list of RED-GREEN cycles:
-
-1. **RED**: Write a test that [describes expected behavior]
-   **GREEN**: [Minimal change to make it pass]
-
-2. **RED**: Write a test that [describes next behavior]
-   **GREEN**: [Minimal change to make it pass]
-
-...
-
-**REFACTOR**: [Any cleanup needed after all tests pass]
-
-## Acceptance Criteria
-
-- [ ] Criterion 1
-- [ ] Criterion 2
-- [ ] All new tests pass
-- [ ] Existing tests still pass
-
-</issue-template>
-
-After creating the issue, print the issue URL and a one-line summary of the root cause.

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "claude-ctx"
-version = "1.0.5"
+version = "1.0.6"
 description = "Skill and agent recommendation system for Claude Code — knowledge graph, wiki, and intake quality gates"
 authors = [{ name = "Steve Solun" }]
 license = "MIT"

scripts/build_dashboard_graph_index.py

@@ -0,0 +1,169 @@
+#!/usr/bin/env python3
+"""Build the compact dashboard graph-neighborhood SQLite index."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sqlite3
+import zlib
+from pathlib import Path
+from typing import Any
+
+
+def _graph_edges(data: dict[str, Any]) -> list[dict[str, Any]]:
+    raw = data.get("links") if "links" in data else data.get("edges", [])
+    if not isinstance(raw, list):
+        return []
+    return [item for item in raw if isinstance(item, dict)]
+
+
+def build_dashboard_index(graph_json: Path, output: Path, *, top_k: int = 40) -> None:
+    data = json.loads(graph_json.read_text(encoding="utf-8"))
+    nodes_raw = [item for item in data.get("nodes", []) if isinstance(item, dict)]
+    edges_raw = _graph_edges(data)
+    nodes: dict[str, dict[str, Any]] = {}
+    slug_rows: list[tuple[str, str, str]] = []
+    neighbors: dict[str, list[dict[str, Any]]] = {}
+
+    for node in nodes_raw:
+        node_id = node.get("id")
+        if not isinstance(node_id, str) or not node_id:
+            continue
+        slug = node_id.split(":", 1)[-1]
+        node_type = str(node.get("type") or node_id.split(":", 1)[0])
+        raw_tags = node.get("tags")
+        tags = raw_tags if isinstance(raw_tags, list) else []
+        nodes[node_id] = {
+            "id": node_id,
+            "label": node.get("label") or slug,
+            "type": node_type,
+            "tags": tags[:8],
+            "description": node.get("description") or "",
+            "quality_score": node.get("quality_score"),
+            "usage_score": node.get("usage_score"),
+            "degree": 0,
+        }
+        slug_rows.append((slug, node_type, node_id))
+        neighbors[node_id] = []
+
+    for edge in edges_raw:
+        source = edge.get("source")
+        target = edge.get("target")
+        if not isinstance(source, str) or not isinstance(target, str):
+            continue
+        if source not in nodes or target not in nodes:
+            continue
+        weight = float(edge.get("weight", 1.0) or 0.0)
+        row = {
+            "target": target,
+            "weight": weight,
+            "shared_tags": (edge.get("shared_tags") or [])[:4],
+            "reasons": (edge.get("reasons") or edge.get("edge_reasons") or [])[:4],
+            "semantic": edge.get("semantic"),
+            "tag_sim": edge.get("tag_sim"),
+            "slug_token_sim": edge.get("slug_token_sim"),
+            "source_overlap": edge.get("source_overlap"),
+        }
+        neighbors[source].append(row)
+        reverse = dict(row)
+        reverse["target"] = source
+        neighbors[target].append(reverse)
+
+    for node_id, rows in neighbors.items():
+        rows.sort(key=lambda row: -float(row.get("weight") or 0.0))
+        nodes[node_id]["degree"] = len(rows)
+        del rows[top_k:]
+
+    output.parent.mkdir(parents=True, exist_ok=True)
+    build_path = output.with_name(f".{output.name}.{os.getpid()}.tmp")
+    if build_path.exists():
+        build_path.unlink()
+    try:
+        conn = sqlite3.connect(build_path)
+        try:
+            conn.execute("PRAGMA journal_mode=OFF")
+            conn.execute("PRAGMA synchronous=OFF")
+            conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+            conn.execute(
+                "CREATE TABLE nodes("
+                "id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,description TEXT,"
+                "quality_score REAL,usage_score REAL,degree INTEGER)"
+            )
+            conn.execute(
+                "CREATE TABLE slug_index("
+                "slug TEXT,type TEXT,node_id TEXT,PRIMARY KEY(slug,type,node_id))"
+            )
+            conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+            meta = {
+                "version": 1,
+                "export_id": data.get("graph", {}).get("export_id"),
+                "nodes_count": len(nodes),
+                "edges_count": len(edges_raw),
+                "max_degree": max((int(node["degree"]) for node in nodes.values()), default=1),
+                "top_k": top_k,
+            }
+            conn.executemany(
+                "INSERT INTO meta(key,value) VALUES(?,?)",
+                [(key, json.dumps(value)) for key, value in meta.items()],
+            )
+            conn.executemany(
+                "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+                [
+                    (
+                        node["id"],
+                        node["label"],
+                        node["type"],
+                        json.dumps(node["tags"], separators=(",", ":")),
+                        node["description"],
+                        node["quality_score"],
+                        node["usage_score"],
+                        node["degree"],
+                    )
+                    for node in nodes.values()
+                ],
+            )
+            conn.executemany("INSERT OR IGNORE INTO slug_index VALUES(?,?,?)", slug_rows)
+            neighbor_rows = []
+            for source, rows in neighbors.items():
+                slim = [
+                    {
+                        key: value
+                        for key, value in row.items()
+                        if value not in (None, [], "")
+                    }
+                    for row in rows
+                ]
+                payload = zlib.compress(
+                    json.dumps(slim, separators=(",", ":")).encode("utf-8"),
+                    level=6,
+                )
+                neighbor_rows.append((source, payload))
+                if len(neighbor_rows) >= 10_000:
+                    conn.executemany("INSERT INTO neighbors VALUES(?,?)", neighbor_rows)
+                    neighbor_rows.clear()
+            if neighbor_rows:
+                conn.executemany("INSERT INTO neighbors VALUES(?,?)", neighbor_rows)
+            conn.execute("CREATE INDEX idx_slug_index_slug ON slug_index(slug)")
+            conn.commit()
+            conn.execute("VACUUM")
+        finally:
+            conn.close()
+        os.replace(build_path, output)
+    finally:
+        if build_path.exists():
+            build_path.unlink()
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--graph-json", type=Path, required=True)
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--top-k", type=int, default=40)
+    args = parser.parse_args()
+    build_dashboard_index(args.graph_json, args.output, top_k=args.top_k)
+
+
+if __name__ == "__main__":
+    main()

src/__init__.py

@@ -1,3 +1,3 @@
 """ctx — skill and agent recommendation for Claude Code."""
 
-__version__ = "1.0.5"
+__version__ = "1.0.6"

src/ctx/__init__.py

@@ -30,7 +30,7 @@ Package layout:
     ctx.utils      - low-level primitives (safe names, atomic IO)
 """
 
-__version__ = "1.0.5"
+__version__ = "1.0.6"
 
 
 # Public library surface — anything listed here is safe for third-

src/ctx/core/graph/resolve_graph.py

@@ -230,7 +230,11 @@ def _apply_entity_overlays(G: nx.Graph, graph_path: Path) -> nx.Graph:
     return G
 
 
-def load_graph(path: Path | None = None) -> nx.Graph:
+def load_graph(
+    path: Path | None = None,
+    *,
+    apply_runtime_filter: bool = True,
+) -> nx.Graph:
     """Load the knowledge graph from graph.json.
 
     Returns an empty graph on any parse or schema error rather than crashing.
@@ -260,7 +264,9 @@ def load_graph(path: Path | None = None) -> nx.Graph:
         graph = node_link_graph(data, edges=edges_key)
         graph.graph.setdefault("ctx_graph_path", str(graph_path))
         graph = _apply_entity_overlays(graph, graph_path)
-        return _filter_runtime_edges(graph, _configured_semantic_min_cosine())
+        if apply_runtime_filter:
+            return _filter_runtime_edges(graph, _configured_semantic_min_cosine())
+        return graph
     except json.JSONDecodeError as exc:
         logger.warning("graph.json is not valid JSON (%s); returning empty graph", exc)
     except UnicodeDecodeError as exc:

src/ctx/core/source_registry.py

@@ -1,228 +1,228 @@
-"""External source registry and license gate for graph/wiki ingestion."""
-
-from __future__ import annotations
-
-import argparse
-import json
-from dataclasses import asdict, dataclass
-from pathlib import Path
-from typing import Any, Iterable
-
-PERMISSIVE_LICENSES = {
-    "apache-2.0",
-    "bsd-2-clause",
-    "bsd-3-clause",
-    "cc-by-4.0",
-    "cc0-1.0",
-    "isc",
-    "mit",
-    "mpl-2.0",
-    "unlicense",
-}
-FULL_IMPORT_MODES = {"full", "full-body"}
-SAFE_IMPORT_MODES = {"external-link", "metadata-only"}
-ALLOWED_IMPORT_MODES = FULL_IMPORT_MODES | SAFE_IMPORT_MODES
-EXPLICIT_PERMISSION_STATUSES = {"explicit-permission", "owner-permission"}
-
-
-class LicenseGateError(ValueError):
-    """Raised when a source cannot be imported with the requested mode."""
-
-
-@dataclass(frozen=True)
-class ExternalSourceRecord:
-    name: str
-    url: str
-    revision: str
-    license: str
-    source_kind: str
-    import_mode: str
-    permission_status: str
-    permission_reference: str | None = None
-    notes: str | None = None
-
-    @classmethod
-    def from_mapping(cls, raw: dict[str, Any]) -> "ExternalSourceRecord":
-        required = (
-            "name",
-            "url",
-            "revision",
-            "license",
-            "source_kind",
-            "import_mode",
-            "permission_status",
-        )
-        missing = [field for field in required if not str(raw.get(field) or "").strip()]
-        if missing:
-            raise ValueError(f"source record missing required field(s): {', '.join(missing)}")
-        return cls(
-            name=_string(raw["name"], "name"),
-            url=_string(raw["url"], "url"),
-            revision=_string(raw["revision"], "revision"),
-            license=_string(raw["license"], "license"),
-            source_kind=_string(raw["source_kind"], "source_kind"),
-            import_mode=_string(raw["import_mode"], "import_mode"),
-            permission_status=_string(raw["permission_status"], "permission_status"),
-            permission_reference=_optional_string(raw.get("permission_reference")),
-            notes=_optional_string(raw.get("notes")),
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        return {key: value for key, value in asdict(self).items() if value is not None}
-
-
-BUILTIN_EXTERNAL_SOURCES: tuple[ExternalSourceRecord, ...] = (
-    ExternalSourceRecord(
-        name="mattpocock-skills",
-        url="https://github.com/mattpocock/skills",
-        revision="f304057d61d3df3c9fd992ac2b6e3833cb9325fb",
-        license="MIT",
-        source_kind="skill-suite",
-        import_mode="full",
-        permission_status="license",
-    ),
-    ExternalSourceRecord(
-        name="academic-research-skills",
-        url="https://github.com/Imbad0202/academic-research-skills",
-        revision="153203d129b1d0e83dd65ab96340048257cd45b2",
-        license="CC BY-NC 4.0",
-        source_kind="skill-suite",
-        import_mode="metadata-only",
-        permission_status="license",
-        notes="Full-body import requires explicit noncommercial-license permission.",
-    ),
-    ExternalSourceRecord(
-        name="agents-md",
-        url="https://github.com/agentsmd/agents.md",
-        revision="d1ac7f063d20e70015ed6732664049ae4ba9d74e",
-        license="MIT",
-        source_kind="knowledge-protocol",
-        import_mode="metadata-only",
-        permission_status="license",
-    ),
-    ExternalSourceRecord(
-        name="lat-md",
-        url="https://github.com/1st1/lat.md",
-        revision="bf8d95ca7ece6e1a9e4a325eddb51ddd5db038b0",
-        license="MIT",
-        source_kind="knowledge-protocol",
-        import_mode="metadata-only",
-        permission_status="license",
-    ),
-    ExternalSourceRecord(
-        name="optillm",
-        url="https://github.com/algorithmicsuperintelligence/optillm",
-        revision="df018d64db96d07fdd338d71a35fc567f9d50c7b",
-        license="Apache-2.0",
-        source_kind="harness",
-        import_mode="metadata-only",
-        permission_status="license",
-    ),
-    ExternalSourceRecord(
-        name="julius-caveman",
-        url="https://github.com/JuliusBrussee/caveman",
-        revision="63a91ecadbf4c4719a4602a5abb00883f9966034",
-        license="MIT",
-        source_kind="skill-suite",
-        import_mode="full",
-        permission_status="license",
-    ),
-)
-
-
-def _string(value: object, field: str) -> str:
-    if not isinstance(value, str) or not value.strip():
-        raise ValueError(f"{field}: expected non-empty string")
-    return value.strip()
-
-
-def _optional_string(value: object) -> str | None:
-    if value is None:
-        return None
-    if not isinstance(value, str):
-        raise ValueError("optional string field must be a string when set")
-    return value.strip() or None
-
-
-def _normalize_license(value: str) -> str:
-    return (
-        value.lower()
-        .replace("_", "-")
-        .replace(" ", "-")
-        .replace("license", "")
-        .strip("-")
-    )
-
-
-def _license_block_reason(record: ExternalSourceRecord) -> str | None:
-    license_norm = _normalize_license(record.license)
-    if license_norm in PERMISSIVE_LICENSES:
-        return None
-    if "noncommercial" in license_norm or "-nc" in license_norm:
-        return "non-commercial license"
-    if "unknown" in license_norm or "no-explicit" in license_norm:
-        return "unknown license"
-    if "gpl" in license_norm or "agpl" in license_norm or "lgpl" in license_norm:
-        return "copyleft license"
-    return f"unapproved license {record.license!r}"
-
-
-def validate_import_plan(record: ExternalSourceRecord) -> ExternalSourceRecord:
-    """Validate whether a source may be imported into shipped graph/wiki artifacts."""
-
-    import_mode = record.import_mode.strip().lower()
-    if import_mode not in ALLOWED_IMPORT_MODES:
-        raise ValueError(
-            f"{record.name}: import_mode must be one of {sorted(ALLOWED_IMPORT_MODES)}",
-        )
-    if import_mode in SAFE_IMPORT_MODES:
-        return record
-
-    reason = _license_block_reason(record)
-    if reason is None:
-        return record
-
-    has_permission = record.permission_status in EXPLICIT_PERMISSION_STATUSES
-    has_reference = bool(record.permission_reference)
-    if has_permission and has_reference:
-        return record
-
-    raise LicenseGateError(
-        f"{record.name}: full-body import blocked by {reason}; use metadata-only "
-        "or record explicit permission with permission_reference.",
-    )
-
-
-def load_source_registry(path: Path) -> list[ExternalSourceRecord]:
-    raw = json.loads(path.read_text(encoding="utf-8"))
-    records_raw: Iterable[Any]
-    if isinstance(raw, dict):
-        records_raw = raw.get("sources", [])
-    else:
-        records_raw = raw
-    if not isinstance(records_raw, list):
-        raise ValueError("source registry must be a list or an object with a sources list")
-    records = [ExternalSourceRecord.from_mapping(item) for item in records_raw]
-    for record in records:
-        validate_import_plan(record)
-    return records
-
-
-def main(argv: list[str] | None = None) -> None:
-    parser = argparse.ArgumentParser(description="Validate ctx external source import policy.")
-    parser.add_argument("--registry", type=Path, help="Optional JSON registry path.")
-    parser.add_argument("--json", action="store_true", help="Emit records as JSON.")
-    args = parser.parse_args(argv)
-
-    records = load_source_registry(args.registry) if args.registry else list(BUILTIN_EXTERNAL_SOURCES)
-    for record in records:
-        validate_import_plan(record)
-
-    if args.json:
-        print(json.dumps({"sources": [record.to_dict() for record in records]}, indent=2))
-    else:
-        print(f"Validated {len(records)} external source record(s).")
-
-
-if __name__ == "__main__":
-    main()
+"""External source registry and license gate for graph/wiki ingestion."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Iterable
+
+PERMISSIVE_LICENSES = {
+    "apache-2.0",
+    "bsd-2-clause",
+    "bsd-3-clause",
+    "cc-by-4.0",
+    "cc0-1.0",
+    "isc",
+    "mit",
+    "mpl-2.0",
+    "unlicense",
+}
+FULL_IMPORT_MODES = {"full", "full-body"}
+SAFE_IMPORT_MODES = {"external-link", "metadata-only"}
+ALLOWED_IMPORT_MODES = FULL_IMPORT_MODES | SAFE_IMPORT_MODES
+EXPLICIT_PERMISSION_STATUSES = {"explicit-permission", "owner-permission"}
+
+
+class LicenseGateError(ValueError):
+    """Raised when a source cannot be imported with the requested mode."""
+
+
+@dataclass(frozen=True)
+class ExternalSourceRecord:
+    name: str
+    url: str
+    revision: str
+    license: str
+    source_kind: str
+    import_mode: str
+    permission_status: str
+    permission_reference: str | None = None
+    notes: str | None = None
+
+    @classmethod
+    def from_mapping(cls, raw: dict[str, Any]) -> "ExternalSourceRecord":
+        required = (
+            "name",
+            "url",
+            "revision",
+            "license",
+            "source_kind",
+            "import_mode",
+            "permission_status",
+        )
+        missing = [field for field in required if not str(raw.get(field) or "").strip()]
+        if missing:
+            raise ValueError(f"source record missing required field(s): {', '.join(missing)}")
+        return cls(
+            name=_string(raw["name"], "name"),
+            url=_string(raw["url"], "url"),
+            revision=_string(raw["revision"], "revision"),
+            license=_string(raw["license"], "license"),
+            source_kind=_string(raw["source_kind"], "source_kind"),
+            import_mode=_string(raw["import_mode"], "import_mode"),
+            permission_status=_string(raw["permission_status"], "permission_status"),
+            permission_reference=_optional_string(raw.get("permission_reference")),
+            notes=_optional_string(raw.get("notes")),
+        )
+
+    def to_dict(self) -> dict[str, Any]:
+        return {key: value for key, value in asdict(self).items() if value is not None}
+
+
+BUILTIN_EXTERNAL_SOURCES: tuple[ExternalSourceRecord, ...] = (
+    ExternalSourceRecord(
+        name="mattpocock-skills",
+        url="https://github.com/mattpocock/skills",
+        revision="e74f0061bb67222181640effa98c675bdb2fdaa7",
+        license="MIT",
+        source_kind="skill-suite",
+        import_mode="full",
+        permission_status="license",
+    ),
+    ExternalSourceRecord(
+        name="academic-research-skills",
+        url="https://github.com/Imbad0202/academic-research-skills",
+        revision="153203d129b1d0e83dd65ab96340048257cd45b2",
+        license="CC BY-NC 4.0",
+        source_kind="skill-suite",
+        import_mode="metadata-only",
+        permission_status="license",
+        notes="Full-body import requires explicit noncommercial-license permission.",
+    ),
+    ExternalSourceRecord(
+        name="agents-md",
+        url="https://github.com/agentsmd/agents.md",
+        revision="d1ac7f063d20e70015ed6732664049ae4ba9d74e",
+        license="MIT",
+        source_kind="knowledge-protocol",
+        import_mode="metadata-only",
+        permission_status="license",
+    ),
+    ExternalSourceRecord(
+        name="lat-md",
+        url="https://github.com/1st1/lat.md",
+        revision="bf8d95ca7ece6e1a9e4a325eddb51ddd5db038b0",
+        license="MIT",
+        source_kind="knowledge-protocol",
+        import_mode="metadata-only",
+        permission_status="license",
+    ),
+    ExternalSourceRecord(
+        name="optillm",
+        url="https://github.com/algorithmicsuperintelligence/optillm",
+        revision="df018d64db96d07fdd338d71a35fc567f9d50c7b",
+        license="Apache-2.0",
+        source_kind="harness",
+        import_mode="metadata-only",
+        permission_status="license",
+    ),
+    ExternalSourceRecord(
+        name="julius-caveman",
+        url="https://github.com/JuliusBrussee/caveman",
+        revision="63a91ecadbf4c4719a4602a5abb00883f9966034",
+        license="MIT",
+        source_kind="skill-suite",
+        import_mode="full",
+        permission_status="license",
+    ),
+)
+
+
+def _string(value: object, field: str) -> str:
+    if not isinstance(value, str) or not value.strip():
+        raise ValueError(f"{field}: expected non-empty string")
+    return value.strip()
+
+
+def _optional_string(value: object) -> str | None:
+    if value is None:
+        return None
+    if not isinstance(value, str):
+        raise ValueError("optional string field must be a string when set")
+    return value.strip() or None
+
+
+def _normalize_license(value: str) -> str:
+    return (
+        value.lower()
+        .replace("_", "-")
+        .replace(" ", "-")
+        .replace("license", "")
+        .strip("-")
+    )
+
+
+def _license_block_reason(record: ExternalSourceRecord) -> str | None:
+    license_norm = _normalize_license(record.license)
+    if license_norm in PERMISSIVE_LICENSES:
+        return None
+    if "noncommercial" in license_norm or "-nc" in license_norm:
+        return "non-commercial license"
+    if "unknown" in license_norm or "no-explicit" in license_norm:
+        return "unknown license"
+    if "gpl" in license_norm or "agpl" in license_norm or "lgpl" in license_norm:
+        return "copyleft license"
+    return f"unapproved license {record.license!r}"
+
+
+def validate_import_plan(record: ExternalSourceRecord) -> ExternalSourceRecord:
+    """Validate whether a source may be imported into shipped graph/wiki artifacts."""
+
+    import_mode = record.import_mode.strip().lower()
+    if import_mode not in ALLOWED_IMPORT_MODES:
+        raise ValueError(
+            f"{record.name}: import_mode must be one of {sorted(ALLOWED_IMPORT_MODES)}",
+        )
+    if import_mode in SAFE_IMPORT_MODES:
+        return record
+
+    reason = _license_block_reason(record)
+    if reason is None:
+        return record
+
+    has_permission = record.permission_status in EXPLICIT_PERMISSION_STATUSES
+    has_reference = bool(record.permission_reference)
+    if has_permission and has_reference:
+        return record
+
+    raise LicenseGateError(
+        f"{record.name}: full-body import blocked by {reason}; use metadata-only "
+        "or record explicit permission with permission_reference.",
+    )
+
+
+def load_source_registry(path: Path) -> list[ExternalSourceRecord]:
+    raw = json.loads(path.read_text(encoding="utf-8"))
+    records_raw: Iterable[Any]
+    if isinstance(raw, dict):
+        records_raw = raw.get("sources", [])
+    else:
+        records_raw = raw
+    if not isinstance(records_raw, list):
+        raise ValueError("source registry must be a list or an object with a sources list")
+    records = [ExternalSourceRecord.from_mapping(item) for item in records_raw]
+    for record in records:
+        validate_import_plan(record)
+    return records
+
+
+def main(argv: list[str] | None = None) -> None:
+    parser = argparse.ArgumentParser(description="Validate ctx external source import policy.")
+    parser.add_argument("--registry", type=Path, help="Optional JSON registry path.")
+    parser.add_argument("--json", action="store_true", help="Emit records as JSON.")
+    args = parser.parse_args(argv)
+
+    records = load_source_registry(args.registry) if args.registry else list(BUILTIN_EXTERNAL_SOURCES)
+    for record in records:
+        validate_import_plan(record)
+
+    if args.json:
+        print(json.dumps({"sources": [record.to_dict() for record in records]}, indent=2))
+    else:
+        print(f"Validated {len(records)} external source record(s).")
+
+
+if __name__ == "__main__":
+    main()

src/ctx/core/wiki/wiki_queue_worker.py

@@ -124,12 +124,22 @@ def _process_job(wiki_path: Path, job: wiki_queue.QueueJob) -> str:
 def _process_entity_upsert(wiki_path: Path, payload: dict[str, Any]) -> str:
     entity_type = _required_string(payload, "entity_type")
     slug = _required_string(payload, "slug")
+    action = str(payload.get("action", "upsert")).strip() or "upsert"
     expected_hash = _required_string(payload, "content_hash")
     subject_type = _ENTITY_SUBJECT_TYPES.get(entity_type)
     if subject_type is None:
         raise ValueError(f"unsupported entity_type for entity-upsert: {entity_type}")
 
     entity_path = _resolve_entity_path(wiki_path, _required_string(payload, "entity_path"))
+    if action == "delete":
+        wiki_queue.enqueue_maintenance_job(
+            wiki_path,
+            kind=wiki_queue.GRAPH_EXPORT_JOB,
+            payload={"graph_only": True, "incremental": False},
+            source="entity-delete",
+        )
+        return f"queued full graph refresh for deleted {subject_type} entity {slug}"
+
     text = entity_path.read_text(encoding="utf-8")
     actual_hash = sha256(text.encode("utf-8")).hexdigest()
     if actual_hash != expected_hash:

src/ctx_init.py

@@ -26,8 +26,9 @@ What it does:
      ``~/.claude/settings.json``.
   6. Optionally: installs the initial graph/wiki archive if missing.
      Skipped unless the wizard or ``--graph`` asks for it. Source
-     checkouts use ``graph/wiki-graph.tar.gz``; pip installs download
-     the matching release asset.
+     checkouts use ``graph/wiki-graph-runtime.tar.gz`` by default and
+     fall back to the full ``graph/wiki-graph.tar.gz`` archive; pip installs
+     download the matching release asset.
 
 Idempotent: re-running only writes what's missing. Never overwrites
 a user's config or hook settings without an explicit ``--force`` flag.
@@ -41,11 +42,13 @@ import json
 import os
 import re
 import shutil
+import sqlite3
 import subprocess
 import sys
 import tarfile
 import tempfile
 import urllib.request
+import zlib
 from dataclasses import dataclass
 from importlib.metadata import PackageNotFoundError, version as package_version
 from pathlib import Path
@@ -223,8 +226,8 @@ _GRAPH_ARCHIVE_NAMES = {
     "full": _GRAPH_ARCHIVE_NAME,
 }
 _GRAPH_ARCHIVE_SHA256 = {
-    "runtime": "84634152dea0f7c8881bc717eaefcce5bfe1b97c4cee90b3202a2ee48b95dd8c",
-    "full": "a3968445d6ef9a27d5a684d30019b5730e9c40c62ba7fcd1b66e8567baa756b6",
+    "runtime": "27cd757cabaf7209d864b460d14b0755e258cc9bcf93581cacf987e1a7ef1e21",
+    "full": "57974831189e6fa6c828f3dc2b6b54ebff50879dcc301ed749d20fa9cc495414",
 }
 _GRAPH_RELEASE_URL = (
     "https://github.com/stevesolun/ctx/releases/download/"
@@ -237,6 +240,7 @@ _GRAPH_REQUIRED_FILES = frozenset({
     "graphify-out/communities.json",
     "graphify-out/graph-report.md",
     "graphify-out/graph-export-manifest.json",
+    "graphify-out/dashboard-neighborhoods.sqlite3",
     "external-catalogs/skills-sh/catalog.json",
 })
 _GRAPH_MANAGED_PATHS = (
@@ -302,7 +306,7 @@ def build_graph(
         return 0
 
     temp_dir: tempfile.TemporaryDirectory[str] | None = None
-    archive = _find_local_graph_archive(install_mode)
+    archive = None if graph_url is not None else _find_local_graph_archive(install_mode)
     try:
         if archive is None:
             temp_dir = tempfile.TemporaryDirectory(prefix="ctx-graph-download-")
@@ -317,6 +321,7 @@ def build_graph(
             print(f"Downloading pre-built graph from {url}")
             _download_graph_archive(archive, url=url, expected_sha256=expected_sha256)
         else:
+            _verify_local_graph_archive(archive, requested_install_mode=install_mode)
             print(f"Installing pre-built graph from {archive}")
         _extract_graph_archive(archive, wiki_dir, install_mode=install_mode)
         _install_graph_entity_overlay(
@@ -475,6 +480,25 @@ def _expected_graph_archive_sha256(
     )
 
 
+def _verify_local_graph_archive(archive: Path, *, requested_install_mode: str) -> None:
+    archive_mode = (
+        "full" if archive.name == _GRAPH_ARCHIVE_NAME else requested_install_mode
+    )
+    expected = _GRAPH_ARCHIVE_SHA256.get(archive_mode)
+    if expected is None:
+        return
+    hasher = hashlib.sha256()
+    with archive.open("rb") as fh:
+        while chunk := fh.read(1024 * 1024):
+            hasher.update(chunk)
+    actual = hasher.hexdigest()
+    if actual.lower() != expected.lower():
+        raise ValueError(
+            "local graph archive checksum mismatch: "
+            f"{archive} expected {expected.lower()} got {actual.lower()}"
+        )
+
+
 def _package_version() -> str:
     try:
         return package_version("claude-ctx")
@@ -610,6 +634,10 @@ def _validate_graph_install_tree(wiki_dir: Path) -> None:
     }
     if not isinstance(artifacts, dict) or artifacts != expected_artifacts:
         raise ValueError("graph export manifest artifacts map is incomplete")
+    _validate_dashboard_index_file(
+        wiki_dir / "graphify-out" / "dashboard-neighborhoods.sqlite3",
+        expected_export_id=export_id.strip(),
+    )
 
 
 def _validate_graph_json_outline(path: Path) -> None:
@@ -635,6 +663,50 @@ def _validate_graph_json_outline(path: Path) -> None:
         raise ValueError("graphify-out/graph.json is missing an edges/links list")
 
 
+def _validate_dashboard_index_file(path: Path, *, expected_export_id: str) -> None:
+    try:
+        conn = sqlite3.connect(f"file:{path.as_posix()}?mode=ro", uri=True)
+        conn.row_factory = sqlite3.Row
+    except sqlite3.Error as exc:
+        raise ValueError(f"dashboard-neighborhoods.sqlite3 is not valid SQLite: {exc}") from exc
+    try:
+        quick = conn.execute("PRAGMA quick_check").fetchone()
+        if quick is None or str(quick[0]).lower() != "ok":
+            raise ValueError("dashboard-neighborhoods.sqlite3 failed quick_check")
+        tables = {
+            str(row["name"])
+            for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")
+        }
+        required = {"meta", "nodes", "slug_index", "neighbors"}
+        missing = sorted(required - tables)
+        if missing:
+            raise ValueError(f"dashboard-neighborhoods.sqlite3 missing tables: {missing}")
+        meta = {
+            str(row["key"]): json.loads(str(row["value"]))
+            for row in conn.execute("SELECT key,value FROM meta")
+        }
+        if meta.get("export_id") != expected_export_id:
+            raise ValueError(
+                "dashboard-neighborhoods.sqlite3 export_id mismatch: "
+                f"expected {expected_export_id}, got {meta.get('export_id') or 'missing'}",
+            )
+        nodes_count = int(meta.get("nodes_count") or 0)
+        actual_nodes = int(conn.execute("SELECT COUNT(*) FROM nodes").fetchone()[0])
+        if nodes_count != actual_nodes:
+            raise ValueError("dashboard-neighborhoods.sqlite3 nodes_count mismatch")
+        payload = conn.execute("SELECT payload FROM neighbors LIMIT 1").fetchone()
+        if payload is not None:
+            decoded = json.loads(zlib.decompress(payload["payload"]).decode("utf-8"))
+            if not isinstance(decoded, list):
+                raise ValueError("dashboard-neighborhoods.sqlite3 neighbor payload is invalid")
+    except (sqlite3.Error, json.JSONDecodeError, TypeError, ValueError, zlib.error) as exc:
+        if isinstance(exc, ValueError):
+            raise
+        raise ValueError(f"dashboard-neighborhoods.sqlite3 validation failed: {exc}") from exc
+    finally:
+        conn.close()
+
+
 def _read_json_file(path: Path) -> Any:
     with path.open("r", encoding="utf-8") as f:
         return json.load(f)

src/ctx_monitor.py

@@ -64,9 +64,12 @@ import math
 import os
 import re
 import secrets
+import sqlite3
 import sys
+import tarfile
 import threading
 import time
+import zlib
 from collections import defaultdict, deque
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path, PurePosixPath
@@ -90,6 +93,7 @@ _SIDECAR_INDEX_CACHE_VALUE: dict[tuple[str, str], dict] | None = None
 _WIKI_INDEX_LIMIT_PER_TYPE = 500
 _GRAPH_REPORT_RE = re.compile(r"Nodes:\s*([\d,]+)\s*\|\s*Edges:\s*([\d,]+)")
 _MAX_POST_BODY_BYTES = 64 * 1024
+_DASHBOARD_INDEX_MEMBER = "graphify-out/dashboard-neighborhoods.sqlite3"
 
 
 # ─── Data sources ────────────────────────────────────────────────────────────
@@ -163,7 +167,10 @@ def _load_dashboard_graph() -> Any:
     if _GRAPH_CACHE_KEY == cache_key and _GRAPH_CACHE_VALUE is not None:
         return _GRAPH_CACHE_VALUE
 
-    graph = _lg(graph_path)
+    try:
+        graph = _lg(graph_path, apply_runtime_filter=False)
+    except TypeError:
+        graph = _lg(graph_path)
     _GRAPH_CACHE_KEY = cache_key
     _GRAPH_CACHE_VALUE = graph
     return graph
@@ -437,6 +444,8 @@ def _queue_entity_refresh(
         action=action,
         source="ctx-monitor",
     )
+    if action == "delete":
+        return
     wiki_queue.enqueue_maintenance_job(
         wiki,
         kind=wiki_queue.GRAPH_EXPORT_JOB,
@@ -455,6 +464,21 @@ def _upsert_wiki_entity(payload: dict[str, Any]) -> tuple[bool, str]:
             if isinstance(existing_detail, dict)
             else None
         )
+        confirm_update = str(payload.get("confirm_update", "")).strip().lower() in {
+            "1",
+            "true",
+            "yes",
+            "y",
+            "on",
+        }
+        if existing_detail is not None and not confirm_update:
+            return (
+                False,
+                f"existing {requested_type}:{requested_slug} found; review before "
+                "replacing. Benefit: keeps the catalog current. Risk: a lower-quality "
+                "manual edit can degrade recommendations. Resubmit with "
+                "confirm_update=true to apply.",
+            )
         slug, entity_type, content = _entity_content_from_payload(
             payload,
             existing=existing_meta if isinstance(existing_meta, dict) else None,
@@ -845,8 +869,8 @@ def _render_entity_subgraph_svg(
             ),
         })
 
-    nodes_json = json.dumps(node_payload)
-    edges_json = json.dumps(edge_payload)
+    nodes_json = _json_for_script(node_payload)
+    edges_json = _json_for_script(edge_payload)
 
     return (
         "<div data-testid='entity-subgraph-graph' "
@@ -1566,6 +1590,11 @@ def _sidecar_files() -> list[Path]:
 
 def _sidecar_index_cache_key() -> tuple[tuple[Path, float, int], ...]:
     keys: list[tuple[Path, float, int]] = []
+    for path in _sidecar_files():
+        stat = path.stat()
+        keys.append((path.resolve(), stat.st_mtime, stat.st_size))
+    if keys:
+        return tuple(keys)
     for root in (_sidecar_dir(), _sidecar_dir() / "mcp"):
         if not root.is_dir():
             continue
@@ -1595,12 +1624,7 @@ def _sidecar_index() -> dict[tuple[str, str], dict]:
 
 
 def _all_sidecars() -> list[dict]:
-    out: list[dict] = []
-    for p in _sidecar_files():
-        sidecar = _read_sidecar_file(p)
-        if sidecar is not None:
-            out.append(sidecar)
-    return out
+    return list(_sidecar_index().values())
 
 
 # ─── Aggregations ────────────────────────────────────────────────────────────
@@ -1726,6 +1750,11 @@ def _grade_distribution() -> dict[str, int]:
     return dist
 
 
+def _grade_distribution_payload() -> dict[str, Any]:
+    grades = _grade_distribution()
+    return {"grades": grades, "total": sum(grades.values())}
+
+
 def _session_detail(session_id: str) -> dict:
     audit = _read_jsonl(_audit_log_path())
     events = _read_jsonl(_events_jsonl_path())
@@ -2257,6 +2286,407 @@ def _graph_node_size(
     }
 
 
+def _dashboard_graph_index_path() -> Path:
+    return _wiki_dir() / "graphify-out" / "dashboard-neighborhoods.sqlite3"
+
+
+def _dashboard_graph_manifest_export_id() -> str | None:
+    manifest_path = _wiki_dir() / "graphify-out" / "graph-export-manifest.json"
+    try:
+        data = json.loads(manifest_path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+    export_id = data.get("export_id") if isinstance(data, dict) else None
+    if not isinstance(export_id, str) or not export_id.strip():
+        return None
+    return export_id.strip()
+
+
+def _dashboard_index_meta(index_path: Path) -> dict[str, Any] | None:
+    try:
+        conn = sqlite3.connect(f"file:{index_path.as_posix()}?mode=ro", uri=True)
+    except sqlite3.Error:
+        return None
+    try:
+        rows = conn.execute("SELECT key,value FROM meta").fetchall()
+    except sqlite3.Error:
+        return None
+    finally:
+        conn.close()
+    try:
+        return {str(key): json.loads(str(value)) for key, value in rows}
+    except (TypeError, ValueError, json.JSONDecodeError):
+        return None
+
+
+def _dashboard_index_matches_manifest(index_path: Path) -> bool:
+    manifest_export_id = _dashboard_graph_manifest_export_id()
+    if manifest_export_id is None:
+        return False
+    meta = _dashboard_index_meta(index_path)
+    if meta is None:
+        return False
+    return meta.get("export_id") == manifest_export_id
+
+
+def _dashboard_graph_has_runtime_overlays() -> bool:
+    overlay = _wiki_dir() / "graphify-out" / "entity-overlays.jsonl"
+    try:
+        return overlay.is_file() and overlay.stat().st_size > 0
+    except OSError:
+        return False
+
+
+def _dashboard_graph_index_archives() -> list[Path]:
+    module_root = Path(__file__).resolve().parent.parent
+    roots = (module_root,)
+    names = ("wiki-graph-runtime.tar.gz", "wiki-graph.tar.gz")
+    seen: set[Path] = set()
+    archives: list[Path] = []
+    for root in roots:
+        for name in names:
+            candidate = (root / "graph" / name).resolve()
+            if candidate in seen:
+                continue
+            seen.add(candidate)
+            if candidate.is_file():
+                archives.append(candidate)
+    return archives
+
+
+def _archive_graph_export_id(archive: Path) -> str | None:
+    try:
+        with tarfile.open(archive, "r:gz") as tar:
+            try:
+                member = tar.getmember("./graphify-out/graph-export-manifest.json")
+            except KeyError:
+                member = tar.getmember("graphify-out/graph-export-manifest.json")
+            source = tar.extractfile(member)
+            if source is None:
+                return None
+            try:
+                data = json.loads(source.read().decode("utf-8", errors="replace"))
+            finally:
+                source.close()
+    except (KeyError, OSError, tarfile.TarError, json.JSONDecodeError):
+        return None
+    export_id = data.get("export_id") if isinstance(data, dict) else None
+    return export_id.strip() if isinstance(export_id, str) and export_id.strip() else None
+
+
+def _ensure_dashboard_graph_index() -> Path | None:
+    target = _dashboard_graph_index_path()
+    if target.is_file():
+        if _dashboard_index_matches_manifest(target):
+            return target
+        try:
+            target.unlink()
+        except OSError:
+            return None
+    if (_wiki_dir() / "graphify-out" / "graph-report.md").is_file():
+        return None
+
+    archives = _dashboard_graph_index_archives()
+    if not archives:
+        return None
+    if _dashboard_graph_manifest_export_id() is None:
+        return None
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        with file_lock(target):
+            if target.is_file():
+                if _dashboard_index_matches_manifest(target):
+                    return target
+                try:
+                    target.unlink()
+                except OSError:
+                    return None
+            for archive in archives:
+                archive_export_id = _archive_graph_export_id(archive)
+                manifest_export_id = _dashboard_graph_manifest_export_id()
+                if manifest_export_id and archive_export_id and archive_export_id != manifest_export_id:
+                    continue
+                try:
+                    with tarfile.open(archive, "r:gz") as tar:
+                        try:
+                            member = tar.getmember(f"./{_DASHBOARD_INDEX_MEMBER}")
+                        except KeyError:
+                            member = tar.getmember(_DASHBOARD_INDEX_MEMBER)
+                        if not member.isfile():
+                            continue
+                        source = tar.extractfile(member)
+                        if source is None:
+                            continue
+                        tmp = target.with_name(f".{target.name}.{os.getpid()}.tmp")
+                        try:
+                            with tmp.open("wb") as out:
+                                for chunk in iter(lambda: source.read(1024 * 1024), b""):
+                                    out.write(chunk)
+                            if not _dashboard_index_matches_manifest(tmp):
+                                continue
+                            os.replace(tmp, target)
+                            return target
+                        finally:
+                            source.close()
+                            if tmp.exists():
+                                tmp.unlink()
+                except (KeyError, OSError, tarfile.TarError):
+                    continue
+    except TimeoutError:
+        return None
+    return target if target.is_file() else None
+
+
+def _index_node_size(
+    *,
+    slug: str,
+    entity_type: str,
+    quality: Any,
+    usage: Any,
+    degree: int,
+    max_degree: int,
+) -> dict[str, Any]:
+    quality_value = _unit_score(quality)
+    usage_value = _unit_score(usage)
+    if quality_value is None or usage_value is None:
+        sidecar_quality, sidecar_usage = _sidecar_score_inputs(slug, entity_type)
+        quality_value = quality_value if quality_value is not None else sidecar_quality
+        usage_value = usage_value if usage_value is not None else sidecar_usage
+    q = 0.35 if quality_value is None else quality_value
+    u = 0.0 if usage_value is None else usage_value
+    popularity = (
+        math.log1p(max(0, degree)) / math.log1p(max(1, max_degree))
+        if max_degree > 0
+        else 0.0
+    )
+    signal = max(0.0, min(1.0, 0.45 * q + 0.35 * u + 0.20 * popularity))
+    return {
+        "node_size": round(8.0 + signal * 16.0, 2),
+        "size_signal": round(signal, 4),
+        "size_reason": f"quality {q:.3f}; usage {u:.3f}; popularity {popularity:.3f}",
+    }
+
+
+def _resolve_index_center(
+    conn: sqlite3.Connection,
+    raw_query: str,
+    entity_type: str | None,
+) -> tuple[str | None, dict[str, str] | None, list[str]]:
+    raw_query = str(raw_query or "").strip()
+    if not raw_query or "/" in raw_query or "\\" in raw_query or ".." in raw_query:
+        return None, None, []
+    normalized_query = _slugish(raw_query)
+    if not normalized_query or not _is_safe_slug(normalized_query):
+        return None, None, []
+
+    entity_types = (
+        (entity_type,)
+        if entity_type is not None
+        else _DASHBOARD_ENTITY_TYPES
+    )
+    candidates = []
+    for candidate in (raw_query, normalized_query):
+        if candidate and candidate not in candidates:
+            candidates.append(candidate)
+    for current_type in entity_types:
+        for candidate_slug in candidates:
+            row = conn.execute(
+                "SELECT node_id FROM slug_index WHERE slug=? AND type=? LIMIT 1",
+                (candidate_slug, current_type),
+            ).fetchone()
+            if row is not None:
+                return str(row["node_id"]), None, [candidate_slug]
+
+    where = ""
+    params: list[Any] = []
+    if entity_type is not None:
+        where = "WHERE s.type=?"
+        params.append(entity_type)
+    rows = conn.execute(
+        "SELECT s.slug,s.type,s.node_id,n.label,n.tags,n.degree "
+        "FROM slug_index s JOIN nodes n ON n.id=s.node_id "
+        f"{where}",
+        params,
+    )
+    matches: list[tuple[tuple[int, int, int], str, str]] = []
+    query_tokens = set(normalized_query.split("-"))
+    for row in rows:
+        node_slug = str(row["slug"] or "")
+        label = str(row["label"] or node_slug)
+        haystacks = {_slugish(node_slug), _slugish(label)}
+        try:
+            tags = json.loads(row["tags"] or "[]")
+        except (TypeError, json.JSONDecodeError):
+            tags = []
+        if isinstance(tags, list):
+            haystacks.update(_slugish(str(tag)) for tag in tags[:12])
+        rank = None
+        if normalized_query in haystacks:
+            rank = 0
+        elif any(h.startswith(normalized_query) for h in haystacks):
+            rank = 1
+        elif any(normalized_query in h for h in haystacks):
+            rank = 2
+        elif query_tokens and all(
+            any(token in h for h in haystacks) for token in query_tokens
+        ):
+            rank = 3
+        if rank is None:
+            continue
+        try:
+            degree = int(row["degree"] or 0)
+        except (TypeError, ValueError):
+            degree = 0
+        matches.append(((rank, len(node_slug), -degree), str(row["node_id"]), node_slug))
+
+    matches.sort(key=lambda item: item[0])
+    suggestions: list[str] = []
+    for _, _node_id, suggestion in matches[:8]:
+        if suggestion not in suggestions:
+            suggestions.append(suggestion)
+    if not matches:
+        return None, None, suggestions
+    center = matches[0][1]
+    return (
+        center,
+        {"query": raw_query, "slug": _graph_slug_from_node_id(center), "id": center},
+        suggestions,
+    )
+
+
+def _graph_neighborhood_from_index(
+    slug: str,
+    *,
+    hops: int,
+    limit: int,
+    entity_type: str | None,
+) -> dict | None:
+    index_path = _ensure_dashboard_graph_index()
+    if index_path is None or not index_path.is_file():
+        return None
+    try:
+        conn = sqlite3.connect(f"file:{index_path.as_posix()}?mode=ro", uri=True)
+    except sqlite3.Error:
+        return None
+    conn.row_factory = sqlite3.Row
+    try:
+        meta = {
+            row["key"]: json.loads(row["value"])
+            for row in conn.execute("SELECT key,value FROM meta")
+        }
+        max_degree = int(meta.get("max_degree") or 1)
+        top_k = int(meta.get("top_k") or 0)
+        if hops > 1 or (top_k > 0 and limit > top_k):
+            return None
+
+        center, resolved, suggestions = _resolve_index_center(conn, slug, entity_type)
+        if center is None:
+            return {"nodes": [], "edges": [], "center": None, "suggestions": suggestions}
+
+        nodes_out: dict[str, dict[str, Any]] = {}
+        edges_out: list[dict[str, Any]] = []
+        emitted_edges: set[tuple[str, str]] = set()
+        frontier = [center]
+        seen = {center}
+
+        def add_node(node_id: str, depth: int) -> None:
+            if node_id in nodes_out:
+                return
+            row = conn.execute("SELECT * FROM nodes WHERE id=?", (node_id,)).fetchone()
+            if row is None:
+                return
+            tags = json.loads(row["tags"] or "[]")
+            degree = int(row["degree"] or 0)
+            node_type = str(row["type"] or _graph_type_from_node_id(node_id))
+            node_slug = _graph_slug_from_node_id(node_id)
+            size_data = _index_node_size(
+                slug=node_slug,
+                entity_type=node_type,
+                quality=row["quality_score"],
+                usage=row["usage_score"],
+                degree=degree,
+                max_degree=max_degree,
+            )
+            nodes_out[node_id] = {
+                "data": {
+                    "id": node_id,
+                    "label": row["label"] or node_slug,
+                    "type": node_type,
+                    "depth": depth,
+                    "degree": degree,
+                    "tags": tags[:6],
+                    "description": row["description"] or "",
+                    "quality_score": row["quality_score"],
+                    "usage_score": row["usage_score"],
+                    "filter_tokens": [node_id, row["label"], node_slug, *tags],
+                    **size_data,
+                },
+            }
+
+        add_node(center, 0)
+        for depth in range(1, hops + 1):
+            next_frontier: list[str] = []
+            for node_id in frontier:
+                row = conn.execute(
+                    "SELECT payload FROM neighbors WHERE source=?",
+                    (node_id,),
+                ).fetchone()
+                if row is None:
+                    continue
+                neighbors = json.loads(zlib.decompress(row["payload"]).decode("utf-8"))
+                for edge in neighbors:
+                    if len(nodes_out) >= limit:
+                        break
+                    other = str(edge.get("target") or "")
+                    if not other:
+                        continue
+                    add_node(other, depth)
+                    edge_a, edge_b = sorted((node_id, other))
+                    edge_key = (edge_a, edge_b)
+                    if edge_key not in emitted_edges and other in nodes_out:
+                        emitted_edges.add(edge_key)
+                        shared_tags = list(edge.get("shared_tags") or [])[:4]
+                        for current in (node_id, other):
+                            tokens = nodes_out[current]["data"].setdefault(
+                                "filter_tokens", []
+                            )
+                            tokens.extend(shared_tags)
+                        edges_out.append({
+                            "data": {
+                                "id": f"{edge_key[0]}__{edge_key[1]}",
+                                "source": node_id,
+                                "target": other,
+                                "weight": edge.get("weight", 1),
+                                "shared_tags": shared_tags,
+                                "reasons": edge.get("reasons", []),
+                                "semantic": edge.get("semantic"),
+                                "tag_sim": edge.get("tag_sim"),
+                                "slug_token_sim": edge.get("slug_token_sim"),
+                                "source_overlap": edge.get("source_overlap"),
+                            },
+                        })
+                    if other not in seen:
+                        seen.add(other)
+                        next_frontier.append(other)
+                if len(nodes_out) >= limit:
+                    break
+            frontier = next_frontier
+            if len(nodes_out) >= limit:
+                break
+        return {
+            "nodes": list(nodes_out.values()),
+            "edges": edges_out,
+            "center": center,
+            "resolved": resolved or {"source": "dashboard-index"},
+            "suggestions": [],
+        }
+    except (OSError, sqlite3.Error, json.JSONDecodeError, zlib.error, KeyError, TypeError):
+        return None
+    finally:
+        conn.close()
+
+
 def _graph_neighborhood(
     slug: str,
     hops: int = 1,
@@ -2271,6 +2701,16 @@ def _graph_neighborhood(
     """
     if "/" in slug or "\\" in slug or ".." in slug:
         return {"nodes": [], "edges": [], "center": None}
+    normalized_entity_type = _normalize_dashboard_entity_type(entity_type)
+    if not _dashboard_graph_has_runtime_overlays():
+        indexed = _graph_neighborhood_from_index(
+            slug,
+            hops=hops,
+            limit=limit,
+            entity_type=normalized_entity_type,
+        )
+        if indexed is not None:
+            return indexed
     try:
         G = _load_dashboard_graph()
     except Exception:  # noqa: BLE001 — graph is advisory; blank on error
@@ -2279,7 +2719,6 @@ def _graph_neighborhood(
         return {"nodes": [], "edges": [], "center": None}
 
     center = None
-    normalized_entity_type = _normalize_dashboard_entity_type(entity_type)
     if entity_type is not None and normalized_entity_type is None:
         return {"nodes": [], "edges": [], "center": None}
     center, resolved, suggestions = _resolve_graph_center(
@@ -2409,6 +2848,25 @@ def _graph_stats() -> dict:
             }
     except OSError:
         pass
+
+    index_path = _ensure_dashboard_graph_index()
+    if index_path is not None and index_path.is_file():
+        try:
+            conn = sqlite3.connect(f"file:{index_path.as_posix()}?mode=ro", uri=True)
+            try:
+                meta = {
+                    row[0]: json.loads(row[1])
+                    for row in conn.execute("SELECT key,value FROM meta")
+                }
+                return {
+                    "nodes": int(meta.get("nodes_count") or 0),
+                    "edges": int(meta.get("edges_count") or 0),
+                    "available": int(meta.get("nodes_count") or 0) > 0,
+                }
+            finally:
+                conn.close()
+        except (OSError, sqlite3.Error, ValueError, TypeError, json.JSONDecodeError):
+            pass
     try:
         G = _load_dashboard_graph()
     except Exception:  # noqa: BLE001
@@ -2420,6 +2878,33 @@ def _graph_stats() -> dict:
     }
 
 
+def _wiki_stats_from_dashboard_index() -> dict[str, int] | None:
+    index_path = _dashboard_graph_index_path()
+    if not index_path.is_file() or not _dashboard_index_matches_manifest(index_path):
+        return None
+    try:
+        conn = sqlite3.connect(f"file:{index_path.as_posix()}?mode=ro", uri=True)
+        try:
+            rows = {
+                str(row[0]): int(row[1])
+                for row in conn.execute("SELECT type,COUNT(*) FROM nodes GROUP BY type")
+            }
+        finally:
+            conn.close()
+    except (OSError, sqlite3.Error, ValueError, TypeError):
+        return None
+
+    stats = {
+        "skills": rows.get("skill", 0),
+        "agents": rows.get("agent", 0),
+        "mcps": rows.get("mcp-server", 0),
+        "harnesses": rows.get("harness", 0),
+    }
+    stats["total"] = sum(stats.values())
+    stats["split_known"] = True
+    return stats
+
+
 def _wiki_stats() -> dict:
     """Entity counts across all dashboard-supported entity types.
 
@@ -2429,7 +2914,22 @@ def _wiki_stats() -> dict:
     individual counts for the dashboard entity-type detail
     line.
     """
+    indexed = _wiki_stats_from_dashboard_index()
+    if indexed is not None:
+        return indexed
+
     base = _wiki_dir() / "entities"
+    graph_out = _wiki_dir() / "graphify-out"
+    if graph_out.is_dir() and (graph_out / "graph-report.md").is_file():
+        graph_stats = _graph_stats()
+        return {
+            "skills": 0,
+            "agents": 0,
+            "mcps": 0,
+            "harnesses": 0,
+            "total": int(graph_stats.get("nodes") or 0),
+            "split_known": False,
+        }
     skills = len(list((base / "skills").glob("*.md"))) if (base / "skills").is_dir() else 0
     agents = len(list((base / "agents").glob("*.md"))) if (base / "agents").is_dir() else 0
     mcp_dir = base / "mcp-servers"
@@ -2441,12 +2941,12 @@ def _wiki_stats() -> dict:
         "mcps": mcps,
         "harnesses": harnesses,
         "total": skills + agents + mcps + harnesses,
+        "split_known": True,
     }
 
 
 def _render_home() -> str:
     sessions = _summarize_sessions()
-    grades = _grade_distribution()
     recent = sessions[:10]
     gstats = _graph_stats()
     wstats = _wiki_stats()
@@ -2455,6 +2955,13 @@ def _render_home() -> str:
         if _audit_log_path().exists() else 0
     manifest = _read_manifest()
     recent_audit = _read_jsonl(_audit_log_path(), limit=10)
+    if wstats.get("split_known", True):
+        wiki_detail = (
+            f"{wstats['skills']:,} skills · {wstats['agents']:,} agents · "
+            f"{wstats['mcps']:,} MCPs · {wstats['harnesses']:,} harnesses"
+        )
+    else:
+        wiki_detail = "entity split unavailable; install the current graph index"
 
     rows = []
     for s in recent:
@@ -2486,14 +2993,13 @@ def _render_home() -> str:
         + f"<div class='card'><div class='muted' style='font-size:0.8rem;'>Currently loaded</div>"
         f"<div style='font-size:1.6rem; font-weight:600;'>{len(manifest.get('load', []))}</div>"
         f"<a href='/loaded'>manage →</a></div>"
-        + f"<div class='card'><div class='muted' style='font-size:0.8rem;'>Sidecars</div>"
-        f"<div style='font-size:1.6rem; font-weight:600;'>{sum(grades.values())}</div>"
-        f"<a href='/skills'>browse →</a></div>"
+        + "<div class='card'><div class='muted' style='font-size:0.8rem;'>Sidecars</div>"
+        "<div id='home-sidecar-count' style='font-size:1.6rem; font-weight:600;'>...</div>"
+        "<a href='/skills'>browse →</a></div>"
         + f"<div class='card'><div class='muted' style='font-size:0.8rem;'>Wiki entities</div>"
         f"<div style='font-size:1.6rem; font-weight:600;'>{wstats['total']:,}</div>"
         f"<span class='muted' style='font-size:0.75rem;'>"
-        f"{wstats['skills']:,} skills · {wstats['agents']:,} agents · "
-        f"{wstats['mcps']:,} MCPs · {wstats['harnesses']:,} harnesses</span></div>"
+        f"{html.escape(wiki_detail)}</span></div>"
         + f"<div class='card'><div class='muted' style='font-size:0.8rem;'>Knowledge graph</div>"
         f"<div style='font-size:1.6rem; font-weight:600;'>{gstats['nodes']}</div>"
         f"<span class='muted' style='font-size:0.75rem;'>{gstats['edges']:,} edges</span>"
@@ -2514,11 +3020,31 @@ def _render_home() -> str:
         # ── Grade distribution ────────────────────────────────────────
         "<div class='card'><strong>Skill quality grades:</strong> "
         + "".join(
-            f"<span class='pill grade-{g}'>{g}: {n}</span> "
-            for g, n in grades.items()
+            f"<span class='pill grade-{g}' data-home-grade='{g}'>{g}: ...</span> "
+            for g in ("A", "B", "C", "D", "F")
         )
-        + f"<span class='muted'> · total {sum(grades.values())}</span>"
+        + "<span id='home-grade-total' class='muted'> · total loading</span>"
         "</div>"
+        "<script>"
+        "(() => {"
+        "const countEl = document.getElementById('home-sidecar-count');"
+        "const totalEl = document.getElementById('home-grade-total');"
+        "fetch('/api/grades.json').then(r => r.ok ? r.json() : Promise.reject())"
+        ".then(data => {"
+        "const grades = data.grades || {};"
+        "['A','B','C','D','F'].forEach(g => {"
+        "const el = document.querySelector(`[data-home-grade=\"${g}\"]`);"
+        "if (el) el.textContent = `${g}: ${grades[g] || 0}`;"
+        "});"
+        "if (countEl) countEl.textContent = String(data.total || 0);"
+        "if (totalEl) totalEl.textContent = ` · total ${data.total || 0}`;"
+        "})"
+        ".catch(() => {"
+        "if (countEl) countEl.textContent = 'open';"
+        "if (totalEl) totalEl.textContent = ' · open Skills for counts';"
+        "});"
+        "})();"
+        "</script>"
         # ── Two-column: recent sessions + recent audit ────────────────
         "<div style='display:grid; grid-template-columns:2fr 1fr; gap:1rem;'>"
         f"<div class='card'><strong>Recent sessions</strong> ({len(sessions)} total)"
@@ -2760,6 +3286,36 @@ def _render_skill_detail(slug: str, entity_type: str | None = None) -> str:
     return _layout(slug, body)
 
 
+def _top_degree_seeds_from_index(limit: int = 18) -> list[dict]:
+    if _dashboard_graph_has_runtime_overlays():
+        return []
+    index_path = _ensure_dashboard_graph_index()
+    if index_path is None or not index_path.is_file():
+        return []
+    conn: sqlite3.Connection | None = None
+    try:
+        conn = sqlite3.connect(f"file:{index_path.as_posix()}?mode=ro", uri=True)
+        conn.row_factory = sqlite3.Row
+        rows = conn.execute(
+            "SELECT id,label,type,degree FROM nodes ORDER BY degree DESC,id LIMIT ?",
+            (max(1, limit),),
+        ).fetchall()
+    except (OSError, sqlite3.Error, TimeoutError):
+        return []
+    finally:
+        if conn is not None:
+            conn.close()
+    return [
+        {
+            "slug": _graph_slug_from_node_id(str(row["id"])),
+            "type": _graph_type_from_node_id(str(row["id"]), str(row["type"] or "skill")),
+            "degree": int(row["degree"] or 0),
+            "label": row["label"] or _graph_slug_from_node_id(str(row["id"])),
+        }
+        for row in rows
+    ]
+
+
 def _top_degree_seeds(limit: int = 18, *, allow_load: bool = True) -> list[dict]:
     """Pick high-degree nodes from the graph as seed suggestions.
 
@@ -2771,7 +3327,7 @@ def _top_degree_seeds(limit: int = 18, *, allow_load: bool = True) -> list[dict]
     except Exception:  # noqa: BLE001
         return []
     if G is None:
-        return []
+        return _top_degree_seeds_from_index(limit)
     if G.number_of_nodes() == 0:
         return []
     ranked = sorted(G.degree, key=lambda kv: -kv[1])[:limit]
@@ -3094,8 +3650,8 @@ def _render_config() -> str:
 def _render_graph(focus: str | None = None, focus_type: str | None = None) -> str:
     """Interactive graph view backed by a dependency-free SVG renderer."""
     focus_slug = focus or ""
-    focus_js = json.dumps(focus_slug)
-    focus_type_js = json.dumps(focus_type or "")
+    focus_js = _json_for_script(focus_slug)
+    focus_type_js = _json_for_script(focus_type or "")
     gstats = _graph_stats()
     seeds = (
         _top_degree_seeds(allow_load=False)
@@ -4366,6 +4922,12 @@ def _render_manage(mutations_enabled: bool | None = None) -> str:
         "form.addEventListener('submit', async ev => {\n"
         "  ev.preventDefault();\n"
         "  const payload = Object.fromEntries(new FormData(form).entries());\n"
+        "  const isUpdate = selected && selected.slug === payload.slug && selected.type === payload.entity_type;\n"
+        "  if (isUpdate) {\n"
+        "    const ok = confirm('Update existing ' + payload.entity_type + ':' + payload.slug + '?\\n\\nBenefit: keeps the catalog current.\\nRisk: a lower-quality edit can degrade recommendations.');\n"
+        "    if (!ok) { setStatus('update cancelled'); return; }\n"
+        "    payload.confirm_update = 'true';\n"
+        "  }\n"
         "  setStatus('saving...');\n"
         "  const data = await post('/api/entity/upsert', payload);\n"
         "  setStatus(data.detail || (data.ok ? 'saved' : 'save failed'));\n"
@@ -5550,6 +6112,8 @@ class _MonitorHandler(BaseHTTPRequestHandler):
                 self._send_json(summary.to_dict() if summary is not None else {
                     "total": 0, "detail": "no sidecars yet",
                 })
+            elif path == "/api/grades.json":
+                self._send_json(_grade_distribution_payload())
             elif path == "/api/runtime.json":
                 self._send_json(_runtime_lifecycle_summary())
             elif path == "/api/config.json":

src/mcp_add.py

@@ -29,18 +29,18 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
 
-import yaml  # type: ignore[import-untyped]
-
-from ctx.core.entity_update import build_update_review, render_update_review
-from ctx_config import cfg
-from intake_pipeline import IntakeRejected, check_intake, record_embedding
-import mcp_canonical_index
+import yaml  # type: ignore[import-untyped]
+
+from ctx.core.entity_update import build_update_review, render_update_review
+from ctx_config import cfg
+from intake_pipeline import IntakeRejected, check_intake, record_embedding
+import mcp_canonical_index
 from mcp_entity import McpRecord
-from wiki_batch_entities import generate_mcp_page
-from ctx.core.wiki.wiki_sync import append_log, ensure_wiki, update_index
-from ctx.core.wiki.wiki_queue import enqueue_entity_upsert
-from ctx.core.wiki.wiki_utils import validate_skill_name
-from ctx.utils._fs_utils import reject_symlink_path, safe_atomic_write_text
+from wiki_batch_entities import generate_mcp_page
+from ctx.core.wiki.wiki_sync import append_log, ensure_wiki, update_index
+from ctx.core.wiki.wiki_queue import enqueue_entity_upsert
+from ctx.core.wiki.wiki_utils import validate_skill_name
+from ctx.utils._fs_utils import reject_symlink_path, safe_atomic_write_text
 
 TODAY = datetime.now(timezone.utc).strftime("%Y-%m-%d")
 
@@ -237,14 +237,14 @@ def _find_existing_by_github_url(
     return None
 
 
-def add_mcp(
-    *,
-    record: McpRecord,
-    wiki_path: Path,
-    dry_run: bool = False,
-    review_existing: bool = False,
-    update_existing: bool = False,
-) -> dict[str, Any]:
+def add_mcp(
+    *,
+    record: McpRecord,
+    wiki_path: Path,
+    dry_run: bool = False,
+    review_existing: bool = False,
+    update_existing: bool = False,
+) -> dict[str, Any]:
     """Add (or merge sources for) one MCP record into the wiki catalog.
 
     Flow:
@@ -265,11 +265,11 @@ def add_mcp(
       6. update_index + append_log (only when is_new_page).
 
     Args:
-        record: Populated McpRecord dataclass instance.
-        wiki_path: Absolute path to the wiki root directory.
-        dry_run: Compute everything but skip writes and embeddings.
-        review_existing: Return an update review instead of mutating existing pages.
-        update_existing: Apply an existing-page update after review.
+        record: Populated McpRecord dataclass instance.
+        wiki_path: Absolute path to the wiki root directory.
+        dry_run: Compute everything but skip writes and embeddings.
+        review_existing: Return an update review instead of mutating existing pages.
+        update_existing: Apply an existing-page update after review.
 
     Returns:
         dict with keys: slug, is_new_page, merged_sources, path
@@ -288,12 +288,13 @@ def add_mcp(
     # listing-page records currently have only homepage_url (Phase 6
     # detail-page enrichment will populate github_url so this dedup
     # path becomes meaningful for them too).
-    canonical_match = _find_existing_by_github_url(mcp_dir, record.github_url)
-    if canonical_match is not None and canonical_match != target_path:
-        target_path = canonical_match
-
-    reject_symlink_path(target_path)
-    target_path.parent.mkdir(parents=True, exist_ok=True)
+    canonical_match = _find_existing_by_github_url(mcp_dir, record.github_url)
+    if canonical_match is not None and canonical_match != target_path:
+        target_path = canonical_match
+
+    reject_symlink_path(target_path)
+    target_path.parent.mkdir(parents=True, exist_ok=True)
+    target_slug = target_path.stem
 
     is_new_page: bool
     merged_sources: list[str]
@@ -329,52 +330,52 @@ def add_mcp(
         merged_sources = sorted(record.sources)
         kept_description = record.description
 
-    if is_new_page:
-        final_text = generate_mcp_page(record)
-    else:
-        updated_fm = {
-            **existing_fm,
-            "sources": merged_sources,
-            "description": kept_description,
-            "updated": TODAY,
-        }
-        final_text = _rewrite_frontmatter(existing_text, updated_fm)
-
-    if review_existing and not is_new_page and not update_existing:
-        review = build_update_review(
-            entity_type="mcp-server",
-            slug=record.slug,
-            existing_text=existing_text,
-            proposed_text=final_text,
-        )
-        return {
-            "slug": record.slug,
-            "is_new_page": False,
-            "merged_sources": merged_sources,
-            "path": str(target_path),
-            "skipped": True,
-            "update_required": True,
-            "update_review": render_update_review(review),
-            "queued_job_id": None,
-        }
-
-    queue_job = None
-    if not dry_run:
-        # Phase 2 of branching: render and write. Any YAML serialization
-        # failure now is a real error, not a dry-run side-effect.
-        safe_atomic_write_text(target_path, final_text, encoding="utf-8")
-        queue_job = enqueue_entity_upsert(
-            wiki_path=wiki_path,
-            entity_type="mcp-server",
-            slug=record.slug,
-            entity_path=target_path,
-            content=final_text,
-            action="created" if is_new_page else "updated",
-            source="mcp_add",
-        )
-
-        # Phase 6b: keep the canonical sidecar index hot. Upsert on
-        # every successful write so the first cross-source dedup after
+    if is_new_page:
+        final_text = generate_mcp_page(record)
+    else:
+        updated_fm = {
+            **existing_fm,
+            "sources": merged_sources,
+            "description": kept_description,
+            "updated": TODAY,
+        }
+        final_text = _rewrite_frontmatter(existing_text, updated_fm)
+
+    if review_existing and not is_new_page and not update_existing:
+        review = build_update_review(
+            entity_type="mcp-server",
+            slug=target_slug,
+            existing_text=existing_text,
+            proposed_text=final_text,
+        )
+        return {
+            "slug": target_slug,
+            "is_new_page": False,
+            "merged_sources": merged_sources,
+            "path": str(target_path),
+            "skipped": True,
+            "update_required": True,
+            "update_review": render_update_review(review),
+            "queued_job_id": None,
+        }
+
+    queue_job = None
+    if not dry_run:
+        # Phase 2 of branching: render and write. Any YAML serialization
+        # failure now is a real error, not a dry-run side-effect.
+        safe_atomic_write_text(target_path, final_text, encoding="utf-8")
+        queue_job = enqueue_entity_upsert(
+            wiki_path=wiki_path,
+            entity_type="mcp-server",
+            slug=target_slug,
+            entity_path=target_path,
+            content=final_text,
+            action="created" if is_new_page else "updated",
+            source="mcp_add",
+        )
+
+        # Phase 6b: keep the canonical sidecar index hot. Upsert on
+        # every successful write so the first cross-source dedup after
         # this add is O(1) without needing a rebuild. Applies to both
         # new pages AND source merges — a merge can land a github_url
         # from the second source when the first source lacked one.
@@ -387,7 +388,7 @@ def add_mcp(
                 mcp_canonical_index.upsert(
                     mcp_dir,
                     canonical,
-                    slug=record.slug,
+                    slug=target_slug,
                     relpath=relpath,
                 )
             except (OSError, ValueError) as exc:
@@ -413,10 +414,10 @@ def add_mcp(
                     file=sys.stderr,
                 )
 
-            update_index(str(wiki_path), [record.slug], subject_type="mcp-servers")
+            update_index(str(wiki_path), [target_slug], subject_type="mcp-servers")
 
             log_details = [
-                f"Slug: {record.slug}",
+                f"Slug: {target_slug}",
                 f"Path: {target_path}",
                 f"Sources: {', '.join(merged_sources) if merged_sources else 'none'}",
                 f"Tags: {', '.join(record.tags) if record.tags else 'none'}",
@@ -431,32 +432,32 @@ def add_mcp(
                 log_details.append(
                     "Warnings: " + "; ".join(f"{w.code}:{w.message}" for w in warnings)
                 )
-            append_log(str(wiki_path), "add-mcp", record.slug, log_details)
+            append_log(str(wiki_path), "add-mcp", target_slug, log_details)
 
     return {
-        "slug": record.slug,
-        "is_new_page": is_new_page,
-        "merged_sources": merged_sources,
-        "path": str(target_path),
-        "skipped": False,
-        "update_required": False,
-        "queued_job_id": queue_job.id if queue_job is not None else None,
-    }
+        "slug": target_slug,
+        "is_new_page": is_new_page,
+        "merged_sources": merged_sources,
+        "path": str(target_path),
+        "skipped": False,
+        "update_required": False,
+        "queued_job_id": queue_job.id if queue_job is not None else None,
+    }
 
 
 # ── CLI ───────────────────────────────────────────────────────────────────────
 
 
-def _process_batch(
-    records: list[dict[str, Any]],
-    wiki_path: Path,
-    dry_run: bool,
-    skip_existing: bool,
-    update_existing: bool,
-    mcp_entity_dir: Path,
-) -> tuple[int, int, int, int, int]:
-    """Process records. Returns (added, merged, reviewed, rejected, errors)."""
-    added = merged = reviewed = rejected = errors = 0
+def _process_batch(
+    records: list[dict[str, Any]],
+    wiki_path: Path,
+    dry_run: bool,
+    skip_existing: bool,
+    update_existing: bool,
+    mcp_entity_dir: Path,
+) -> tuple[int, int, int, int, int]:
+    """Process records. Returns (added, merged, reviewed, rejected, errors)."""
+    added = merged = reviewed = rejected = errors = 0
     total = len(records)
 
     for i, raw in enumerate(records, 1):
@@ -476,26 +477,26 @@ def _process_batch(
             print(f"  [{i}/{total}] [skipped] {record.slug}")
             continue
 
-        try:
-            result = add_mcp(
-                record=record,
-                wiki_path=wiki_path,
-                dry_run=dry_run,
-                review_existing=True,
-                update_existing=update_existing,
-            )
-            if result["is_new_page"]:
-                added += 1
-                status = "added"
-            elif result.get("update_required"):
-                reviewed += 1
-                status = "update-review"
-                if result.get("update_review"):
-                    print(result["update_review"])
-            else:
-                merged += 1
-                status = "updated" if update_existing else "merged"
-            print(f"  [{i}/{total}] [{status}] {record.slug}")
+        try:
+            result = add_mcp(
+                record=record,
+                wiki_path=wiki_path,
+                dry_run=dry_run,
+                review_existing=True,
+                update_existing=update_existing,
+            )
+            if result["is_new_page"]:
+                added += 1
+                status = "added"
+            elif result.get("update_required"):
+                reviewed += 1
+                status = "update-review"
+                if result.get("update_review"):
+                    print(result["update_review"])
+            else:
+                merged += 1
+                status = "updated" if update_existing else "merged"
+            print(f"  [{i}/{total}] [{status}] {record.slug}")
         except IntakeRejected as exc:
             rejected += 1
             codes = ", ".join(f.code for f in exc.decision.failures) or "unknown"
@@ -504,7 +505,7 @@ def _process_batch(
             errors += 1
             print(f"  [{i}/{total}] ERROR: {record.slug}: {exc}", file=sys.stderr)
 
-    return added, merged, reviewed, rejected, errors
+    return added, merged, reviewed, rejected, errors
 
 
 def main() -> None:
@@ -532,16 +533,16 @@ def main() -> None:
 
     parser.add_argument("--dry-run", action="store_true", help="Parse and validate but skip writes")
     parser.add_argument("--wiki", default=str(cfg.wiki_dir), help="Wiki root path")
-    parser.add_argument(
-        "--skip-existing",
-        action="store_true",
-        help="Skip records whose entity page already exists (no source merge)",
-    )
-    parser.add_argument(
-        "--update-existing",
-        action="store_true",
-        help="Apply the reviewed replacement when an MCP entity already exists",
-    )
+    parser.add_argument(
+        "--skip-existing",
+        action="store_true",
+        help="Skip records whose entity page already exists (no source merge)",
+    )
+    parser.add_argument(
+        "--update-existing",
+        action="store_true",
+        help="Apply the reviewed replacement when an MCP entity already exists",
+    )
     args = parser.parse_args()
 
     wiki_path = Path(os.path.expanduser(args.wiki))
@@ -591,20 +592,20 @@ def main() -> None:
         print("No records to process.", file=sys.stderr)
         sys.exit(0)
 
-    added, merged, reviewed, rejected, errors = _process_batch(
-        records=raw_records,
-        wiki_path=wiki_path,
-        dry_run=args.dry_run,
-        skip_existing=args.skip_existing,
-        update_existing=args.update_existing,
-        mcp_entity_dir=mcp_entity_dir,
-    )
-
-    dry_label = " (dry-run)" if args.dry_run else ""
-    print(
-        f"\nDone{dry_label}: {added} added, {merged} updated, "
-        f"{reviewed} reviewed, {rejected} rejected, {errors} errors"
-    )
+    added, merged, reviewed, rejected, errors = _process_batch(
+        records=raw_records,
+        wiki_path=wiki_path,
+        dry_run=args.dry_run,
+        skip_existing=args.skip_existing,
+        update_existing=args.update_existing,
+        mcp_entity_dir=mcp_entity_dir,
+    )
+
+    dry_label = " (dry-run)" if args.dry_run else ""
+    print(
+        f"\nDone{dry_label}: {added} added, {merged} updated, "
+        f"{reviewed} reviewed, {rejected} rejected, {errors} errors"
+    )
 
 
 if __name__ == "__main__":

src/tests/test_ctx_init.py

@@ -6,8 +6,10 @@ import builtins
 import hashlib
 import io
 import json
+import sqlite3
 import sys
 import tarfile
+import zlib
 from pathlib import Path
 from types import SimpleNamespace
 
@@ -16,6 +18,40 @@ import pytest
 import ctx_init as ci
 
 
+def _write_dashboard_index(path: Path, *, export_id: str = "test-export") -> None:
+    conn = sqlite3.connect(path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany(
+            "INSERT INTO meta VALUES(?,?)",
+            [
+                ("export_id", json.dumps(export_id)),
+                ("nodes_count", "1"),
+                ("edges_count", "0"),
+                ("max_degree", "1"),
+                ("top_k", "40"),
+            ],
+        )
+        conn.execute(
+            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+            ("skill:current", "current", "skill", "[]", "", None, None, 0),
+        )
+        conn.execute("INSERT INTO slug_index VALUES(?,?,?)", ("current", "skill", "skill:current"))
+        conn.execute("INSERT INTO neighbors VALUES(?,?)", ("skill:current", zlib.compress(b"[]")))
+        conn.commit()
+    finally:
+        conn.close()
+
+
 def _artifact_sha256_or_lfs_oid(path: Path, *, normalize_text: bool = False) -> str:
     data = path.read_bytes()
     if data.startswith(b"version https://git-lfs.github.com/spec/v1\n"):
@@ -299,6 +335,7 @@ def _write_graph_archive(tmp_path: Path) -> Path:
         }),
         encoding="utf-8",
     )
+    _write_dashboard_index(graph_out / "dashboard-neighborhoods.sqlite3")
     external = source / "external-catalogs" / "skills-sh"
     external.mkdir(parents=True)
     (external / "catalog.json").write_text("{}", encoding="utf-8")
@@ -321,6 +358,12 @@ def _tar_text(tf: tarfile.TarFile, name: str, text: str) -> None:
     tf.addfile(info, io.BytesIO(payload))
 
 
+def _tar_bytes(tf: tarfile.TarFile, name: str, payload: bytes) -> None:
+    info = tarfile.TarInfo(name)
+    info.size = len(payload)
+    tf.addfile(info, io.BytesIO(payload))
+
+
 def test_download_graph_archive_verifies_sha256(
     tmp_path: Path,
     monkeypatch,
@@ -371,6 +414,14 @@ def test_graph_download_checksums_match_shipped_artifacts() -> None:
     )
 
 
+def test_local_graph_archive_checksum_is_verified(tmp_path: Path) -> None:
+    archive = tmp_path / "wiki-graph-runtime.tar.gz"
+    archive.write_bytes(b"not the shipped runtime archive")
+
+    with pytest.raises(ValueError, match="local graph archive checksum mismatch"):
+        ci._verify_local_graph_archive(archive, requested_install_mode="runtime")
+
+
 def test_custom_graph_url_requires_checksum_or_explicit_opt_out(
     tmp_path: Path,
     monkeypatch,
@@ -392,6 +443,44 @@ def test_custom_graph_url_requires_checksum_or_explicit_opt_out(
     assert rc == 1
 
 
+def test_custom_graph_url_bypasses_local_archive(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    archive = _write_graph_archive(tmp_path)
+    archive_bytes = archive.read_bytes()
+    calls: list[dict[str, object]] = []
+
+    monkeypatch.setattr(
+        ci,
+        "_find_local_graph_archive",
+        lambda _mode: (_ for _ in ()).throw(
+            AssertionError("explicit graph_url must not use local archive")
+        ),
+    )
+
+    def fake_download(destination: Path, **kwargs: object) -> None:
+        calls.append(dict(kwargs))
+        destination.write_bytes(archive_bytes)
+
+    monkeypatch.setattr(ci, "_download_graph_archive", fake_download)
+    monkeypatch.setattr(ci, "_install_graph_entity_overlay", lambda *_a, **_k: None)
+
+    rc = ci.build_graph(
+        tmp_path / "home",
+        graph_url="https://example.invalid/custom-wiki-graph.tar.gz",
+        graph_sha256=hashlib.sha256(archive_bytes).hexdigest(),
+    )
+
+    assert rc == 0
+    assert calls == [
+        {
+            "url": "https://example.invalid/custom-wiki-graph.tar.gz",
+            "expected_sha256": hashlib.sha256(archive_bytes).hexdigest(),
+        }
+    ]
+
+
 def test_main_with_graph_flag_installs_prebuilt_graph(
     tmp_path: Path,
     monkeypatch,
@@ -406,6 +495,7 @@ def test_main_with_graph_flag_installs_prebuilt_graph(
         lambda _install_mode="runtime": archive,
         raising=False,
     )
+    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
     monkeypatch.setattr(
         ci,
         "_download_graph_archive",
@@ -471,6 +561,7 @@ def test_graph_install_copies_local_entity_overlay(
         raising=False,
     )
     monkeypatch.setattr(ci, "_find_local_graph_entity_overlay", lambda: overlay)
+    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
 
     assert ci.build_graph(claude) == 0
 
@@ -520,6 +611,13 @@ def test_runtime_graph_install_extracts_harness_pages_after_required_files(
                 },
             }),
         )
+        index_path = tmp_path / "runtime-dashboard-neighborhoods.sqlite3"
+        _write_dashboard_index(index_path)
+        _tar_bytes(
+            tf,
+            "graphify-out/dashboard-neighborhoods.sqlite3",
+            index_path.read_bytes(),
+        )
         _tar_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
         _tar_text(tf, "index.md", "# Wiki\n")
         _tar_text(tf, "entities/harnesses/text-to-cad.md", "# Text to CAD\n")
@@ -531,6 +629,7 @@ def test_runtime_graph_install_extracts_harness_pages_after_required_files(
         "_find_local_graph_archive",
         lambda _install_mode="runtime": archive,
     )
+    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
 
     assert ci.build_graph(claude) == 0
     assert (
@@ -562,6 +661,7 @@ def test_graph_install_rejects_incomplete_archive(
         "_find_local_graph_archive",
         lambda _install_mode="runtime": archive,
     )
+    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
 
     assert ci.build_graph(claude) == 1
     assert not (claude / "skill-wiki" / "graphify-out" / "graph.json").exists()
@@ -604,6 +704,7 @@ def test_graph_install_validation_does_not_parse_full_graph_json(
         }),
         encoding="utf-8",
     )
+    _write_dashboard_index(graph_out / "dashboard-neighborhoods.sqlite3")
     external = wiki / "external-catalogs" / "skills-sh"
     external.mkdir(parents=True)
     (external / "catalog.json").write_text("{}", encoding="utf-8")
@@ -634,6 +735,7 @@ def test_graph_install_force_prunes_stale_generated_files(
         "_find_local_graph_archive",
         lambda _install_mode="runtime": archive,
     )
+    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
 
     assert ci.main([
         "--graph",
@@ -662,6 +764,7 @@ def test_graph_install_rejects_path_traversal_archive(
         "_find_local_graph_archive",
         lambda _install_mode="runtime": archive,
     )
+    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
 
     assert ci.build_graph(claude) == 1
     assert not (tmp_path / "evil.txt").exists()

src/tests/test_ctx_monitor.py

@@ -4,9 +4,14 @@ from __future__ import annotations
 
 import http.client
 import json
+import os
+import sqlite3
+import tarfile
 import threading
+import time
 import urllib.error
 import urllib.request
+import zlib
 from pathlib import Path
 
 import pytest
@@ -21,6 +26,7 @@ def fake_claude(tmp_path: Path, monkeypatch) -> Path:
     claude = tmp_path / ".claude"
     (claude / "skill-quality").mkdir(parents=True)
     monkeypatch.setattr(cm, "_claude_dir", lambda: claude)
+    monkeypatch.setattr(cm, "_dashboard_graph_index_archives", lambda: [])
     return claude
 
 
@@ -60,6 +66,15 @@ def _write_mcp_sidecar(claude: Path, slug: str, body: dict) -> None:
     (mcp_dir / f"{slug}.json").write_text(json.dumps(body), encoding="utf-8")
 
 
+def _write_graph_manifest(claude: Path, export_id: str) -> None:
+    graph_dir = claude / "skill-wiki" / "graphify-out"
+    graph_dir.mkdir(parents=True, exist_ok=True)
+    (graph_dir / "graph-export-manifest.json").write_text(
+        json.dumps({"version": 1, "export_id": export_id}),
+        encoding="utf-8",
+    )
+
+
 def test_read_jsonl_skips_non_object_lines(tmp_path: Path) -> None:
     path = tmp_path / "events.jsonl"
     path.write_text(
@@ -1254,7 +1269,10 @@ def test_graph_neighborhood_rejects_unsafe_slug() -> None:
     assert result == {"nodes": [], "edges": [], "center": None}
 
 
-def test_graph_neighborhood_supports_mcp_nodes(monkeypatch) -> None:
+def test_graph_neighborhood_supports_mcp_nodes(
+    fake_claude: Path,
+    monkeypatch,
+) -> None:
     import networkx as nx
     import sys
 
@@ -1274,7 +1292,10 @@ def test_graph_neighborhood_supports_mcp_nodes(monkeypatch) -> None:
     assert result["nodes"][0]["data"]["type"] == "mcp-server"
 
 
-def test_graph_neighborhood_resolves_partial_slug(monkeypatch) -> None:
+def test_graph_neighborhood_resolves_partial_slug(
+    fake_claude: Path,
+    monkeypatch,
+) -> None:
     import networkx as nx
 
     G = nx.Graph()
@@ -1307,6 +1328,7 @@ def test_graph_neighborhood_resolves_partial_slug(monkeypatch) -> None:
 
 
 def test_graph_neighborhood_sizes_nodes_by_score_usage_and_popularity(
+    fake_claude: Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
     import networkx as nx
@@ -1430,7 +1452,474 @@ def test_graph_helpers_reuse_graph_loaded_from_same_file(
     assert calls == [graph_file]
 
 
-def test_graph_neighborhood_empty_when_graph_absent(monkeypatch) -> None:
+def test_graph_neighborhood_uses_dashboard_index_without_full_graph_load(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    _write_graph_manifest(fake_claude, "test-export")
+    index_path = fake_claude / "skill-wiki" / "graphify-out" / "dashboard-neighborhoods.sqlite3"
+    index_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(index_path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany(
+            "INSERT INTO meta VALUES(?,?)",
+            [
+                ("max_degree", "10"),
+                ("export_id", json.dumps("test-export")),
+                ("nodes_count", "2"),
+                ("edges_count", "1"),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+            [
+                ("skill:python-patterns", "python-patterns", "skill", '["python"]', "", 0.9, 0.1, 10),
+                ("skill:fastapi-pro", "fastapi-pro", "skill", '["python","api"]', "", 0.8, 0.0, 4),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO slug_index VALUES(?,?,?)",
+            [
+                ("python-patterns", "skill", "skill:python-patterns"),
+                ("fastapi-pro", "skill", "skill:fastapi-pro"),
+            ],
+        )
+        payload = zlib.compress(json.dumps([
+            {
+                "target": "skill:fastapi-pro",
+                "weight": 0.8,
+                "shared_tags": ["python"],
+                "reasons": ["semantic"],
+            }
+        ]).encode("utf-8"))
+        conn.execute("INSERT INTO neighbors VALUES(?,?)", ("skill:python-patterns", payload))
+        conn.commit()
+    finally:
+        conn.close()
+
+    monkeypatch.setattr(
+        cm,
+        "_load_dashboard_graph",
+        lambda: (_ for _ in ()).throw(AssertionError("full graph loaded")),
+    )
+
+    result = cm._graph_neighborhood("python-patterns", entity_type="skill")
+
+    assert result["center"] == "skill:python-patterns"
+    assert [node["data"]["id"] for node in result["nodes"]] == [
+        "skill:python-patterns",
+        "skill:fastapi-pro",
+    ]
+    assert result["edges"][0]["data"]["shared_tags"] == ["python"]
+    assert cm._graph_stats() == {"nodes": 2, "edges": 1, "available": True}
+    assert cm._wiki_stats() == {
+        "skills": 2,
+        "agents": 0,
+        "mcps": 0,
+        "harnesses": 0,
+        "total": 2,
+        "split_known": True,
+    }
+
+
+def test_graph_index_honors_requested_type_on_exact_slug(
+    fake_claude: Path,
+) -> None:
+    _write_graph_manifest(fake_claude, "test-export")
+    index_path = fake_claude / "skill-wiki" / "graphify-out" / "dashboard-neighborhoods.sqlite3"
+    index_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(index_path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany(
+            "INSERT INTO meta VALUES(?,?)",
+            [("max_degree", "1"), ("top_k", "40"), ("export_id", json.dumps("test-export"))],
+        )
+        conn.executemany(
+            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+            [
+                ("skill:github", "github", "skill", "[]", "", None, None, 0),
+                ("mcp-server:github", "github", "mcp-server", "[]", "", None, None, 0),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO slug_index VALUES(?,?,?)",
+            [
+                ("github", "skill", "skill:github"),
+                ("github", "mcp-server", "mcp-server:github"),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO neighbors VALUES(?,?)",
+            [
+                ("skill:github", zlib.compress(b"[]")),
+                ("mcp-server:github", zlib.compress(b"[]")),
+            ],
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+    result = cm._graph_neighborhood("github", entity_type="skill")
+
+    assert result["center"] == "skill:github"
+
+
+def test_graph_index_matches_fuzzy_slug_resolution(
+    fake_claude: Path,
+) -> None:
+    _write_graph_manifest(fake_claude, "test-export")
+    index_path = fake_claude / "skill-wiki" / "graphify-out" / "dashboard-neighborhoods.sqlite3"
+    index_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(index_path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany(
+            "INSERT INTO meta VALUES(?,?)",
+            [("max_degree", "1"), ("top_k", "40"), ("export_id", json.dumps("test-export"))],
+        )
+        conn.execute(
+            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+            ("skill:github-actions", "GitHub Actions", "skill", '["ci"]', "", None, None, 0),
+        )
+        conn.execute(
+            "INSERT INTO slug_index VALUES(?,?,?)",
+            ("github-actions", "skill", "skill:github-actions"),
+        )
+        conn.execute("INSERT INTO neighbors VALUES(?,?)", ("skill:github-actions", zlib.compress(b"[]")))
+        conn.commit()
+    finally:
+        conn.close()
+
+    result = cm._graph_neighborhood("git hub", entity_type="skill")
+
+    assert result["center"] == "skill:github-actions"
+    assert result["resolved"]["slug"] == "github-actions"
+
+
+def test_entity_subgraph_script_json_escapes_script_end_tag() -> None:
+    graph_html = cm._render_entity_subgraph_svg(
+        center="skill:evil",
+        node_by_id={
+            "skill:evil": {
+                "label": "</script><script>alert(1)</script>",
+                "type": "skill",
+            },
+        },
+        edges=[],
+        sidecar_by_id={},
+    )
+
+    assert "</script><script>alert(1)</script>" not in graph_html
+    assert "<\\/script>" in graph_html
+
+
+def test_graph_page_initial_query_escapes_script_end_tag() -> None:
+    html_out = cm._render_graph("</script><script>alert(1)</script>")
+
+    assert "const initial = \"<\\/script>" in html_out
+    assert "const initial = \"</script>" not in html_out
+
+
+def test_graph_neighborhood_extracts_missing_dashboard_index_from_archive(
+    fake_claude: Path,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    seed = tmp_path / "dashboard-neighborhoods.sqlite3"
+    conn = sqlite3.connect(seed)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany(
+            "INSERT INTO meta VALUES(?,?)",
+            [
+                ("max_degree", "10"),
+                ("export_id", json.dumps("archive-export")),
+                ("nodes_count", "1"),
+                ("edges_count", "0"),
+                ("top_k", "40"),
+            ],
+        )
+        conn.execute(
+            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+            ("skill:python-patterns", "python-patterns", "skill", '["python"]', "", 0.9, 0.1, 10),
+        )
+        conn.execute(
+            "INSERT INTO slug_index VALUES(?,?,?)",
+            ("python-patterns", "skill", "skill:python-patterns"),
+        )
+        conn.execute(
+            "INSERT INTO neighbors VALUES(?,?)",
+            ("skill:python-patterns", zlib.compress(b"[]")),
+        )
+        conn.commit()
+    finally:
+        conn.close()
+
+    manifest = fake_claude / "skill-wiki" / "graphify-out" / "graph-export-manifest.json"
+    manifest.parent.mkdir(parents=True)
+    manifest.write_text(
+        json.dumps({"version": 1, "export_id": "archive-export"}),
+        encoding="utf-8",
+    )
+
+    archive = tmp_path / "wiki-graph-runtime.tar.gz"
+    with tarfile.open(archive, "w:gz") as tar:
+        tar.add(seed, arcname="./graphify-out/dashboard-neighborhoods.sqlite3")
+
+    monkeypatch.setattr(cm, "_dashboard_graph_index_archives", lambda: [archive])
+    monkeypatch.setattr(
+        cm,
+        "_load_dashboard_graph",
+        lambda: (_ for _ in ()).throw(AssertionError("full graph loaded")),
+    )
+
+    result = cm._graph_neighborhood("python-patterns", entity_type="skill")
+
+    assert result["center"] == "skill:python-patterns"
+    assert (fake_claude / "skill-wiki" / "graphify-out" / "dashboard-neighborhoods.sqlite3").is_file()
+
+
+def test_dashboard_index_extraction_skips_archive_export_mismatch(
+    fake_claude: Path,
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    graph_dir = fake_claude / "skill-wiki" / "graphify-out"
+    graph_dir.mkdir(parents=True)
+    (graph_dir / "graph-export-manifest.json").write_text(
+        json.dumps({"version": 1, "export_id": "local-export"}),
+        encoding="utf-8",
+    )
+    manifest = tmp_path / "graph-export-manifest.json"
+    manifest.write_text(
+        json.dumps({"version": 1, "export_id": "archive-export"}),
+        encoding="utf-8",
+    )
+    seed = tmp_path / "dashboard-neighborhoods.sqlite3"
+    seed.write_bytes(b"should-not-be-extracted")
+    archive = tmp_path / "wiki-graph-runtime.tar.gz"
+    with tarfile.open(archive, "w:gz") as tar:
+        tar.add(manifest, arcname="./graphify-out/graph-export-manifest.json")
+        tar.add(seed, arcname="./graphify-out/dashboard-neighborhoods.sqlite3")
+
+    monkeypatch.setattr(cm, "_dashboard_graph_index_archives", lambda: [archive])
+    monkeypatch.setattr(
+        cm,
+        "_dashboard_index_matches_manifest",
+        lambda path: (_ for _ in ()).throw(
+            AssertionError(f"should not validate extracted index: {path}"),
+        ),
+    )
+
+    assert cm._ensure_dashboard_graph_index() is None
+    assert not (graph_dir / "dashboard-neighborhoods.sqlite3").exists()
+
+
+def test_dashboard_index_extraction_skips_installed_graph_report(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    graph_dir = fake_claude / "skill-wiki" / "graphify-out"
+    graph_dir.mkdir(parents=True)
+    (graph_dir / "graph-export-manifest.json").write_text(
+        json.dumps({"version": 1, "export_id": "local-export"}),
+        encoding="utf-8",
+    )
+    (graph_dir / "graph-report.md").write_text(
+        "> Nodes: 12 | Edges: 34 | Communities: 2\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        cm,
+        "_dashboard_graph_index_archives",
+        lambda: (_ for _ in ()).throw(AssertionError("archive scan should be skipped")),
+    )
+
+    assert cm._ensure_dashboard_graph_index() is None
+
+
+def test_graph_neighborhood_bypasses_archive_index_when_runtime_overlays_exist(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import networkx as nx
+
+    overlay = fake_claude / "skill-wiki" / "graphify-out" / "entity-overlays.jsonl"
+    overlay.parent.mkdir(parents=True)
+    overlay.write_text('{"source":"test"}\n', encoding="utf-8")
+    monkeypatch.setattr(
+        cm,
+        "_dashboard_graph_index_archives",
+        lambda: (_ for _ in ()).throw(AssertionError("archive index should be bypassed")),
+    )
+    G = nx.Graph()
+    G.add_node("skill:local-overlay", label="local-overlay", type="skill", tags=["local"])
+    monkeypatch.setattr(cm, "_load_dashboard_graph", lambda: G)
+
+    result = cm._graph_neighborhood("local-overlay", entity_type="skill")
+
+    assert result["center"] == "skill:local-overlay"
+
+
+def test_graph_neighborhood_rejects_stale_dashboard_index(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import networkx as nx
+
+    graph_dir = fake_claude / "skill-wiki" / "graphify-out"
+    graph_dir.mkdir(parents=True)
+    (graph_dir / "graph-export-manifest.json").write_text(
+        json.dumps({"version": 1, "export_id": "new-export"}),
+        encoding="utf-8",
+    )
+    index_path = graph_dir / "dashboard-neighborhoods.sqlite3"
+    conn = sqlite3.connect(index_path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany("INSERT INTO meta VALUES(?,?)", [("export_id", json.dumps("old-export"))])
+        conn.commit()
+    finally:
+        conn.close()
+
+    G = nx.Graph()
+    G.add_node("skill:fallback", label="fallback", type="skill", tags=[])
+    monkeypatch.setattr(cm, "_load_dashboard_graph", lambda: G)
+
+    result = cm._graph_neighborhood("fallback", entity_type="skill")
+
+    assert result["center"] == "skill:fallback"
+    assert not index_path.exists()
+
+
+def test_graph_neighborhood_rejects_orphan_dashboard_index_without_manifest(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import networkx as nx
+
+    graph_dir = fake_claude / "skill-wiki" / "graphify-out"
+    graph_dir.mkdir(parents=True)
+    index_path = graph_dir / "dashboard-neighborhoods.sqlite3"
+    conn = sqlite3.connect(index_path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.executemany("INSERT INTO meta VALUES(?,?)", [("export_id", json.dumps("old-export"))])
+        conn.commit()
+    finally:
+        conn.close()
+
+    G = nx.Graph()
+    G.add_node("skill:fallback", label="fallback", type="skill", tags=[])
+    monkeypatch.setattr(cm, "_load_dashboard_graph", lambda: G)
+
+    result = cm._graph_neighborhood("fallback", entity_type="skill")
+
+    assert result["center"] == "skill:fallback"
+    assert not index_path.exists()
+
+
+def test_graph_index_node_size_uses_live_sidecar_when_scores_missing(
+    fake_claude: Path,
+) -> None:
+    _write_graph_manifest(fake_claude, "test-export")
+    _write_sidecar(fake_claude, "python-patterns", {
+        "slug": "python-patterns",
+        "subject_type": "skill",
+        "grade": "A",
+        "score": 1.0,
+        "signals": {"telemetry": {"score": 1.0}},
+    })
+    index_path = fake_claude / "skill-wiki" / "graphify-out" / "dashboard-neighborhoods.sqlite3"
+    index_path.parent.mkdir(parents=True, exist_ok=True)
+    conn = sqlite3.connect(index_path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany(
+            "INSERT INTO meta VALUES(?,?)",
+            [("max_degree", "1"), ("top_k", "40"), ("export_id", json.dumps("test-export"))],
+        )
+        conn.execute(
+            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+            ("skill:python-patterns", "python-patterns", "skill", "[]", "", None, None, 0),
+        )
+        conn.execute(
+            "INSERT INTO slug_index VALUES(?,?,?)",
+            ("python-patterns", "skill", "skill:python-patterns"),
+        )
+        conn.execute("INSERT INTO neighbors VALUES(?,?)", ("skill:python-patterns", zlib.compress(b"[]")))
+        conn.commit()
+    finally:
+        conn.close()
+
+    result = cm._graph_neighborhood("python-patterns", entity_type="skill")
+    node = result["nodes"][0]["data"]
+
+    assert node["size_signal"] > 0.7
+    assert "quality 1.000" in node["size_reason"]
+    assert "usage 1.000" in node["size_reason"]
+
+
+def test_graph_neighborhood_empty_when_graph_absent(
+    fake_claude: Path,
+    monkeypatch,
+) -> None:
     # Force load_graph to raise so the helper returns the empty shape
     # deterministically, independent of whether the user's graph is built.
     import ctx_monitor as cm_mod
@@ -1471,6 +1960,22 @@ def test_render_home_shows_stat_grid_even_with_no_sessions(fake_claude: Path) ->
     assert "No sessions recorded" in html_out or "Recent sessions" in html_out
 
 
+def test_render_home_defers_sidecar_grade_scan(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    def fail_scan() -> dict[str, int]:
+        raise AssertionError("home page should not synchronously scan sidecars")
+
+    monkeypatch.setattr(cm, "_grade_distribution", fail_scan)
+
+    html_out = cm._render_home()
+
+    assert "/api/grades.json" in html_out
+    assert "home-sidecar-count" in html_out
+    assert "data-home-grade='A'" in html_out
+
+
 def test_render_skills_emits_sidebar_filters(fake_claude: Path) -> None:
     _write_sidecar(fake_claude, "a", {"slug": "a", "grade": "A", "raw_score": 0.9,
                                        "subject_type": "skill"})
@@ -1679,6 +2184,58 @@ def test_entity_upsert_api_writes_wiki_page_and_queues_graph_refresh(
         server.server_close()
 
 
+def test_entity_upsert_api_requires_confirmation_for_existing_page(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    entity_path = (
+        fake_claude / "skill-wiki" / "entities" / "agents" / "custom-reviewer.md"
+    )
+    entity_path.parent.mkdir(parents=True)
+    entity_path.write_text(
+        "---\ntitle: Custom Reviewer\ntype: agent\ntags: [python]\n"
+        "---\n# Custom Reviewer\n\nOriginal body.\n",
+        encoding="utf-8",
+    )
+    server, thread, port = _serve_monitor(monkeypatch)
+    try:
+        status, payload = _post_json(
+            port,
+            "/api/entity/upsert",
+            {
+                "slug": "custom-reviewer",
+                "entity_type": "agent",
+                "title": "Custom Reviewer",
+                "body": "# Custom Reviewer\n\nReplacement body.\n",
+            },
+            token="test-token",
+        )
+        assert status == 400
+        assert payload["ok"] is False
+        assert "confirm_update=true" in payload["detail"]
+        assert "Original body." in entity_path.read_text(encoding="utf-8")
+
+        status, payload = _post_json(
+            port,
+            "/api/entity/upsert",
+            {
+                "slug": "custom-reviewer",
+                "entity_type": "agent",
+                "title": "Custom Reviewer",
+                "body": "# Custom Reviewer\n\nReplacement body.\n",
+                "confirm_update": "true",
+            },
+            token="test-token",
+        )
+        assert status == 200
+        assert payload["ok"] is True
+        assert "Replacement body." in entity_path.read_text(encoding="utf-8")
+    finally:
+        server.shutdown()
+        thread.join(timeout=5)
+        server.server_close()
+
+
 def test_entity_delete_api_removes_wiki_page_and_queues_graph_refresh(
     fake_claude: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -1710,17 +2267,34 @@ def test_entity_delete_api_removes_wiki_page_and_queues_graph_refresh(
             wiki_queue.queue_db_path(fake_claude / "skill-wiki"),
             limit=10,
         )
-        assert [job.kind for job in jobs[:2]] == [
-            wiki_queue.GRAPH_EXPORT_JOB,
-            wiki_queue.ENTITY_UPSERT_JOB,
-        ]
-        assert jobs[1].payload["action"] == "delete"
+        assert [job.kind for job in jobs] == [wiki_queue.ENTITY_UPSERT_JOB]
+        assert jobs[0].payload["action"] == "delete"
     finally:
         server.shutdown()
         thread.join(timeout=5)
         server.server_close()
 
 
+def test_sidecar_cache_invalidates_on_file_rewrite(fake_claude: Path) -> None:
+    cm._SIDECAR_INDEX_CACHE_KEY = None
+    cm._SIDECAR_INDEX_CACHE_VALUE = None
+    path = fake_claude / "skill-quality" / "alpha.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        json.dumps({"slug": "alpha", "subject_type": "skill", "grade": "A"}),
+        encoding="utf-8",
+    )
+    assert cm._all_sidecars()[0]["grade"] == "A"
+
+    path.write_text(
+        json.dumps({"slug": "alpha", "subject_type": "skill", "grade": "F"}),
+        encoding="utf-8",
+    )
+    os.utime(path, (time.time() + 2.0, time.time() + 2.0))
+
+    assert cm._all_sidecars()[0]["grade"] == "F"
+
+
 def test_render_kpi_empty_state(fake_claude: Path) -> None:
     """With no sidecars, /kpi must render a helpful empty state, not 500."""
     html_out = cm._render_kpi()

src/tests/test_ctx_monitor_3type.py

@@ -79,6 +79,7 @@ def wiki_3type(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
     )
 
     monkeypatch.setattr(_cm, "_wiki_dir", lambda: wiki)
+    monkeypatch.setattr(_cm, "_dashboard_graph_index_archives", lambda: [])
     return wiki
 
 
@@ -888,6 +889,7 @@ class TestRenderGraphSidebar:
 
     def test_graph_neighborhood_filter_tokens_include_edge_shared_tags(
         self,
+        wiki_3type,
         monkeypatch,
     ):
         graph = nx.Graph()

src/tests/test_ctx_monitor_browser.py

@@ -39,6 +39,7 @@ def fake_claude(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
     claude = tmp_path / ".claude"
     (claude / "skill-quality").mkdir(parents=True)
     monkeypatch.setattr(cm, "_claude_dir", lambda: claude)
+    monkeypatch.setattr(cm, "_dashboard_graph_index_archives", lambda: [])
     return claude
 
 

src/tests/test_incremental_attach_az_flow.py

@@ -116,6 +116,7 @@ def test_entity_onboarding_incremental_attach_a_to_z(
     monkeypatch.setattr(mcp_add, "check_intake", _allow_intake)
     monkeypatch.setattr(mcp_add, "record_embedding", lambda **_kwargs: None)
     monkeypatch.setattr(cm, "_claude_dir", lambda: claude)
+    monkeypatch.setattr(cm, "_dashboard_graph_index_archives", lambda: [])
 
     source = tmp_path / "SKILL.md"
     source.write_text(

src/tests/test_mcp_add.py

@@ -30,6 +30,7 @@ if str(SRC_DIR) not in sys.path:
     sys.path.insert(0, str(SRC_DIR))
 
 from mcp_entity import McpRecord  # noqa: E402
+from ctx.core.wiki import wiki_queue  # noqa: E402
 
 
 # ---------------------------------------------------------------------------
@@ -197,85 +198,85 @@ class TestAddMcpIdempotency:
         assert len(result2["merged_sources"]) == 1
 
 
-class TestAddMcpSourceMerging:
-    def test_two_different_sources_merged_and_sorted(
-        self, patched_mcp_add: Any, wiki_dir: Path
-    ) -> None:
-        record_a = _make_record(name="github-mcp", sources=["awesome-mcp"])
+class TestAddMcpSourceMerging:
+    def test_two_different_sources_merged_and_sorted(
+        self, patched_mcp_add: Any, wiki_dir: Path
+    ) -> None:
+        record_a = _make_record(name="github-mcp", sources=["awesome-mcp"])
         record_b = _make_record(name="github-mcp", sources=["pulsemcp"])
 
         patched_mcp_add.add_mcp(record=record_a, wiki_path=wiki_dir)
         result2 = patched_mcp_add.add_mcp(record=record_b, wiki_path=wiki_dir)
 
-        assert sorted(result2["merged_sources"]) == ["awesome-mcp", "pulsemcp"]
-        assert result2["is_new_page"] is False
-
-
-class TestAddMcpExistingReview:
-    def test_review_existing_skips_and_preserves_existing_page(
-        self, patched_mcp_add: Any, wiki_dir: Path
-    ) -> None:
-        record_a = _make_record(
-            name="github-mcp",
-            sources=["awesome-mcp"],
-            description="A GitHub MCP server with repository management support.",
-        )
-        patched_mcp_add.add_mcp(record=record_a, wiki_path=wiki_dir)
-        page = wiki_dir / "entities" / "mcp-servers" / "g" / "github-mcp.md"
-        original_text = page.read_text(encoding="utf-8")
-
-        record_b = _make_record(
-            name="github-mcp",
-            sources=["pulsemcp"],
-            description="GitHub MCP.",
-        )
-        result = patched_mcp_add.add_mcp(
-            record=record_b,
-            wiki_path=wiki_dir,
-            review_existing=True,
-        )
-
-        assert result["is_new_page"] is False
-        assert result["skipped"] is True
-        assert result["update_required"] is True
-        assert result["merged_sources"] == ["awesome-mcp", "pulsemcp"]
-        assert "Existing mcp-server already exists: github-mcp" in result["update_review"]
-        assert "Benefits:" in result["update_review"]
-        assert page.read_text(encoding="utf-8") == original_text
-
-    def test_update_existing_applies_reviewed_merge(
-        self, patched_mcp_add: Any, wiki_dir: Path
-    ) -> None:
-        record_a = _make_record(name="github-mcp", sources=["awesome-mcp"])
-        patched_mcp_add.add_mcp(record=record_a, wiki_path=wiki_dir)
-
-        record_b = _make_record(
-            name="github-mcp",
-            sources=["pulsemcp"],
-            description="A longer GitHub MCP server description with more detail.",
-        )
-        result = patched_mcp_add.add_mcp(
-            record=record_b,
-            wiki_path=wiki_dir,
-            review_existing=True,
-            update_existing=True,
-        )
-
-        page = wiki_dir / "entities" / "mcp-servers" / "g" / "github-mcp.md"
-        text = page.read_text(encoding="utf-8")
-        _, fm_block, _ = text.split("---", 2)
-        fm = yaml.safe_load(fm_block)
-        assert isinstance(fm, dict)
-        assert result["is_new_page"] is False
-        assert result["skipped"] is False
-        assert result["merged_sources"] == ["awesome-mcp", "pulsemcp"]
-        assert fm["sources"] == ["awesome-mcp", "pulsemcp"]
-        assert fm["description"] == record_b.description
-
-
-# ---------------------------------------------------------------------------
-# dry_run
-# ---------------------------------------------------------------------------
+        assert sorted(result2["merged_sources"]) == ["awesome-mcp", "pulsemcp"]
+        assert result2["is_new_page"] is False
+
+
+class TestAddMcpExistingReview:
+    def test_review_existing_skips_and_preserves_existing_page(
+        self, patched_mcp_add: Any, wiki_dir: Path
+    ) -> None:
+        record_a = _make_record(
+            name="github-mcp",
+            sources=["awesome-mcp"],
+            description="A GitHub MCP server with repository management support.",
+        )
+        patched_mcp_add.add_mcp(record=record_a, wiki_path=wiki_dir)
+        page = wiki_dir / "entities" / "mcp-servers" / "g" / "github-mcp.md"
+        original_text = page.read_text(encoding="utf-8")
+
+        record_b = _make_record(
+            name="github-mcp",
+            sources=["pulsemcp"],
+            description="GitHub MCP.",
+        )
+        result = patched_mcp_add.add_mcp(
+            record=record_b,
+            wiki_path=wiki_dir,
+            review_existing=True,
+        )
+
+        assert result["is_new_page"] is False
+        assert result["skipped"] is True
+        assert result["update_required"] is True
+        assert result["merged_sources"] == ["awesome-mcp", "pulsemcp"]
+        assert "Existing mcp-server already exists: github-mcp" in result["update_review"]
+        assert "Benefits:" in result["update_review"]
+        assert page.read_text(encoding="utf-8") == original_text
+
+    def test_update_existing_applies_reviewed_merge(
+        self, patched_mcp_add: Any, wiki_dir: Path
+    ) -> None:
+        record_a = _make_record(name="github-mcp", sources=["awesome-mcp"])
+        patched_mcp_add.add_mcp(record=record_a, wiki_path=wiki_dir)
+
+        record_b = _make_record(
+            name="github-mcp",
+            sources=["pulsemcp"],
+            description="A longer GitHub MCP server description with more detail.",
+        )
+        result = patched_mcp_add.add_mcp(
+            record=record_b,
+            wiki_path=wiki_dir,
+            review_existing=True,
+            update_existing=True,
+        )
+
+        page = wiki_dir / "entities" / "mcp-servers" / "g" / "github-mcp.md"
+        text = page.read_text(encoding="utf-8")
+        _, fm_block, _ = text.split("---", 2)
+        fm = yaml.safe_load(fm_block)
+        assert isinstance(fm, dict)
+        assert result["is_new_page"] is False
+        assert result["skipped"] is False
+        assert result["merged_sources"] == ["awesome-mcp", "pulsemcp"]
+        assert fm["sources"] == ["awesome-mcp", "pulsemcp"]
+        assert fm["description"] == record_b.description
+
+
+# ---------------------------------------------------------------------------
+# dry_run
+# ---------------------------------------------------------------------------
 
 
 class TestAddMcpDryRun:
@@ -545,8 +546,15 @@ class TestCrossSourceCanonicalKeyDedup:
         # not its own slug-based path.
         assert result2["is_new_page"] is False
         assert result2["path"] == str(first_path)
+        assert result2["slug"] == first_path.stem
         assert result2["merged_sources"] == ["awesome-mcp", "pulsemcp"]
 
+        jobs = wiki_queue.list_jobs(wiki_queue.queue_db_path(wiki_dir))
+        assert jobs[-1].payload["slug"] == first_path.stem
+        assert jobs[-1].payload["entity_path"] == str(
+            first_path.relative_to(wiki_dir)
+        ).replace("\\", "/")
+
         # And only ONE entity file exists in the wiki.
         all_entities = list(
             (wiki_dir / "entities" / "mcp-servers").rglob("*.md")

src/tests/test_validate_graph_artifacts.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import gzip
 import json
+import sqlite3
 import tarfile
+import zlib
 from io import BytesIO
 from pathlib import Path
 from typing import Any
@@ -35,6 +37,69 @@ def _add_text(tf: tarfile.TarFile, name: str, text: str) -> None:
     tf.addfile(info, BytesIO(payload))
 
 
+def _add_bytes(tf: tarfile.TarFile, name: str, payload: bytes) -> None:
+    info = tarfile.TarInfo(name)
+    info.size = len(payload)
+    info.mode = 0o644
+    tf.addfile(info, BytesIO(payload))
+
+
+def _dashboard_index_bytes(graph_dir: Path, *, export_id: str) -> bytes:
+    path = graph_dir / f"dashboard-index-{export_id}.sqlite3"
+    if path.exists():
+        path.unlink()
+    conn = sqlite3.connect(path)
+    try:
+        conn.execute("CREATE TABLE meta(key TEXT PRIMARY KEY, value TEXT NOT NULL)")
+        conn.execute(
+            "CREATE TABLE nodes(id TEXT PRIMARY KEY,label TEXT,type TEXT,tags TEXT,"
+            "description TEXT,quality_score REAL,usage_score REAL,degree INTEGER)"
+        )
+        conn.execute(
+            "CREATE TABLE slug_index(slug TEXT,type TEXT,node_id TEXT,"
+            "PRIMARY KEY(slug,type,node_id))"
+        )
+        conn.execute("CREATE TABLE neighbors(source TEXT PRIMARY KEY, payload BLOB NOT NULL)")
+        conn.executemany(
+            "INSERT INTO meta VALUES(?,?)",
+            [
+                ("version", "1"),
+                ("export_id", json.dumps(export_id)),
+                ("nodes_count", "2"),
+                ("edges_count", "1"),
+                ("max_degree", "1"),
+                ("top_k", "40"),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO nodes VALUES(?,?,?,?,?,?,?,?)",
+            [
+                ("skill:skills-sh-example-skill", "skills-sh-example-skill", "skill", "[]", "", None, None, 1),
+                ("harness:langgraph", "langgraph", "harness", "[]", "", None, None, 1),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO slug_index VALUES(?,?,?)",
+            [
+                ("skills-sh-example-skill", "skill", "skill:skills-sh-example-skill"),
+                ("langgraph", "harness", "harness:langgraph"),
+            ],
+        )
+        conn.executemany(
+            "INSERT INTO neighbors VALUES(?,?)",
+            [
+                ("skill:skills-sh-example-skill", zlib.compress(json.dumps([{"target": "harness:langgraph"}]).encode("utf-8"))),
+                ("harness:langgraph", zlib.compress(json.dumps([{"target": "skill:skills-sh-example-skill"}]).encode("utf-8"))),
+            ],
+        )
+        conn.commit()
+    finally:
+        conn.close()
+    payload = path.read_bytes()
+    path.unlink()
+    return payload
+
+
 def _write_catalog(graph_dir: Path, *, converted_path: str | None = None) -> None:
     skill = {
         "ctx_slug": "skills-sh-example-skill",
@@ -101,6 +166,11 @@ def _write_runtime_archive(
                     "counts": {"nodes": 2, "edges": 1, "communities": 1},
                 }),
             )
+        _add_bytes(
+            tf,
+            "graphify-out/dashboard-neighborhoods.sqlite3",
+            _dashboard_index_bytes(graph_dir, export_id=manifest_export_id),
+        )
         _add_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
         if include_queue:
             _add_text(tf, ".ctx/wiki-queue.sqlite3", "not a shipped artifact\n")
@@ -181,6 +251,11 @@ def _write_archive(
                     "counts": {"nodes": 2, "edges": 1, "communities": 1},
                 }),
             )
+        _add_bytes(
+            tf,
+            "./graphify-out/dashboard-neighborhoods.sqlite3",
+            _dashboard_index_bytes(graph_dir, export_id=manifest_export_id),
+        )
         _add_text(tf, "./external-catalogs/skills-sh/catalog.json", "{}")
         _add_text(tf, "./entities/skills/skills-sh-example-skill.md", "# Example\n")
         _add_text(tf, "./entities/harnesses/langgraph.md", "# LangGraph\n")
@@ -312,6 +387,161 @@ def test_validate_graph_artifacts_rejects_mixed_export_generation(
         )
 
 
+def test_validate_graph_artifacts_rejects_runtime_full_export_split(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    _write_archive(tmp_path, graph_export_id="full-export")
+    runtime_graph = {
+        "graph": {"export_id": "runtime-export"},
+        "nodes": [
+            {"id": "skill:skills-sh-example-skill", "type": "skill"},
+            {"id": "harness:langgraph", "type": "harness"},
+        ],
+        "edges": [
+            {"source": "skill:skills-sh-example-skill", "target": "harness:langgraph"},
+        ],
+    }
+    _write_runtime_archive(
+        tmp_path,
+        graph=runtime_graph,
+        delta_export_id="runtime-export",
+        communities_export_id="runtime-export",
+        report_export_id="runtime-export",
+        manifest_export_id="runtime-export",
+    )
+
+    with pytest.raises(GraphArtifactError, match="runtime graph archive export_id mismatch"):
+        validate_graph_artifacts(
+            tmp_path,
+            deep=True,
+            min_nodes=2,
+            min_edges=1,
+            min_skills_sh_nodes=1,
+            min_semantic_edges=1,
+            expected_harnesses={"langgraph"},
+        )
+
+
+def test_validate_graph_artifacts_rejects_corrupt_dashboard_index(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    _write_archive(tmp_path)
+    with tarfile.open(tmp_path / "wiki-graph-runtime.tar.gz", "w:gz") as tf:
+        graph = {
+            "graph": {"export_id": "export-test"},
+            "nodes": [
+                {"id": "skill:skills-sh-example-skill", "type": "skill"},
+                {"id": "harness:langgraph", "type": "harness"},
+            ],
+            "edges": [
+                {"source": "skill:skills-sh-example-skill", "target": "harness:langgraph"},
+            ],
+        }
+        _add_text(tf, "index.md", "# Wiki\n")
+        _add_text(tf, "graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
+        _add_text(tf, "graphify-out/graph-delta.json", json.dumps({"export_id": "export-test"}))
+        _add_text(tf, "graphify-out/communities.json", json.dumps({"export_id": "export-test"}))
+        _add_text(tf, "graphify-out/graph-report.md", "# Graph Report\n\n> Export ID: export-test\n")
+        _add_text(
+            tf,
+            "graphify-out/graph-export-manifest.json",
+            json.dumps({
+                "version": 1,
+                "export_id": "export-test",
+                "artifacts": {
+                    "graph": "graph.json",
+                    "delta": "graph-delta.json",
+                    "communities": "communities.json",
+                    "report": "graph-report.md",
+                },
+                "counts": {"nodes": 2, "edges": 1, "communities": 1},
+            }),
+        )
+        _add_text(tf, "graphify-out/dashboard-neighborhoods.sqlite3", "not sqlite\n")
+        _add_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
+        for slug in sorted(DEFAULT_HARNESSES):
+            _add_text(tf, f"entities/harnesses/{slug}.md", f"# {slug}\n")
+
+    with pytest.raises(GraphArtifactError, match="dashboard index"):
+        validate_graph_artifacts(
+            tmp_path,
+            deep=True,
+            min_nodes=2,
+            min_edges=1,
+            min_skills_sh_nodes=1,
+            min_semantic_edges=1,
+            expected_harnesses={"langgraph"},
+        )
+
+
+def test_validate_graph_artifacts_rejects_stale_dashboard_index(
+    tmp_path: Path,
+) -> None:
+    _write_catalog(
+        tmp_path,
+        converted_path="converted/skills-sh-example-skill/SKILL.md",
+    )
+    _write_archive(tmp_path, graph_export_id="new-export", manifest_export_id="new-export")
+    with tarfile.open(tmp_path / "wiki-graph-runtime.tar.gz", "w:gz") as tf:
+        graph = {
+            "graph": {"export_id": "new-export"},
+            "nodes": [
+                {"id": "skill:skills-sh-example-skill", "type": "skill"},
+                {"id": "harness:langgraph", "type": "harness"},
+            ],
+            "edges": [
+                {"source": "skill:skills-sh-example-skill", "target": "harness:langgraph"},
+            ],
+        }
+        _add_text(tf, "index.md", "# Wiki\n")
+        _add_text(tf, "graphify-out/graph.json", json.dumps(graph, separators=(",", ":")))
+        _add_text(tf, "graphify-out/graph-delta.json", json.dumps({"export_id": "new-export"}))
+        _add_text(tf, "graphify-out/communities.json", json.dumps({"export_id": "new-export"}))
+        _add_text(tf, "graphify-out/graph-report.md", "# Graph Report\n\n> Export ID: new-export\n")
+        _add_text(
+            tf,
+            "graphify-out/graph-export-manifest.json",
+            json.dumps({
+                "version": 1,
+                "export_id": "new-export",
+                "artifacts": {
+                    "graph": "graph.json",
+                    "delta": "graph-delta.json",
+                    "communities": "communities.json",
+                    "report": "graph-report.md",
+                },
+                "counts": {"nodes": 2, "edges": 1, "communities": 1},
+            }),
+        )
+        _add_bytes(
+            tf,
+            "graphify-out/dashboard-neighborhoods.sqlite3",
+            _dashboard_index_bytes(tmp_path, export_id="old-export"),
+        )
+        _add_text(tf, "external-catalogs/skills-sh/catalog.json", "{}")
+        for slug in sorted(DEFAULT_HARNESSES):
+            _add_text(tf, f"entities/harnesses/{slug}.md", f"# {slug}\n")
+
+    with pytest.raises(GraphArtifactError, match="dashboard index export_id mismatch"):
+        validate_graph_artifacts(
+            tmp_path,
+            deep=True,
+            min_nodes=2,
+            min_edges=1,
+            min_skills_sh_nodes=1,
+            min_semantic_edges=1,
+            expected_harnesses={"langgraph"},
+        )
+
+
 def test_validate_graph_artifacts_rejects_stale_preview_html(
     tmp_path: Path,
 ) -> None:
@@ -618,17 +848,17 @@ def test_graph_only_workflow_uses_exact_release_counts() -> None:
         "--min-edges": "2000000",
         "--min-skills-sh-nodes": "89000",
         "--min-semantic-edges": "1000000",
-        "--expected-nodes": "102718",
-        "--expected-edges": "2911220",
-        "--expected-semantic-edges": "1683265",
-        "--expected-harness-nodes": "14",
+        "--expected-nodes": "102717",
+        "--expected-edges": "2911162",
+        "--expected-semantic-edges": "1683182",
+        "--expected-harness-nodes": "15",
         "--expected-skills-sh-nodes": "89463",
         "--expected-skills-sh-catalog-entries": "89463",
         "--expected-skills-sh-converted": "89463",
-        "--expected-skill-pages": "91450",
+        "--expected-skill-pages": "91448",
         "--expected-agent-pages": "467",
         "--expected-mcp-pages": "10787",
-        "--expected-harness-pages": "14",
+        "--expected-harness-pages": "15",
         "--line-threshold": "180",
         "--max-stage-lines": "40",
     }

src/tests/test_wiki_queue_worker.py

@@ -154,6 +154,44 @@ def test_process_next_entity_upsert_does_not_fail_when_incremental_attach_fails(
     assert "incremental attach skipped (embedding backend missing)" in result.message
 
 
+def test_process_next_entity_delete_queues_full_graph_refresh(
+    tmp_path: Path,
+    monkeypatch: Any,
+) -> None:
+    wiki = tmp_path / "wiki"
+    entity_path = wiki / "entities" / "skills" / "deleted.md"
+    queued = wiki_queue.enqueue_entity_upsert(
+        wiki,
+        entity_type="skill",
+        slug="deleted",
+        entity_path=entity_path,
+        content="",
+        action="delete",
+        source="test",
+        now=10.0,
+    )
+    update_index = MagicMock()
+    monkeypatch.setattr(wiki_queue_worker, "update_index", update_index)
+
+    result = wiki_queue_worker.process_next(wiki, worker_id="worker-a", now=20.0)
+
+    assert result is not None
+    assert result.job_id == queued.id
+    assert result.status == wiki_queue.STATUS_SUCCEEDED
+    assert result.message == "queued full graph refresh for deleted skills entity deleted"
+    update_index.assert_not_called()
+    jobs = wiki_queue.list_jobs(wiki_queue.queue_db_path(wiki))
+    assert [job.kind for job in jobs] == [
+        wiki_queue.ENTITY_UPSERT_JOB,
+        wiki_queue.GRAPH_EXPORT_JOB,
+    ]
+    assert jobs[1].payload == {
+        "graph_only": True,
+        "incremental": False,
+        "source": "entity-delete",
+    }
+
+
 def test_process_next_retries_hash_mismatch(
     tmp_path: Path,
     monkeypatch: Any,

src/validate_graph_artifacts.py

@@ -7,7 +7,10 @@ import argparse
 import gzip
 import json
 import re
+import sqlite3
 import tarfile
+import tempfile
+import zlib
 from dataclasses import dataclass
 from pathlib import Path
 from typing import IO, Any
@@ -23,7 +26,9 @@ DEFAULT_HARNESSES = {
     "langgraph",
     "litellm",
     "mastra",
+    "mirage",
     "openai-agents-sdk",
+    "optillm",
     "pydantic-ai",
     "semantic-kernel",
     "text-to-cad",
@@ -56,8 +61,32 @@ _GRAPH_RUNTIME_REQUIRED_NAMES = {
     "graphify-out/communities.json",
     "graphify-out/graph-report.md",
     "graphify-out/graph-export-manifest.json",
+    "graphify-out/dashboard-neighborhoods.sqlite3",
     "external-catalogs/skills-sh/catalog.json",
 }
+_DASHBOARD_INDEX_REQUIRED_TABLES = {"meta", "nodes", "slug_index", "neighbors"}
+_DASHBOARD_INDEX_REQUIRED_META = {
+    "export_id",
+    "nodes_count",
+    "edges_count",
+    "max_degree",
+    "top_k",
+}
+_DASHBOARD_INDEX_REQUIRED_COLUMNS = {
+    "meta": {"key", "value"},
+    "nodes": {
+        "id",
+        "label",
+        "type",
+        "tags",
+        "description",
+        "quality_score",
+        "usage_score",
+        "degree",
+    },
+    "slug_index": {"slug", "type", "node_id"},
+    "neighbors": {"source", "payload"},
+}
 
 
 class GraphArtifactError(RuntimeError):
@@ -102,6 +131,84 @@ def _require_real_file(path: Path) -> None:
         raise GraphArtifactError(f"{path} is a Git LFS pointer, not hydrated content")
 
 
+def _copy_tar_member_to_path(
+    tf: tarfile.TarFile,
+    member: tarfile.TarInfo,
+    target: Path,
+) -> None:
+    source = tf.extractfile(member)
+    if source is None:
+        raise GraphArtifactError(f"{member.name} could not be read")
+    try:
+        with target.open("wb") as out:
+            while chunk := source.read(1024 * 1024):
+                out.write(chunk)
+    finally:
+        source.close()
+
+
+def _validate_dashboard_index(
+    path: Path,
+    *,
+    expected_export_id: str,
+    context: str,
+) -> None:
+    try:
+        conn = sqlite3.connect(f"file:{path.as_posix()}?mode=ro", uri=True)
+        conn.row_factory = sqlite3.Row
+    except sqlite3.Error as exc:
+        raise GraphArtifactError(f"{context} dashboard index is not valid SQLite: {exc}") from exc
+    try:
+        quick = conn.execute("PRAGMA quick_check").fetchone()
+        if quick is None or str(quick[0]).lower() != "ok":
+            raise GraphArtifactError(f"{context} dashboard index quick_check failed: {quick}")
+        tables = {
+            str(row["name"])
+            for row in conn.execute("SELECT name FROM sqlite_master WHERE type='table'")
+        }
+        missing_tables = sorted(_DASHBOARD_INDEX_REQUIRED_TABLES - tables)
+        if missing_tables:
+            raise GraphArtifactError(
+                f"{context} dashboard index missing tables: {missing_tables}",
+            )
+        for table, expected_columns in _DASHBOARD_INDEX_REQUIRED_COLUMNS.items():
+            columns = {str(row["name"]) for row in conn.execute(f"PRAGMA table_info({table})")}
+            missing_columns = sorted(expected_columns - columns)
+            if missing_columns:
+                raise GraphArtifactError(
+                    f"{context} dashboard index table {table} missing columns: "
+                    f"{missing_columns}",
+                )
+        meta_rows = conn.execute("SELECT key,value FROM meta").fetchall()
+        meta = {str(row["key"]): json.loads(str(row["value"])) for row in meta_rows}
+        missing_meta = sorted(_DASHBOARD_INDEX_REQUIRED_META - set(meta))
+        if missing_meta:
+            raise GraphArtifactError(
+                f"{context} dashboard index missing meta keys: {missing_meta}",
+            )
+        if meta.get("export_id") != expected_export_id:
+            raise GraphArtifactError(
+                f"{context} dashboard index export_id mismatch: expected "
+                f"{expected_export_id}, got {meta.get('export_id') or 'missing'}",
+            )
+        nodes_count = int(meta.get("nodes_count") or 0)
+        if nodes_count != int(conn.execute("SELECT COUNT(*) FROM nodes").fetchone()[0]):
+            raise GraphArtifactError(f"{context} dashboard index nodes_count mismatch")
+        if nodes_count > 0 and int(conn.execute("SELECT COUNT(*) FROM slug_index").fetchone()[0]) == 0:
+            raise GraphArtifactError(f"{context} dashboard index slug_index is empty")
+        payload = conn.execute("SELECT payload FROM neighbors LIMIT 1").fetchone()
+        if payload is not None:
+            decoded = json.loads(zlib.decompress(payload["payload"]).decode("utf-8"))
+            if not isinstance(decoded, list):
+                raise GraphArtifactError(
+                    f"{context} dashboard index neighbor payload is not a list",
+                )
+    except (sqlite3.Error, json.JSONDecodeError, ValueError, TypeError, zlib.error) as exc:
+        raise GraphArtifactError(f"{context} dashboard index validation failed: {exc}") from exc
+    finally:
+        conn.close()
+
+
 def _safe_tar_name(raw_name: str) -> str:
     name = raw_name.replace("\\", "/")
     if (
@@ -252,7 +359,7 @@ def validate_graph_artifacts(
         _require_real_file(path)
 
     expected_harnesses = DEFAULT_HARNESSES if expected_harnesses is None else expected_harnesses
-    _validate_runtime_graph_archive(
+    runtime_export_id = _validate_runtime_graph_archive(
         runtime_tarball,
         expected_harnesses=expected_harnesses,
     )
@@ -289,6 +396,7 @@ def validate_graph_artifacts(
     export_ids: dict[str, str] = {}
     manifest: dict[str, Any] | None = None
     archive_communities: dict[str, Any] | None = None
+    dashboard_index_path: Path | None = None
 
     with tarfile.open(tarball, "r:gz") as tf:
         for member in tf:
@@ -353,6 +461,11 @@ def validate_graph_artifacts(
                 if f is None:
                     raise GraphArtifactError(f"{member.name} could not be read")
                 _record_export_id(export_ids, name, _export_id_from_report(f.read()))
+            elif member.isfile() and name == "graphify-out/dashboard-neighborhoods.sqlite3":
+                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".sqlite3")
+                tmp.close()
+                dashboard_index_path = Path(tmp.name)
+                _copy_tar_member_to_path(tf, member, dashboard_index_path)
             elif member.isfile() and deep and name.startswith("converted/skills-sh-"):
                 if name.endswith("/SKILL.md") or "/references/" in name:
                     f = tf.extractfile(member)
@@ -370,11 +483,26 @@ def validate_graph_artifacts(
     if missing_required:
         raise GraphArtifactError(f"wiki graph archive is missing: {missing_required}")
     manifest_export_id = _validate_graph_export_manifest(manifest, names)
+    if runtime_export_id != manifest_export_id:
+        raise GraphArtifactError(
+            "runtime graph archive export_id mismatch: expected "
+            f"{manifest_export_id}, got {runtime_export_id}",
+        )
     _record_export_id(
         export_ids,
         "graphify-out/graph-export-manifest.json",
         manifest_export_id,
     )
+    if dashboard_index_path is None:
+        raise GraphArtifactError("graphify-out/dashboard-neighborhoods.sqlite3 is missing")
+    try:
+        _validate_dashboard_index(
+            dashboard_index_path,
+            expected_export_id=manifest_export_id,
+            context="full archive",
+        )
+    finally:
+        dashboard_index_path.unlink(missing_ok=True)
     if "graphify-out/graph.json" not in export_ids:
         raise GraphArtifactError("graphify-out/graph.json is missing export_id")
     _validate_export_ids(export_ids, expected=manifest_export_id)
@@ -461,10 +589,12 @@ def _validate_runtime_graph_archive(
     tarball: Path,
     *,
     expected_harnesses: set[str],
-) -> None:
+    expected_export_id: str | None = None,
+) -> str:
     names: set[str] = set()
     export_ids: dict[str, str] = {}
     manifest: dict[str, Any] | None = None
+    dashboard_index_path: Path | None = None
     with tarfile.open(tarball, "r:gz") as tf:
         for member in tf:
             name = _safe_tar_name(member.name)
@@ -506,6 +636,11 @@ def _validate_runtime_graph_archive(
                 if f is None:
                     raise GraphArtifactError(f"{member.name} could not be read")
                 _record_export_id(export_ids, name, _export_id_from_report(f.read()))
+            elif member.isfile() and name == "graphify-out/dashboard-neighborhoods.sqlite3":
+                tmp = tempfile.NamedTemporaryFile(delete=False, suffix=".sqlite3")
+                tmp.close()
+                dashboard_index_path = Path(tmp.name)
+                _copy_tar_member_to_path(tf, member, dashboard_index_path)
 
     missing_required = sorted(_GRAPH_RUNTIME_REQUIRED_NAMES - names)
     if missing_required:
@@ -527,9 +662,27 @@ def _validate_runtime_graph_archive(
         "graphify-out/graph-export-manifest.json",
         manifest_export_id,
     )
+    if dashboard_index_path is None:
+        raise GraphArtifactError(
+            "runtime graph archive is missing dashboard-neighborhoods.sqlite3",
+        )
+    try:
+        _validate_dashboard_index(
+            dashboard_index_path,
+            expected_export_id=manifest_export_id,
+            context="runtime archive",
+        )
+    finally:
+        dashboard_index_path.unlink(missing_ok=True)
     if "graphify-out/graph.json" not in export_ids:
         raise GraphArtifactError("runtime graph.json is missing export_id")
     _validate_export_ids(export_ids, expected=manifest_export_id)
+    if expected_export_id is not None and manifest_export_id != expected_export_id:
+        raise GraphArtifactError(
+            "runtime graph archive export_id mismatch: expected "
+            f"{expected_export_id}, got {manifest_export_id}",
+        )
+    return manifest_export_id
 
 
 def _validate_root_communities(