Add files using upload-large-folder tool

scripts/ci_classifier.py

@@ -86,6 +86,12 @@ def _normalize_path(path: str) -> str:
     return path.strip().lstrip("\ufeff").replace("\\", "/")
 
 
+def _is_graph_artifact_path(path: str) -> bool:
+    if _matches(path, GRAPH_ARTIFACT_PATTERNS):
+        return True
+    return _matches(path, ("graph/**",)) and path != "graph/README.md"
+
+
 def classify_paths(paths: Iterable[str]) -> dict[str, bool]:
     files = [
         normalized
@@ -94,9 +100,7 @@ def classify_paths(paths: Iterable[str]) -> dict[str, bool]:
     ]
     ci_changed = any(_matches(path, (".github/workflows/**",)) for path in files)
     docs_changed = any(_matches(path, DOCS_PATTERNS) for path in files)
-    graph_artifact_changed = any(
-        _matches(path, GRAPH_ARTIFACT_PATTERNS) for path in files
-    )
+    graph_artifact_changed = any(_is_graph_artifact_path(path) for path in files)
     graph_only = bool(files) and all(_matches(path, ("graph/**",)) for path in files)
     return {
         "browser_changed": ci_changed

scripts/ci_preflight.py

@@ -36,28 +36,28 @@ GRAPH_VALIDATE_ARGS = (
     "89000",
     "--min-semantic-edges",
     "1000000",
-    "--expected-nodes",
-    "102925",
-    "--expected-edges",
-    "2913930",
+    "--expected-nodes",
+    "102928",
+    "--expected-edges",
+    "2913960",
     "--expected-semantic-edges",
-    "1683163",
-    "--expected-harness-nodes",
-    "207",
+    "1683193",
+    "--expected-harness-nodes",
+    "207",
     "--expected-skills-sh-nodes",
     "89471",
     "--expected-skills-sh-catalog-entries",
     "89465",
     "--expected-skills-sh-converted",
     "89465",
-    "--expected-skill-pages",
-    "91463",
+    "--expected-skill-pages",
+    "91464",
     "--expected-agent-pages",
     "467",
-    "--expected-mcp-pages",
-    "10788",
-    "--expected-harness-pages",
-    "207",
+    "--expected-mcp-pages",
+    "10790",
+    "--expected-harness-pages",
+    "207",
     "--line-threshold",
     "180",
     "--max-stage-lines",

scripts/ci_required.py

@@ -71,6 +71,10 @@ def failed_required_jobs(
         event_name == "pull_request"
         and _job_output(needs, "classify", "graph_artifact_changed") == "true"
     )
+    similarity_changed_pr = (
+        event_name == "pull_request"
+        and _job_output(needs, "classify", "similarity_changed") == "true"
+    )
     cheap_pr = docs_only_pr or graph_only_pr
     for name, details in sorted(needs.items()):
         result = details.get("result")
@@ -82,7 +86,12 @@ def failed_required_jobs(
             and result == "skipped"
         ):
             continue
-        if cheap_pr and name in CHEAP_PR_SKIPPABLE_JOBS and result == "skipped":
+        if (
+            cheap_pr
+            and name in CHEAP_PR_SKIPPABLE_JOBS
+            and not (name == "similarity-integration" and similarity_changed_pr)
+            and result == "skipped"
+        ):
             continue
         if (
             event_name == "pull_request"

scripts/graph_artifact_guard.py

@@ -10,6 +10,8 @@ DEFAULT_ARTIFACTS = (
     "graph/wiki-graph.tar.gz",
     "graph/wiki-graph-runtime.tar.gz",
     "graph/skills-sh-catalog.json.gz",
+    "graph/communities.json",
+    "graph/entity-overlays.jsonl",
 )
 
 STALE_GRAPH_PATTERNS = (
@@ -80,12 +82,15 @@ def _print_status(repo: Path, artifacts: list[str]) -> None:
     _run_git(repo, ["count-objects", "-vH"])
 
 
-def _prune(repo: Path, *, include_lfs: bool) -> None:
-    _run_git(repo, ["prune", "--expire=now", "--verbose"])
+def _prune(repo: Path, *, include_lfs: bool, include_git_prune: bool) -> None:
+    if include_git_prune:
+        _run_git(repo, ["prune", "--expire=now", "--verbose"])
     if include_lfs:
         result = _run_git(repo, ["lfs", "prune", "--verbose"], check=False)
         if result.returncode != 0:
             raise SystemExit(result.returncode)
+    if not include_lfs and not include_git_prune:
+        print("No prune action selected.")
 
 
 def _clean_stale_graph_files(repo: Path, *, dry_run: bool) -> None:
@@ -125,7 +130,7 @@ def _parser() -> argparse.ArgumentParser:
         help=(
             "status shows skip-worktree state; park hides generated archives from "
             "normal Git status/stage scans; unpark re-enables release staging; "
-            "prune removes unreachable local Git/LFS objects; clean-stale "
+            "prune removes prunable local LFS cache entries; clean-stale "
             "removes interrupted graph promotion leftovers."
         ),
     )
@@ -149,6 +154,14 @@ def _parser() -> argparse.ArgumentParser:
         action="store_true",
         help="For prune only: skip git lfs prune.",
     )
+    parser.add_argument(
+        "--include-git-prune",
+        action="store_true",
+        help=(
+            "For prune only: also run repo-wide git prune --expire=now. "
+            "This can discard unrelated dangling recovery objects."
+        ),
+    )
     parser.add_argument(
         "--dry-run",
         action="store_true",
@@ -169,7 +182,11 @@ def main(argv: list[str] | None = None) -> int:
     elif args.command == "unpark":
         _set_skip_worktree(repo, artifacts, enabled=False)
     elif args.command == "prune":
-        _prune(repo, include_lfs=not args.skip_lfs)
+        _prune(
+            repo,
+            include_lfs=not args.skip_lfs,
+            include_git_prune=args.include_git_prune,
+        )
     elif args.command == "clean-stale":
         _clean_stale_graph_files(repo, dry_run=args.dry_run)
     return 0

scripts/overlay_wiki_entities.py

@@ -1,524 +1,540 @@
-"""Overlay explicit local wiki entities onto shipped graph tarballs.
-
-This is a narrow release-maintenance tool.  It starts from the current shipped
-tarball, copies every existing member except graph export files and explicit
-page replacements, then appends selected nodes/pages from a local wiki graph.
-It deliberately does not rebuild Skills.sh semantic topology.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import tarfile
-import tempfile
-from collections import Counter
-from dataclasses import dataclass
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Any
-
-from ctx.core.wiki.artifact_promotion import promote_staged_artifact
-from ctx.utils._fs_utils import atomic_write_text, reject_symlink_path
-from scripts.build_dashboard_graph_index import build_dashboard_index
-
-GRAPH_EXPORT_NAMES = {
-    "graphify-out/graph.json",
-    "graphify-out/graph-delta.json",
-    "graphify-out/communities.json",
-    "graphify-out/graph-report.md",
-    "graphify-out/graph-export-manifest.json",
-}
-OVERLAY_GZIP_COMPRESSLEVEL = 3
-
-
-@dataclass(frozen=True)
-class OverlayStats:
-    node_count: int
-    edge_count: int
-    added_nodes: int
-    added_edges: int
-    export_id: str
-
-
-def overlay_entities(
-    *,
-    source_wiki: Path,
-    tarball: Path,
-    entity_ids: list[str],
-    skills_root: Path | None = None,
-    root_communities: Path | None = None,
-    runtime: bool = False,
-    now: datetime | None = None,
-) -> OverlayStats:
-    if not entity_ids:
-        raise ValueError("at least one entity id is required")
-    source_graph = _read_json(source_wiki / "graphify-out" / "graph.json")
-    source_nodes = _nodes_by_id(source_graph)
-    selected = list(dict.fromkeys(entity_ids))
-    missing = [node_id for node_id in selected if node_id not in source_nodes]
-    if missing:
-        raise ValueError(f"source graph is missing selected nodes: {missing}")
-
-    graph, communities = _read_tar_graph_artifacts(tarball)
-    graph, added_nodes, added_edges = _merge_graph(graph, source_graph, selected)
-    timestamp = _timestamp(now)
-    export_id = f"ctx-graph-overlay-{timestamp}-{len(graph['nodes'])}-{len(graph['edges'])}"
-    graph.setdefault("graph", {})["export_id"] = export_id
-    graph["graph"]["generated"] = timestamp
-    graph["graph"]["overlay_entities"] = selected
-    communities = _merge_communities(
-        communities,
-        graph=graph,
-        selected=selected,
-        export_id=export_id,
-        generated=timestamp,
-    )
-    if root_communities is not None:
-        atomic_write_text(root_communities, json.dumps(communities, indent=2) + "\n")
-
-    replacements = _collect_replacements(
-        source_wiki=source_wiki,
-        entity_ids=selected,
-        skills_root=skills_root,
-        runtime=runtime,
-    )
-    replacements.update({
-        "graphify-out/graph.json": _json_bytes(graph, compact=True),
-        "graphify-out/dashboard-neighborhoods.sqlite3": _dashboard_index_bytes(graph),
-        "graphify-out/graph-delta.json": _json_bytes(
-            _render_delta(graph, selected, export_id=export_id, generated=timestamp),
-            compact=False,
-        ),
-        "graphify-out/communities.json": _json_bytes(communities, compact=False),
-        "graphify-out/graph-report.md": _render_report(
-            graph,
-            communities,
-            selected=selected,
-            export_id=export_id,
-            generated=timestamp,
-        ).encode("utf-8"),
-        "graphify-out/graph-export-manifest.json": _json_bytes(
-            _render_manifest(graph, communities, export_id=export_id, generated=timestamp),
-            compact=False,
-        ),
-    })
-    _rewrite_tarball(tarball, replacements)
-    return OverlayStats(
-        node_count=len(graph["nodes"]),
-        edge_count=len(graph["edges"]),
-        added_nodes=added_nodes,
-        added_edges=added_edges,
-        export_id=export_id,
-    )
-
-
-def _merge_graph(
-    graph: dict[str, Any],
-    source_graph: dict[str, Any],
-    selected: list[str],
-) -> tuple[dict[str, Any], int, int]:
-    nodes = _list_field(graph, "nodes")
-    edges = _list_field(graph, "edges")
-    source_nodes = _nodes_by_id(source_graph)
-    dest_ids = {str(node.get("id")) for node in nodes if isinstance(node, dict)}
-    by_id = {
-        str(node.get("id")): index
-        for index, node in enumerate(nodes)
-        if isinstance(node, dict) and node.get("id")
-    }
-    added_nodes = 0
-    for node_id in selected:
-        node = dict(source_nodes[node_id])
-        if node_id in by_id:
-            nodes[by_id[node_id]] = node
-        else:
-            nodes.append(node)
-            dest_ids.add(node_id)
-            added_nodes += 1
-
-    edge_keys = {_edge_key(edge) for edge in edges if isinstance(edge, dict)}
-    added_edges = 0
-    for edge in _list_field(source_graph, "edges"):
-        if not isinstance(edge, dict):
-            continue
-        source = str(edge.get("source") or "")
-        target = str(edge.get("target") or "")
-        if source not in selected and target not in selected:
-            continue
-        if source not in dest_ids or target not in dest_ids:
-            continue
-        key = _edge_key(edge)
-        if key in edge_keys:
-            continue
-        edges.append(dict(edge))
-        edge_keys.add(key)
-        added_edges += 1
-    graph["nodes"] = nodes
-    graph["edges"] = edges
-    return graph, added_nodes, added_edges
-
-
-def _merge_communities(
-    communities: dict[str, Any],
-    *,
-    graph: dict[str, Any],
-    selected: list[str],
-    export_id: str,
-    generated: str,
-) -> dict[str, Any]:
-    raw = communities.get("communities")
-    if not isinstance(raw, dict) or not raw:
-        raw = {"0": {"label": "Overlay", "members": []}}
-    node_to_community: dict[str, str] = {}
-    for cid, payload in raw.items():
-        members = payload.get("members") if isinstance(payload, dict) else []
-        if not isinstance(members, list):
-            continue
-        for member in members:
-            node_to_community[str(member)] = str(cid)
-    edge_pairs = [
-        (str(edge.get("source") or ""), str(edge.get("target") or ""))
-        for edge in _list_field(graph, "edges")
-        if isinstance(edge, dict)
-    ]
-    for node_id in selected:
-        if node_id in node_to_community:
-            continue
-        counts: Counter[str] = Counter()
-        for source, target in edge_pairs:
-            other = target if source == node_id else source if target == node_id else ""
-            if other and other in node_to_community:
-                counts[node_to_community[other]] += 1
-        cid = counts.most_common(1)[0][0] if counts else sorted(raw)[0]
-        payload = raw.setdefault(cid, {"label": "Overlay", "members": []})
-        members = payload.setdefault("members", [])
-        if isinstance(members, list):
-            members.append(node_id)
-            node_to_community[node_id] = cid
-    communities["export_id"] = export_id
-    communities["generated"] = generated
-    communities["total_communities"] = len(raw)
-    communities["communities"] = raw
-    return communities
-
-
-def _collect_replacements(
-    *,
-    source_wiki: Path,
-    entity_ids: list[str],
-    skills_root: Path | None,
-    runtime: bool,
-) -> dict[str, bytes]:
-    replacements: dict[str, bytes] = {}
-    for node_id in entity_ids:
-        entity_type, slug = _split_node_id(node_id)
-        page = _entity_page(source_wiki, entity_type, slug)
-        if page is not None and (not runtime or entity_type == "harness"):
-            replacements[page.relative_to(source_wiki).as_posix()] = page.read_bytes()
-        if not runtime and entity_type == "skill":
-            replacements.update(_skill_replacements(source_wiki, slug, skills_root=skills_root))
-    return replacements
-
-
-def _dashboard_index_bytes(graph: dict[str, Any]) -> bytes:
-    with tempfile.TemporaryDirectory(prefix="ctx-overlay-index-") as tmp:
-        tmp_path = Path(tmp)
-        graph_path = tmp_path / "graph.json"
-        index_path = tmp_path / "dashboard-neighborhoods.sqlite3"
-        graph_path.write_bytes(_json_bytes(graph, compact=True))
-        build_dashboard_index(graph_path, index_path)
-        return index_path.read_bytes()
-
-
-def _entity_page(source_wiki: Path, entity_type: str, slug: str) -> Path | None:
-    candidates = {
-        "skill": [source_wiki / "entities" / "skills" / f"{slug}.md"],
-        "agent": [source_wiki / "entities" / "agents" / f"{slug}.md"],
-        "harness": [source_wiki / "entities" / "harnesses" / f"{slug}.md"],
-        "mcp-server": [
-            source_wiki / "entities" / "mcp-servers" / slug[:1].lower() / f"{slug}.md",
-        ],
-    }.get(entity_type, [])
-    for candidate in candidates:
-        if candidate.is_file():
-            return candidate
-    if entity_type == "mcp-server":
-        matches = list((source_wiki / "entities" / "mcp-servers").rglob(f"{slug}.md"))
-        if matches:
-            return matches[0]
-    return None
-
-
-def _skill_replacements(source_wiki: Path, slug: str, *, skills_root: Path | None) -> dict[str, bytes]:
-    root = skills_root or Path.home() / ".claude" / "skills"
-    candidates = [
-        source_wiki / "converted" / slug / "SKILL.md",
-        root / slug / "SKILL.md",
-    ]
-    for candidate in candidates:
-        if candidate.is_file():
-            skill_dir = candidate.parent
-            return {
-                f"converted/{slug}/{path.relative_to(skill_dir).as_posix()}": path.read_bytes()
-                for path in sorted(skill_dir.rglob("*"))
-                if path.is_file() and not path.name.endswith((".original", ".lock"))
-            }
-    return {}
-
-
-def _rewrite_tarball(tarball: Path, replacements: dict[str, bytes]) -> None:
-    reject_symlink_path(tarball)
-    staged = tarball.with_name(f"{tarball.name}.staged")
-    reject_symlink_path(staged)
-    skip_names = set(replacements)
-    with tarfile.open(tarball, "r:gz") as src, tarfile.open(
-        staged,
-        "w:gz",
-        compresslevel=OVERLAY_GZIP_COMPRESSLEVEL,
-    ) as dst:
-        for member in src:
-            safe_name = _safe_tar_name(member.name)
-            if safe_name is None:
-                continue
-            if safe_name in GRAPH_EXPORT_NAMES or safe_name in skip_names:
-                continue
-            if safe_name.endswith(".original") or safe_name.endswith(".lock"):
-                continue
-            if member.isfile():
-                f = src.extractfile(member)
-                if f is not None:
-                    dst.addfile(member, f)
-            elif member.isdir():
-                dst.addfile(member)
-        for name, payload in sorted(replacements.items()):
-            _add_bytes(dst, name=f"./{name}", payload=payload)
-    promote_staged_artifact(staged, tarball, validate=_validate_tarball)
-
-
-def _validate_tarball(candidate: Path) -> None:
-    seen: set[str] = set()
-    with tarfile.open(candidate, "r:gz") as tf:
-        for member in tf:
-            safe_name = _safe_tar_name(member.name)
-            if safe_name is None:
-                raise ValueError(f"unsafe tar member: {member.name}")
-            if safe_name.endswith(".original") or safe_name.endswith(".lock"):
-                raise ValueError(f"transient member leaked: {safe_name}")
-            seen.add(safe_name)
-    missing = sorted(GRAPH_EXPORT_NAMES - seen)
-    if missing:
-        raise ValueError(f"candidate tarball missing graph exports: {missing}")
-
-
-def _read_tar_graph_artifacts(tarball: Path) -> tuple[dict[str, Any], dict[str, Any]]:
-    graph: dict[str, Any] | None = None
-    communities: dict[str, Any] | None = None
-    with tarfile.open(tarball, "r:gz") as tf:
-        for member in tf:
-            safe_name = _safe_tar_name(member.name)
-            if safe_name not in {"graphify-out/graph.json", "graphify-out/communities.json"}:
-                continue
-            f = tf.extractfile(member)
-            if f is None:
-                continue
-            data = json.loads(f.read().decode("utf-8"))
-            if safe_name.endswith("graph.json"):
-                graph = data
-            else:
-                communities = data
-    if graph is None or communities is None:
-        raise ValueError("tarball is missing graph.json or communities.json")
-    return graph, communities
-
-
-def _render_delta(
-    graph: dict[str, Any],
-    selected: list[str],
-    *,
-    export_id: str,
-    generated: str,
-) -> dict[str, Any]:
-    selected_set = set(selected)
-    nodes = [
-        node for node in _list_field(graph, "nodes")
-        if isinstance(node, dict) and node.get("id") in selected_set
-    ]
-    edges = [
-        edge for edge in _list_field(graph, "edges")
-        if isinstance(edge, dict)
-        and (edge.get("source") in selected_set or edge.get("target") in selected_set)
-    ]
-    return {
-        "version": 1,
-        "full_rebuild": False,
-        "export_id": export_id,
-        "generated": generated,
-        "node_count": len(graph["nodes"]),
-        "edge_count": len(graph["edges"]),
-        "delta_node_count": len(nodes),
-        "delta_edge_count": len(edges),
-        "nodes": nodes,
-        "edges": edges,
-    }
-
-
-def _render_manifest(
-    graph: dict[str, Any],
-    communities: dict[str, Any],
-    *,
-    export_id: str,
-    generated: str,
-) -> dict[str, Any]:
-    return {
-        "version": 1,
-        "export_id": export_id,
-        "generated": generated,
-        "artifacts": {
-            "graph": "graph.json",
-            "delta": "graph-delta.json",
-            "communities": "communities.json",
-            "report": "graph-report.md",
-        },
-        "counts": {
-            "nodes": len(graph["nodes"]),
-            "edges": len(graph["edges"]),
-            "communities": communities.get("total_communities", 0),
-        },
-    }
-
-
-def _render_report(
-    graph: dict[str, Any],
-    communities: dict[str, Any],
-    *,
-    selected: list[str],
-    export_id: str,
-    generated: str,
-) -> str:
-    degree: Counter[str] = Counter()
-    for edge in _list_field(graph, "edges"):
-        if not isinstance(edge, dict):
-            continue
-        degree[str(edge.get("source") or "")] += 1
-        degree[str(edge.get("target") or "")] += 1
-    node_by_id = _nodes_by_id(graph)
-    lines = [
-        "# Graph Report",
-        "",
-        f"> Generated: {generated}",
-        f"> Export ID: {export_id}",
-        (
-            f"> Nodes: {len(graph['nodes'])} | Edges: {len(graph['edges'])} | "
-            f"Communities: {communities.get('total_communities', 0)}"
-        ),
-        "",
-        "## Overlay Entities",
-        "",
-    ]
-    for node_id in selected:
-        node = node_by_id.get(node_id, {})
-        lines.append(f"- **{node.get('label', node_id)}** ({node_id})")
-    lines.extend(["", "## Most Connected Nodes", ""])
-    for node_id, count in degree.most_common(20):
-        if not node_id:
-            continue
-        node = node_by_id.get(node_id, {})
-        lines.append(f"- **{node.get('label', node_id)}** ({count} connections)")
-    return "\n".join(lines) + "\n"
-
-
-def _read_json(path: Path) -> dict[str, Any]:
-    data = json.loads(path.read_text(encoding="utf-8"))
-    if not isinstance(data, dict):
-        raise ValueError(f"{path} must contain a JSON object")
-    return data
-
-
-def _nodes_by_id(graph: dict[str, Any]) -> dict[str, dict[str, Any]]:
-    return {
-        str(node.get("id")): node
-        for node in _list_field(graph, "nodes")
-        if isinstance(node, dict) and node.get("id")
-    }
-
-
-def _list_field(data: dict[str, Any], key: str) -> list[Any]:
-    value = data.get(key)
-    if not isinstance(value, list):
-        raise ValueError(f"graph field {key!r} must be a list")
-    return value
-
-
-def _edge_key(edge: dict[str, Any]) -> tuple[str, str]:
-    source = str(edge.get("source") or "")
-    target = str(edge.get("target") or "")
-    return (source, target) if source <= target else (target, source)
-
-
-def _split_node_id(node_id: str) -> tuple[str, str]:
-    if ":" not in node_id:
-        raise ValueError(f"invalid node id: {node_id}")
-    entity_type, slug = node_id.split(":", 1)
-    return entity_type, slug
-
-
-def _safe_tar_name(name: str) -> str | None:
-    normalized = name.replace("\\", "/")
-    while normalized.startswith("./"):
-        normalized = normalized[2:]
-    if not normalized or normalized.startswith("/") or normalized.startswith("../"):
-        return None
-    if "/../" in normalized or normalized == "..":
-        return None
-    return normalized
-
-
-def _add_bytes(
-    tf: tarfile.TarFile,
-    *,
-    name: str,
-    payload: bytes,
-    mode: int = 0o644,
-) -> None:
-    import io
-
-    info = tarfile.TarInfo(name)
-    info.size = len(payload)
-    info.mode = mode
-    info.mtime = 0
-    tf.addfile(info, io.BytesIO(payload))
-
-
-def _json_bytes(data: dict[str, Any], *, compact: bool) -> bytes:
-    if compact:
-        return json.dumps(data, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
-    return (json.dumps(data, ensure_ascii=False, indent=2) + "\n").encode("utf-8")
-
-
-def _timestamp(now: datetime | None = None) -> str:
-    value = now or datetime.now(timezone.utc)
-    return value.astimezone(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--source-wiki", type=Path, default=Path.home() / ".claude" / "skill-wiki")
-    parser.add_argument("--tarball", type=Path, required=True)
-    parser.add_argument("--entity", action="append", required=True, help="Node id, e.g. skill:foo")
-    parser.add_argument("--root-communities", type=Path)
-    parser.add_argument("--runtime", action="store_true")
-    args = parser.parse_args()
-    stats = overlay_entities(
-        source_wiki=args.source_wiki,
-        tarball=args.tarball,
-        entity_ids=args.entity,
-        skills_root=Path.home() / ".claude" / "skills",
-        root_communities=args.root_communities,
-        runtime=args.runtime,
-    )
-    print(json.dumps(stats.__dict__, indent=2))
-
-
-if __name__ == "__main__":
-    main()
+"""Overlay explicit local wiki entities onto shipped graph tarballs.
+
+This is a narrow release-maintenance tool.  It starts from the current shipped
+tarball, copies every existing member except graph export files and explicit
+page replacements, then appends selected nodes/pages from a local wiki graph.
+It deliberately does not rebuild Skills.sh semantic topology.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import tarfile
+import tempfile
+from collections import Counter
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+if str(REPO_ROOT) not in sys.path:
+    sys.path.insert(0, str(REPO_ROOT))
+
+from ctx.core.wiki.artifact_promotion import promote_staged_artifact  # noqa: E402
+from ctx.utils._fs_utils import atomic_write_text, reject_symlink_path  # noqa: E402
+from scripts.build_dashboard_graph_index import build_dashboard_index  # noqa: E402
+
+GRAPH_EXPORT_NAMES = {
+    "graphify-out/graph.json",
+    "graphify-out/graph-delta.json",
+    "graphify-out/communities.json",
+    "graphify-out/graph-report.md",
+    "graphify-out/graph-export-manifest.json",
+}
+OVERLAY_GZIP_COMPRESSLEVEL = 3
+
+
+@dataclass(frozen=True)
+class OverlayStats:
+    node_count: int
+    edge_count: int
+    added_nodes: int
+    added_edges: int
+    export_id: str
+
+
+def overlay_entities(
+    *,
+    source_wiki: Path,
+    tarball: Path,
+    entity_ids: list[str],
+    skills_root: Path | None = None,
+    root_communities: Path | None = None,
+    runtime: bool = False,
+    now: datetime | None = None,
+) -> OverlayStats:
+    if not entity_ids:
+        raise ValueError("at least one entity id is required")
+    source_graph = _read_json(source_wiki / "graphify-out" / "graph.json")
+    source_nodes = _nodes_by_id(source_graph)
+    selected = list(dict.fromkeys(entity_ids))
+    missing = [node_id for node_id in selected if node_id not in source_nodes]
+    if missing:
+        raise ValueError(f"source graph is missing selected nodes: {missing}")
+
+    graph, communities = _read_tar_graph_artifacts(tarball)
+    graph, added_nodes, added_edges = _merge_graph(graph, source_graph, selected)
+    timestamp = _timestamp(now)
+    export_id = f"ctx-graph-overlay-{timestamp}-{len(graph['nodes'])}-{len(graph['edges'])}"
+    graph.setdefault("graph", {})["export_id"] = export_id
+    graph["graph"]["generated"] = timestamp
+    graph["graph"]["overlay_entities"] = selected
+    communities = _merge_communities(
+        communities,
+        graph=graph,
+        selected=selected,
+        export_id=export_id,
+        generated=timestamp,
+    )
+    if root_communities is not None:
+        atomic_write_text(root_communities, json.dumps(communities, indent=2) + "\n")
+
+    replacements = _collect_replacements(
+        source_wiki=source_wiki,
+        entity_ids=selected,
+        skills_root=skills_root,
+        runtime=runtime,
+    )
+    replacements.update({
+        "graphify-out/graph.json": _json_bytes(graph, compact=True),
+        "graphify-out/dashboard-neighborhoods.sqlite3": _dashboard_index_bytes(graph),
+        "graphify-out/graph-delta.json": _json_bytes(
+            _render_delta(graph, selected, export_id=export_id, generated=timestamp),
+            compact=False,
+        ),
+        "graphify-out/communities.json": _json_bytes(communities, compact=False),
+        "graphify-out/graph-report.md": _render_report(
+            graph,
+            communities,
+            selected=selected,
+            export_id=export_id,
+            generated=timestamp,
+        ).encode("utf-8"),
+        "graphify-out/graph-export-manifest.json": _json_bytes(
+            _render_manifest(graph, communities, export_id=export_id, generated=timestamp),
+            compact=False,
+        ),
+    })
+    _rewrite_tarball(tarball, replacements)
+    return OverlayStats(
+        node_count=len(graph["nodes"]),
+        edge_count=len(graph["edges"]),
+        added_nodes=added_nodes,
+        added_edges=added_edges,
+        export_id=export_id,
+    )
+
+
+def _merge_graph(
+    graph: dict[str, Any],
+    source_graph: dict[str, Any],
+    selected: list[str],
+) -> tuple[dict[str, Any], int, int]:
+    nodes = _list_field(graph, "nodes")
+    edges = _list_field(graph, "edges")
+    source_nodes = _nodes_by_id(source_graph)
+    dest_ids = {str(node.get("id")) for node in nodes if isinstance(node, dict)}
+    by_id = {
+        str(node.get("id")): index
+        for index, node in enumerate(nodes)
+        if isinstance(node, dict) and node.get("id")
+    }
+    added_nodes = 0
+    for node_id in selected:
+        node = dict(source_nodes[node_id])
+        if node_id in by_id:
+            nodes[by_id[node_id]] = node
+        else:
+            nodes.append(node)
+            dest_ids.add(node_id)
+            added_nodes += 1
+
+    edge_keys = {_edge_key(edge) for edge in edges if isinstance(edge, dict)}
+    added_edges = 0
+    for edge in _list_field(source_graph, "edges"):
+        if not isinstance(edge, dict):
+            continue
+        source = str(edge.get("source") or "")
+        target = str(edge.get("target") or "")
+        if source not in selected and target not in selected:
+            continue
+        if source not in dest_ids or target not in dest_ids:
+            continue
+        key = _edge_key(edge)
+        if key in edge_keys:
+            continue
+        edges.append(dict(edge))
+        edge_keys.add(key)
+        added_edges += 1
+    graph["nodes"] = nodes
+    graph["edges"] = edges
+    return graph, added_nodes, added_edges
+
+
+def _merge_communities(
+    communities: dict[str, Any],
+    *,
+    graph: dict[str, Any],
+    selected: list[str],
+    export_id: str,
+    generated: str,
+) -> dict[str, Any]:
+    raw = communities.get("communities")
+    if not isinstance(raw, dict) or not raw:
+        raw = {"0": {"label": "Overlay", "members": []}}
+    node_to_community: dict[str, str] = {}
+    for cid, payload in raw.items():
+        members = payload.get("members") if isinstance(payload, dict) else []
+        if not isinstance(members, list):
+            continue
+        for member in members:
+            node_to_community[str(member)] = str(cid)
+    edge_pairs = [
+        (str(edge.get("source") or ""), str(edge.get("target") or ""))
+        for edge in _list_field(graph, "edges")
+        if isinstance(edge, dict)
+    ]
+    for node_id in selected:
+        if node_id in node_to_community:
+            continue
+        counts: Counter[str] = Counter()
+        for source, target in edge_pairs:
+            other = target if source == node_id else source if target == node_id else ""
+            if other and other in node_to_community:
+                counts[node_to_community[other]] += 1
+        cid = counts.most_common(1)[0][0] if counts else sorted(raw)[0]
+        payload = raw.setdefault(cid, {"label": "Overlay", "members": []})
+        members = payload.setdefault("members", [])
+        if isinstance(members, list):
+            members.append(node_id)
+            node_to_community[node_id] = cid
+    communities["export_id"] = export_id
+    communities["generated"] = generated
+    communities["total_communities"] = len(raw)
+    communities["communities"] = raw
+    return communities
+
+
+def _collect_replacements(
+    *,
+    source_wiki: Path,
+    entity_ids: list[str],
+    skills_root: Path | None,
+    runtime: bool,
+) -> dict[str, bytes]:
+    replacements: dict[str, bytes] = {}
+    for node_id in entity_ids:
+        entity_type, slug = _split_node_id(node_id)
+        page = _entity_page(source_wiki, entity_type, slug)
+        if page is not None and (not runtime or entity_type == "harness"):
+            replacements[page.relative_to(source_wiki).as_posix()] = _read_safe_bytes(page)
+        if not runtime and entity_type == "skill":
+            replacements.update(_skill_replacements(source_wiki, slug, skills_root=skills_root))
+    return replacements
+
+
+def _dashboard_index_bytes(graph: dict[str, Any]) -> bytes:
+    with tempfile.TemporaryDirectory(prefix="ctx-overlay-index-") as tmp:
+        tmp_path = Path(tmp)
+        graph_path = tmp_path / "graph.json"
+        index_path = tmp_path / "dashboard-neighborhoods.sqlite3"
+        graph_path.write_bytes(_json_bytes(graph, compact=True))
+        build_dashboard_index(graph_path, index_path)
+        return index_path.read_bytes()
+
+
+def _entity_page(source_wiki: Path, entity_type: str, slug: str) -> Path | None:
+    candidates = {
+        "skill": [source_wiki / "entities" / "skills" / f"{slug}.md"],
+        "agent": [source_wiki / "entities" / "agents" / f"{slug}.md"],
+        "harness": [source_wiki / "entities" / "harnesses" / f"{slug}.md"],
+        "mcp-server": [
+            source_wiki / "entities" / "mcp-servers" / slug[:1].lower() / f"{slug}.md",
+        ],
+    }.get(entity_type, [])
+    for candidate in candidates:
+        if _is_safe_file(candidate):
+            return candidate
+    if entity_type == "mcp-server":
+        matches = list((source_wiki / "entities" / "mcp-servers").rglob(f"{slug}.md"))
+        for match in matches:
+            if _is_safe_file(match):
+                return match
+    return None
+
+
+def _skill_replacements(source_wiki: Path, slug: str, *, skills_root: Path | None) -> dict[str, bytes]:
+    root = skills_root or Path.home() / ".claude" / "skills"
+    candidates = [
+        source_wiki / "converted" / slug / "SKILL.md",
+        root / slug / "SKILL.md",
+    ]
+    for candidate in candidates:
+        if _is_safe_file(candidate):
+            skill_dir = candidate.parent
+            return {
+                f"converted/{slug}/{path.relative_to(skill_dir).as_posix()}": _read_safe_bytes(path)
+                for path in sorted(skill_dir.rglob("*"))
+                if _is_safe_file(path) and not path.name.endswith((".original", ".lock"))
+            }
+    return {}
+
+
+def _is_safe_file(path: Path) -> bool:
+    reject_symlink_path(path)
+    return path.is_file()
+
+
+def _read_safe_bytes(path: Path) -> bytes:
+    reject_symlink_path(path)
+    return path.read_bytes()
+
+
+def _rewrite_tarball(tarball: Path, replacements: dict[str, bytes]) -> None:
+    reject_symlink_path(tarball)
+    staged = tarball.with_name(f"{tarball.name}.staged")
+    reject_symlink_path(staged)
+    skip_names = set(replacements)
+    with tarfile.open(tarball, "r:gz") as src, tarfile.open(
+        staged,
+        "w:gz",
+        compresslevel=OVERLAY_GZIP_COMPRESSLEVEL,
+    ) as dst:
+        for member in src:
+            safe_name = _safe_tar_name(member.name)
+            if safe_name is None:
+                continue
+            if safe_name in GRAPH_EXPORT_NAMES or safe_name in skip_names:
+                continue
+            if safe_name.endswith(".original") or safe_name.endswith(".lock"):
+                continue
+            if member.isfile():
+                f = src.extractfile(member)
+                if f is not None:
+                    dst.addfile(member, f)
+            elif member.isdir():
+                dst.addfile(member)
+        for name, payload in sorted(replacements.items()):
+            _add_bytes(dst, name=f"./{name}", payload=payload)
+    promote_staged_artifact(staged, tarball, validate=_validate_tarball)
+
+
+def _validate_tarball(candidate: Path) -> None:
+    seen: set[str] = set()
+    with tarfile.open(candidate, "r:gz") as tf:
+        for member in tf:
+            safe_name = _safe_tar_name(member.name)
+            if safe_name is None:
+                raise ValueError(f"unsafe tar member: {member.name}")
+            if safe_name.endswith(".original") or safe_name.endswith(".lock"):
+                raise ValueError(f"transient member leaked: {safe_name}")
+            seen.add(safe_name)
+    missing = sorted(GRAPH_EXPORT_NAMES - seen)
+    if missing:
+        raise ValueError(f"candidate tarball missing graph exports: {missing}")
+
+
+def _read_tar_graph_artifacts(tarball: Path) -> tuple[dict[str, Any], dict[str, Any]]:
+    graph: dict[str, Any] | None = None
+    communities: dict[str, Any] | None = None
+    with tarfile.open(tarball, "r:gz") as tf:
+        for member in tf:
+            safe_name = _safe_tar_name(member.name)
+            if safe_name not in {"graphify-out/graph.json", "graphify-out/communities.json"}:
+                continue
+            f = tf.extractfile(member)
+            if f is None:
+                continue
+            data = json.loads(f.read().decode("utf-8"))
+            if safe_name.endswith("graph.json"):
+                graph = data
+            else:
+                communities = data
+    if graph is None or communities is None:
+        raise ValueError("tarball is missing graph.json or communities.json")
+    return graph, communities
+
+
+def _render_delta(
+    graph: dict[str, Any],
+    selected: list[str],
+    *,
+    export_id: str,
+    generated: str,
+) -> dict[str, Any]:
+    selected_set = set(selected)
+    nodes = [
+        node for node in _list_field(graph, "nodes")
+        if isinstance(node, dict) and node.get("id") in selected_set
+    ]
+    edges = [
+        edge for edge in _list_field(graph, "edges")
+        if isinstance(edge, dict)
+        and (edge.get("source") in selected_set or edge.get("target") in selected_set)
+    ]
+    return {
+        "version": 1,
+        "full_rebuild": False,
+        "export_id": export_id,
+        "generated": generated,
+        "node_count": len(graph["nodes"]),
+        "edge_count": len(graph["edges"]),
+        "delta_node_count": len(nodes),
+        "delta_edge_count": len(edges),
+        "nodes": nodes,
+        "edges": edges,
+    }
+
+
+def _render_manifest(
+    graph: dict[str, Any],
+    communities: dict[str, Any],
+    *,
+    export_id: str,
+    generated: str,
+) -> dict[str, Any]:
+    return {
+        "version": 1,
+        "export_id": export_id,
+        "generated": generated,
+        "artifacts": {
+            "graph": "graph.json",
+            "delta": "graph-delta.json",
+            "communities": "communities.json",
+            "report": "graph-report.md",
+        },
+        "counts": {
+            "nodes": len(graph["nodes"]),
+            "edges": len(graph["edges"]),
+            "communities": communities.get("total_communities", 0),
+        },
+    }
+
+
+def _render_report(
+    graph: dict[str, Any],
+    communities: dict[str, Any],
+    *,
+    selected: list[str],
+    export_id: str,
+    generated: str,
+) -> str:
+    degree: Counter[str] = Counter()
+    for edge in _list_field(graph, "edges"):
+        if not isinstance(edge, dict):
+            continue
+        degree[str(edge.get("source") or "")] += 1
+        degree[str(edge.get("target") or "")] += 1
+    node_by_id = _nodes_by_id(graph)
+    lines = [
+        "# Graph Report",
+        "",
+        f"> Generated: {generated}",
+        f"> Export ID: {export_id}",
+        (
+            f"> Nodes: {len(graph['nodes'])} | Edges: {len(graph['edges'])} | "
+            f"Communities: {communities.get('total_communities', 0)}"
+        ),
+        "",
+        "## Overlay Entities",
+        "",
+    ]
+    for node_id in selected:
+        node = node_by_id.get(node_id, {})
+        lines.append(f"- **{node.get('label', node_id)}** ({node_id})")
+    lines.extend(["", "## Most Connected Nodes", ""])
+    for node_id, count in degree.most_common(20):
+        if not node_id:
+            continue
+        node = node_by_id.get(node_id, {})
+        lines.append(f"- **{node.get('label', node_id)}** ({count} connections)")
+    return "\n".join(lines) + "\n"
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError(f"{path} must contain a JSON object")
+    return data
+
+
+def _nodes_by_id(graph: dict[str, Any]) -> dict[str, dict[str, Any]]:
+    return {
+        str(node.get("id")): node
+        for node in _list_field(graph, "nodes")
+        if isinstance(node, dict) and node.get("id")
+    }
+
+
+def _list_field(data: dict[str, Any], key: str) -> list[Any]:
+    value = data.get(key)
+    if not isinstance(value, list):
+        raise ValueError(f"graph field {key!r} must be a list")
+    return value
+
+
+def _edge_key(edge: dict[str, Any]) -> tuple[str, str]:
+    source = str(edge.get("source") or "")
+    target = str(edge.get("target") or "")
+    return (source, target) if source <= target else (target, source)
+
+
+def _split_node_id(node_id: str) -> tuple[str, str]:
+    if ":" not in node_id:
+        raise ValueError(f"invalid node id: {node_id}")
+    entity_type, slug = node_id.split(":", 1)
+    return entity_type, slug
+
+
+def _safe_tar_name(name: str) -> str | None:
+    normalized = name.replace("\\", "/")
+    while normalized.startswith("./"):
+        normalized = normalized[2:]
+    if not normalized or normalized.startswith("/") or normalized.startswith("../"):
+        return None
+    if "/../" in normalized or normalized == "..":
+        return None
+    return normalized
+
+
+def _add_bytes(
+    tf: tarfile.TarFile,
+    *,
+    name: str,
+    payload: bytes,
+    mode: int = 0o644,
+) -> None:
+    import io
+
+    info = tarfile.TarInfo(name)
+    info.size = len(payload)
+    info.mode = mode
+    info.mtime = 0
+    tf.addfile(info, io.BytesIO(payload))
+
+
+def _json_bytes(data: dict[str, Any], *, compact: bool) -> bytes:
+    if compact:
+        return json.dumps(data, ensure_ascii=False, separators=(",", ":")).encode("utf-8")
+    return (json.dumps(data, ensure_ascii=False, indent=2) + "\n").encode("utf-8")
+
+
+def _timestamp(now: datetime | None = None) -> str:
+    value = now or datetime.now(timezone.utc)
+    return value.astimezone(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--source-wiki", type=Path, default=Path.home() / ".claude" / "skill-wiki")
+    parser.add_argument("--tarball", type=Path, required=True)
+    parser.add_argument("--entity", action="append", required=True, help="Node id, e.g. skill:foo")
+    parser.add_argument("--root-communities", type=Path)
+    parser.add_argument("--runtime", action="store_true")
+    args = parser.parse_args()
+    stats = overlay_entities(
+        source_wiki=args.source_wiki,
+        tarball=args.tarball,
+        entity_ids=args.entity,
+        skills_root=Path.home() / ".claude" / "skills",
+        root_communities=args.root_communities,
+        runtime=args.runtime,
+    )
+    print(json.dumps(stats.__dict__, indent=2))
+
+
+if __name__ == "__main__":
+    main()

src/__init__.py

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

src/agent_add.py

@@ -24,17 +24,17 @@ import argparse
 import os
 import sys
 from datetime import datetime, timezone
-from pathlib import Path
-
-from ctx.core.entity_update import build_update_review, render_update_review
-from ctx_config import cfg
-from ctx.adapters.claude_code.install.install_utils import safe_copy_file
-from intake_pipeline import IntakeRejected, check_intake, record_embedding
-from wiki_batch_entities import generate_agent_page
-from ctx.core.wiki.wiki_queue import enqueue_entity_upsert
-from ctx.core.wiki.wiki_sync import append_log, ensure_wiki, update_index
-from ctx.core.wiki.wiki_utils import validate_skill_name
-from ctx.utils._fs_utils import reject_symlink_path, safe_atomic_write_text
+from pathlib import Path
+
+from ctx.core.entity_update import build_update_review, render_update_review
+from ctx_config import cfg
+from ctx.adapters.claude_code.install.install_utils import safe_copy_file
+from intake_pipeline import IntakeRejected, check_intake, record_embedding
+from wiki_batch_entities import generate_agent_page
+from ctx.core.wiki.wiki_queue import enqueue_entity_upsert
+from ctx.core.wiki.wiki_sync import append_log, ensure_wiki, update_index
+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")
 
@@ -53,24 +53,52 @@ def install_agent(source: Path, agents_dir: Path, name: str) -> Path:
     return dest
 
 
-def write_entity_page(wiki_path: Path, name: str, content: str) -> bool:
-    """Write agent entity page. Returns True if newly created."""
-    page = wiki_path / "entities" / "agents" / f"{name}.md"
-    reject_symlink_path(page)
-    is_new = not page.exists()
-    safe_atomic_write_text(page, content, encoding="utf-8")
-    return is_new
-
-
-def add_agent(
-    *,
-    source_path: Path,
-    name: str,
-    wiki_path: Path,
-    agents_dir: Path,
-    review_existing: bool = False,
-    update_existing: bool = False,
-) -> dict:
+def mirror_agent_body(installed_path: Path, wiki_path: Path, name: str) -> Path:
+    """Mirror the installed agent body into the wiki install source tree."""
+    mirror_root = wiki_path / "converted-agents"
+    dest = mirror_root / f"{name}.md"
+    safe_copy_file(installed_path, dest, dest_root=mirror_root)
+    return dest
+
+
+def write_entity_page(wiki_path: Path, name: str, content: str) -> bool:
+    """Write agent entity page. Returns True if newly created."""
+    page = wiki_path / "entities" / "agents" / f"{name}.md"
+    reject_symlink_path(page)
+    is_new = not page.exists()
+    safe_atomic_write_text(page, content, encoding="utf-8")
+    return is_new
+
+
+def _existing_agent_review_text(entity_page: Path, installed_path: Path) -> str:
+    if entity_page.exists():
+        existing = entity_page.read_text(encoding="utf-8", errors="replace")
+        if installed_path.exists():
+            installed = installed_path.read_text(encoding="utf-8", errors="replace")
+            existing += f"\n\n## Installed agent definition\n\n{installed}"
+        return existing
+    return installed_path.read_text(encoding="utf-8", errors="replace")
+
+
+def _proposed_agent_review_text(
+    *,
+    name: str,
+    source_path: Path,
+    source_content: str,
+) -> str:
+    page_content = generate_agent_page(name, source_path)
+    return f"{page_content}\n\n## Proposed agent definition\n\n{source_content}"
+
+
+def add_agent(
+    *,
+    source_path: Path,
+    name: str,
+    wiki_path: Path,
+    agents_dir: Path,
+    review_existing: bool = False,
+    update_existing: bool = False,
+) -> dict:
     """Add a single agent: validate, gate, install, ingest, log.
 
     Returns a result dict with keys: name, installed, is_new_page.
@@ -83,48 +111,51 @@ def add_agent(
             f"agent file too large ({file_size:,} bytes). Max "
             f"{_MAX_AGENT_BYTES:,}. Trim before ingestion."
         )
-
-    content = source_path.read_text(encoding="utf-8", errors="replace")
-    line_count = len(content.splitlines())
-
-    installed_path = agents_dir / f"{name}.md"
-    entity_page = wiki_path / "entities" / "agents" / f"{name}.md"
-    existing_path = (
-        installed_path
-        if installed_path.exists()
-        else entity_page if entity_page.exists() else None
-    )
-    has_existing = existing_path is not None
-
-    if review_existing and has_existing and not update_existing:
-        assert existing_path is not None
-        existing_text = existing_path.read_text(encoding="utf-8", errors="replace")
-        review = build_update_review(
-            entity_type="agent",
-            slug=name,
-            existing_text=existing_text,
-            proposed_text=content,
-        )
-        return {
-            "name": name,
-            "installed": str(installed_path),
-            "is_new_page": False,
-            "skipped": True,
-            "update_required": True,
-            "update_review": render_update_review(review),
-        }
-
-    decision = None
-    if not has_existing:
-        # Intake gate: reject broken/duplicate agents before we install.
-        # Existing updates bypass similarity intake because they compare
-        # against their own cached embedding.
-        decision = check_intake(content, "agents")
-        if not decision.allow:
-            raise IntakeRejected(decision)
-
-    # 1. Install into agents-dir.
-    installed_path = install_agent(source_path, agents_dir, name)
+
+    content = source_path.read_text(encoding="utf-8", errors="replace")
+    line_count = len(content.splitlines())
+
+    installed_path = agents_dir / f"{name}.md"
+    entity_page = wiki_path / "entities" / "agents" / f"{name}.md"
+    existing_path = (
+        installed_path
+        if installed_path.exists()
+        else entity_page if entity_page.exists() else None
+    )
+    has_existing = existing_path is not None
+
+    if review_existing and has_existing and not update_existing:
+        review = build_update_review(
+            entity_type="agent",
+            slug=name,
+            existing_text=_existing_agent_review_text(entity_page, installed_path),
+            proposed_text=_proposed_agent_review_text(
+                name=name,
+                source_path=source_path,
+                source_content=content,
+            ),
+        )
+        return {
+            "name": name,
+            "installed": str(installed_path),
+            "is_new_page": False,
+            "skipped": True,
+            "update_required": True,
+            "update_review": render_update_review(review),
+        }
+
+    decision = None
+    if not has_existing:
+        # Intake gate: reject broken/duplicate agents before we install.
+        # Existing updates bypass similarity intake because they compare
+        # against their own cached embedding.
+        decision = check_intake(content, "agents")
+        if not decision.allow:
+            raise IntakeRejected(decision)
+
+    # 1. Install into agents-dir.
+    installed_path = install_agent(source_path, agents_dir, name)
+    mirror_agent_body(installed_path, wiki_path, name)
 
     # 2. Record embedding. Non-fatal on failure — install already
     # succeeded and a missing vector only weakens the next check.
@@ -150,30 +181,30 @@ def add_agent(
         f"Installed: {installed_path}",
         f"Lines: {line_count}",
     ]
-    warnings = decision.warnings if decision is not None else ()
-    if warnings:
-        log_details.append(
-            "Warnings: " + "; ".join(f"{w.code}:{w.message}" for w in warnings)
-        )
-    append_log(str(wiki_path), "add-agent", name, log_details)
-    queue_job = enqueue_entity_upsert(
-        wiki_path,
-        entity_type="agent",
-        slug=name,
-        entity_path=wiki_path / "entities" / "agents" / f"{name}.md",
-        content=page_content,
-        action="created" if is_new else "updated",
-        source="agent_add",
-    )
-
-    return {
-        "name": name,
-        "installed": str(installed_path),
-        "is_new_page": is_new,
-        "skipped": False,
-        "update_required": False,
-        "queued_job_id": queue_job.id,
-    }
+    warnings = decision.warnings if decision is not None else ()
+    if warnings:
+        log_details.append(
+            "Warnings: " + "; ".join(f"{w.code}:{w.message}" for w in warnings)
+        )
+    append_log(str(wiki_path), "add-agent", name, log_details)
+    queue_job = enqueue_entity_upsert(
+        wiki_path,
+        entity_type="agent",
+        slug=name,
+        entity_path=wiki_path / "entities" / "agents" / f"{name}.md",
+        content=page_content,
+        action="created" if is_new else "updated",
+        source="agent_add",
+    )
+
+    return {
+        "name": name,
+        "installed": str(installed_path),
+        "is_new_page": is_new,
+        "skipped": False,
+        "update_required": False,
+        "queued_job_id": queue_job.id,
+    }
 
 
 # ── CLI ───────────────────────────────────────────────────────────────
@@ -186,16 +217,16 @@ def main() -> None:
         "--scan-dir",
         help="Directory of agent .md files to batch-add (non-recursive)",
     )
-    parser.add_argument(
-        "--skip-existing",
-        action="store_true",
-        help="Skip agents already installed (prevents overwrites)",
-    )
-    parser.add_argument(
-        "--update-existing",
-        action="store_true",
-        help="Apply the reviewed replacement when an agent already exists",
-    )
+    parser.add_argument(
+        "--skip-existing",
+        action="store_true",
+        help="Skip agents already installed (prevents overwrites)",
+    )
+    parser.add_argument(
+        "--update-existing",
+        action="store_true",
+        help="Apply the reviewed replacement when an agent already exists",
+    )
     parser.add_argument("--wiki", default=str(cfg.wiki_dir), help="Wiki path")
     parser.add_argument(
         "--agents-dir",
@@ -245,7 +276,7 @@ def main() -> None:
             print(f"No agent .md files found under {scan_root}.", file=sys.stderr)
             sys.exit(0)
 
-    added = updated = skipped = rejected = errors = 0
+    added = updated = skipped = rejected = errors = 0
     total = len(candidates)
     for i, (source_path, name) in enumerate(candidates, 1):
         if args.skip_existing and (agents_dir / f"{name}.md").exists():
@@ -254,27 +285,27 @@ def main() -> None:
                 print(f"  [{i}/{total}] [skipped] {name}")
             continue
         try:
-            result = add_agent(
-                source_path=source_path,
-                name=name,
-                wiki_path=wiki_path,
-                agents_dir=agents_dir,
-                review_existing=True,
-                update_existing=args.update_existing,
-            )
-            if result.get("skipped"):
-                skipped += 1
-                if result.get("update_review"):
-                    print(result["update_review"])
-                print(f"  [{i}/{total}] [update-review] {name}")
-                continue
-            if result["is_new_page"]:
-                added += 1
-                status = "installed"
-            else:
-                updated += 1
-                status = "updated"
-            print(f"  [{i}/{total}] [{status}] {name}")
+            result = add_agent(
+                source_path=source_path,
+                name=name,
+                wiki_path=wiki_path,
+                agents_dir=agents_dir,
+                review_existing=True,
+                update_existing=args.update_existing,
+            )
+            if result.get("skipped"):
+                skipped += 1
+                if result.get("update_review"):
+                    print(result["update_review"])
+                print(f"  [{i}/{total}] [update-review] {name}")
+                continue
+            if result["is_new_page"]:
+                added += 1
+                status = "installed"
+            else:
+                updated += 1
+                status = "updated"
+            print(f"  [{i}/{total}] [{status}] {name}")
         except IntakeRejected as exc:
             rejected += 1
             codes = ", ".join(f.code for f in exc.decision.failures) or "unknown"
@@ -283,10 +314,10 @@ def main() -> None:
             errors += 1
             print(f"  [{i}/{total}] ERROR: {name}: {exc}", file=sys.stderr)
 
-    print(
-        f"\nDone: {added} added, {updated} updated, {skipped} skipped, "
-        f"{rejected} rejected, {errors} errors"
-    )
+    print(
+        f"\nDone: {added} added, {updated} updated, {skipped} skipped, "
+        f"{rejected} rejected, {errors} errors"
+    )
 
 
 if __name__ == "__main__":

src/backup_mirror.py

@@ -370,12 +370,16 @@ def create_snapshot(backups_dir: Path | None = None,
             for src in _iter_tree(src_rel):
                 rel = src.relative_to(root)
                 dest_rel_path = Path(dest_rel) / rel
+                if _CFG.is_excluded(dest_rel_path.as_posix()):
+                    continue
                 entries.append(_capture_file(src, tmp_path, dest_rel_path.as_posix()))
 
         for slug, src in _iter_memory_files():
             memory_root = claude_home / "projects" / slug / "memory"
             rel = src.relative_to(memory_root)
             dest_rel_path = Path("memory") / slug / rel
+            if _CFG.is_excluded(dest_rel_path.as_posix()):
+                continue
             entries.append(_capture_file(src, tmp_path, dest_rel_path.as_posix()))
 
         manifest = {

src/ctx/__init__.py

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

src/ctx/adapters/claude_code/hooks/context_monitor.py

@@ -250,7 +250,7 @@ def graph_suggest(
             query=" ".join(unmatched_tags),
             entity_types=("skill", "agent", "mcp-server"),
             min_normalized_score=min_score,
-            use_semantic_query=True,
+            use_semantic_query=False,
         )
     except Exception as exc:
         print(f"Warning: graph suggest error: {exc}", file=sys.stderr)

src/ctx/adapters/claude_code/inject_hooks.py

@@ -12,13 +12,13 @@ Usage:
 """
 
 import argparse
-import json
-import os
-import shlex
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
+import json
+import os
+import shlex
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
 
 
 def load_settings(path: Path) -> dict:
@@ -31,11 +31,11 @@ def load_settings(path: Path) -> dict:
     return {}
 
 
-def make_hooks(ctx_dir: str) -> dict:
-    """Return the hooks config block for this installation."""
-    _ = ctx_dir  # Kept for CLI/API compatibility; commands now use modules.
-    # Commands are quoted for the host OS so Python paths with spaces do not
-    # break the hook shell/command runner.
+def make_hooks(ctx_dir: str) -> dict:
+    """Return the hooks config block for this installation."""
+    _ = ctx_dir  # Kept for CLI/API compatibility; commands now use modules.
+    # Commands are quoted for the host OS so Python paths with spaces do not
+    # break the hook shell/command runner.
     # Tool input is delivered by Claude Code on stdin as JSON; --from-stdin reads it
     # from there instead of interpolating $CLAUDE_TOOL_INPUT into argv (which would
     # allow shell injection via malicious tool-input blobs).
@@ -113,12 +113,12 @@ def make_hooks(ctx_dir: str) -> dict:
 
 
 # Old filenames that were renamed — remove stale hook entries referencing them
-def _module_cmd(module: str, *args: str) -> str:
-    """Return a hook command that targets an installed Python module."""
-    parts = [sys.executable, "-m", module, *args]
-    if os.name == "nt":
-        return subprocess.list2cmdline(parts)
-    return " ".join(shlex.quote(part) for part in parts)
+def _module_cmd(module: str, *args: str) -> str:
+    """Return a hook command that targets an installed Python module."""
+    parts = [sys.executable, "-m", module, *args]
+    if os.name == "nt":
+        return subprocess.list2cmdline(parts)
+    return " ".join(shlex.quote(part) for part in parts)
 
 
 _STALE_PATTERNS = ["context-monitor.py", "usage-tracker.py", "skill-transformer.py"]
@@ -173,10 +173,40 @@ def merge_hooks(existing: dict, new_hooks: dict) -> dict:
                 new_cmd = new_entry.get("command", "")
                 new_hooks_list = new_entry.get("hooks", [])
 
-                # Check if any command in this entry already exists
-                new_cmds = {new_cmd} if new_cmd else {h.get("command", "") for h in new_hooks_list}
-                if not new_cmds.intersection(existing_commands):
+                if isinstance(new_hooks_list, list) and new_hooks_list:
+                    missing_hooks = [
+                        hook for hook in new_hooks_list
+                        if isinstance(hook, dict)
+                        and hook.get("command")
+                        and hook.get("command") not in existing_commands
+                    ]
+                    if not missing_hooks:
+                        continue
+                    matcher = new_entry.get("matcher")
+                    target_entry = next(
+                        (
+                            entry for entry in existing_list
+                            if isinstance(entry, dict)
+                            and entry.get("matcher") == matcher
+                            and isinstance(entry.get("hooks"), list)
+                        ),
+                        None,
+                    )
+                    if target_entry is not None:
+                        target_entry["hooks"].extend(missing_hooks)
+                    else:
+                        entry = dict(new_entry)
+                        entry["hooks"] = missing_hooks
+                        existing_list.append(entry)
+                    existing_commands.update(
+                        hook["command"] for hook in missing_hooks
+                        if isinstance(hook.get("command"), str)
+                    )
+                    continue
+
+                if new_cmd and new_cmd not in existing_commands:
                     existing_list.append(new_entry)
+                    existing_commands.add(new_cmd)
 
     return existing
 

src/ctx/adapters/claude_code/install/install_utils.py

@@ -29,12 +29,12 @@ from __future__ import annotations
 
 import json
 import logging
-import os
 import re
 import shutil
 from pathlib import Path
 from typing import Callable, Literal
 
+from ctx_config import cfg
 from ctx.utils._fs_utils import atomic_write_text as _atomic_write_text
 from ctx.utils._file_lock import file_lock
 
@@ -42,19 +42,19 @@ _logger = logging.getLogger(__name__)
 
 EntityType = Literal["skill", "agent", "mcp-server"]
 
-MANIFEST_PATH = Path(os.path.expanduser("~/.claude/skill-manifest.json"))
-
-_FRONTMATTER_HEAD_RE = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)
-
-
-def _has_symlink_in_path(path: Path) -> bool:
-    return any(candidate.is_symlink() for candidate in (path, *path.parents))
-
-
-def safe_copy_file(source: Path, dest: Path, *, dest_root: Path) -> None:
-    """Copy one file while refusing symlink write-through paths."""
-    if _has_symlink_in_path(source):
-        raise ValueError(f"refusing to copy symlinked source: {source}")
+MANIFEST_PATH = cfg.skill_manifest
+
+_FRONTMATTER_HEAD_RE = re.compile(r"^---\n(.*?)\n---\n", re.DOTALL)
+
+
+def _has_symlink_in_path(path: Path) -> bool:
+    return any(candidate.is_symlink() for candidate in (path, *path.parents))
+
+
+def safe_copy_file(source: Path, dest: Path, *, dest_root: Path) -> None:
+    """Copy one file while refusing symlink write-through paths."""
+    if _has_symlink_in_path(source):
+        raise ValueError(f"refusing to copy symlinked source: {source}")
     if not source.is_file():
         raise FileNotFoundError(f"copy source missing: {source}")
     if dest_root.exists() and dest_root.is_symlink():
@@ -134,18 +134,37 @@ def record_install(
     when an agent with the same slug already existed.)
     """
     def mutate(manifest: dict) -> None:
-        loaded: set[tuple[str, str]] = {
-            (e.get("skill"), e.get("entity_type", "skill"))
-            for e in manifest["load"]
+        entry: dict = {
+            "skill": slug,
+            "entity_type": entity_type,
+            "source": source,
         }
-        if (slug, entity_type) not in loaded:
-            entry: dict = {
-                "skill": slug,
-                "entity_type": entity_type,
-                "source": source,
-            }
-            if extra:
-                entry.update(extra)
+        if extra:
+            entry.update(extra)
+
+        replaced = False
+        stale_extra_fields = {
+            "command",
+            "json_config_sha256",
+            "json_config_keys",
+            "json_config_command",
+            "json_config_args_count",
+            "json_config_env_keys",
+            "priority",
+            "reason",
+        }
+        for existing in manifest["load"]:
+            if (
+                existing.get("skill") == slug
+                and existing.get("entity_type", "skill") == entity_type
+            ):
+                for field in stale_extra_fields - set(entry):
+                    existing.pop(field, None)
+                existing.update(entry)
+                replaced = True
+                break
+
+        if not replaced:
             manifest["load"].append(entry)
 
         manifest["unload"] = [
@@ -159,59 +178,59 @@ def record_install(
     _update_manifest(mutate)
 
 
-def record_uninstall(slug: str, *, entity_type: EntityType, source: str) -> None:
+def record_uninstall(slug: str, *, entity_type: EntityType, source: str) -> None:
     """Drop the load entry for ``(slug, entity_type)`` and record an unload.
 
     The unload dedup also keys on (slug, entity_type); re-unloading
-    the same pair doesn't produce duplicates.
-    """
-    def mutate(manifest: dict) -> None:
-        removed_entry: dict | None = next(
-            (
-                e for e in manifest["load"]
-                if (
-                    e.get("skill") == slug
-                    and e.get("entity_type", "skill") == entity_type
-                )
-            ),
-            None,
-        )
-        manifest["load"] = [
-            e for e in manifest["load"]
-            if not (
-                e.get("skill") == slug
-                and e.get("entity_type", "skill") == entity_type
+    the same pair doesn't produce duplicates.
+    """
+    def mutate(manifest: dict) -> None:
+        removed_entry: dict | None = next(
+            (
+                e for e in manifest["load"]
+                if (
+                    e.get("skill") == slug
+                    and e.get("entity_type", "skill") == entity_type
+                )
+            ),
+            None,
+        )
+        manifest["load"] = [
+            e for e in manifest["load"]
+            if not (
+                e.get("skill") == slug
+                and e.get("entity_type", "skill") == entity_type
             )
         ]
-        unloaded: set[tuple[str, str]] = {
-            (e.get("skill"), e.get("entity_type", "skill"))
-            for e in manifest["unload"]
-        }
-        preserved: dict[str, object] = {}
-        if removed_entry:
-            for field in ("command", "json_config", "priority", "reason"):
-                value = removed_entry.get(field)
-                if value not in (None, ""):
-                    preserved[field] = value
-        if (slug, entity_type) not in unloaded:
-            entry: dict[str, object] = {
-                "skill": slug,
-                "entity_type": entity_type,
-                "source": source,
-            }
-            entry.update(preserved)
-            manifest["unload"].append(entry)
-        elif preserved:
-            for entry in manifest["unload"]:
-                if (
-                    entry.get("skill") == slug
-                    and entry.get("entity_type", "skill") == entity_type
-                ):
-                    for field, value in preserved.items():
-                        entry.setdefault(field, value)
-                    break
-
-    _update_manifest(mutate)
+        unloaded: set[tuple[str, str]] = {
+            (e.get("skill"), e.get("entity_type", "skill"))
+            for e in manifest["unload"]
+        }
+        preserved: dict[str, object] = {}
+        if removed_entry:
+            for field in ("command", "json_config", "priority", "reason"):
+                value = removed_entry.get(field)
+                if value not in (None, ""):
+                    preserved[field] = value
+        if (slug, entity_type) not in unloaded:
+            entry: dict[str, object] = {
+                "skill": slug,
+                "entity_type": entity_type,
+                "source": source,
+            }
+            entry.update(preserved)
+            manifest["unload"].append(entry)
+        elif preserved:
+            for entry in manifest["unload"]:
+                if (
+                    entry.get("skill") == slug
+                    and entry.get("entity_type", "skill") == entity_type
+                ):
+                    for field, value in preserved.items():
+                        entry.setdefault(field, value)
+                    break
+
+    _update_manifest(mutate)
 
 
 # ── Entity status frontmatter ────────────────────────────────────────────────
@@ -297,9 +316,9 @@ def _render_scalar(value: object) -> str:
         # The full set mirrors the YAML 1.1 reserved-indicator table:
         # flow indicators (,[]{}), block/map indicators (:?-), anchor/
         # alias (&*), tag (!), pipe/fold (|>), comment (#), directive (%),
-        # reserved (@`), both quote marks, and ``<`` so bare ``<<`` is
-        # never resolved as YAML's merge tag.
-        yaml_structural = set(",[]{}:?#&*!|>%@`=\"'\\<")
+        # reserved (@`), both quote marks, and ``<`` so bare ``<<`` is
+        # never resolved as YAML's merge tag.
+        yaml_structural = set(",[]{}:?#&*!|>%@`=\"'\\<")
         needs_quote = (
             any(ch in safe for ch in yaml_structural)
             or (safe and (safe[0] == "-" or safe[0].isspace() or safe[-1].isspace()))

src/ctx/adapters/claude_code/install/mcp_install.py

@@ -59,6 +59,7 @@ from pathlib import Path
 from ctx_config import cfg
 from ctx.adapters.claude_code.install.install_utils import (
     bump_entity_status,
+    load_manifest,
     record_install,
     record_uninstall,
 )
@@ -103,6 +104,7 @@ _BANNED_INTERPRETER_ARGS: dict[str, frozenset[str]] = {
     # npx / uvx / bunx intentionally unrestricted — they ARE the
     # package-launcher pattern MCP servers are expected to use.
 }
+_WINDOWS_EXEC_SUFFIXES = (".exe", ".cmd", ".bat", ".ps1")
 
 _SECRET_KEY_MARKERS: tuple[str, ...] = (
     "token",
@@ -141,7 +143,7 @@ def _rejects_banned_args(tokens: list[str]) -> str | None:
     for the rest."""
     if not tokens:
         return None
-    exe = tokens[0]
+    exe = _normalized_executable(tokens[0])
     banned = _BANNED_INTERPRETER_ARGS.get(exe)
     if banned is None:
         return None
@@ -208,6 +210,42 @@ def _find_inline_secret(obj: object, *, path: str = "") -> str | None:
     return None
 
 
+def _normalized_executable(value: str) -> str:
+    name = Path(value).name.lower()
+    for suffix in _WINDOWS_EXEC_SUFFIXES:
+        if name.endswith(suffix):
+            return name[: -len(suffix)]
+    return name
+
+
+def _find_inline_secret_arg(tokens: list[str]) -> str | None:
+    for token in tokens:
+        assignment = _SECRET_ASSIGNMENT_RE.search(token)
+        if assignment and not _placeholder_secret_value(assignment.group(2)):
+            return assignment.group(1)
+        for pattern in _TOKEN_VALUE_PATTERNS:
+            if pattern.search(token):
+                return token
+        if token.startswith("--") and "=" in token:
+            key, value = token.split("=", 1)
+            if _secret_key_like(key) and not _placeholder_secret_value(value):
+                return key
+
+    for index, token in enumerate(tokens[:-1]):
+        if not token.startswith("-"):
+            continue
+        key = token.lstrip("-").replace("-", "_")
+        value = tokens[index + 1]
+        if (
+            _secret_key_like(key)
+            and value
+            and not value.startswith("-")
+            and not _placeholder_secret_value(value)
+        ):
+            return token
+    return None
+
+
 def _redact_output(text: str) -> str:
     if not text:
         return text
@@ -427,6 +465,16 @@ def install_mcp(
     existing_status = fm.get("status", "")
 
     if existing_status == "installed" and not force:
+        skipped_extra: dict[str, str] = {}
+        install_cmd = fm.get("install_cmd")
+        if isinstance(install_cmd, str) and install_cmd:
+            skipped_extra["command"] = install_cmd
+        record_install(
+            slug,
+            entity_type="mcp-server",
+            source="ctx-mcp-install",
+            extra=skipped_extra,
+        )
         return InstallResult(
             slug=slug, status="skipped-existing", command=None,
             message="already installed; pass --force to reinstall",
@@ -469,6 +517,25 @@ def install_mcp(
                 ),
             )
 
+    command_tokens: list[str] | None = None
+    if effective_cmd:
+        try:
+            command_tokens = _split_install_command(effective_cmd)
+        except ValueError as exc:
+            return InstallResult(
+                slug=slug, status="invalid-cmd", command=effective_cmd,
+                message=f"could not parse --cmd/install_cmd: {exc}",
+            )
+        inline_secret_arg = _find_inline_secret_arg(command_tokens)
+        if inline_secret_arg is not None:
+            return InstallResult(
+                slug=slug, status="invalid-cmd", command=None,
+                message=(
+                    f"--cmd/install_cmd argument {inline_secret_arg!r} looks like "
+                    "an inline secret; pass an environment variable reference instead."
+                ),
+            )
+
     card = render_card(fm, slug, command=effective_cmd)
     print(card)
 
@@ -489,13 +556,7 @@ def install_mcp(
         rc, stdout, stderr = _run_claude_mcp(["add-json", slug, json_config])
     else:
         assert effective_cmd is not None  # narrowed by dry_run branch above
-        try:
-            tokens = _split_install_command(effective_cmd)
-        except ValueError as exc:
-            return InstallResult(
-                slug=slug, status="invalid-cmd", command=effective_cmd,
-                message=f"could not parse --cmd/install_cmd: {exc}",
-            )
+        tokens = command_tokens if command_tokens is not None else _split_install_command(effective_cmd)
         if not tokens:
             return InstallResult(
                 slug=slug, status="invalid-cmd", command=effective_cmd,
@@ -505,7 +566,8 @@ def install_mcp(
         # (which is under entity-file control); treat it as untrusted.
         # Only known MCP-runtime launchers are allowed — if your
         # server needs a bespoke runtime, add-json is the right path.
-        if tokens[0] not in _ALLOWED_CMD_EXECS:
+        executable = _normalized_executable(tokens[0])
+        if executable not in _ALLOWED_CMD_EXECS:
             return InstallResult(
                 slug=slug, status="invalid-cmd", command=effective_cmd,
                 message=(
@@ -592,9 +654,14 @@ def uninstall_mcp(
         )
 
     entity = _entity_path(wiki_dir, slug)
+    manifest_entry = _manifest_load_entry(slug)
     if entity.is_file():
         fm = _parse_entity_frontmatter(entity)
-        if fm.get("status", "") != "installed" and not force:
+        if (
+            fm.get("status", "") != "installed"
+            and manifest_entry is None
+            and not force
+        ):
             return UninstallResult(
                 slug=slug, status="not-installed",
                 message="entity status is not 'installed'; pass --force to run claude mcp remove anyway",
@@ -628,6 +695,17 @@ def uninstall_mcp(
     )
 
 
+def _manifest_load_entry(slug: str) -> dict | None:
+    manifest = load_manifest()
+    for entry in manifest.get("load", []):
+        if (
+            entry.get("skill") == slug
+            and entry.get("entity_type", "skill") == "mcp-server"
+        ):
+            return entry
+    return None
+
+
 # ── CLIs ─────────────────────────────────────────────────────────────────────
 
 

src/ctx/adapters/claude_code/install/skill_install.py

@@ -140,20 +140,26 @@ def _ensure_micro_converted(
 # ── Copy logic ───────────────────────────────────────────────────────────────
 
 
-def _copy_references(src_dir: Path, dest_dir: Path) -> int:
-    """Copy every .md in ``src_dir/references/`` to ``dest_dir/references/``.
+_BUNDLE_DIR_NAMES = ("references", "reference", "resources", "scripts", "assets")
 
-    Returns the number of reference files copied. Skips silently when no
-    references dir exists in the wiki.
-    """
-    src_refs = src_dir / "references"
-    if not src_refs.is_dir():
-        return 0
-    dest_refs = dest_dir / "references"
+
+def _iter_bundle_files(src_dir: Path) -> list[tuple[Path, Path]]:
+    """Return ``(source, relative_destination)`` pairs for skill bundle files."""
+    files: list[tuple[Path, Path]] = []
+    for dirname in _BUNDLE_DIR_NAMES:
+        bundle_dir = src_dir / dirname
+        if not bundle_dir.is_dir():
+            continue
+        for source in sorted(path for path in bundle_dir.rglob("*") if path.is_file()):
+            files.append((source, source.relative_to(src_dir)))
+    return files
+
+
+def _copy_bundle_files(src_dir: Path, dest_dir: Path) -> int:
+    """Copy bundled references/resources/scripts/assets into an install dir."""
     copied = 0
-    for md_file in sorted(src_refs.glob("*.md")):
-        dest = dest_refs / md_file.name
-        safe_copy_file(md_file, dest, dest_root=dest_dir)
+    for source, relative in _iter_bundle_files(src_dir):
+        safe_copy_file(source, dest_dir / relative, dest_root=dest_dir)
         copied += 1
     return copied
 
@@ -174,7 +180,7 @@ def install_skill(
       1. Validated (slug passes ``validate_skill_name``).
       2. Sourced from the wiki (``converted/<slug>/SKILL.md``, with
          ``.original`` as fallback).
-      3. Copied to ``<skills_dir>/<slug>/SKILL.md`` plus any references.
+      3. Copied to ``<skills_dir>/<slug>/SKILL.md`` plus bundled resources.
       4. Mirrored into the skill manifest and the wiki entity's status
          frontmatter.
 
@@ -232,10 +238,7 @@ def install_skill(
         )
 
     if dry_run:
-        refs_count = 0
-        refs_dir = converted / "references"
-        if refs_dir.is_dir():
-            refs_count = sum(1 for _ in refs_dir.glob("*.md"))
+        refs_count = len(_iter_bundle_files(converted))
         message = "dry-run: no files written"
         try:
             if _line_count(source) > cfg.line_threshold:
@@ -262,7 +265,7 @@ def install_skill(
 
     try:
         safe_copy_file(source, dest, dest_root=skills_dir)
-        refs_copied = _copy_references(converted, dest_dir)
+        refs_copied = _copy_bundle_files(converted, dest_dir)
     except (OSError, ValueError) as exc:
         return InstallResult(
             slug=slug, status="failed", installed_path=None,

src/ctx/adapters/claude_code/install/skill_unload.py

@@ -22,11 +22,12 @@ from pathlib import Path
 from ctx.core.wiki.wiki_utils import validate_skill_name
 from ctx.utils._file_lock import file_lock
 from ctx.utils._fs_utils import atomic_write_text as _atomic_write_text
+from ctx_config import cfg
 
-CLAUDE_DIR = Path(os.path.expanduser("~/.claude"))
-MANIFEST_PATH = CLAUDE_DIR / "skill-manifest.json"
+CLAUDE_DIR = cfg.claude_dir
+MANIFEST_PATH = cfg.skill_manifest
 PENDING_UNLOAD = CLAUDE_DIR / "pending-unload.json"
-WIKI_DIR = CLAUDE_DIR / "skill-wiki"
+WIKI_DIR = cfg.wiki_dir
 SKILL_ENTITIES = WIKI_DIR / "entities" / "skills"
 AGENT_ENTITIES = WIKI_DIR / "entities" / "agents"
 

src/ctx/adapters/claude_code/skill_health.py

@@ -32,27 +32,26 @@ from __future__ import annotations
 
 import argparse
 import json
-import os
 import sys
 import time
 from dataclasses import asdict, dataclass, field
 from pathlib import Path
-from typing import Iterable, Sequence
-
-from ctx_config import cfg
-from ctx.utils._file_lock import file_lock
-from ctx.utils._fs_utils import atomic_write_text as _atomic_write
+from typing import Iterable, Sequence
+
+from ctx_config import cfg
+from ctx.utils._file_lock import file_lock
+from ctx.utils._fs_utils import atomic_write_text as _atomic_write
 
 
 # ── Paths & config defaults ────────────────────────────────────────────────
 
 
-SKILLS_DIR = Path(os.path.expanduser("~/.claude/skills"))
-AGENTS_DIR = Path(os.path.expanduser("~/.claude/agents"))
-MANIFEST_PATH = Path(os.path.expanduser("~/.claude/skill-manifest.json"))
-PENDING_PATH = Path(os.path.expanduser("~/.claude/pending-skills.json"))
-
-DEFAULT_LINE_THRESHOLD = cfg.line_threshold
+SKILLS_DIR = cfg.skills_dir
+AGENTS_DIR = cfg.agents_dir
+MANIFEST_PATH = cfg.skill_manifest
+PENDING_PATH = cfg.pending_skills
+
+DEFAULT_LINE_THRESHOLD = cfg.line_threshold
 DEFAULT_MIN_BODY_LINES = 5
 ERROR_SEVERITIES = frozenset({"error"})
 _SEVERITY_RANK = {"ok": 0, "warning": 1, "error": 2}

src/ctx/adapters/claude_code/skill_loader.py

@@ -16,12 +16,12 @@ Outputs the skill/agent content path so Claude can read and apply it.
 import argparse
 import json
 import logging
-import os
 import sys
 import uuid
 from pathlib import Path
 from typing import Any
 
+from ctx_config import cfg
 from ctx.core.wiki.wiki_utils import validate_skill_name
 from ctx.utils._file_lock import file_lock
 from ctx.utils._fs_utils import atomic_write_text as _atomic_write_text
@@ -32,11 +32,11 @@ _logger = logging.getLogger(__name__)
 _SESSION_ID: str = uuid.uuid4().hex
 
 
-SKILLS_DIR = Path(os.path.expanduser("~/.claude/skills"))
-AGENTS_DIR = Path(os.path.expanduser("~/.claude/agents"))
-WIKI_DIR = Path(os.path.expanduser("~/.claude/skill-wiki"))
-PENDING_SKILLS = Path(os.path.expanduser("~/.claude/pending-skills.json"))
-MANIFEST_PATH = Path(os.path.expanduser("~/.claude/skill-manifest.json"))
+SKILLS_DIR = cfg.skills_dir
+AGENTS_DIR = cfg.agents_dir
+WIKI_DIR = cfg.wiki_dir
+PENDING_SKILLS = cfg.pending_skills
+MANIFEST_PATH = cfg.skill_manifest
 
 
 def _resolved_under(candidate: Path, base: Path) -> bool:

src/ctx/adapters/generic/ctx_core_tools.py

@@ -159,6 +159,13 @@ class CtxCoreToolbox:
                                 "harness recommendations."
                             ),
                         },
+                        "use_semantic_query": {
+                            "type": "boolean",
+                            "description": (
+                                "Opt in to local embedding-based query scoring. "
+                                "Default false keeps recommendations latency-safe."
+                            ),
+                        },
                     },
                     "required": ["query"],
                 },
@@ -313,7 +320,8 @@ class CtxCoreToolbox:
         )
 
         tags = _query_to_tags(query)
-        if not tags:
+        use_semantic_query = bool(args.get("use_semantic_query"))
+        if not tags and not use_semantic_query:
             return json.dumps({
                 "error": "query produced no usable tags",
                 "results": [],
@@ -328,10 +336,10 @@ class CtxCoreToolbox:
 
         from ctx.core.resolve.recommendations import recommend_by_tags  # noqa: PLC0415
 
-        # Pass the original query through so the recommender can apply
-        # semantic-similarity scoring (in addition to tag/slug-token).
-        # Falls through silently if the embedding cache is missing.
-        self._refresh_semantic_cache_signature()
+        semantic_cache_dir = None
+        if use_semantic_query:
+            self._refresh_semantic_cache_signature()
+            semantic_cache_dir = _semantic_cache_dir(self._wiki_dir_resolved())
         raw = recommend_by_tags(
             graph,
             tags,
@@ -339,7 +347,8 @@ class CtxCoreToolbox:
             query=query,
             entity_types=("skill", "agent", "mcp-server"),
             min_normalized_score=cfg.recommendation_min_normalized_score,
-            use_semantic_query=True,
+            use_semantic_query=use_semantic_query,
+            semantic_cache_dir=semantic_cache_dir,
         )
         results = [
             {
@@ -722,6 +731,16 @@ def _wiki_pages_signature(wiki: Path) -> tuple[int, int, int]:
 def _semantic_cache_signature(
     wiki: Path | None,
 ) -> tuple[FileSignature | None, ...] | None:
+    cache_dir = _semantic_cache_dir(wiki)
+    if cache_dir is None:
+        return None
+    return (
+        _file_signature(cache_dir / "embeddings.npz"),
+        _file_signature(cache_dir / "topk-state.json"),
+    )
+
+
+def _semantic_cache_dir(wiki: Path | None) -> Path | None:
     try:
         from ctx_config import cfg  # noqa: PLC0415
 
@@ -734,10 +753,7 @@ def _semantic_cache_signature(
         default_cache = Path("~/.claude/skill-wiki/.embedding-cache/graph").expanduser()
         if wiki is not None and cache_dir == default_cache:
             cache_dir = wiki / ".embedding-cache" / "graph"
-    return (
-        _file_signature(cache_dir / "embeddings.npz"),
-        _file_signature(cache_dir / "topk-state.json"),
-    )
+    return cache_dir
 
 
 def _query_to_tags(query: str) -> list[str]:

src/ctx/core/graph/entity_overlays.py

@@ -36,19 +36,60 @@ _LIST_EDGE_ATTRS = frozenset(
 def active_overlay_records(records: Iterable[Mapping[str, Any]]) -> list[Mapping[str, Any]]:
     """Return deduped active records, superseding stale rows by scope."""
     by_attach_key: dict[str, Mapping[str, Any]] = {}
+    by_scope: dict[str, Mapping[str, Any]] = {}
     for index, record in enumerate(records):
         if record.get("superseded_at"):
             continue
+        node_id = _record_node_id(record)
+        if _is_delete_record(record):
+            if node_id:
+                by_attach_key = {
+                    key: value
+                    for key, value in by_attach_key.items()
+                    if _record_node_id(value) != node_id
+                }
+                by_scope = {
+                    key: value
+                    for key, value in by_scope.items()
+                    if _record_node_id(value) != node_id
+                }
+            continue
         attach_key = overlay_attach_key(record, fallback_index=index)
-        if attach_key not in by_attach_key:
-            by_attach_key[attach_key] = record
+        if attach_key in by_attach_key:
+            continue
+        by_attach_key[attach_key] = record
 
-    by_scope: dict[str, Mapping[str, Any]] = {}
-    for index, record in enumerate(by_attach_key.values()):
         by_scope[overlay_replace_scope(record, fallback_index=index)] = record
     return list(by_scope.values())
 
 
+def append_overlay_tombstone(path: Path, *, node_id: str, source: str) -> str:
+    """Append a delete tombstone so stale overlay nodes stay removed."""
+    if not node_id:
+        raise ValueError("node_id must be non-empty")
+    if not source:
+        raise ValueError("source must be non-empty")
+    with file_lock(path):
+        records = load_overlay_records(path)
+        if not records:
+            return "skipped"
+        records.append({
+            "action": "delete",
+            "node_id": node_id,
+            "source": source,
+            "deleted_at": _utc_now(),
+        })
+        write_overlay_records_atomic(path, records)
+        return "inserted"
+
+
+def _is_delete_record(record: Mapping[str, Any]) -> bool:
+    action = record.get("action")
+    if isinstance(action, str) and action.strip().lower() in {"delete", "tombstone"}:
+        return True
+    return bool(record.get("tombstone"))
+
+
 def overlay_attach_key(record: Mapping[str, Any], *, fallback_index: int = 0) -> str:
     for key in ("attach_key", "idempotency_key", "overlay_id"):
         value = record.get(key)
@@ -83,6 +124,16 @@ def merge_node_attrs(existing: Mapping[str, Any], incoming: Mapping[str, Any]) -
     return merged
 
 
+def replace_node_attrs(existing: Mapping[str, Any], incoming: Mapping[str, Any]) -> dict[str, Any]:
+    """Overlay incoming non-empty node attrs onto an existing node."""
+    merged = dict(existing)
+    for key, value in incoming.items():
+        if key == "id" or value in _EMPTY_VALUES:
+            continue
+        merged[key] = value
+    return merged
+
+
 def merge_edge_attrs(existing: Mapping[str, Any], incoming: Mapping[str, Any]) -> dict[str, Any]:
     merged = dict(existing)
     for key, value in incoming.items():
@@ -99,6 +150,15 @@ def merge_edge_attrs(existing: Mapping[str, Any], incoming: Mapping[str, Any]) -
     return merged
 
 
+def replace_edge_attrs(incoming: Mapping[str, Any]) -> dict[str, Any]:
+    """Return only the current non-empty edge attrs from an authoritative overlay."""
+    return {
+        key: value
+        for key, value in incoming.items()
+        if key not in {"source", "target"} and value not in _EMPTY_VALUES
+    }
+
+
 def load_overlay_records(path: Path) -> list[dict[str, Any]]:
     """Load JSONL overlay records for writer paths.
 

src/ctx/core/graph/incremental_attach.py

@@ -15,11 +15,13 @@ from typing import Any, Iterable
 import networkx as nx
 import numpy as np
 
+from ctx.core.graph.edge_scoring import type_affinity_score
 from ctx.core.graph.entity_overlays import upsert_overlay_record
 from ctx.core.graph.vector_index import load_vector_index
 
 _PERCENTILES = (50, 60, 75, 90, 95)
-_DEFAULT_MIN_SEMANTIC_SCORE = 0.75
+_DEFAULT_MIN_SEMANTIC_SCORE = 0.80
+_DEFAULT_SEMANTIC_BUILD_FLOOR = 0.50
 _DEFAULT_MIN_FINAL_WEIGHT = 0.03
 _ATTACH_METHOD = "ann_attach_v1"
 
@@ -177,6 +179,7 @@ def attach_entity(
         model_id=resolved_model_id,
         created_at=now,
         candidates_considered=len(neighbors),
+        min_final_weight=min_final_weight,
         neighbors=[
             {
                 "node_id": neighbor.node_id,
@@ -184,7 +187,6 @@ def attach_entity(
                 "rank": rank,
             }
             for rank, neighbor in enumerate(neighbors, 1)
-            if float(neighbor.score) >= min_final_weight
         ],
     )
     status = "dry-run" if dry_run else upsert_overlay_record(overlay_path, record)
@@ -217,7 +219,7 @@ def main(argv: list[str] | None = None) -> int:
     attach.add_argument("--embedding-backend", default="sentence-transformers")
     attach.add_argument("--embedding-model")
     attach.add_argument("--top-k", type=int, default=20)
-    attach.add_argument("--min-score", type=float, default=_DEFAULT_MIN_SEMANTIC_SCORE)
+    attach.add_argument("--min-score", type=float)
     attach.add_argument("--min-final-weight", type=float, default=_DEFAULT_MIN_FINAL_WEIGHT)
     attach.add_argument("--dry-run", action="store_true", help="Print the overlay record without writing")
     attach.add_argument("--json", action="store_true", help="Emit machine-readable JSON")
@@ -245,7 +247,11 @@ def main(argv: list[str] | None = None) -> int:
                 vector_json=args.vector_json,
                 model_id=args.model_id,
                 top_k=args.top_k,
-                min_score=args.min_score,
+                min_score=(
+                    args.min_score
+                    if args.min_score is not None
+                    else _default_min_semantic_score()
+                ),
                 min_final_weight=args.min_final_weight,
                 dry_run=args.dry_run,
                 embedding_backend=args.embedding_backend,
@@ -274,6 +280,15 @@ def _resolve_text_input(text: str | None, text_file: str | None) -> str | None:
         raise ValueError(f"cannot read --text-file {path}") from exc
 
 
+def _default_min_semantic_score() -> float:
+    try:
+        from ctx_config import cfg  # noqa: PLC0415
+
+        return float(cfg.graph_semantic_build_floor)
+    except Exception:  # pragma: no cover - standalone CLI fallback.
+        return _DEFAULT_SEMANTIC_BUILD_FLOOR
+
+
 def _read_index_meta(index_dir: Path) -> dict[str, Any]:
     meta_path = index_dir / "vector-index.meta.json"
     try:
@@ -340,25 +355,43 @@ def _build_attach_record(
     model_id: str,
     created_at: str,
     candidates_considered: int,
+    min_final_weight: float,
     neighbors: list[dict[str, Any]],
 ) -> dict[str, Any]:
     attach_key = f"ann:v1:{model_id}:{node_id}:{content_hash}"
     edges: list[dict[str, Any]] = []
     for neighbor in neighbors:
-        score = float(neighbor["score"])
+        semantic = float(neighbor["score"])
+        target_type = _node_type_from_id(str(neighbor["node_id"]))
+        type_affinity = type_affinity_score(entity_type, target_type)
+        final, components = _blend_ann_score(
+            semantic=semantic,
+            type_affinity=type_affinity,
+        )
+        if final < min_final_weight:
+            continue
         edges.append(
             {
                 "source": node_id,
                 "target": neighbor["node_id"],
-                "weight": score,
-                "final_weight": score,
-                "semantic_sim": score,
-                "similarity_score": score,
+                "weight": final,
+                "final_weight": final,
+                "semantic_sim": semantic,
+                "similarity_score": semantic,
+                "type_affinity": type_affinity,
+                "score_components": components,
                 "method": _ATTACH_METHOD,
                 "provenance": _ATTACH_METHOD,
                 "rank": int(neighbor["rank"]),
                 "candidates_considered": candidates_considered,
-                "edge_reasons": ["semantic-ann"],
+                "edge_reasons": [
+                    reason
+                    for reason, enabled in (
+                        ("semantic-ann", semantic > 0.0),
+                        ("type-affinity", type_affinity > 0.0),
+                    )
+                    if enabled
+                ],
                 "created_at": created_at,
             }
         )
@@ -398,6 +431,33 @@ def _slug_label(node_id: str) -> str:
     return node_id.split(":", 1)[-1]
 
 
+def _node_type_from_id(node_id: str) -> str:
+    return node_id.split(":", 1)[0] if ":" in node_id else ""
+
+
+def _blend_ann_score(
+    *,
+    semantic: float,
+    type_affinity: float,
+) -> tuple[float, dict[str, float]]:
+    try:
+        from ctx_config import cfg  # noqa: PLC0415
+
+        semantic_weight = float(cfg.graph_edge_weight_semantic)
+        type_weight = float(cfg.graph_edge_boost_type_affinity)
+    except Exception:  # pragma: no cover - defensive fallback for standalone CLI use.
+        semantic_weight = 0.70
+        type_weight = 0.03
+    components = {
+        "semantic": round(semantic_weight * semantic, 4),
+        "type_affinity": round(type_weight * type_affinity, 4),
+    }
+    final = min(sum(components.values()), 1.0)
+    return round(final, 4), {
+        key: value for key, value in components.items() if value > 0.0
+    }
+
+
 def _utc_now() -> str:
     return datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
 

src/ctx/core/graph/resolve_graph.py

@@ -18,7 +18,9 @@ import math
 import os
 import sys
 from collections import defaultdict
+from collections.abc import Mapping
 from pathlib import Path
+from typing import Any
 
 import networkx as nx
 from networkx.readwrite import node_link_graph
@@ -27,6 +29,8 @@ from ctx.core.graph.entity_overlays import (
     active_overlay_records,
     merge_edge_attrs,
     merge_node_attrs,
+    replace_edge_attrs,
+    replace_node_attrs,
 )
 
 logger = logging.getLogger(__name__)
@@ -189,18 +193,27 @@ def _apply_entity_overlays(G: nx.Graph, graph_path: Path) -> nx.Graph:
         records.append(payload)
 
     for payload in active_overlay_records(records):
+        authoritative_nodes = _authoritative_overlay_nodes(payload)
+        for node_id in authoritative_nodes:
+            if node_id in G:
+                G.remove_edges_from(list(G.edges(node_id)))
         nodes = payload.get("nodes", [])
         if isinstance(nodes, list):
             for node in nodes:
                 if not isinstance(node, dict):
                     continue
-                node_id = node.get("id")
-                if not isinstance(node_id, str) or not node_id:
+                incoming_node_id = node.get("id")
+                if not isinstance(incoming_node_id, str) or not incoming_node_id:
                     continue
+                overlay_node_id: str = incoming_node_id
                 attrs = {key: value for key, value in node.items() if key != "id"}
-                if node_id in G:
-                    attrs = merge_node_attrs(G.nodes[node_id], attrs)
-                G.add_node(node_id, **attrs)
+                if overlay_node_id in G:
+                    attrs = (
+                        replace_node_attrs(G.nodes[overlay_node_id], attrs)
+                        if overlay_node_id in authoritative_nodes
+                        else merge_node_attrs(G.nodes[overlay_node_id], attrs)
+                    )
+                G.add_node(overlay_node_id, **attrs)
                 applied_nodes += 1
 
         edges = payload.get("edges", [])
@@ -219,7 +232,12 @@ def _apply_entity_overlays(G: nx.Graph, graph_path: Path) -> nx.Graph:
                     for key, value in edge.items()
                     if key not in {"source", "target"}
                 }
-                if G.has_edge(source, target):
+                authoritative_edge = source in authoritative_nodes or target in authoritative_nodes
+                if authoritative_edge:
+                    attrs = replace_edge_attrs(edge)
+                    if G.has_edge(source, target):
+                        G.remove_edge(source, target)
+                elif G.has_edge(source, target):
                     attrs = merge_edge_attrs(G.edges[source, target], attrs)
                 G.add_edge(source, target, **attrs)
                 applied_edges += 1
@@ -230,6 +248,33 @@ def _apply_entity_overlays(G: nx.Graph, graph_path: Path) -> nx.Graph:
     return G
 
 
+def _authoritative_overlay_nodes(payload: Mapping[str, Any]) -> set[str]:
+    """Return node IDs whose overlay rows should replace current ANN scores."""
+    kind = payload.get("kind")
+    attach_key = payload.get("attach_key")
+    replace_scope = payload.get("replace_scope")
+    is_ann_record = (
+        kind == "ann_attach"
+        or (isinstance(attach_key, str) and attach_key.startswith("ann:v1:"))
+        or (isinstance(replace_scope, str) and replace_scope.startswith("ann:v1:"))
+    )
+    if not is_ann_record:
+        return set()
+
+    node_ids: set[str] = set()
+    node_id = payload.get("node_id")
+    if isinstance(node_id, str) and node_id:
+        node_ids.add(node_id)
+    nodes = payload.get("nodes")
+    if isinstance(nodes, list):
+        for node in nodes:
+            if isinstance(node, dict):
+                nested_id = node.get("id")
+                if isinstance(nested_id, str) and nested_id:
+                    node_ids.add(nested_id)
+    return node_ids
+
+
 def load_graph(
     path: Path | None = None,
     *,

src/ctx/core/graph/semantic_edges.py

@@ -210,6 +210,13 @@ def _partition_for_incremental(
     removed = prior_ids - current_ids
     overlap = current_ids & prior_ids
 
+    if new:
+        # A new node can displace any existing node's prior top-K even when
+        # no prior row could reference it. Interactive single-entity adds use
+        # the ANN overlay attach path; the semantic graph builder must preserve
+        # parity with a full top-K rebuild.
+        return current_ids, set()
+
     changed: set[str] = set()
     for nid in overlap:
         cached_hash = prior.nodes[nid].get("content_hash", "")
@@ -524,6 +531,9 @@ def _topk_pairs(
     n = vecs.shape[0]
     out: dict[tuple[str, str], float] = {}
 
+    if top_k <= 0 or n <= 1:
+        return {}
+
     # top_k + 1 because argpartition returns the node itself (cosine=1.0)
     # as its own nearest neighbor. We mask self below, but asking for
     # one extra is defensive against ties.
@@ -542,17 +552,16 @@ def _topk_pairs(
         idx_unsorted = np.argpartition(-sims, effective_k - 1, axis=1)[:, :effective_k]
         for i in range(end - start):
             src_id = node_ids[start + i]
-            for j in idx_unsorted[i]:
-                if j == start + i:
-                    continue
-                score = float(sims[i, j])
-                if score < min_cosine:
-                    continue
-                dst_id = node_ids[int(j)]
-                pair = (src_id, dst_id) if src_id < dst_id else (dst_id, src_id)
-                existing = out.get(pair)
-                if existing is None or score > existing:
-                    out[pair] = score
+            _merge_exact_topk_row(
+                out,
+                src_id=src_id,
+                src_index=start + i,
+                node_ids=node_ids,
+                scores=sims[i],
+                candidate_indices=idx_unsorted[i],
+                top_k=top_k,
+                min_cosine=min_cosine,
+            )
         if end == n or (start // chunk_size + 1) % 10 == 0:
             print(
                 "semantic_edges: top-k rows "
@@ -848,6 +857,8 @@ def _topk_pairs_subset(
 
     if not subset_indices:
         return {}
+    if top_k <= 0 or vecs.shape[0] <= 1:
+        return {}
 
     out: dict[tuple[str, str], float] = {}
     effective_k = min(top_k + 1, vecs.shape[0])
@@ -867,18 +878,16 @@ def _topk_pairs_subset(
         idx_unsorted = np.argpartition(-sims, effective_k - 1, axis=1)[:, :effective_k]
         for i, abs_i in enumerate(chunk_indices):
             src_id = node_ids[abs_i]
-            for j in idx_unsorted[i]:
-                j = int(j)
-                if j == abs_i:
-                    continue
-                score = float(sims[i, j])
-                if score < min_cosine:
-                    continue
-                dst_id = node_ids[j]
-                pair = (src_id, dst_id) if src_id < dst_id else (dst_id, src_id)
-                existing = out.get(pair)
-                if existing is None or score > existing:
-                    out[pair] = score
+            _merge_exact_topk_row(
+                out,
+                src_id=src_id,
+                src_index=abs_i,
+                node_ids=node_ids,
+                scores=sims[i],
+                candidate_indices=idx_unsorted[i],
+                top_k=top_k,
+                min_cosine=min_cosine,
+            )
     return out
 
 
@@ -989,6 +998,41 @@ def _merge_neighbor_rows(
                 break
 
 
+def _merge_exact_topk_row(
+    out: dict[tuple[str, str], float],
+    *,
+    src_id: str,
+    src_index: int,
+    node_ids: Sequence[str],
+    scores: "np.ndarray",
+    candidate_indices: Sequence[int],
+    top_k: int,
+    min_cosine: float,
+) -> None:
+    if top_k <= 0:
+        return
+    ordered = sorted(
+        (int(index) for index in candidate_indices),
+        key=lambda index: float(scores[index]),
+        reverse=True,
+    )
+    emitted = 0
+    for j in ordered:
+        if j == src_index:
+            continue
+        score = float(scores[j])
+        if score < min_cosine:
+            continue
+        dst_id = node_ids[j]
+        pair = (src_id, dst_id) if src_id < dst_id else (dst_id, src_id)
+        existing = out.get(pair)
+        if existing is None or score > existing:
+            out[pair] = score
+        emitted += 1
+        if emitted >= top_k:
+            break
+
+
 def _reuse_prior_pairs(
     prior: TopKState,
     unchanged: set[str],

src/ctx/core/resolve/recommendations.py

@@ -224,15 +224,23 @@ def _token_idf(graph: Any) -> dict[str, float]:
 
 def query_to_tags(query: str) -> list[str]:
     """Extract tag-shaped signals from a free-text query."""
-    tokens = re.findall(r"[A-Za-z0-9_\-]+", query.lower())
+    tokens = re.findall(r"[A-Za-z0-9_/\-]+", query.lower())
     seen: dict[str, None] = {}
-    for token in tokens:
-        if len(token) < 3 or token in _TAG_STOPWORDS:
-            continue
-        seen.setdefault(token, None)
+    for raw_token in tokens:
+        if "/" not in raw_token and _SLUG_TOKEN_RE.search(raw_token):
+            if len(raw_token) >= 3 and raw_token not in _TAG_STOPWORDS:
+                seen.setdefault(raw_token, None)
+        for token in _slug_token_parts(raw_token):
+            if len(token) < 3 or token in _TAG_STOPWORDS:
+                continue
+            seen.setdefault(token, None)
     return list(seen.keys())
 
 
+def _slug_token_parts(label: str) -> list[str]:
+    return [tok for tok in _SLUG_TOKEN_RE.split(label.lower()) if tok]
+
+
 def recommend_by_tags(
     graph: Any,
     tags: list[str],

src/ctx/core/wiki/wiki_queue.py

@@ -137,6 +137,7 @@ def enqueue_entity_upsert(
         payload=payload,
         idempotency_key=f"{ENTITY_UPSERT_JOB}:{entity_type}:{slug}:{content_hash}",
         content_hash=content_hash,
+        reuse_terminal=action != "delete",
         now=now,
     )
 

src/ctx/core/wiki/wiki_queue_worker.py

@@ -12,6 +12,7 @@ from hashlib import sha256
 from pathlib import Path
 from typing import Any, Callable
 
+from ctx.core.graph.entity_overlays import append_overlay_tombstone
 from ctx.core.graph.incremental_attach import attach_entity
 from ctx.core.wiki.artifact_promotion import promote_staged_artifact
 from ctx.core.wiki import wiki_queue
@@ -132,6 +133,11 @@ def _process_entity_upsert(wiki_path: Path, payload: dict[str, Any]) -> str:
 
     entity_path = _resolve_entity_path(wiki_path, _required_string(payload, "entity_path"))
     if action == "delete":
+        append_overlay_tombstone(
+            wiki_path / "graphify-out" / "entity-overlays.jsonl",
+            node_id=f"{entity_type}:{slug}",
+            source="entity-delete",
+        )
         wiki_queue.enqueue_maintenance_job(
             wiki_path,
             kind=wiki_queue.GRAPH_EXPORT_JOB,
@@ -200,7 +206,7 @@ def _try_incremental_attach(
             vector_json=None,
             model_id=None,
             top_k=int(cfg.graph_semantic_top_k),
-            min_score=float(cfg.graph_semantic_min_cosine),
+            min_score=float(cfg.graph_semantic_build_floor),
             min_final_weight=_DEFAULT_ATTACH_MIN_FINAL_WEIGHT,
         )
     except Exception as exc:  # noqa: BLE001 - attach is derived, not source of truth.

src/ctx_init.py

@@ -218,17 +218,25 @@ def _resolve_ctx_src_dir() -> Path:
 _GRAPH_ARCHIVE_NAME = "wiki-graph.tar.gz"
 _GRAPH_RUNTIME_ARCHIVE_NAME = "wiki-graph-runtime.tar.gz"
 _GRAPH_ENTITY_OVERLAY_NAME = "entity-overlays.jsonl"
+_GRAPH_ENTITY_OVERLAY_SCORE_FIELDS = (
+    "weight",
+    "final_weight",
+    "similarity_score",
+    "semantic_sim",
+    "tag_sim",
+    "token_sim",
+)
 _GRAPH_ENTITY_OVERLAY_SHA256 = (
-    "12556f40a8f86fdb10b87bb656a1ef03cb5bd1e5e24dd03a6c5d5eb452bf01cc"
+    "cc1a69d3452d2018bec1e049fc4ab1fa8f933adecfdcae4802a815be03f8611c"
 )
 _GRAPH_ARCHIVE_NAMES = {
     "runtime": _GRAPH_RUNTIME_ARCHIVE_NAME,
     "full": _GRAPH_ARCHIVE_NAME,
 }
-_GRAPH_ARCHIVE_SHA256 = {
-    "runtime": "d00d34d995e0d55bdaba9957b2d8fcf1938bfeca0d0e755874e4ea990360775d",
-    "full": "502fd22c570259d47c3aa5874a728fc533bd11d404ff43a611f3d1e1224db250",
-}
+_GRAPH_ARCHIVE_SHA256 = {
+    "runtime": "334fb19bace3fd6e4b92087850f17297fb248032957d123f3f1432dfde2e36c0",
+    "full": "91b30795e7d200cf31a62a8749969d12658f5f74636d2de06d6b2b24b393c12f",
+}
 _GRAPH_RELEASE_URL = (
     "https://github.com/stevesolun/ctx/releases/download/"
     "v{version}/{archive_name}"
@@ -257,6 +265,9 @@ _GRAPH_MANAGED_PATHS = (
     "versions-catalog.md",
     ".obsidian",
 )
+_GRAPH_RUNTIME_MANAGED_PATHS = tuple(
+    name for name in _GRAPH_MANAGED_PATHS if name != "entities"
+) + ("entities/harnesses",)
 _GRAPH_JSON_OUTLINE_BYTES = 1024 * 1024
 _GRAPH_INSTALL_MODES = ("runtime", "full")
 _GRAPH_RUNTIME_PREFIXES = ("graphify-out/", "external-catalogs/", "entities/harnesses/")
@@ -433,7 +444,8 @@ def _validate_graph_entity_overlay(path: Path) -> None:
                 raise ValueError(
                     f"{path} line {lineno} edge {index} must contain source/target"
                 )
-            for field in ("weight", "final_weight", "similarity_score"):
+            numeric_scores: dict[str, float] = {}
+            for field in _GRAPH_ENTITY_OVERLAY_SCORE_FIELDS:
                 value = edge.get(field)
                 if value is None:
                     continue
@@ -441,6 +453,15 @@ def _validate_graph_entity_overlay(path: Path) -> None:
                     raise ValueError(
                         f"{path} line {lineno} edge {index} {field} must be 0..1"
                     )
+                numeric_scores[field] = float(value)
+            if (
+                "weight" in numeric_scores
+                and "final_weight" in numeric_scores
+                and abs(numeric_scores["weight"] - numeric_scores["final_weight"]) > 1e-9
+            ):
+                raise ValueError(
+                    f"{path} line {lineno} edge {index} weight must equal final_weight"
+                )
 
 
 def _release_graph_url(install_mode: str = "runtime") -> str:
@@ -554,7 +575,7 @@ def _extract_graph_archive(
             install_mode=install_mode,
         )
         _validate_graph_install_tree(staging_dir)
-        _promote_graph_tree(staging_dir, target_dir)
+        _promote_graph_tree(staging_dir, target_dir, install_mode=install_mode)
 
 
 def _extract_graph_archive_to_dir(
@@ -712,10 +733,20 @@ def _read_json_file(path: Path) -> Any:
         return json.load(f)
 
 
-def _promote_graph_tree(staging_dir: Path, target_dir: Path) -> None:
+def _promote_graph_tree(
+    staging_dir: Path,
+    target_dir: Path,
+    *,
+    install_mode: str,
+) -> None:
     target_dir.mkdir(parents=True, exist_ok=True)
     target_root = target_dir.resolve()
-    for name in _GRAPH_MANAGED_PATHS:
+    managed_paths = (
+        _GRAPH_MANAGED_PATHS
+        if install_mode == "full"
+        else _GRAPH_RUNTIME_MANAGED_PATHS
+    )
+    for name in managed_paths:
         source = staging_dir / name
         destination = target_dir / name
         _ensure_path_under_root(destination.parent, target_root)
@@ -860,6 +891,7 @@ _HARNESS_SOFT_REQUIREMENT_SIGNALS = frozenset({
     "linux",
     "mac",
     "macos",
+    "gpt",
     "mcp",
     "npm",
     "pytest",

src/ctx_monitor.py

@@ -66,16 +66,18 @@ import os
 import re
 import secrets
 import sqlite3
+import socket
 import sys
 import tarfile
 import threading
 import time
 import zlib
 from collections import defaultdict, deque
+from http.cookies import CookieError, SimpleCookie
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
 from pathlib import Path, PurePosixPath
 from typing import Any
-from urllib.parse import quote, unquote
+from urllib.parse import quote, unquote, urlsplit
 
 from ctx.core.wiki import wiki_queue
 from ctx.core.wiki.wiki_utils import parse_frontmatter_and_body
@@ -89,14 +91,24 @@ _MONITOR_TOKEN = ""
 _MONITOR_MUTATIONS_ENABLED = True
 _GRAPH_CACHE_KEY: tuple[Any, ...] | None = None
 _GRAPH_CACHE_VALUE: Any | None = None
+_PACKAGED_GRAPH_EXPORT_ID_CACHE: str | None | bool = None
 _OVERLAY_INDEX_COVERAGE_CACHE_KEY: tuple[Any, ...] | None = None
 _OVERLAY_INDEX_COVERAGE_CACHE_VALUE: bool | None = None
 _SIDECAR_INDEX_CACHE_KEY: tuple[tuple[Path, float, int], ...] | None = None
 _SIDECAR_INDEX_CACHE_VALUE: dict[tuple[str, str], dict] | None = None
+_SIDECAR_FILTER_CACHE_SIGNATURE: tuple[Any, ...] | None = None
+_SIDECAR_FILTER_CACHE_VALUE: dict[tuple[Any, ...], list[dict[str, Any]]] = {}
+_KPI_SUMMARY_CACHE_KEY: tuple[Any, ...] | None = None
+_KPI_SUMMARY_CACHE_VALUE: Any | None = None
+_KPI_SUMMARY_CACHE_AT = 0.0
 _WIKI_INDEX_LIMIT_PER_TYPE = 500
+_SKILLS_PAGE_DEFAULT_LIMIT = 100
+_SKILLS_PAGE_MAX_LIMIT = 500
+_KPI_SUMMARY_CACHE_SECONDS = 30
 _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"
+_READ_TOKEN_COOKIE = "ctx_monitor_read_token"
 
 
 # ─── Data sources ────────────────────────────────────────────────────────────
@@ -112,6 +124,38 @@ def _host_allows_mutations(host: str) -> bool:
         return False
 
 
+def _request_host_name(host_header: str) -> str:
+    value = (host_header or "").strip()
+    if not value:
+        return ""
+    if value.startswith("["):
+        end = value.find("]")
+        return value[1:end].rstrip(".").lower() if end != -1 else ""
+    return value.rsplit(":", 1)[0].rstrip(".").lower()
+
+
+def _origin_host_name(origin: str) -> str:
+    try:
+        parsed = urlsplit(origin)
+    except ValueError:
+        return ""
+    if parsed.scheme not in {"http", "https"}:
+        return ""
+    return (parsed.hostname or "").rstrip(".").lower()
+
+
+def _read_token_cookie(cookie_header: str) -> str:
+    if not cookie_header:
+        return ""
+    try:
+        cookie = SimpleCookie()
+        cookie.load(cookie_header)
+    except CookieError:
+        return ""
+    morsel = cookie.get(_READ_TOKEN_COOKIE)
+    return morsel.value if morsel is not None else ""
+
+
 def _claude_dir() -> Path:
     return Path(os.path.expanduser("~/.claude"))
 
@@ -508,6 +552,20 @@ def _upsert_wiki_entity(payload: dict[str, Any]) -> tuple[bool, str]:
     return True, f"saved {entity_type}:{slug} and queued graph refresh"
 
 
+def _entity_live_in_manifest(slug: str, entity_type: str) -> bool:
+    manifest = _read_manifest()
+    for entry in manifest.get("load", []):
+        if not isinstance(entry, dict):
+            continue
+        entry_slug = str(entry.get("skill") or entry.get("slug") or "")
+        entry_type = _normalize_dashboard_entity_type(
+            str(entry.get("entity_type") or entry.get("type") or "skill"),
+        )
+        if entry_slug == slug and entry_type == entity_type:
+            return True
+    return False
+
+
 def _delete_wiki_entity(slug: str, entity_type: str) -> tuple[bool, str]:
     try:
         normalized = _normalize_dashboard_entity_type(entity_type)
@@ -518,6 +576,14 @@ def _delete_wiki_entity(slug: str, entity_type: str) -> tuple[bool, str]:
         path = _wiki_entity_path(slug, entity_type=normalized)
         if path is None:
             return False, f"no wiki entity found for {normalized}:{slug}"
+        if _entity_live_in_manifest(slug, normalized):
+            unloaded, unload_detail = _perform_unload(slug, normalized)
+            if not unloaded:
+                return (
+                    False,
+                    f"{normalized}:{slug} is loaded; unload before delete failed: "
+                    f"{unload_detail}",
+                )
         with file_lock(path):
             path.unlink()
         _queue_entity_refresh(
@@ -608,6 +674,8 @@ def _markdown_link_href(target: str) -> str | None:
     cleaned = target.strip()
     if not cleaned:
         return None
+    if cleaned.startswith("//"):
+        return None
     if cleaned.startswith(("/", "#")):
         return cleaned
     if re.match(r"^https?://", cleaned, re.IGNORECASE):
@@ -1713,6 +1781,231 @@ def _all_sidecars() -> list[dict]:
     return list(_sidecar_index().values())
 
 
+def _skills_page_int(
+    value: str | None,
+    *,
+    default: int,
+    minimum: int = 1,
+    maximum: int | None = None,
+) -> int:
+    try:
+        parsed = int(str(value or "").strip())
+    except ValueError:
+        parsed = default
+    parsed = max(minimum, parsed)
+    if maximum is not None:
+        parsed = min(maximum, parsed)
+    return parsed
+
+
+def _skills_query_values(raw: str | None, allowed: set[str]) -> set[str]:
+    values = {
+        item.strip()
+        for item in str(raw or "").split(",")
+        if item.strip()
+    }
+    return {item for item in values if item in allowed}
+
+
+def _sidecar_sort_key(sidecar: dict) -> tuple[str, float, str]:
+    return (
+        str(sidecar.get("grade") or "F"),
+        -float(sidecar.get("raw_score") or sidecar.get("score") or 0.0),
+        str(sidecar.get("slug") or ""),
+    )
+
+
+def _sidecar_card_payload(sidecar: dict) -> dict[str, Any]:
+    slug = str(sidecar.get("slug") or "")
+    entity_type = _sidecar_entity_type(sidecar)
+    return {
+        "slug": slug,
+        "grade": str(sidecar.get("grade") or "F"),
+        "type": entity_type,
+        "hard_floor": str(sidecar.get("hard_floor") or ""),
+        "raw_score": float(sidecar.get("raw_score") or sidecar.get("score") or 0.0),
+        "sidecar_href": f"/skill/{quote(slug)}?type={quote(entity_type)}",
+        "wiki_href": f"/wiki/{quote(slug)}?type={quote(entity_type)}",
+        "graph_href": f"/graph?slug={quote(slug)}&type={quote(entity_type)}",
+    }
+
+
+def _sidecar_filter_signature(files: list[Path]) -> tuple[Any, ...]:
+    roots = (_sidecar_dir(), _sidecar_dir() / "mcp")
+    root_counts = {
+        root.resolve(): sum(1 for path in files if path.parent == root)
+        for root in roots
+    }
+    signature: list[tuple[str, int, int]] = []
+    for root in roots:
+        if not root.is_dir():
+            signature.append((str(root.resolve()), 0, 0))
+            continue
+        stat = root.stat()
+        signature.append((
+            str(root.resolve()),
+            int(getattr(stat, "st_mtime_ns", int(stat.st_mtime * 1_000_000_000))),
+            root_counts.get(root.resolve(), 0),
+        ))
+    return tuple(signature)
+
+
+def _sidecar_candidate_files(
+    files: list[Path],
+    *,
+    q: str,
+    types: set[str],
+) -> list[Path]:
+    q_lower = q.lower()
+    candidates = [
+        path for path in files
+        if not q_lower or q_lower in path.stem.lower()
+    ]
+    if not types:
+        return candidates
+    if types == {"mcp-server"}:
+        return [path for path in candidates if path.parent.name == "mcp"]
+    if "mcp-server" not in types:
+        return [path for path in candidates if path.parent.name != "mcp"]
+    return candidates
+
+
+def _filtered_sidecar_records(
+    files: list[Path],
+    *,
+    q: str,
+    types: set[str],
+    grades: set[str],
+    hide_floor: bool,
+) -> list[dict[str, Any]]:
+    """Return cached filtered sidecar card records for /skills search."""
+    global _SIDECAR_FILTER_CACHE_SIGNATURE, _SIDECAR_FILTER_CACHE_VALUE
+
+    signature = _sidecar_filter_signature(files)
+    if _SIDECAR_FILTER_CACHE_SIGNATURE != signature:
+        _SIDECAR_FILTER_CACHE_SIGNATURE = signature
+        _SIDECAR_FILTER_CACHE_VALUE = {}
+    cache_key = (
+        q.lower(),
+        tuple(sorted(types)),
+        tuple(sorted(grades)),
+        hide_floor,
+    )
+    cached = _SIDECAR_FILTER_CACHE_VALUE.get(cache_key)
+    if cached is not None:
+        return cached
+
+    records: list[dict[str, Any]] = []
+    for path in _sidecar_candidate_files(files, q=q, types=types):
+        sidecar = _read_sidecar_file(path)
+        if sidecar is None:
+            continue
+        if not _sidecar_matches_filters(
+            sidecar,
+            q=q,
+            types=types,
+            grades=grades,
+            hide_floor=hide_floor,
+        ):
+            continue
+        records.append(_sidecar_card_payload(sidecar))
+    records.sort(key=_sidecar_sort_key)
+    if len(_SIDECAR_FILTER_CACHE_VALUE) >= 32:
+        _SIDECAR_FILTER_CACHE_VALUE.clear()
+    _SIDECAR_FILTER_CACHE_VALUE[cache_key] = records
+    return records
+
+
+def _sidecar_matches_filters(
+    sidecar: dict,
+    *,
+    q: str,
+    types: set[str],
+    grades: set[str],
+    hide_floor: bool,
+) -> bool:
+    entity_type = _sidecar_entity_type(sidecar)
+    grade = str(sidecar.get("grade") or "F")
+    floor = str(sidecar.get("hard_floor") or "")
+    if types and entity_type not in types:
+        return False
+    if grades and grade not in grades:
+        return False
+    if hide_floor and floor:
+        return False
+    if q:
+        return q.lower() in str(sidecar.get("slug") or "").lower()
+    return True
+
+
+def _sidecar_page_payload(qs: dict[str, str] | None = None) -> dict[str, Any]:
+    """Return a paginated sidecar payload for /skills and its JSON API."""
+    qs = qs or {}
+    page = _skills_page_int(qs.get("page"), default=1)
+    limit = _skills_page_int(
+        qs.get("limit"),
+        default=_SKILLS_PAGE_DEFAULT_LIMIT,
+        maximum=_SKILLS_PAGE_MAX_LIMIT,
+    )
+    q = str(qs.get("q") or "").strip()
+    types = _skills_query_values(qs.get("type"), set(_DASHBOARD_ENTITY_TYPES))
+    grades = _skills_query_values(qs.get("grade"), {"A", "B", "C", "D", "F"})
+    hide_floor = str(qs.get("hide_floor") or "").strip().lower() in {
+        "1", "true", "yes", "on",
+    }
+
+    files = _sidecar_files()
+    catalog_total = len(files)
+    has_filters = bool(q or types or grades or hide_floor)
+    if has_filters:
+        sidecars = _filtered_sidecar_records(
+            files,
+            q=q,
+            types=types,
+            grades=grades,
+            hide_floor=hide_floor,
+        )
+        total = len(sidecars)
+        start = (page - 1) * limit
+        page_sidecars = sidecars[start:start + limit]
+    else:
+        total = catalog_total
+        start = (page - 1) * limit
+        selected_files = files[start:start + limit]
+        page_sidecars = [
+            sidecar
+            for path in selected_files
+            if (sidecar := _read_sidecar_file(path)) is not None
+        ]
+        if catalog_total <= limit:
+            page_sidecars.sort(key=_sidecar_sort_key)
+
+    pages = max(1, math.ceil(total / limit)) if total else 1
+    if page > pages:
+        page = pages
+        return _sidecar_page_payload({
+            **qs,
+            "page": str(page),
+            "limit": str(limit),
+        })
+
+    return {
+        "items": [_sidecar_card_payload(sidecar) for sidecar in page_sidecars],
+        "total": total,
+        "catalog_total": catalog_total,
+        "page": page,
+        "limit": limit,
+        "pages": pages,
+        "has_next": page < pages,
+        "has_prev": page > 1,
+        "filtered": has_filters,
+        "q": q,
+        "types": sorted(types),
+        "grades": sorted(grades),
+        "hide_floor": hide_floor,
+    }
+
+
 # ─── Aggregations ────────────────────────────────────────────────────────────
 
 
@@ -2564,6 +2857,30 @@ def _dashboard_graph_index_archives() -> list[Path]:
     return archives
 
 
+def _packaged_graph_export_id() -> str | None:
+    global _PACKAGED_GRAPH_EXPORT_ID_CACHE
+    if isinstance(_PACKAGED_GRAPH_EXPORT_ID_CACHE, bool):
+        return None
+    if isinstance(_PACKAGED_GRAPH_EXPORT_ID_CACHE, str):
+        return _PACKAGED_GRAPH_EXPORT_ID_CACHE
+    module_root = Path(__file__).resolve().parent.parent
+    try:
+        data = json.loads(
+            (module_root / "graph" / "communities.json").read_text(
+                encoding="utf-8",
+            )
+        )
+    except (OSError, json.JSONDecodeError):
+        _PACKAGED_GRAPH_EXPORT_ID_CACHE = False
+        return None
+    export_id = data.get("export_id") if isinstance(data, dict) else None
+    if isinstance(export_id, str) and export_id.strip():
+        _PACKAGED_GRAPH_EXPORT_ID_CACHE = export_id.strip()
+        return export_id.strip()
+    _PACKAGED_GRAPH_EXPORT_ID_CACHE = False
+    return None
+
+
 def _archive_graph_export_id(archive: Path) -> str | None:
     try:
         with tarfile.open(archive, "r:gz") as tar:
@@ -2593,13 +2910,20 @@ def _ensure_dashboard_graph_index() -> Path | None:
             target.unlink()
         except OSError:
             return None
-    if (_wiki_dir() / "graphify-out" / "graph-report.md").is_file():
+
+    manifest_export_id = _dashboard_graph_manifest_export_id()
+    packaged_export_id = _packaged_graph_export_id()
+    if (
+        manifest_export_id is not None
+        and packaged_export_id is not None
+        and manifest_export_id != packaged_export_id
+    ):
         return None
 
     archives = _dashboard_graph_index_archives()
     if not archives:
         return None
-    if _dashboard_graph_manifest_export_id() is None:
+    if manifest_export_id is None:
         return None
 
     target.parent.mkdir(parents=True, exist_ok=True)
@@ -2613,8 +2937,7 @@ def _ensure_dashboard_graph_index() -> Path | None:
                 except OSError:
                     return None
             for archive in archives:
-                archive_export_id = _archive_graph_export_id(archive)
-                manifest_export_id = _dashboard_graph_manifest_export_id()
+                archive_export_id = packaged_export_id or _archive_graph_export_id(archive)
                 if manifest_export_id and archive_export_id and archive_export_id != manifest_export_id:
                     continue
                 try:
@@ -3359,17 +3682,9 @@ def _render_session_detail(session_id: str) -> str:
     return _layout(f"Session {session_id}", body)
 
 
-def _render_skills() -> str:
-    sidecars = _all_sidecars()
-    sidecars.sort(key=lambda s: (s.get("grade", "F"), -s.get("raw_score", 0.0)))
-
-    # Sidebar stats for the filter UI.
-    grade_counts = {"A": 0, "B": 0, "C": 0, "D": 0, "F": 0}
-    type_counts = {entity_type: 0 for entity_type in _DASHBOARD_ENTITY_TYPES}
-    for sc in sidecars:
-        grade_counts[sc.get("grade", "F")] = grade_counts.get(sc.get("grade", "F"), 0) + 1
-        st = _sidecar_entity_type(sc)
-        type_counts[st] = type_counts.get(st, 0) + 1
+def _render_skills(qs: dict[str, str] | None = None) -> str:
+    payload = _sidecar_page_payload(qs)
+    sidecars = payload["items"]
 
     cards = "".join(
         f"<div class='skill-card' data-slug='{html.escape(s.get('slug', ''))}' "
@@ -3383,7 +3698,7 @@ def _render_skills() -> str:
         f"<span class='pill grade-{html.escape(s.get('grade', 'F'))}'>{html.escape(s.get('grade', 'F'))}</span>"
         f"</div>"
         f"<div class='muted' style='font-size:0.78rem;'>"
-        f"score {s.get('raw_score', 0.0):.3f} · {html.escape(s.get('subject_type', 'skill'))}"
+        f"score {s.get('raw_score', 0.0):.3f} · {html.escape(s.get('type', s.get('subject_type', 'skill')))}"
         f"{' · ' + html.escape(s.get('hard_floor','')) if s.get('hard_floor') else ''}"
         f"</div>"
         f"<div style='display:flex; gap:0.4rem; margin-top:0.2rem;'>"
@@ -3395,45 +3710,92 @@ def _render_skills() -> str:
         for s in sidecars
     )
 
-    grade_checkboxes = "".join(
-        f"<label style='display:flex; justify-content:space-between; "
-        f"padding:0.25rem 0;'>"
-        f"<span><input type='checkbox' class='grade-filter' value='{g}' checked> "
-        f"<span class='pill grade-{g}'>{g}</span></span>"
-        f"<span class='muted' style='font-size:0.78rem;'>{grade_counts[g]}</span>"
-        f"</label>"
-        for g in ("A", "B", "C", "D", "F")
+    start_index = ((payload["page"] - 1) * payload["limit"]) + 1 if payload["total"] else 0
+    end_index = min(payload["page"] * payload["limit"], payload["total"])
+    summary = (
+        f"Showing {start_index}-{end_index} of {payload['total']} matching sidecars"
+        if payload["filtered"]
+        else f"Showing {start_index}-{end_index} of {payload['catalog_total']} sidecars"
     )
-    type_checkboxes = "".join(
-        f"<label style='display:flex; justify-content:space-between; "
-        f"padding:0.25rem 0;'>"
-        f"<span><input type='checkbox' class='type-filter' value='{t}' checked> {t}</span>"
-        f"<span class='muted' style='font-size:0.78rem;'>{type_counts.get(t, 0)}</span>"
-        f"</label>"
+    query_base = {
+        key: value
+        for key, value in (qs or {}).items()
+        if key not in {"page"}
+    }
+
+    def page_href(page: int) -> str:
+        params = {
+            **query_base,
+            "page": str(max(1, page)),
+            "limit": str(payload["limit"]),
+        }
+        query = "&".join(
+            f"{quote(str(key))}={quote(str(value))}"
+            for key, value in params.items()
+            if str(value).strip()
+        )
+        return "/skills" + (f"?{query}" if query else "")
+
+    prev_link = (
+        f"<a href='{html.escape(page_href(payload['page'] - 1))}'>previous</a>"
+        if payload["has_prev"]
+        else "<span class='muted'>previous</span>"
+    )
+    next_link = (
+        f"<a href='{html.escape(page_href(payload['page'] + 1))}'>next</a>"
+        if payload["has_next"]
+        else "<span class='muted'>next</span>"
+    )
+    pagination = (
+        "<div class='card' style='display:flex; justify-content:space-between; "
+        "align-items:center; gap:1rem;'>"
+        f"<span id='match-count' class='muted'>{html.escape(summary)} · page "
+        f"{payload['page']} of {payload['pages']}</span>"
+        f"<span>{prev_link} · {next_link}</span>"
+        "</div>"
+    )
+    selected_type = ",".join(payload["types"])
+    selected_grade = ",".join(payload["grades"])
+    type_options = "<option value=''>all types</option>" + "".join(
+        f"<option value='{html.escape(t)}'"
+        f"{' selected' if selected_type == t else ''}>{html.escape(t)}</option>"
         for t in _DASHBOARD_ENTITY_TYPES
     )
+    grade_options = "<option value=''>all grades</option>" + "".join(
+        f"<option value='{g}'{' selected' if selected_grade == g else ''}>{g}</option>"
+        for g in ("A", "B", "C", "D", "F")
+    )
+    limit_options = "".join(
+        f"<option value='{n}'{' selected' if payload['limit'] == n else ''}>{n}</option>"
+        for n in (50, 100, 200, 500)
+    )
+    hide_checked = " checked" if payload["hide_floor"] else ""
 
     body = (
         "<h1>Quality sidecars</h1>"
-        f"<p class='muted'>{len(sidecars)} sidecars · click any card to drill in.</p>"
-        "<div style='display:grid; grid-template-columns:220px 1fr; gap:1.25rem; align-items:start;'>"
+        f"<p class='muted'>{payload['catalog_total']} sidecars · click any card to drill in.</p>"
+        + pagination
+        + "<div style='display:grid; grid-template-columns:220px 1fr; gap:1.25rem; align-items:start;'>"
         # ── Left filter sidebar ──────────────────────────────────────
         "<aside style='position:sticky; top:1rem;'>"
-        "<div class='card'><strong>Search</strong>"
-        "<input type='text' id='skill-search' placeholder='filter by slug…' "
+        "<form class='card' id='skills-filter-form' method='get' action='/skills'>"
+        "<strong>Search</strong>"
+        f"<input type='text' id='skill-search' name='q' value='{html.escape(payload['q'])}' placeholder='filter by slug...' "
         "style='width:100%; margin-top:0.4rem; padding:0.35rem 0.5rem; "
-        "border:1px solid #ccc; border-radius:4px;'></div>"
-        "<div class='card'><strong>Grade</strong>"
-        + grade_checkboxes
-        + "</div>"
-        "<div class='card'><strong>Type</strong>"
-        + type_checkboxes
-        + "</div>"
-        "<div class='card'><strong>Hard floor</strong>"
-        "<label style='display:block; padding:0.25rem 0;'>"
-        "<input type='checkbox' id='hide-floor'> hide floored</label>"
-        "</div>"
-        "<div class='card'><span id='match-count' class='muted'>—</span></div>"
+        "border:1px solid #ccc; border-radius:4px;'>"
+        "<label style='display:block; margin-top:0.6rem; font-size:0.82rem;'>Type"
+        f"<select class='type-filter' name='type' style='width:100%; margin-top:0.25rem;'>{type_options}</select>"
+        "</label>"
+        "<label style='display:block; margin-top:0.6rem; font-size:0.82rem;'>Grade"
+        f"<select class='grade-filter' name='grade' style='width:100%; margin-top:0.25rem;'>{grade_options}</select>"
+        "</label>"
+        "<label style='display:block; margin-top:0.6rem; font-size:0.82rem;'>Limit"
+        f"<select name='limit' style='width:100%; margin-top:0.25rem;'>{limit_options}</select>"
+        "</label>"
+        "<label style='display:block; padding:0.55rem 0 0.35rem;'>"
+        f"<input type='checkbox' id='hide-floor' name='hide_floor' value='1'{hide_checked}> hide floored</label>"
+        "<button type='submit' style='width:100%;'>apply</button>"
+        "</form>"
         "</aside>"
         # ── Card grid ────────────────────────────────────────────────
         "<div id='card-grid' style='display:grid; "
@@ -3442,30 +3804,9 @@ def _render_skills() -> str:
         + "</div>"
         "</div>"
         "<script>\n"
-        "const cards = document.querySelectorAll('.skill-card');\n"
-        "const search = document.getElementById('skill-search');\n"
-        "const hideFloor = document.getElementById('hide-floor');\n"
-        "function activeGrades() { return Array.from(document.querySelectorAll('.grade-filter:checked')).map(x => x.value); }\n"
-        "function activeTypes() { return Array.from(document.querySelectorAll('.type-filter:checked')).map(x => x.value); }\n"
-        "function apply() {\n"
-        "  const q = search.value.trim().toLowerCase();\n"
-        "  const grades = new Set(activeGrades());\n"
-        "  const types = new Set(activeTypes());\n"
-        "  const hideF = hideFloor.checked;\n"
-        "  let shown = 0;\n"
-        "  cards.forEach(c => {\n"
-        "    const ok = grades.has(c.dataset.grade) && types.has(c.dataset.type)\n"
-        "      && (!q || c.dataset.slug.toLowerCase().includes(q))\n"
-        "      && (!hideF || !c.dataset.floor);\n"
-        "    c.style.display = ok ? '' : 'none';\n"
-        "    if (ok) shown++;\n"
-        "  });\n"
-        "  document.getElementById('match-count').textContent = shown + ' of ' + cards.length + ' match';\n"
-        "}\n"
-        "search.addEventListener('input', apply);\n"
-        "hideFloor.addEventListener('change', apply);\n"
-        "document.querySelectorAll('.grade-filter, .type-filter').forEach(el => el.addEventListener('change', apply));\n"
-        "apply();\n"
+        "document.querySelectorAll('#skills-filter-form select').forEach(el => {\n"
+        "  el.addEventListener('change', () => el.form.submit());\n"
+        "});\n"
         "</script>"
     )
     return _layout("Skills", body)
@@ -4280,7 +4621,8 @@ def _render_runtime_entity_load_script(
         "        body: JSON.stringify({slug: CTX_RUNTIME_ENTITY_SLUG, entity_type: CTX_RUNTIME_ENTITY_TYPE})\n"
         "      });\n"
         "      const payload = await response.json();\n"
-        "      if (result) result.textContent = (payload.ok ? 'loaded: ' : 'not loaded: ') + (payload.msg || response.status);\n"
+        "      const message = payload.detail || payload.msg || response.status;\n"
+        "      if (result) result.textContent = (payload.ok ? 'loaded: ' : 'not loaded: ') + message;\n"
         "    } catch (error) {\n"
         "      if (result) result.textContent = 'load failed: ' + error;\n"
         "    } finally {\n"
@@ -4952,7 +5294,7 @@ def _render_docs_markdown(markdown_text: str, page_anchor: str) -> str:
     try:
         import markdown as markdown_lib  # type: ignore[import-untyped]
 
-        return str(markdown_lib.markdown(
+        rendered = str(markdown_lib.markdown(
             markdown_text,
             extensions=[
                 "admonition",
@@ -4979,14 +5321,75 @@ def _render_docs_markdown(markdown_text: str, page_anchor: str) -> str:
             },
             output_format="html5",
         ))
+        return _sanitize_docs_html(rendered)
     except Exception:
         return _render_wiki_markdown(markdown_text)
 
 
+def _sanitize_docs_html(rendered_html: str) -> str:
+    """Remove active HTML from local docs before embedding in the dashboard."""
+    dangerous_blocks = (
+        "script",
+        "style",
+        "iframe",
+        "object",
+        "embed",
+        "form",
+        "textarea",
+        "select",
+    )
+    dangerous_tags = (
+        "base",
+        "button",
+        "input",
+        "link",
+        "meta",
+    )
+
+    def escape_match(match: re.Match[str]) -> str:
+        return html.escape(match.group(0))
+
+    for tag in dangerous_blocks:
+        rendered_html = re.sub(
+            rf"<\s*{tag}\b[^>]*>.*?<\s*/\s*{tag}\s*>",
+            escape_match,
+            rendered_html,
+            flags=re.IGNORECASE | re.DOTALL,
+        )
+        rendered_html = re.sub(
+            rf"<\s*/?\s*{tag}\b[^>]*>",
+            escape_match,
+            rendered_html,
+            flags=re.IGNORECASE,
+        )
+    for tag in dangerous_tags:
+        rendered_html = re.sub(
+            rf"<\s*/?\s*{tag}\b[^>]*>",
+            escape_match,
+            rendered_html,
+            flags=re.IGNORECASE,
+        )
+
+    rendered_html = re.sub(
+        r"\s+on[a-zA-Z0-9_-]+\s*=\s*(\"[^\"]*\"|'[^']*'|[^\s>]+)",
+        "",
+        rendered_html,
+        flags=re.IGNORECASE,
+    )
+    rendered_html = re.sub(
+        r"\s+(href|src)\s*=\s*([\"'])\s*(javascript:|data:text/html)",
+        r" \1=\2#",
+        rendered_html,
+        flags=re.IGNORECASE,
+    )
+    return rendered_html
+
+
 def _docs_search_text(entry: dict[str, str]) -> str:
     text = f"{entry['title']} {entry['path']} {entry['summary']} {entry['body']}"
     text = re.sub(r"```.*?```", " ", text, flags=re.DOTALL)
     text = re.sub(r"!!!\s+\w+(?:\s+\"[^\"]+\")?", " ", text)
+    text = re.sub(r"<[^>]+>", " ", text)
     text = re.sub(r"[*_`#>\[\]().!:-]+", " ", text)
     return re.sub(r"\s+", " ", text).strip().lower()
 
@@ -5624,6 +6027,17 @@ def _render_harness_wizard() -> str:
     return _layout("Harness Setup", body)
 
 
+def _kpi_summary_cache_key(sidecar_dir: Path) -> tuple[Any, ...]:
+    parts: list[Any] = []
+    for path in (sidecar_dir, sidecar_dir / "mcp"):
+        try:
+            stat = path.stat()
+            parts.extend((path.resolve(), stat.st_mtime_ns, stat.st_size))
+        except OSError:
+            parts.extend((path.resolve(), None, None))
+    return tuple(parts)
+
+
 def _kpi_summary():
     """Compute the KPI DashboardSummary using the default source layout.
 
@@ -5639,6 +6053,14 @@ def _kpi_summary():
     sidecar_dir = _sidecar_dir()
     if not sidecar_dir.is_dir():
         return None
+    cache_key = _kpi_summary_cache_key(sidecar_dir)
+    global _KPI_SUMMARY_CACHE_AT, _KPI_SUMMARY_CACHE_KEY, _KPI_SUMMARY_CACHE_VALUE
+    if (
+        _KPI_SUMMARY_CACHE_KEY == cache_key
+        and _KPI_SUMMARY_CACHE_VALUE is not None
+        and time.monotonic() - _KPI_SUMMARY_CACHE_AT < _KPI_SUMMARY_CACHE_SECONDS
+    ):
+        return _KPI_SUMMARY_CACHE_VALUE
     try:
         from ctx_config import cfg  # type: ignore
         sources = LifecycleSources(
@@ -5653,9 +6075,13 @@ def _kpi_summary():
             sidecar_dir=sidecar_dir,
         )
     try:
-        return generate(sources=sources, top_n=25)
+        summary = generate(sources=sources, top_n=25)
     except Exception:  # noqa: BLE001
         return None
+    _KPI_SUMMARY_CACHE_KEY = cache_key
+    _KPI_SUMMARY_CACHE_VALUE = summary
+    _KPI_SUMMARY_CACHE_AT = time.monotonic()
+    return summary
 
 
 def _render_kpi() -> str:
@@ -6361,11 +6787,12 @@ class _MonitorHandler(BaseHTTPRequestHandler):
     # require same-origin POSTs plus a per-process token injected into the
     # served dashboard page.
     def _same_origin(self) -> bool:
+        request_host = _request_host_name(self.headers.get("Host", ""))
+        if not _host_allows_mutations(request_host):
+            return False
         origin = self.headers.get("Origin") or ""
         if origin:
-            host_header = self.headers.get("Host", "")
-            expected = f"http://{host_header}"
-            return origin == expected
+            return _origin_host_name(origin) == request_host
         # No Origin header (curl, direct tool calls) is acceptable only
         # when the mutation token below is also present.
         return True
@@ -6387,15 +6814,26 @@ class _MonitorHandler(BaseHTTPRequestHandler):
         return self._mutations_enabled()
 
     def _read_authorized(self, qs: dict[str, str]) -> bool:
+        request_host = _request_host_name(self.headers.get("Host", ""))
         if self._mutations_enabled():
-            return True
-        token = self.headers.get("X-CTX-Monitor-Token") or qs.get("token", "")
+            return _host_allows_mutations(request_host)
+        token = (
+            self.headers.get("X-CTX-Monitor-Token")
+            or qs.get("token", "")
+            or _read_token_cookie(self.headers.get("Cookie", ""))
+        )
         return bool(_MONITOR_TOKEN) and secrets.compare_digest(token, _MONITOR_TOKEN)
 
     def _send_security_headers(self, *, html_response: bool = False) -> None:
         self.send_header("X-Content-Type-Options", "nosniff")
         self.send_header("Referrer-Policy", "no-referrer")
         self.send_header("X-Frame-Options", "DENY")
+        if getattr(self, "_ctx_set_read_cookie", False):
+            self.send_header(
+                "Set-Cookie",
+                f"{_READ_TOKEN_COOKIE}={_MONITOR_TOKEN}; Path=/; "
+                "HttpOnly; SameSite=Strict",
+            )
         if html_response:
             self.send_header(
                 "Content-Security-Policy",
@@ -6460,6 +6898,7 @@ class _MonitorHandler(BaseHTTPRequestHandler):
             from urllib.parse import parse_qs
             qs = {k: v[0] for k, v in parse_qs(raw_query).items()}
         try:
+            self._ctx_set_read_cookie = False
             read_authorized = getattr(self, "_read_authorized", lambda _qs: True)
             if not read_authorized(qs):
                 if path.startswith("/api/"):
@@ -6474,6 +6913,13 @@ class _MonitorHandler(BaseHTTPRequestHandler):
                         "<p>monitor read token required on non-loopback bind</p>",
                     )
                 return
+            query_token = qs.get("token", "")
+            self._ctx_set_read_cookie = (
+                not self._mutations_enabled()
+                and bool(query_token)
+                and bool(_MONITOR_TOKEN)
+                and secrets.compare_digest(query_token, _MONITOR_TOKEN)
+            )
             if path == "/":
                 self._send_html(_render_home())
             elif path == "/sessions":
@@ -6481,7 +6927,7 @@ class _MonitorHandler(BaseHTTPRequestHandler):
             elif path.startswith("/session/"):
                 self._send_html(_render_session_detail(path.split("/session/", 1)[1]))
             elif path == "/skills":
-                self._send_html(_render_skills())
+                self._send_html(_render_skills(qs))
             elif path.startswith("/skill/"):
                 self._send_html(_render_skill_detail(
                     path.split("/skill/", 1)[1],
@@ -6533,6 +6979,8 @@ class _MonitorHandler(BaseHTTPRequestHandler):
                 })
             elif path == "/api/grades.json":
                 self._send_json(_grade_distribution_payload())
+            elif path == "/api/sidecars.json":
+                self._send_json(_sidecar_page_payload(qs))
             elif path == "/api/runtime.json":
                 self._send_json(_runtime_lifecycle_summary())
             elif path == "/api/config.json":
@@ -6811,16 +7259,16 @@ def serve(host: str = "127.0.0.1", port: int = 8765) -> None:
     """Run the monitor. Blocks until Ctrl+C."""
     global _MONITOR_TOKEN
     server = _make_monitor_server(host, port)
-    _MONITOR_TOKEN = (
-        secrets.token_urlsafe(32)
-        if bool(getattr(server, "_ctx_mutations_enabled", False))
-        else ""
-    )
-    url = f"http://{host}:{port}/"
+    _MONITOR_TOKEN = secrets.token_urlsafe(32)
+    mutations_enabled = bool(getattr(server, "_ctx_mutations_enabled", False))
+    url = f"http://{_monitor_display_host(host)}:{port}/"
+    if not mutations_enabled:
+        url = f"{url}?token={_MONITOR_TOKEN}"
     print(f"ctx-monitor serving at {url}  (Ctrl+C to stop)", flush=True)
-    if not bool(getattr(server, "_ctx_mutations_enabled", False)):
+    if not mutations_enabled:
         print(
-            "ctx-monitor: non-loopback bind; load/unload mutations disabled",
+            "ctx-monitor: non-loopback bind; read token required and "
+            "load/unload mutations disabled",
             flush=True,
         )
     try:
@@ -6831,6 +7279,21 @@ def serve(host: str = "127.0.0.1", port: int = 8765) -> None:
         server.server_close()
 
 
+def _monitor_display_host(host: str) -> str:
+    """Return a URL host users can paste into a browser."""
+    if host in {"0.0.0.0", "::"}:
+        try:
+            candidate = socket.gethostbyname(socket.gethostname())
+        except OSError:
+            candidate = ""
+        if candidate and not candidate.startswith("127."):
+            return candidate
+        return "localhost"
+    if ":" in host and not host.startswith("["):
+        return f"[{host}]"
+    return host
+
+
 def main(argv: list[str] | None = None) -> int:
     parser = argparse.ArgumentParser(
         prog="ctx-monitor",

src/harness_install.py

@@ -252,6 +252,16 @@ def _local_source_from_repo_url(repo_url: str) -> Path | None:
     return candidate if candidate.exists() else None
 
 
+def _validate_remote_repo_url(repo_url: str) -> None:
+    parsed = urlparse(repo_url)
+    if repo_url.startswith("-"):
+        raise ValueError("remote harness repo_url must not start with '-'")
+    if parsed.scheme != "https" or not parsed.netloc:
+        raise ValueError("remote harness repo_url must be an https:// URL")
+    if parsed.username or parsed.password:
+        raise ValueError("remote harness repo_url must not include credentials")
+
+
 def _reject_symlink_tree(root: Path) -> None:
     if root.is_symlink():
         raise ValueError(f"refusing symlinked harness source: {root}")
@@ -265,9 +275,11 @@ def _is_full_commit_sha(value: str | None) -> bool:
 
 
 def _run_git(args: list[str], *, timeout: int = 300) -> subprocess.CompletedProcess[str]:
+    env = _command_env()
+    env["GIT_ALLOW_PROTOCOL"] = "https"
     return subprocess.run(
         ["git", *args],
-        env=_command_env(),
+        env=env,
         capture_output=True,
         text=True,
         check=False,
@@ -296,7 +308,7 @@ def _materialize_source(
         if not allow_local_sources:
             raise ValueError(
                 "local harness repo_url requires --allow-local-source; "
-                "cataloged harnesses should normally use https:// repositories"
+            "cataloged harnesses should normally use https:// repositories"
             )
         local_source = local_source.expanduser().resolve()
         if not local_source.is_dir():
@@ -305,6 +317,8 @@ def _materialize_source(
         shutil.copytree(local_source, target)
         return {"source_type": "local"}
 
+    _validate_remote_repo_url(record.repo_url)
+
     if record.repo_ref and not _is_full_commit_sha(record.repo_ref):
         raise ValueError(
             "harness repo_ref/commit_sha must be a full commit SHA; "
@@ -314,10 +328,10 @@ def _materialize_source(
         raise ValueError(
             "remote harness repo_url is not pinned to a commit; add commit_sha "
             "to the catalog page or pass --allow-mutable-repo-head explicitly"
-        )
+    )
 
     if record.repo_ref:
-        proc = _run_git(["clone", "--no-checkout", record.repo_url, str(target)])
+        proc = _run_git(["clone", "--no-checkout", "--", record.repo_url, str(target)])
         if proc.returncode != 0:
             stderr = proc.stderr.strip() or proc.stdout.strip()
             raise RuntimeError(f"git clone failed: {stderr}")
@@ -337,7 +351,7 @@ def _materialize_source(
             "resolved_commit": _git_resolved_commit(target) or "",
         }
 
-    proc = _run_git(["clone", "--depth", "1", record.repo_url, str(target)])
+    proc = _run_git(["clone", "--depth", "1", "--", record.repo_url, str(target)])
     if proc.returncode != 0:
         stderr = proc.stderr.strip() or proc.stdout.strip()
         raise RuntimeError(f"git clone failed: {stderr}")

src/import_skills_sh_catalog.py

@@ -68,6 +68,8 @@ CONVERTED_SKILL_ROOT = "converted"
 DEFAULT_DETAIL_MAX_BYTES = 2_000_000
 DEFAULT_SKILL_BODY_MAX_CHARS = 120_000
 GITHUB_RAW_HOST = "raw.githubusercontent.com"
+GITHUB_API_HOST = "api.github.com"
+_GITHUB_COMMIT_SHA_RE = re.compile(r"^[0-9a-f]{40}$", re.IGNORECASE)
 _HYDRATION_CHECKPOINT_FIELDS = (
     "id",
     "ctx_slug",
@@ -376,18 +378,23 @@ def _fetch_detail_html(
     return payload.decode("utf-8", errors="replace"), None
 
 
-def _github_raw_skill_urls(source: str, skill_id: str) -> list[str]:
+def _github_repo_parts(source: str) -> tuple[str, str] | None:
     if (
         "/" not in source
         or source.startswith(("http://", "https://"))
-        or not skill_id.strip()
     ):
-        return []
+        return None
     owner, repo = source.split("/", 1)
     if not owner or not repo:
+        return None
+    return owner, repo
+
+
+def _github_raw_skill_candidate_paths(source: str, skill_id: str) -> list[str]:
+    repo_parts = _github_repo_parts(source)
+    if repo_parts is None or not skill_id.strip():
         return []
-    owner_q = urllib.parse.quote(owner, safe="")
-    repo_q = urllib.parse.quote(repo, safe=".-_")
+    _, repo = repo_parts
     skill_q = urllib.parse.quote(skill_id.strip("/"), safe="")
     filenames = ("SKILL.md", "Skill.md", "skill.md")
     candidate_paths = [
@@ -403,11 +410,79 @@ def _github_raw_skill_urls(source: str, skill_id: str) -> list[str]:
     ]
     if _slugify(repo) == _slugify(skill_id):
         candidate_paths.extend(filenames)
+    seen: set[str] = set()
+    deduped: list[str] = []
+    for path in candidate_paths:
+        if path not in seen:
+            seen.add(path)
+            deduped.append(path)
+    return deduped
+
+
+def _resolve_github_branch_sha(
+    owner: str,
+    repo: str,
+    branch: str,
+    *,
+    timeout: int,
+) -> str | None:
+    owner_q = urllib.parse.quote(owner, safe="")
+    repo_q = urllib.parse.quote(repo, safe="")
+    branch_q = urllib.parse.quote(branch, safe="")
+    url = f"https://{GITHUB_API_HOST}/repos/{owner_q}/{repo_q}/branches/{branch_q}"
+    req = urllib.request.Request(
+        url,
+        headers={
+            "User-Agent": USER_AGENT,
+            "Accept": "application/vnd.github+json",
+        },
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as response:
+            payload = response.read(32_768)
+    except Exception:
+        return None
+    try:
+        data = json.loads(payload.decode("utf-8", errors="replace"))
+    except json.JSONDecodeError:
+        return None
+    if not isinstance(data, dict):
+        return None
+    commit = data.get("commit")
+    sha = commit.get("sha") if isinstance(commit, dict) else None
+    if isinstance(sha, str) and _GITHUB_COMMIT_SHA_RE.fullmatch(sha):
+        return sha
+    return None
+
+
+def _github_raw_skill_urls(
+    source: str,
+    skill_id: str,
+    *,
+    timeout: int = 12,
+) -> list[str]:
+    repo_parts = _github_repo_parts(source)
+    if repo_parts is None:
+        return []
+    owner, repo = repo_parts
+    candidate_paths = _github_raw_skill_candidate_paths(source, skill_id)
+    if not candidate_paths:
+        return []
+    owner_q = urllib.parse.quote(owner, safe="")
+    repo_q = urllib.parse.quote(repo, safe=".-_")
     urls: list[str] = []
     for branch in ("main", "master"):
+        branch_sha = _resolve_github_branch_sha(
+            owner,
+            repo,
+            branch,
+            timeout=timeout,
+        )
+        if branch_sha is None:
+            continue
         for path in candidate_paths:
             urls.append(
-                f"https://{GITHUB_RAW_HOST}/{owner_q}/{repo_q}/{branch}/{path}",
+                f"https://{GITHUB_RAW_HOST}/{owner_q}/{repo_q}/{branch_sha}/{path}",
             )
     return urls
 
@@ -421,7 +496,7 @@ def _fetch_github_raw_skill_body(
     source = str(item.get("source") or "")
     skill_id = str(item.get("skill_id") or item.get("skillId") or "")
     raw_timeout = min(timeout, 12)
-    for url in _github_raw_skill_urls(source, skill_id):
+    for url in _github_raw_skill_urls(source, skill_id, timeout=raw_timeout):
         req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
         try:
             with urllib.request.urlopen(req, timeout=raw_timeout) as response:
@@ -433,7 +508,7 @@ def _fetch_github_raw_skill_body(
         body = _normalize_skill_body_text(payload.decode("utf-8", errors="replace"))
         if body:
             return body, url, None
-    return None, None, "GitHub raw fallback found no SKILL.md candidates"
+    return None, None, "GitHub raw fallback found no pinned SKILL.md candidates"
 
 
 def _refresh_body_summary(catalog: dict[str, Any]) -> dict[str, Any]:

src/kpi_dashboard.py

@@ -26,6 +26,7 @@ Design notes:
 from __future__ import annotations
 
 import argparse
+import concurrent.futures
 import json
 import logging
 import sys
@@ -35,15 +36,15 @@ from pathlib import Path
 from typing import Any, Iterable
 
 from ctx_lifecycle import (
+    LifecycleState,
     LifecycleSources,
     STATE_ACTIVE,
     STATE_ARCHIVE,
     STATE_DEMOTE,
     STATE_WATCH,
-    load_lifecycle_state,
 )
 from skill_category import CATEGORIES, infer_category, read_existing_category
-from skill_quality import QualityScore, load_quality
+from skill_quality import QualityScore
 from ctx.core.wiki.wiki_utils import parse_frontmatter_and_body
 
 _logger = logging.getLogger(__name__)
@@ -53,6 +54,8 @@ _UNCATEGORIZED = "uncategorized"
 _LIFECYCLE_STATES: tuple[str, ...] = (
     STATE_ACTIVE, STATE_WATCH, STATE_DEMOTE, STATE_ARCHIVE,
 )
+_PARALLEL_QUALITY_READ_THRESHOLD = 512
+_QUALITY_READ_WORKERS = 8
 
 
 # ────────────────────────────────────────────────────────────────────
@@ -108,19 +111,33 @@ class DashboardSummary:
 # ────────────────────────────────────────────────────────────────────
 
 
-def _skill_source_path(slug: str, sources: LifecycleSources) -> Path | None:
-    skill_path = sources.skills_dir / slug / "SKILL.md"
-    if skill_path.is_file():
-        return skill_path
-    agent_path = sources.agents_dir / f"{slug}.md"
-    if agent_path.is_file():
-        return agent_path
+def _skill_source_path(
+    slug: str,
+    sources: LifecycleSources,
+    *,
+    subject_type: str | None = None,
+) -> Path | None:
+    if subject_type in (None, "skill"):
+        skill_path = sources.skills_dir / slug / "SKILL.md"
+        if skill_path.is_file():
+            return skill_path
+    if subject_type in (None, "agent"):
+        agent_path = sources.agents_dir / f"{slug}.md"
+        if agent_path.is_file():
+            return agent_path
     return None
 
 
-def _resolve_category(slug: str, sources: LifecycleSources) -> str:
+def _resolve_category(
+    slug: str,
+    sources: LifecycleSources,
+    *,
+    subject_type: str | None = None,
+) -> str:
     """Read existing category, else infer from tags, else uncategorized."""
-    path = _skill_source_path(slug, sources)
+    if subject_type not in (None, "skill", "agent"):
+        return _UNCATEGORIZED
+    path = _skill_source_path(slug, sources, subject_type=subject_type)
     if path is None:
         return _UNCATEGORIZED
     try:
@@ -164,18 +181,40 @@ def _iter_quality_slugs(sidecar_dir: Path) -> list[str]:
     return out
 
 
-def _quality_sources(sidecar_dir: Path) -> list[tuple[str, Path]]:
-    out: list[tuple[str, Path]] = [
-        (slug, sidecar_dir)
+def _quality_sources(sidecar_dir: Path) -> list[tuple[str, Path, Path]]:
+    out: list[tuple[str, Path, Path]] = [
+        (slug, sidecar_dir, sidecar_dir / f"{slug}.json")
         for slug in _iter_quality_slugs(sidecar_dir)
     ]
     mcp_dir = sidecar_dir / "mcp"
     if mcp_dir.is_dir():
         for slug in _iter_quality_slugs(mcp_dir):
-            out.append((slug, mcp_dir))
+            out.append((slug, mcp_dir, mcp_dir / f"{slug}.json"))
     return out
 
 
+def _read_quality_file(
+    path: Path,
+    *,
+    subject_type_override: str | None = None,
+) -> QualityScore | None:
+    data = json.loads(path.read_text(encoding="utf-8"))
+    if not isinstance(data, dict):
+        raise ValueError(f"quality sidecar must be a JSON object: {path}")
+    subject_type = subject_type_override or str(data.get("subject_type") or "skill")
+    return QualityScore(
+        slug=str(data["slug"]),
+        subject_type=subject_type,
+        raw_score=float(data.get("raw_score", 0.0)),
+        score=float(data.get("score", 0.0)),
+        grade=str(data.get("grade") or "D"),
+        hard_floor=data.get("hard_floor"),
+        signals={},
+        weights={},
+        computed_at=str(data.get("computed_at") or ""),
+    )
+
+
 def _iter_lifecycle_slugs(sidecar_dir: Path) -> list[str]:
     if not sidecar_dir.is_dir():
         return []
@@ -183,19 +222,62 @@ def _iter_lifecycle_slugs(sidecar_dir: Path) -> list[str]:
     return sorted(p.name[: -len(suffix)] for p in sidecar_dir.glob(f"*{suffix}"))
 
 
+def _read_lifecycle_file(path: Path) -> LifecycleState | None:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return None
+    if not isinstance(data, dict):
+        return None
+    history_raw = data.get("history", [])
+    history = tuple(
+        dict(e) for e in history_raw if isinstance(e, dict)
+    )
+    try:
+        streak = int(data.get("consecutive_d_count", 0))
+    except (TypeError, ValueError):
+        streak = 0
+    return LifecycleState(
+        slug=str(data.get("slug") or path.name.removesuffix(".lifecycle.json")),
+        subject_type=str(data.get("subject_type") or "skill"),
+        state=str(data.get("state") or STATE_ACTIVE),
+        state_since=str(data.get("state_since") or ""),
+        consecutive_d_count=streak,
+        last_grade=str(data.get("last_grade") or ""),
+        last_seen_computed_at=str(data.get("last_seen_computed_at") or ""),
+        history=history,
+    )
+
+
+def _load_lifecycle_states(sidecar_dir: Path) -> dict[str, LifecycleState]:
+    if not sidecar_dir.is_dir():
+        return {}
+    states: dict[str, LifecycleState] = {}
+    for path in sorted(sidecar_dir.glob("*.lifecycle.json")):
+        state = _read_lifecycle_file(path)
+        if state is not None:
+            states[state.slug] = state
+    return states
+
+
 def _build_row(
     slug: str,
     *,
     score: QualityScore | None,
+    lifecycle_subject_type: str | None = None,
     lifecycle_state: str,
     consecutive_d_count: int,
     sources: LifecycleSources,
 ) -> EntityRow:
-    subject = score.subject_type if score is not None else _guess_subject(slug, sources)
+    subject = (
+        score.subject_type
+        if score is not None
+        else lifecycle_subject_type or _guess_subject(slug, sources)
+    )
     return EntityRow(
         slug=slug,
         subject_type=subject,
-        category=_resolve_category(slug, sources),
+        category=_resolve_category(slug, sources, subject_type=subject),
         grade=(score.grade if score is not None else ""),
         score=(score.score if score is not None else 0.0),
         hard_floor=(score.hard_floor if score is not None else None),
@@ -218,35 +300,83 @@ def collect_rows(
     *, sources: LifecycleSources,
 ) -> list[EntityRow]:
     """Walk both sinks and return one row per known slug (union)."""
-    quality_sources = _quality_sources(sources.sidecar_dir)
-    quality_keys = set(quality_sources)
-    quality_slugs = {slug for slug, _sidecar_dir in quality_sources}
-    lifecycle_slugs = set(_iter_lifecycle_slugs(sources.sidecar_dir))
-    row_sources = sorted(quality_keys, key=lambda item: (item[0], str(item[1]))) + [
-        (slug, sources.sidecar_dir)
-        for slug in sorted(lifecycle_slugs - quality_slugs)
-    ]
-    rows: list[EntityRow] = []
-    for slug, sidecar_dir in row_sources:
+    lifecycle_cache: dict[Path, dict[str, LifecycleState]] = {}
+
+    def lifecycle_states(sidecar_dir: Path) -> dict[str, LifecycleState]:
+        if sidecar_dir not in lifecycle_cache:
+            lifecycle_cache[sidecar_dir] = _load_lifecycle_states(sidecar_dir)
+        return lifecycle_cache[sidecar_dir]
+
+    def load_quality_source(
+        source: tuple[str, Path, Path],
+    ) -> tuple[str, Path, QualityScore | None]:
+        slug, sidecar_dir, sidecar_path = source
         try:
-            score = load_quality(
-                slug,
-                sidecar_dir=sidecar_dir,
+            score = _read_quality_file(
+                sidecar_path,
+                subject_type_override=(
+                    "mcp-server" if sidecar_dir.name == "mcp" else None
+                ),
             )
-        except (json.JSONDecodeError, ValueError, OSError) as exc:
+        except (json.JSONDecodeError, ValueError, OSError, KeyError, TypeError) as exc:
             _logger.warning("kpi_dashboard: skipping %s: %s", slug, exc)
             score = None
-        lc = load_lifecycle_state(slug, sidecar_dir=sidecar_dir)
+        return slug, sidecar_dir, score
+
+    quality_sources = _quality_sources(sources.sidecar_dir)
+    if len(quality_sources) >= _PARALLEL_QUALITY_READ_THRESHOLD:
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=_QUALITY_READ_WORKERS,
+        ) as pool:
+            quality_results = list(pool.map(load_quality_source, quality_sources))
+    else:
+        quality_results = [load_quality_source(source) for source in quality_sources]
+
+    quality_rows: list[tuple[str, Path, QualityScore | None, LifecycleState | None]] = []
+    quality_subjects: set[tuple[str, str]] = set()
+    for slug, sidecar_dir, score in quality_results:
+        if score is not None:
+            quality_subjects.add((slug, score.subject_type))
+        quality_rows.append((slug, sidecar_dir, score, None))
+
+    lifecycle_rows: list[tuple[str, Path, QualityScore | None, LifecycleState | None]] = []
+    for lifecycle_slug, lifecycle_state in lifecycle_states(sources.sidecar_dir).items():
+        if (lifecycle_slug, lifecycle_state.subject_type) not in quality_subjects:
+            lifecycle_rows.append(
+                (lifecycle_slug, sources.sidecar_dir, None, lifecycle_state)
+            )
+
+    row_sources = sorted(
+        quality_rows + lifecycle_rows,
+        key=lambda item: (item[0], str(item[1]), item[3].subject_type if item[3] else ""),
+    )
+    rows: list[EntityRow] = []
+    for slug, sidecar_dir, score, lifecycle_override in row_sources:
+        lc = lifecycle_override
+        if lc is None and score is not None:
+            candidates = [sidecar_dir]
+            if sidecar_dir != sources.sidecar_dir:
+                candidates.append(sources.sidecar_dir)
+            for candidate_dir in candidates:
+                candidate = lifecycle_states(candidate_dir).get(slug)
+                if candidate is not None and candidate.subject_type == score.subject_type:
+                    lc = candidate
+                    break
+        elif lc is None:
+            lc = lifecycle_states(sidecar_dir).get(slug)
         if lc is not None:
             state = lc.state
             streak = lc.consecutive_d_count
+            lifecycle_subject_type = lc.subject_type
         else:
             state = STATE_ACTIVE
             streak = 0
+            lifecycle_subject_type = None
         rows.append(
             _build_row(
                 slug,
                 score=score,
+                lifecycle_subject_type=lifecycle_subject_type,
                 lifecycle_state=state,
                 consecutive_d_count=streak,
                 sources=sources,

src/mcp_add.py

@@ -25,6 +25,7 @@ import json
 import os
 import re
 import sys
+from dataclasses import replace
 from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any
@@ -128,6 +129,54 @@ def _rewrite_frontmatter(page_text: str, new_fm: dict[str, Any]) -> str:
     return f"---\n{fm_str}---\n{body}"
 
 
+def _tuple_from_frontmatter(raw: object, fallback: tuple[str, ...]) -> tuple[str, ...]:
+    if isinstance(raw, str):
+        return tuple(item.strip() for item in raw.split(",") if item.strip())
+    if isinstance(raw, (list, tuple, set, frozenset)):
+        return tuple(str(item).strip() for item in raw if str(item).strip())
+    return fallback
+
+
+def _optional_text_from_frontmatter(raw: object, fallback: str | None) -> str | None:
+    if raw is None:
+        return fallback
+    text = str(raw).strip()
+    return text or fallback
+
+
+def _render_existing_update_page(
+    *,
+    existing_fm: dict[str, Any],
+    record: McpRecord,
+    merged_sources: list[str],
+    kept_description: str,
+) -> str:
+    updated_fm = {
+        **existing_fm,
+        "sources": merged_sources,
+        "description": kept_description,
+        "updated": TODAY,
+    }
+    render_record = replace(
+        record,
+        name=str(updated_fm.get("name") or record.name),
+        description=kept_description,
+        sources=tuple(merged_sources),
+        github_url=_optional_text_from_frontmatter(
+            updated_fm.get("github_url"), record.github_url
+        ),
+        homepage_url=_optional_text_from_frontmatter(
+            updated_fm.get("homepage_url"), record.homepage_url
+        ),
+        tags=_tuple_from_frontmatter(updated_fm.get("tags"), record.tags),
+        transports=_tuple_from_frontmatter(
+            updated_fm.get("transports"), record.transports
+        ),
+    )
+    rendered_text = generate_mcp_page(render_record)
+    return _rewrite_frontmatter(rendered_text, updated_fm)
+
+
 def _normalize_github_url(url: str | None) -> str | None:
     """Return the canonical lowercase GitHub URL, or None for non-GitHub inputs.
 
@@ -333,13 +382,12 @@ def add_mcp(
     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)
+        final_text = _render_existing_update_page(
+            existing_fm=existing_fm,
+            record=record,
+            merged_sources=merged_sources,
+            kept_description=kept_description,
+        )
 
     if review_existing and not is_new_page and not update_existing:
         review = build_update_review(

src/skill_add.py

@@ -20,15 +20,15 @@ import yaml  # type: ignore[import-untyped]
 from datetime import datetime, timezone
 from pathlib import Path
 
-from batch_convert import convert_skill
-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
-from ctx.adapters.claude_code.install.install_utils import safe_copy_file
-from ctx.core.wiki.wiki_queue import enqueue_entity_upsert
-from ctx.core.wiki.wiki_sync import append_log, ensure_wiki, update_index
-from ctx.core.wiki.wiki_utils import validate_skill_name
-from ctx.utils._fs_utils import reject_symlink_path, safe_atomic_write_text
+from batch_convert import convert_skill
+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
+from ctx.adapters.claude_code.install.install_utils import safe_copy_file
+from ctx.core.wiki.wiki_queue import enqueue_entity_upsert
+from ctx.core.wiki.wiki_sync import append_log, ensure_wiki, update_index
+from ctx.core.wiki.wiki_utils import parse_frontmatter, 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")
 
@@ -52,6 +52,13 @@ def install_skill(source: Path, skills_dir: Path, name: str) -> Path:
     return dest
 
 
+def mirror_install_body(installed_path: Path, name: str, converted_root: Path) -> Path:
+    """Mirror a short installed SKILL.md into the wiki install source tree."""
+    dest = converted_root / name / "SKILL.md"
+    safe_copy_file(installed_path, dest, dest_root=converted_root)
+    return dest
+
+
 # ── Conversion ────────────────────────────────────────────────────────────────
 
 def maybe_convert(
@@ -92,12 +99,12 @@ def build_entity_page(
     *,
     name: str,
     tags: list[str],
-    line_count: int,
-    has_pipeline: bool,
-    original_path: Path,
-    related: list[str],
-    scan_sources: list[str],
-) -> str:
+    line_count: int,
+    has_pipeline: bool,
+    original_path: Path,
+    related: list[str],
+    scan_sources: list[str],
+) -> str:
     """Render the full entity page markdown for a skill."""
     pipeline_path_str = (
         f"converted/{name}/" if has_pipeline else "null"
@@ -162,17 +169,61 @@ def build_entity_page(
 """
 
 
-def write_entity_page(wiki_path: Path, name: str, content: str) -> bool:
-    """Write entity page. Returns True if newly created."""
-    page = wiki_path / "entities" / "skills" / f"{name}.md"
-    reject_symlink_path(page)
-    is_new = not page.exists()
-    safe_atomic_write_text(page, content, encoding="utf-8")
-    return is_new
+def write_entity_page(wiki_path: Path, name: str, content: str) -> bool:
+    """Write entity page. Returns True if newly created."""
+    page = wiki_path / "entities" / "skills" / f"{name}.md"
+    reject_symlink_path(page)
+    is_new = not page.exists()
+    safe_atomic_write_text(page, content, encoding="utf-8")
+    return is_new
 
 
 # ── Wikilink backfill ─────────────────────────────────────────────────────────
 
+def _tag_set_from_frontmatter(raw: object) -> set[str]:
+    if raw is None:
+        return set()
+    if isinstance(raw, str):
+        values = raw.strip()
+        if values.startswith("[") and values.endswith("]"):
+            values = values[1:-1]
+        return {item.strip().strip("'\"") for item in values.split(",") if item.strip()}
+    if isinstance(raw, (list, tuple, set, frozenset)):
+        return {str(item).strip().strip("'\"") for item in raw if str(item).strip()}
+    return {str(raw).strip().strip("'\"")} if str(raw).strip() else set()
+
+
+def _existing_skill_review_text(entity_page: Path, installed_path: Path) -> str:
+    if entity_page.exists():
+        existing = entity_page.read_text(encoding="utf-8", errors="replace")
+        if installed_path.exists():
+            installed = installed_path.read_text(encoding="utf-8", errors="replace")
+            existing += f"\n\n## Installed SKILL.md\n\n{installed}"
+        return existing
+    return installed_path.read_text(encoding="utf-8", errors="replace")
+
+
+def _proposed_skill_review_text(
+    *,
+    name: str,
+    tags: list[str],
+    line_count: int,
+    source_content: str,
+    installed_path: Path,
+    wiki_path: Path,
+) -> str:
+    page_content = build_entity_page(
+        name=name,
+        tags=tags,
+        line_count=line_count,
+        has_pipeline=line_count > cfg.line_threshold,
+        original_path=installed_path,
+        related=find_related_skills(wiki_path, name, tags),
+        scan_sources=detect_scan_sources(wiki_path, name),
+    )
+    return f"{page_content}\n\n## Proposed SKILL.md\n\n{source_content}"
+
+
 def find_related_skills(wiki_path: Path, name: str, tags: list[str]) -> list[str]:
     """Scan existing entity pages for skills that share at least one tag."""
     skills_dir = wiki_path / "entities" / "skills"
@@ -183,22 +234,19 @@ def find_related_skills(wiki_path: Path, name: str, tags: list[str]) -> list[str
         if page.stem == name:
             continue
         content = page.read_text(encoding="utf-8", errors="replace")
-        m = re.search(r"^tags:\s*\[([^\]]*)\]", content, re.MULTILINE)
-        if not m:
-            continue
-        page_tags = {t.strip() for t in m.group(1).split(",")}
+        page_tags = _tag_set_from_frontmatter(parse_frontmatter(content).get("tags"))
         if tag_set & page_tags:
             related.append(page.stem)
 
     return related
 
 
-def _add_backlink(wiki_path: Path, target_name: str, source_name: str) -> None:
-    """Add a [[wikilink]] from target page back to source if not already present."""
-    page = wiki_path / "entities" / "skills" / f"{target_name}.md"
-    reject_symlink_path(page)
-    if not page.exists():
-        return
+def _add_backlink(wiki_path: Path, target_name: str, source_name: str) -> None:
+    """Add a [[wikilink]] from target page back to source if not already present."""
+    page = wiki_path / "entities" / "skills" / f"{target_name}.md"
+    reject_symlink_path(page)
+    if not page.exists():
+        return
     content = page.read_text(encoding="utf-8", errors="replace")
     link = f"[[entities/skills/{source_name}]]"
     if link in content:
@@ -212,7 +260,7 @@ def _add_backlink(wiki_path: Path, target_name: str, source_name: str) -> None:
         )
     else:
         content = content.rstrip() + f"\n\n- {link}\n"
-    safe_atomic_write_text(page, content, encoding="utf-8")
+    safe_atomic_write_text(page, content, encoding="utf-8")
 
 
 def wire_backlinks(wiki_path: Path, name: str, related: list[str]) -> None:
@@ -241,15 +289,15 @@ def detect_scan_sources(wiki_path: Path, name: str) -> list[str]:
 
 # ── Core orchestration ────────────────────────────────────────────────────────
 
-def add_skill(
-    *,
-    source_path: Path,
-    name: str,
-    wiki_path: Path,
-    skills_dir: Path,
-    review_existing: bool = False,
-    update_existing: bool = False,
-) -> dict:
+def add_skill(
+    *,
+    source_path: Path,
+    name: str,
+    wiki_path: Path,
+    skills_dir: Path,
+    review_existing: bool = False,
+    update_existing: bool = False,
+) -> dict:
     """Add a single skill: install, convert if needed, ingest into wiki.
 
     Returns a result dict with keys: name, installed, converted, is_new_page.
@@ -263,49 +311,53 @@ def add_skill(
             f"SKILL.md too large ({file_size:,} bytes). Max 1 MB. "
             f"Split the skill or trim content before ingestion."
         )
-
-    content = source_path.read_text(encoding="utf-8", errors="replace")
-    line_count = len(content.splitlines())
-
-    installed_path = skills_dir / name / "SKILL.md"
-    entity_page = wiki_path / "entities" / "skills" / f"{name}.md"
-    existing_path = (
-        installed_path
-        if installed_path.exists()
-        else entity_page if entity_page.exists() else None
-    )
-    has_existing = existing_path is not None
-
-    if review_existing and has_existing and not update_existing:
-        assert existing_path is not None
-        existing_text = existing_path.read_text(encoding="utf-8", errors="replace")
-        review = build_update_review(
-            entity_type="skill",
-            slug=name,
-            existing_text=existing_text,
-            proposed_text=content,
-        )
-        return {
-            "name": name,
-            "installed": str(installed_path),
-            "converted": False,
-            "is_new_page": False,
-            "skipped": True,
-            "update_required": True,
-            "update_review": render_update_review(review),
-        }
-
-    if not has_existing:
-        # Intake gate: reject broken/duplicate candidates before we touch
-        # skills-dir. Existing updates bypass similarity intake because
-        # they compare against their own cached embedding.
-        decision = check_intake(content, "skills")
-        if not decision.allow:
-            raise IntakeRejected(decision)
-
-    tags = infer_tags(name, content)
-
-    # 1. Install original into skills-dir (never modified after this)
+
+    content = source_path.read_text(encoding="utf-8", errors="replace")
+    line_count = len(content.splitlines())
+
+    installed_path = skills_dir / name / "SKILL.md"
+    entity_page = wiki_path / "entities" / "skills" / f"{name}.md"
+    existing_path = (
+        installed_path
+        if installed_path.exists()
+        else entity_page if entity_page.exists() else None
+    )
+    has_existing = existing_path is not None
+    tags = infer_tags(name, content)
+
+    if review_existing and has_existing and not update_existing:
+        review = build_update_review(
+            entity_type="skill",
+            slug=name,
+            existing_text=_existing_skill_review_text(entity_page, installed_path),
+            proposed_text=_proposed_skill_review_text(
+                name=name,
+                tags=tags,
+                line_count=line_count,
+                source_content=content,
+                installed_path=installed_path,
+                wiki_path=wiki_path,
+            ),
+        )
+        return {
+            "name": name,
+            "installed": str(installed_path),
+            "converted": False,
+            "is_new_page": False,
+            "skipped": True,
+            "update_required": True,
+            "update_review": render_update_review(review),
+        }
+
+    if not has_existing:
+        # Intake gate: reject broken/duplicate candidates before we touch
+        # skills-dir. Existing updates bypass similarity intake because
+        # they compare against their own cached embedding.
+        decision = check_intake(content, "skills")
+        if not decision.allow:
+            raise IntakeRejected(decision)
+
+    # 1. Install original into skills-dir (never modified after this)
     installed_path = install_skill(source_path, skills_dir, name)
 
     # Record the candidate's embedding so future intake checks can
@@ -323,6 +375,8 @@ def add_skill(
     # 2. Convert if above threshold
     converted_root = wiki_path / "converted"
     converted, pipeline_path = maybe_convert(installed_path, name, converted_root, line_count)
+    if not converted:
+        mirror_install_body(installed_path, name, converted_root)
 
     # 3. Detect related skills and scan sources (before writing new page)
     related = find_related_skills(wiki_path, name, tags)
@@ -341,12 +395,12 @@ def add_skill(
     page_content = build_entity_page(
         name=name,
         tags=tags,
-        line_count=line_count,
-        has_pipeline=converted,
-        original_path=installed_path,
-        related=related,
-        scan_sources=scan_sources,
-    )
+        line_count=line_count,
+        has_pipeline=converted,
+        original_path=installed_path,
+        related=related,
+        scan_sources=scan_sources,
+    )
     is_new = write_entity_page(wiki_path, name, page_content)
 
     # 5. Bidirectional wikilinks
@@ -364,21 +418,21 @@ def add_skill(
         f"Converted: {converted}",
         f"Related: {', '.join(related) if related else 'none'}",
     ]
-    if converted and pipeline_path:
-        log_details.append(f"Pipeline: {pipeline_path}")
-    append_log(str(wiki_path), "add-skill", name, log_details)
-    queue_job = enqueue_entity_upsert(
-        wiki_path,
-        entity_type="skill",
-        slug=name,
-        entity_path=wiki_path / "entities" / "skills" / f"{name}.md",
-        content=page_content,
-        action="created" if is_new else "updated",
-        source="skill_add",
-    )
-
-    # Append to the unified audit log so post-hoc investigations can
-    # reconstruct every add/convert/install event without mining
+    if converted and pipeline_path:
+        log_details.append(f"Pipeline: {pipeline_path}")
+    append_log(str(wiki_path), "add-skill", name, log_details)
+    queue_job = enqueue_entity_upsert(
+        wiki_path,
+        entity_type="skill",
+        slug=name,
+        entity_path=wiki_path / "entities" / "skills" / f"{name}.md",
+        content=page_content,
+        action="created" if is_new else "updated",
+        source="skill_add",
+    )
+
+    # Append to the unified audit log so post-hoc investigations can
+    # reconstruct every add/convert/install event without mining
     # per-subsystem log files. See src/ctx_audit_log.py.
     try:
         from ctx_audit_log import log_skill_event
@@ -403,15 +457,15 @@ def add_skill(
     except Exception:  # noqa: BLE001 — audit is best-effort
         pass
 
-    return {
-        "name": name,
-        "installed": str(installed_path),
-        "converted": converted,
-        "is_new_page": is_new,
-        "skipped": False,
-        "update_required": False,
-        "queued_job_id": queue_job.id,
-    }
+    return {
+        "name": name,
+        "installed": str(installed_path),
+        "converted": converted,
+        "is_new_page": is_new,
+        "skipped": False,
+        "update_required": False,
+        "queued_job_id": queue_job.id,
+    }
 
 
 # ── CLI ───────────────────────────────────────────────────────────────────────
@@ -420,14 +474,14 @@ def main() -> None:
     parser = argparse.ArgumentParser(description="Add new skills with wiki ingestion")
     parser.add_argument("--skill-path", help="Path to a single SKILL.md to add")
     parser.add_argument("--name", help="Skill name (required with --skill-path)")
-    parser.add_argument("--scan-dir", help="Directory of skills to batch-add (each subdir with SKILL.md)")
-    parser.add_argument("--skip-existing", action="store_true", help="Skip skills already installed (prevents overwrites)")
-    parser.add_argument(
-        "--update-existing",
-        action="store_true",
-        help="Apply the reviewed replacement when a skill already exists",
-    )
-    parser.add_argument("--wiki", default=str(cfg.wiki_dir), help="Wiki path")
+    parser.add_argument("--scan-dir", help="Directory of skills to batch-add (each subdir with SKILL.md)")
+    parser.add_argument("--skip-existing", action="store_true", help="Skip skills already installed (prevents overwrites)")
+    parser.add_argument(
+        "--update-existing",
+        action="store_true",
+        help="Apply the reviewed replacement when a skill already exists",
+    )
+    parser.add_argument("--wiki", default=str(cfg.wiki_dir), help="Wiki path")
     parser.add_argument("--skills-dir", default=str(cfg.skills_dir), help="Skills install path")
     args = parser.parse_args()
 
@@ -471,7 +525,7 @@ def main() -> None:
             print(f"No SKILL.md files found under {scan_root}.", file=sys.stderr)
             sys.exit(0)
 
-    added = updated = converted = skipped = errors = 0
+    added = updated = converted = skipped = errors = 0
     total = len(candidates)
     for i, (source_path, name) in enumerate(candidates, 1):
         # Skip if already installed and --skip-existing is set
@@ -483,38 +537,38 @@ def main() -> None:
         try:
             result = add_skill(
                 source_path=source_path,
-                name=name,
-                wiki_path=wiki_path,
-                skills_dir=skills_dir,
-                review_existing=True,
-                update_existing=args.update_existing,
-            )
-            if result.get("skipped"):
-                skipped += 1
-                if result.get("update_review"):
-                    print(result["update_review"])
-                print(f"  [{i}/{total}] [update-review] {name}")
-                continue
-            if result["is_new_page"]:
-                added += 1
-            else:
-                updated += 1
-            if result["converted"]:
-                converted += 1
-            status = (
-                "updated"
-                if not result["is_new_page"]
-                else "converted" if result["converted"] else "installed"
-            )
-            print(f"  [{i}/{total}] [{status}] {name}")
+                name=name,
+                wiki_path=wiki_path,
+                skills_dir=skills_dir,
+                review_existing=True,
+                update_existing=args.update_existing,
+            )
+            if result.get("skipped"):
+                skipped += 1
+                if result.get("update_review"):
+                    print(result["update_review"])
+                print(f"  [{i}/{total}] [update-review] {name}")
+                continue
+            if result["is_new_page"]:
+                added += 1
+            else:
+                updated += 1
+            if result["converted"]:
+                converted += 1
+            status = (
+                "updated"
+                if not result["is_new_page"]
+                else "converted" if result["converted"] else "installed"
+            )
+            print(f"  [{i}/{total}] [{status}] {name}")
         except Exception as exc:
             errors += 1
             print(f"  [{i}/{total}] ERROR: {name}: {exc}", file=sys.stderr)
 
-    print(
-        f"\nDone: {added} added, {updated} updated, {converted} converted, "
-        f"{skipped} skipped, {errors} errors"
-    )
+    print(
+        f"\nDone: {added} added, {updated} updated, {converted} converted, "
+        f"{skipped} skipped, {errors} errors"
+    )
 
 
 if __name__ == "__main__":

src/tests/test_agent_add.py

@@ -1,162 +1,217 @@
-"""Tests for agent_add existing-update review behavior."""
-
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-from typing import Any
-from unittest.mock import MagicMock
-
-SRC_DIR = Path(__file__).resolve().parents[1]
-if str(SRC_DIR) not in sys.path:
-    sys.path.insert(0, str(SRC_DIR))
-
-import agent_add  # noqa: E402
-
-
-class _Decision:
-    allow = True
-    warnings: tuple[Any, ...] = ()
-
-
-def _agent_text(
-    *,
-    description: str = "Agent that reviews code changes with clear findings.",
-    model: str = "inherit",
-    body: str | None = None,
-) -> str:
-    body = body or (
-        "This agent reviews code and reports concrete risks.\n\n"
-        "## Review Process\n\n"
-        "Read the diff, identify regressions, and return prioritized findings."
-    )
-    return "\n".join(
-        [
-            "---",
-            "name: reviewer-agent",
-            f"description: {description}",
-            f"model: {model}",
-            "---",
-            "# reviewer-agent",
-            "",
-            body,
-        ]
-    )
-
-
-def _setup_paths(tmp_path: Path) -> tuple[Path, Path, Path]:
-    wiki = tmp_path / "wiki"
-    agents_dir = tmp_path / "agents"
-    source = tmp_path / "reviewer-agent.md"
-    (wiki / "entities" / "agents").mkdir(parents=True)
-    agents_dir.mkdir(parents=True)
-    return wiki, agents_dir, source
-
-
-def _patch_side_effects(monkeypatch: Any) -> MagicMock:
-    check = MagicMock(return_value=_Decision())
-    monkeypatch.setattr(agent_add, "check_intake", check)
-    monkeypatch.setattr(agent_add, "record_embedding", MagicMock())
-    monkeypatch.setattr(agent_add, "update_index", MagicMock())
-    monkeypatch.setattr(agent_add, "append_log", MagicMock())
-    monkeypatch.setattr(agent_add, "ensure_wiki", MagicMock())
-    return check
-
-
-def test_existing_agent_review_skips_without_mutating_files(
-    tmp_path: Path,
-    monkeypatch: Any,
-) -> None:
-    wiki, agents_dir, source = _setup_paths(tmp_path)
-    installed = agents_dir / "reviewer-agent.md"
-    existing_text = _agent_text(
-        description="Detailed agent with a conservative review process.",
-        model="sonnet",
-    )
-    installed.write_text(existing_text, encoding="utf-8")
-    entity = wiki / "entities" / "agents" / "reviewer-agent.md"
-    entity.write_text("# existing entity\n", encoding="utf-8")
-    entity_text = entity.read_text(encoding="utf-8")
-    source.write_text(
-        _agent_text(description="Short agent.", model="haiku"),
-        encoding="utf-8",
-    )
-    check = _patch_side_effects(monkeypatch)
-
-    result = agent_add.add_agent(
-        source_path=source,
-        name="reviewer-agent",
-        wiki_path=wiki,
-        agents_dir=agents_dir,
-        review_existing=True,
-    )
-
-    assert result["skipped"] is True
-    assert result["update_required"] is True
-    assert "Existing agent already exists: reviewer-agent" in result["update_review"]
-    assert installed.read_text(encoding="utf-8") == existing_text
-    assert entity.read_text(encoding="utf-8") == entity_text
-    check.assert_not_called()
-
-
-def test_existing_agent_update_existing_applies_change(
-    tmp_path: Path,
-    monkeypatch: Any,
-) -> None:
-    wiki, agents_dir, source = _setup_paths(tmp_path)
-    installed = agents_dir / "reviewer-agent.md"
-    installed.write_text(_agent_text(), encoding="utf-8")
-    entity = wiki / "entities" / "agents" / "reviewer-agent.md"
-    entity.write_text("# existing entity\n", encoding="utf-8")
-    updated_text = _agent_text(
-        description="Updated agent with stronger review coverage.",
-        model="opus",
-    )
-    source.write_text(updated_text, encoding="utf-8")
-    _patch_side_effects(monkeypatch)
-
-    result = agent_add.add_agent(
-        source_path=source,
-        name="reviewer-agent",
-        wiki_path=wiki,
-        agents_dir=agents_dir,
-        review_existing=True,
-        update_existing=True,
-    )
-
-    assert result["skipped"] is False
-    assert result["update_required"] is False
-    assert result["is_new_page"] is False
-    assert installed.read_text(encoding="utf-8") == updated_text
-    assert "Updated agent with stronger review coverage" in entity.read_text(
-        encoding="utf-8"
-    )
-
-
-def test_main_existing_agent_prints_update_review(
-    tmp_path: Path,
-    monkeypatch: Any,
-    capsys: Any,
-) -> None:
-    wiki, agents_dir, source = _setup_paths(tmp_path)
-    installed = agents_dir / "reviewer-agent.md"
-    installed.write_text(_agent_text(), encoding="utf-8")
-    source.write_text(
-        _agent_text(description="Replacement agent."),
-        encoding="utf-8",
-    )
-    _patch_side_effects(monkeypatch)
-    monkeypatch.setattr(sys, "argv", [
-        "agent_add.py",
-        "--agent-path", str(source),
-        "--name", "reviewer-agent",
-        "--wiki", str(wiki),
-        "--agents-dir", str(agents_dir),
-    ])
-
-    agent_add.main()
-
-    out = capsys.readouterr().out
-    assert "Existing agent already exists: reviewer-agent" in out
-    assert "Use the explicit update flag" in out
-    assert "Replacement agent." not in installed.read_text(encoding="utf-8")
+"""Tests for agent_add existing-update review behavior."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+from unittest.mock import MagicMock
+
+SRC_DIR = Path(__file__).resolve().parents[1]
+if str(SRC_DIR) not in sys.path:
+    sys.path.insert(0, str(SRC_DIR))
+
+import agent_add  # noqa: E402
+
+
+class _Decision:
+    allow = True
+    warnings: tuple[Any, ...] = ()
+
+
+def _agent_text(
+    *,
+    description: str = "Agent that reviews code changes with clear findings.",
+    model: str = "inherit",
+    body: str | None = None,
+) -> str:
+    body = body or (
+        "This agent reviews code and reports concrete risks.\n\n"
+        "## Review Process\n\n"
+        "Read the diff, identify regressions, and return prioritized findings."
+    )
+    return "\n".join(
+        [
+            "---",
+            "name: reviewer-agent",
+            f"description: {description}",
+            f"model: {model}",
+            "---",
+            "# reviewer-agent",
+            "",
+            body,
+        ]
+    )
+
+
+def _setup_paths(tmp_path: Path) -> tuple[Path, Path, Path]:
+    wiki = tmp_path / "wiki"
+    agents_dir = tmp_path / "agents"
+    source = tmp_path / "reviewer-agent.md"
+    (wiki / "entities" / "agents").mkdir(parents=True)
+    agents_dir.mkdir(parents=True)
+    return wiki, agents_dir, source
+
+
+def _patch_side_effects(monkeypatch: Any) -> MagicMock:
+    check = MagicMock(return_value=_Decision())
+    monkeypatch.setattr(agent_add, "check_intake", check)
+    monkeypatch.setattr(agent_add, "record_embedding", MagicMock())
+    monkeypatch.setattr(agent_add, "update_index", MagicMock())
+    monkeypatch.setattr(agent_add, "append_log", MagicMock())
+    monkeypatch.setattr(agent_add, "ensure_wiki", MagicMock())
+    return check
+
+
+def test_existing_agent_review_skips_without_mutating_files(
+    tmp_path: Path,
+    monkeypatch: Any,
+) -> None:
+    wiki, agents_dir, source = _setup_paths(tmp_path)
+    installed = agents_dir / "reviewer-agent.md"
+    existing_text = _agent_text(
+        description="Detailed agent with a conservative review process.",
+        model="sonnet",
+    )
+    installed.write_text(existing_text, encoding="utf-8")
+    entity = wiki / "entities" / "agents" / "reviewer-agent.md"
+    entity.write_text(
+        agent_add.generate_agent_page("reviewer-agent", installed),
+        encoding="utf-8",
+    )
+    entity_text = entity.read_text(encoding="utf-8")
+    source.write_text(
+        _agent_text(description="Short agent.", model="haiku"),
+        encoding="utf-8",
+    )
+    check = _patch_side_effects(monkeypatch)
+
+    result = agent_add.add_agent(
+        source_path=source,
+        name="reviewer-agent",
+        wiki_path=wiki,
+        agents_dir=agents_dir,
+        review_existing=True,
+    )
+
+    assert result["skipped"] is True
+    assert result["update_required"] is True
+    assert "Existing agent already exists: reviewer-agent" in result["update_review"]
+    assert "Changed frontmatter fields:" in result["update_review"]
+    assert "model" in result["update_review"]
+    assert installed.read_text(encoding="utf-8") == existing_text
+    assert entity.read_text(encoding="utf-8") == entity_text
+    check.assert_not_called()
+
+
+def test_existing_agent_update_existing_applies_change(
+    tmp_path: Path,
+    monkeypatch: Any,
+) -> None:
+    wiki, agents_dir, source = _setup_paths(tmp_path)
+    installed = agents_dir / "reviewer-agent.md"
+    installed.write_text(_agent_text(), encoding="utf-8")
+    entity = wiki / "entities" / "agents" / "reviewer-agent.md"
+    entity.write_text("# existing entity\n", encoding="utf-8")
+    updated_text = _agent_text(
+        description="Updated agent with stronger review coverage.",
+        model="opus",
+    )
+    source.write_text(updated_text, encoding="utf-8")
+    _patch_side_effects(monkeypatch)
+
+    result = agent_add.add_agent(
+        source_path=source,
+        name="reviewer-agent",
+        wiki_path=wiki,
+        agents_dir=agents_dir,
+        review_existing=True,
+        update_existing=True,
+    )
+
+    assert result["skipped"] is False
+    assert result["update_required"] is False
+    assert result["is_new_page"] is False
+    assert installed.read_text(encoding="utf-8") == updated_text
+    assert "Updated agent with stronger review coverage" in entity.read_text(
+        encoding="utf-8"
+    )
+
+
+def test_new_agent_add_writes_converted_agent_mirror(
+    tmp_path: Path,
+    monkeypatch: Any,
+) -> None:
+    wiki, agents_dir, source = _setup_paths(tmp_path)
+    source_text = _agent_text(description="Installable mirrored agent.")
+    source.write_text(source_text, encoding="utf-8")
+    _patch_side_effects(monkeypatch)
+
+    result = agent_add.add_agent(
+        source_path=source,
+        name="reviewer-agent",
+        wiki_path=wiki,
+        agents_dir=agents_dir,
+    )
+
+    mirror = wiki / "converted-agents" / "reviewer-agent.md"
+    assert result["is_new_page"] is True
+    assert mirror.read_text(encoding="utf-8") == source_text
+
+
+def test_existing_agent_update_refreshes_converted_agent_mirror(
+    tmp_path: Path,
+    monkeypatch: Any,
+) -> None:
+    wiki, agents_dir, source = _setup_paths(tmp_path)
+    installed = agents_dir / "reviewer-agent.md"
+    installed.write_text(_agent_text(), encoding="utf-8")
+    mirror = wiki / "converted-agents" / "reviewer-agent.md"
+    mirror.parent.mkdir(parents=True)
+    mirror.write_text("old mirror\n", encoding="utf-8")
+    entity = wiki / "entities" / "agents" / "reviewer-agent.md"
+    entity.write_text("# existing entity\n", encoding="utf-8")
+    updated_text = _agent_text(description="Updated mirrored agent.")
+    source.write_text(updated_text, encoding="utf-8")
+    _patch_side_effects(monkeypatch)
+
+    result = agent_add.add_agent(
+        source_path=source,
+        name="reviewer-agent",
+        wiki_path=wiki,
+        agents_dir=agents_dir,
+        review_existing=True,
+        update_existing=True,
+    )
+
+    assert result["is_new_page"] is False
+    assert mirror.read_text(encoding="utf-8") == updated_text
+
+
+def test_main_existing_agent_prints_update_review(
+    tmp_path: Path,
+    monkeypatch: Any,
+    capsys: Any,
+) -> None:
+    wiki, agents_dir, source = _setup_paths(tmp_path)
+    installed = agents_dir / "reviewer-agent.md"
+    installed.write_text(_agent_text(), encoding="utf-8")
+    source.write_text(
+        _agent_text(description="Replacement agent."),
+        encoding="utf-8",
+    )
+    _patch_side_effects(monkeypatch)
+    monkeypatch.setattr(sys, "argv", [
+        "agent_add.py",
+        "--agent-path", str(source),
+        "--name", "reviewer-agent",
+        "--wiki", str(wiki),
+        "--agents-dir", str(agents_dir),
+    ])
+
+    agent_add.main()
+
+    out = capsys.readouterr().out
+    assert "Existing agent already exists: reviewer-agent" in out
+    assert "Use the explicit update flag" in out
+    assert "Replacement agent." not in installed.read_text(encoding="utf-8")

src/tests/test_backup_mirror.py

@@ -77,6 +77,27 @@ def test_create_captures_all_expected_files(fake_home):
     assert "memory/demo-slug/MEMORY.md" in dests
 
 
+def test_create_snapshot_does_not_copy_always_excluded_names_inside_trees(fake_home):
+    _seed_home(fake_home)
+    (fake_home / "skills" / "brainstorming" / ".credentials.json").write_text(
+        '{"token":"leaked"}',
+        encoding="utf-8",
+    )
+    (fake_home / "projects" / "demo-slug" / "memory" / "claude.json").write_text(
+        '{"token":"leaked"}',
+        encoding="utf-8",
+    )
+
+    snap = bm.create_snapshot()
+    manifest = json.loads((snap / "manifest.json").read_text())
+    dests = {entry["dest"] for entry in manifest["entries"]}
+
+    assert "skills/brainstorming/.credentials.json" not in dests
+    assert "memory/demo-slug/claude.json" not in dests
+    assert not (snap / "skills" / "brainstorming" / ".credentials.json").exists()
+    assert not (snap / "memory" / "demo-slug" / "claude.json").exists()
+
+
 def test_create_hashes_every_non_skipped_file(fake_home):
     _seed_home(fake_home)
     snap = bm.create_snapshot()

src/tests/test_ci_classifier.py

@@ -70,6 +70,16 @@ def test_graph_preview_html_is_graph_artifact() -> None:
     assert flags["graph_only"] is True
 
 
+def test_unknown_graph_file_is_graph_artifact() -> None:
+    flags = classify_paths(["graph/notes.json"])
+
+    assert flags["docs_changed"] is False
+    assert flags["docs_only"] is False
+    assert flags["graph_artifact_changed"] is True
+    assert flags["graph_changed"] is True
+    assert flags["graph_only"] is True
+
+
 def test_graph_readme_is_docs_not_graph_artifact() -> None:
     flags = classify_paths(["graph/README.md"])
 
@@ -534,6 +544,23 @@ def test_ci_required_rejects_missing_graph_check_on_graph_only_pr() -> None:
     }
 
 
+def test_ci_required_allows_graph_check_skip_for_nonartifact_graph_change() -> None:
+    needs = _required_needs(
+        classify={
+            "result": "success",
+            "outputs": {
+                "docs_only": "false",
+                "graph_artifact_changed": "false",
+                "graph_changed": "true",
+                "graph_only": "true",
+            },
+        },
+        **{"graph-check": {"result": "skipped"}},
+    )
+
+    assert failed_required_jobs(needs, event_name="pull_request") == {}
+
+
 def test_ci_required_allows_browser_skip_for_unrelated_pr_only() -> None:
     needs = _required_needs(
         classify={"result": "success", "outputs": {"browser_changed": "false"}},
@@ -564,6 +591,25 @@ def test_ci_required_rejects_missing_similarity_gate_on_source_pr() -> None:
     }
 
 
+def test_ci_required_rejects_missing_similarity_gate_on_graph_only_pr() -> None:
+    needs = _required_needs(
+        classify={
+            "result": "success",
+            "outputs": {
+                "docs_only": "false",
+                "graph_only": "true",
+                "graph_artifact_changed": "true",
+                "similarity_changed": "true",
+            },
+        },
+        **{"similarity-integration": {"result": "skipped"}},
+    )
+
+    assert failed_required_jobs(needs, event_name="pull_request") == {
+        "similarity-integration": "skipped",
+    }
+
+
 def test_ci_required_allows_similarity_skip_for_unrelated_source_pr() -> None:
     needs = _required_needs(
         classify={

src/tests/test_config.py

@@ -162,6 +162,25 @@ class TestConfigExpandTilde:
         assert cfg.wiki_dir.is_absolute()
 
 
+def test_claude_adapter_modules_use_cfg_paths() -> None:
+    from ctx.adapters.claude_code import skill_health, skill_loader
+    from ctx.adapters.claude_code.install import install_utils, skill_unload
+
+    assert install_utils.MANIFEST_PATH == ctx_config.cfg.skill_manifest
+    assert skill_loader.SKILLS_DIR == ctx_config.cfg.skills_dir
+    assert skill_loader.AGENTS_DIR == ctx_config.cfg.agents_dir
+    assert skill_loader.WIKI_DIR == ctx_config.cfg.wiki_dir
+    assert skill_loader.PENDING_SKILLS == ctx_config.cfg.pending_skills
+    assert skill_loader.MANIFEST_PATH == ctx_config.cfg.skill_manifest
+    assert skill_unload.CLAUDE_DIR == ctx_config.cfg.claude_dir
+    assert skill_unload.WIKI_DIR == ctx_config.cfg.wiki_dir
+    assert skill_unload.MANIFEST_PATH == ctx_config.cfg.skill_manifest
+    assert skill_health.SKILLS_DIR == ctx_config.cfg.skills_dir
+    assert skill_health.AGENTS_DIR == ctx_config.cfg.agents_dir
+    assert skill_health.PENDING_PATH == ctx_config.cfg.pending_skills
+    assert skill_health.MANIFEST_PATH == ctx_config.cfg.skill_manifest
+
+
 class TestConfigReload:
     """test_config_reload -- reload() picks up changes to the raw config."""
 

src/tests/test_ctx_init.py

@@ -571,6 +571,57 @@ def test_graph_install_copies_local_entity_overlay(
     assert payload["edges"][0]["method"] == "manual_direct_overlay_v1"
 
 
+@pytest.mark.parametrize("field", ["semantic_sim", "tag_sim", "token_sim"])
+def test_graph_overlay_validation_rejects_out_of_range_similarity_fields(
+    tmp_path: Path,
+    field: str,
+) -> None:
+    overlay = tmp_path / "entity-overlays.jsonl"
+    overlay.write_text(
+        json.dumps({
+            "nodes": [{"id": "skill:a"}],
+            "edges": [
+                {
+                    "source": "skill:a",
+                    "target": "skill:b",
+                    "weight": 0.5,
+                    "final_weight": 0.5,
+                    field: 2.0,
+                },
+            ],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(ValueError, match=f"{field} must be 0..1"):
+        ci._validate_graph_entity_overlay(overlay)
+
+
+def test_graph_overlay_validation_rejects_weight_final_weight_drift(
+    tmp_path: Path,
+) -> None:
+    overlay = tmp_path / "entity-overlays.jsonl"
+    overlay.write_text(
+        json.dumps({
+            "nodes": [{"id": "skill:a"}],
+            "edges": [
+                {
+                    "source": "skill:a",
+                    "target": "skill:b",
+                    "weight": 0.7,
+                    "final_weight": 0.5,
+                },
+            ],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(ValueError, match="weight must equal final_weight"):
+        ci._validate_graph_entity_overlay(overlay)
+
+
 def test_runtime_graph_install_extracts_harness_pages_after_required_files(
     tmp_path: Path,
     monkeypatch,
@@ -640,6 +691,36 @@ def test_runtime_graph_install_extracts_harness_pages_after_required_files(
     ).exists()
 
 
+def test_runtime_graph_install_preserves_existing_non_harness_entities(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    archive = _write_graph_archive(tmp_path)
+    claude = tmp_path / "home"
+    local_skill = claude / "skill-wiki" / "entities" / "skills" / "private.md"
+    local_agent = claude / "skill-wiki" / "entities" / "agents" / "private.md"
+    local_mcp = claude / "skill-wiki" / "entities" / "mcp-servers" / "p" / "private.md"
+    local_harness = claude / "skill-wiki" / "entities" / "harnesses" / "old.md"
+    for path in (local_skill, local_agent, local_mcp, local_harness):
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(f"# {path.stem}\n", encoding="utf-8")
+
+    monkeypatch.setattr(
+        ci,
+        "_find_local_graph_archive",
+        lambda _install_mode="runtime": archive,
+    )
+    monkeypatch.setattr(ci, "_verify_local_graph_archive", lambda *_a, **_k: None)
+    monkeypatch.setattr(ci, "_install_graph_entity_overlay", lambda *_a, **_k: None)
+
+    assert ci.build_graph(claude, force=True, install_mode="runtime") == 0
+
+    assert local_skill.is_file()
+    assert local_agent.is_file()
+    assert local_mcp.is_file()
+    assert not local_harness.exists()
+
+
 def test_graph_install_rejects_incomplete_archive(
     tmp_path: Path,
     monkeypatch,

src/tests/test_ctx_monitor.py

@@ -29,6 +29,13 @@ def fake_claude(tmp_path: Path, monkeypatch) -> Path:
     (claude / "skill-quality").mkdir(parents=True)
     monkeypatch.setattr(cm, "_claude_dir", lambda: claude)
     monkeypatch.setattr(cm, "_dashboard_graph_index_archives", lambda: [])
+    monkeypatch.setattr(cm, "_SIDECAR_INDEX_CACHE_KEY", None)
+    monkeypatch.setattr(cm, "_SIDECAR_INDEX_CACHE_VALUE", None)
+    monkeypatch.setattr(cm, "_SIDECAR_FILTER_CACHE_SIGNATURE", None)
+    monkeypatch.setattr(cm, "_SIDECAR_FILTER_CACHE_VALUE", {})
+    monkeypatch.setattr(cm, "_KPI_SUMMARY_CACHE_KEY", None)
+    monkeypatch.setattr(cm, "_KPI_SUMMARY_CACHE_VALUE", None)
+    monkeypatch.setattr(cm, "_KPI_SUMMARY_CACHE_AT", 0.0)
     return claude
 
 
@@ -127,6 +134,25 @@ def _get_json(port: int, path: str) -> tuple[int, dict]:
         return exc.code, json.loads(exc.read().decode("utf-8"))
 
 
+def _get_raw(
+    port: int,
+    path: str,
+    *,
+    headers: dict[str, str],
+) -> tuple[int, dict]:
+    conn = http.client.HTTPConnection("127.0.0.1", port, timeout=5)
+    try:
+        conn.putrequest("GET", path, skip_host=True)
+        for key, value in headers.items():
+            conn.putheader(key, value)
+        conn.endheaders()
+        response = conn.getresponse()
+        payload = json.loads(response.read().decode("utf-8"))
+        return response.status, payload
+    finally:
+        conn.close()
+
+
 def _post_raw(
     port: int,
     path: str,
@@ -136,7 +162,9 @@ def _post_raw(
 ) -> tuple[int, dict]:
     conn = http.client.HTTPConnection("127.0.0.1", port, timeout=5)
     try:
-        conn.putrequest("POST", path)
+        conn.putrequest("POST", path, skip_host=True)
+        if "Host" not in headers:
+            conn.putheader("Host", f"127.0.0.1:{port}")
         for key, value in headers.items():
             conn.putheader(key, value)
         conn.endheaders()
@@ -279,7 +307,8 @@ def test_render_skills_includes_harness_filter_and_typed_links(fake_claude: Path
 
     html = cm._render_skills()
 
-    assert "class='type-filter' value='harness'" in html
+    assert "class='type-filter'" in html
+    assert "value='harness'" in html
     assert "/skill/langgraph?type=harness" in html
     assert "/wiki/langgraph?type=harness" in html
     assert "/graph?slug=langgraph&type=harness" in html
@@ -780,6 +809,59 @@ def test_monitor_post_rejects_cross_origin_with_valid_token(
         thread.join(timeout=2)
 
 
+def test_monitor_post_rejects_rebound_host_with_valid_token(
+    fake_claude: Path, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    calls: list[str] = []
+
+    def fake_load(slug: str, entity_type: str = "skill") -> tuple[bool, str]:
+        calls.append(slug)
+        return True, f"loaded {entity_type}"
+
+    monkeypatch.setattr(cm, "_perform_load", fake_load)
+    server, thread, port = _serve_monitor(monkeypatch)
+    body = json.dumps({"slug": "python-patterns"}).encode("utf-8")
+    try:
+        status, payload = _post_raw(
+            port,
+            "/api/load",
+            headers={
+                "Host": "evil.example",
+                "Content-Type": "application/json",
+                "Content-Length": str(len(body)),
+                "X-CTX-Monitor-Token": "test-token",
+                "Origin": "http://evil.example",
+            },
+            body=body,
+        )
+        assert status == 403
+        assert "cross-origin" in payload["detail"]
+        assert calls == []
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=2)
+
+
+def test_monitor_get_rejects_rebound_host_in_loopback_mode(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    server, thread, port = _serve_monitor(monkeypatch)
+    try:
+        status, payload = _get_raw(
+            port,
+            "/api/status.json",
+            headers={"Host": "evil.example"},
+        )
+        assert status == 403
+        assert "monitor read" in payload["detail"]
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=2)
+
+
 @pytest.mark.parametrize(
     ("length", "status", "detail"),
     [
@@ -869,9 +951,11 @@ def test_monitor_non_loopback_bind_is_read_only(
         ) as response:
             loaded_html = response.read().decode("utf-8")
             csp = response.headers.get("Content-Security-Policy", "")
+            cookie = response.headers.get("Set-Cookie", "")
         assert "browser-token" not in loaded_html
         assert "Read-only mode" in loaded_html
         assert "script-src 'self' 'unsafe-inline'" in csp
+        assert "ctx_monitor_read_token=browser-token" in cookie
 
         with pytest.raises(urllib.error.HTTPError) as excinfo:
             urllib.request.urlopen(
@@ -882,6 +966,17 @@ def test_monitor_non_loopback_bind_is_read_only(
         body = json.loads(excinfo.value.read().decode("utf-8"))
         assert "read token required" in body["detail"]
 
+        status, body = _get_raw(
+            port,
+            "/api/manifest.json",
+            headers={
+                "Host": f"127.0.0.1:{port}",
+                "Cookie": "ctx_monitor_read_token=browser-token",
+            },
+        )
+        assert status == 200
+        assert body["load"] == []
+
         status, body = _post_json(
             port,
             "/api/load",
@@ -897,6 +992,34 @@ def test_monitor_non_loopback_bind_is_read_only(
         thread.join(timeout=2)
 
 
+def test_serve_generates_read_token_for_non_loopback(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    class FakeServer:
+        _ctx_mutations_enabled = False
+
+        def serve_forever(self) -> None:
+            raise KeyboardInterrupt
+
+        def server_close(self) -> None:
+            return None
+
+    monkeypatch.setattr(cm, "_MONITOR_TOKEN", "")
+    monkeypatch.setattr(cm, "_make_monitor_server", lambda _host, _port: FakeServer())
+    monkeypatch.setattr(cm.secrets, "token_urlsafe", lambda _size: "lan-token")
+    monkeypatch.setattr(cm.socket, "gethostname", lambda: "devbox")
+    monkeypatch.setattr(cm.socket, "gethostbyname", lambda _name: "192.168.1.50")
+
+    cm.serve(host="0.0.0.0", port=8765)
+
+    assert cm._MONITOR_TOKEN == "lan-token"
+    out = capsys.readouterr().out
+    assert "http://192.168.1.50:8765/?token=lan-token" in out
+    assert "http://0.0.0.0:8765" not in out
+    assert "read token required" in out
+
+
 def test_host_allows_mutations_only_for_loopback() -> None:
     assert cm._host_allows_mutations("127.0.0.1")
     assert cm._host_allows_mutations("::1")
@@ -1076,6 +1199,7 @@ def test_render_wiki_entity_renders_markdown_and_wikilinks(fake_claude: Path) ->
         "Use `pytest` with [[entities/skills/find-skills]].\n\n"
         "Source: [Homepage](https://example.com/docs).\n\n"
         "Unsafe: [bad](javascript:alert(1)).\n\n"
+        "Protocol relative: [offsite](//evil.example/x).\n\n"
         "- first item\n"
         "- [[entities/agents/reviewer|reviewer agent]]\n",
         encoding="utf-8",
@@ -1089,6 +1213,7 @@ def test_render_wiki_entity_renders_markdown_and_wikilinks(fake_claude: Path) ->
     assert "href='/wiki/reviewer?type=agent'" in html_out
     assert "<a href='https://example.com/docs'>Homepage</a>" in html_out
     assert "href='javascript:alert(1)'" not in html_out
+    assert "href='//evil.example/x'" not in html_out
     assert "<li>first item</li>" in html_out
     assert "<pre style=" not in html_out
 
@@ -1275,6 +1400,7 @@ def test_render_wiki_entity_falls_back_to_runtime_graph_metadata(
     assert "data-testid='runtime-entity-load'" in html_out
     assert "/api/load" in html_out
     assert "X-CTX-Monitor-Token" in html_out
+    assert "payload.detail || payload.msg || response.status" in html_out
 
 
 def test_render_runtime_harness_entity_shows_install_commands(
@@ -1949,6 +2075,7 @@ def test_graph_neighborhood_extracts_missing_dashboard_index_from_archive(
         tar.add(seed, arcname="./graphify-out/dashboard-neighborhoods.sqlite3")
 
     monkeypatch.setattr(cm, "_dashboard_graph_index_archives", lambda: [archive])
+    monkeypatch.setattr(cm, "_packaged_graph_export_id", lambda: "archive-export")
     monkeypatch.setattr(
         cm,
         "_load_dashboard_graph",
@@ -1985,6 +2112,7 @@ def test_dashboard_index_extraction_skips_archive_export_mismatch(
         tar.add(seed, arcname="./graphify-out/dashboard-neighborhoods.sqlite3")
 
     monkeypatch.setattr(cm, "_dashboard_graph_index_archives", lambda: [archive])
+    monkeypatch.setattr(cm, "_packaged_graph_export_id", lambda: None)
     monkeypatch.setattr(
         cm,
         "_dashboard_index_matches_manifest",
@@ -1997,20 +2125,17 @@ def test_dashboard_index_extraction_skips_archive_export_mismatch(
     assert not (graph_dir / "dashboard-neighborhoods.sqlite3").exists()
 
 
-def test_dashboard_index_extraction_skips_installed_graph_report(
+def test_dashboard_index_extraction_skips_packaged_export_mismatch(
     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",
+        json.dumps({"version": 1, "export_id": "old-local-export"}),
         encoding="utf-8",
     )
+    monkeypatch.setattr(cm, "_packaged_graph_export_id", lambda: "new-packaged-export")
     monkeypatch.setattr(
         cm,
         "_dashboard_graph_index_archives",
@@ -2020,6 +2145,66 @@ def test_dashboard_index_extraction_skips_installed_graph_report(
     assert cm._ensure_dashboard_graph_index() is None
 
 
+def test_graph_neighborhood_uses_local_graph_on_packaged_export_mismatch(
+    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": "old-local-export"}),
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(cm, "_packaged_graph_export_id", lambda: "new-packaged-export")
+    G = nx.Graph()
+    G.add_node("mcp-server:github", label="GitHub", type="mcp-server", tags=["git"])
+    monkeypatch.setattr(cm, "_load_dashboard_graph", lambda: G)
+
+    result = cm._graph_neighborhood("github", entity_type="mcp-server")
+    assert result["center"] == "mcp-server:github"
+    assert result["nodes"][0]["data"]["type"] == "mcp-server"
+
+
+def test_dashboard_index_extraction_works_with_installed_graph_report(
+    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",
+    )
+    (graph_dir / "graph-report.md").write_text(
+        "> Nodes: 12 | Edges: 34 | Communities: 2\n",
+        encoding="utf-8",
+    )
+    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("INSERT INTO meta VALUES(?,?)", ("export_id", json.dumps("local-export")))
+        conn.commit()
+    finally:
+        conn.close()
+    archive_manifest = tmp_path / "graph-export-manifest.json"
+    archive_manifest.write_text(
+        json.dumps({"version": 1, "export_id": "local-export"}),
+        encoding="utf-8",
+    )
+    archive = tmp_path / "wiki-graph-runtime.tar.gz"
+    with tarfile.open(archive, "w:gz") as tar:
+        tar.add(archive_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, "_packaged_graph_export_id", lambda: "local-export")
+
+    assert cm._ensure_dashboard_graph_index() == graph_dir / "dashboard-neighborhoods.sqlite3"
+
+
 def test_graph_neighborhood_bypasses_archive_index_when_runtime_overlays_exist(
     fake_claude: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -2075,6 +2260,7 @@ def test_graph_neighborhood_rejects_stale_dashboard_index(
 
     G = nx.Graph()
     G.add_node("skill:fallback", label="fallback", type="skill", tags=[])
+    monkeypatch.setattr(cm, "_packaged_graph_export_id", lambda: None)
     monkeypatch.setattr(cm, "_load_dashboard_graph", lambda: G)
 
     result = cm._graph_neighborhood("fallback", entity_type="skill")
@@ -2227,7 +2413,7 @@ def test_render_skills_emits_sidebar_filters(fake_claude: Path) -> None:
                                        "subject_type": "agent",
                                        "hard_floor": "intake_fail"})
     html_out = cm._render_skills()
-    # Sidebar must expose a text search + grade checkboxes + type checkboxes.
+    # Sidebar must expose text search plus grade/type filters.
     assert "id='skill-search'" in html_out
     assert "class='grade-filter'" in html_out
     assert "class='type-filter'" in html_out
@@ -2239,6 +2425,113 @@ def test_render_skills_emits_sidebar_filters(fake_claude: Path) -> None:
     assert ">graph</a>" in html_out
 
 
+def test_render_skills_paginates_sidecar_page(fake_claude: Path) -> None:
+    for slug in ("a", "b", "c"):
+        _write_sidecar(fake_claude, slug, {
+            "slug": slug,
+            "grade": "A",
+            "raw_score": 0.9,
+            "subject_type": "skill",
+        })
+
+    html_out = cm._render_skills({"limit": "2"})
+
+    assert "Showing 1-2 of 3 sidecars" in html_out
+    assert "next</a>" in html_out
+    assert "a</code>" in html_out
+    assert "b</code>" in html_out
+    assert "c</code>" not in html_out
+
+
+def test_sidecar_page_payload_searches_full_catalog(fake_claude: Path) -> None:
+    for slug in ("alpha-review", "beta-build", "gamma-review"):
+        _write_sidecar(fake_claude, slug, {
+            "slug": slug,
+            "grade": "A",
+            "raw_score": 0.9,
+            "subject_type": "skill",
+        })
+
+    payload = cm._sidecar_page_payload({"q": "review", "limit": "1"})
+
+    assert payload["total"] == 2
+    assert payload["pages"] == 2
+    assert [item["slug"] for item in payload["items"]] == ["alpha-review"]
+
+
+def test_sidecar_page_payload_filters_type_grade_and_floor(fake_claude: Path) -> None:
+    _write_sidecar(fake_claude, "agent-a", {
+        "slug": "agent-a",
+        "grade": "A",
+        "raw_score": 0.9,
+        "subject_type": "agent",
+    })
+    _write_sidecar(fake_claude, "skill-a", {
+        "slug": "skill-a",
+        "grade": "A",
+        "raw_score": 0.9,
+        "subject_type": "skill",
+    })
+    _write_sidecar(fake_claude, "agent-floored", {
+        "slug": "agent-floored",
+        "grade": "A",
+        "raw_score": 0.9,
+        "subject_type": "agent",
+        "hard_floor": "intake_fail",
+    })
+
+    payload = cm._sidecar_page_payload({
+        "type": "agent",
+        "grade": "A",
+        "hide_floor": "1",
+    })
+
+    assert payload["total"] == 1
+    assert payload["items"][0]["slug"] == "agent-a"
+
+
+def test_sidecar_page_payload_reuses_cached_search_records(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    for slug in ("alpha-review", "beta-review"):
+        _write_sidecar(fake_claude, slug, {
+            "slug": slug,
+            "grade": "A",
+            "raw_score": 0.9,
+            "subject_type": "skill",
+        })
+    original_read = cm._read_sidecar_file
+    reads = 0
+
+    def counting_read(path: Path) -> dict | None:
+        nonlocal reads
+        reads += 1
+        return original_read(path)
+
+    monkeypatch.setattr(cm, "_read_sidecar_file", counting_read)
+
+    first = cm._sidecar_page_payload({"q": "review"})
+    reads_after_first_search = reads
+    second = cm._sidecar_page_payload({"q": "review"})
+
+    assert [item["slug"] for item in first["items"]] == ["alpha-review", "beta-review"]
+    assert [item["slug"] for item in second["items"]] == ["alpha-review", "beta-review"]
+    assert reads_after_first_search == 2
+    assert reads == reads_after_first_search
+
+    _write_sidecar(fake_claude, "delta-review", {
+        "slug": "delta-review",
+        "grade": "A",
+        "raw_score": 0.8,
+        "subject_type": "skill",
+    })
+    refreshed = cm._sidecar_page_payload({"q": "delta"})
+
+    assert [item["slug"] for item in refreshed["items"]] == ["delta-review"]
+    assert reads > reads_after_first_search
+
+
 def test_render_wiki_index_lists_entities(fake_claude: Path) -> None:
     skills_dir = fake_claude / "skill-wiki" / "entities" / "skills"
     agents_dir = fake_claude / "skill-wiki" / "entities" / "agents"
@@ -2535,6 +2828,67 @@ def test_entity_delete_api_removes_wiki_page_and_queues_graph_refresh(
         server.server_close()
 
 
+def test_entity_delete_unloads_live_entity_before_removing_page(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    skill_dir = fake_claude / "skill-wiki" / "entities" / "skills"
+    skill_dir.mkdir(parents=True)
+    entity_path = skill_dir / "python-patterns.md"
+    entity_path.write_text(
+        "---\ntitle: Python Patterns\ntype: skill\n---\n# Python Patterns\n",
+        encoding="utf-8",
+    )
+    calls: list[tuple[str, str]] = []
+    monkeypatch.setattr(
+        cm,
+        "_read_manifest",
+        lambda: {"load": [{"skill": "python-patterns", "entity_type": "skill"}]},
+    )
+
+    def fake_unload(slug: str, entity_type: str = "skill") -> tuple[bool, str]:
+        calls.append((slug, entity_type))
+        return True, "unloaded"
+
+    monkeypatch.setattr(cm, "_perform_unload", fake_unload)
+
+    ok, detail = cm._delete_wiki_entity("python-patterns", "skill")
+
+    assert ok is True
+    assert "deleted skill:python-patterns" in detail
+    assert calls == [("python-patterns", "skill")]
+    assert not entity_path.exists()
+
+
+def test_entity_delete_keeps_page_when_live_unload_fails(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    harness_dir = fake_claude / "skill-wiki" / "entities" / "harnesses"
+    harness_dir.mkdir(parents=True)
+    entity_path = harness_dir / "local-harness.md"
+    entity_path.write_text(
+        "---\ntitle: Local Harness\ntype: harness\n---\n# Local Harness\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(
+        cm,
+        "_read_manifest",
+        lambda: {"load": [{"skill": "local-harness", "entity_type": "harness"}]},
+    )
+    monkeypatch.setattr(
+        cm,
+        "_perform_unload",
+        lambda slug, entity_type="skill": (False, "use ctx-harness-install"),
+    )
+
+    ok, detail = cm._delete_wiki_entity("local-harness", "harness")
+
+    assert ok is False
+    assert "is loaded" in detail
+    assert entity_path.exists()
+
+
 def test_sidecar_cache_invalidates_on_file_rewrite(fake_claude: Path) -> None:
     cm._SIDECAR_INDEX_CACHE_KEY = None
     cm._SIDECAR_INDEX_CACHE_VALUE = None
@@ -2618,6 +2972,33 @@ def test_api_kpi_summary_shape(fake_claude: Path) -> None:
     assert d["grade_counts"].get("A", 0) == 1
 
 
+def test_kpi_summary_cache_reuses_recent_summary(
+    fake_claude: Path, monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import kpi_dashboard as kd
+
+    _write_sidecar(fake_claude, "alpha", {
+        "slug": "alpha", "subject_type": "skill",
+        "grade": "A", "raw_score": 0.9, "score": 0.9,
+        "hard_floor": None, "computed_at": "2026-04-19T10:00:00+00:00",
+    })
+    monkeypatch.setattr(cm, "_KPI_SUMMARY_CACHE_KEY", None)
+    monkeypatch.setattr(cm, "_KPI_SUMMARY_CACHE_VALUE", None)
+    real_generate = kd.generate
+    calls = 0
+
+    def wrapped_generate(*, sources, top_n=10, now=None):
+        nonlocal calls
+        calls += 1
+        return real_generate(sources=sources, top_n=top_n, now=now)
+
+    monkeypatch.setattr(kd, "generate", wrapped_generate)
+
+    assert cm._kpi_summary() is not None
+    assert cm._kpi_summary() is not None
+    assert calls == 1
+
+
 def test_layout_nav_includes_wiki_and_kpi() -> None:
     """Every rendered page must include the new Wiki + KPI tabs in the
     top nav — the user explicitly asked for them to be accessible."""
@@ -2750,6 +3131,31 @@ def test_render_docs_lists_repo_docs(
     assert "doc-card" not in html_out
 
 
+def test_render_docs_sanitizes_active_html(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    (tmp_path / "docs").mkdir()
+    (tmp_path / "mkdocs.yml").write_text(
+        "site_name: ctx\nnav:\n  - Home: index.md\n",
+        encoding="utf-8",
+    )
+    (tmp_path / "docs" / "index.md").write_text(
+        "# Home\n\n"
+        "<script>alert('x')</script>\n\n"
+        "<a href=\"javascript:alert('x')\" onclick=\"alert('x')\">bad</a>\n",
+        encoding="utf-8",
+    )
+    monkeypatch.setattr(cm, "_docs_roots", lambda: [tmp_path])
+
+    html_out = cm._render_docs()
+
+    assert "<script>alert('x')</script>" not in html_out
+    assert "&lt;script" in html_out
+    assert "onclick=" not in html_out
+    assert "href=\"javascript:" not in html_out
+
+
 def test_render_docs_falls_back_to_public_docs(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -2964,6 +3370,7 @@ def test_render_graph_landing_does_not_cold_load_graph_for_seed_chips(
         "available": True,
     })
     monkeypatch.setattr(cm, "_load_dashboard_graph", fake_load_graph)
+    monkeypatch.setattr(cm, "_top_degree_seeds_from_index", lambda _limit=18: [])
     monkeypatch.setattr(cm, "_GRAPH_CACHE_VALUE", None)
 
     html_out = cm._render_graph(None)
@@ -2986,6 +3393,7 @@ def test_render_graph_landing_hides_seeds_when_graph_absent(monkeypatch) -> None
     # braces in case a downstream path still routes through it.
     monkeypatch.setitem(sys.modules, "ctx.core.graph.resolve_graph", fake)
     monkeypatch.setitem(sys.modules, "resolve_graph", fake)
+    monkeypatch.setattr(cm, "_graph_stats", lambda: {"available": False})
     monkeypatch.setattr(cm, "_GRAPH_CACHE_VALUE", None)
     monkeypatch.setattr(cm, "_GRAPH_CACHE_KEY", None)
     html_out = cm._render_graph(None)

src/tests/test_graph_artifact_guard.py

@@ -40,17 +40,23 @@ def test_graph_artifact_guard_parks_and_unparks_tracked_artifacts(
     _git(repo, "config", "user.name", "ctx test")
 
     artifact = graph / "wiki-graph.tar.gz"
+    overlay = graph / "entity-overlays.jsonl"
     artifact.write_bytes(b"fake graph artifact")
-    _git(repo, "add", "graph/wiki-graph.tar.gz")
+    overlay.write_text('{"nodes":[],"edges":[]}\n', encoding="utf-8")
+    _git(repo, "add", "graph/wiki-graph.tar.gz", "graph/entity-overlays.jsonl")
     _git(repo, "commit", "-m", "track graph artifact")
 
     assert guard.main(["--repo", str(repo), "park"]) == 0
     assert _git(repo, "ls-files", "-v", "graph/wiki-graph.tar.gz").startswith("S ")
+    assert _git(repo, "ls-files", "-v", "graph/entity-overlays.jsonl").startswith("S ")
 
     assert guard.main(["--repo", str(repo), "unpark"]) == 0
     assert not _git(repo, "ls-files", "-v", "graph/wiki-graph.tar.gz").startswith(
         "S "
     )
+    assert not _git(repo, "ls-files", "-v", "graph/entity-overlays.jsonl").startswith(
+        "S "
+    )
 
 
 def test_graph_artifact_guard_removes_only_stale_graph_files(
@@ -79,3 +85,55 @@ def test_graph_artifact_guard_removes_only_stale_graph_files(
     assert not staged.exists()
     assert not partial.exists()
     assert outside.exists()
+
+
+def test_graph_artifact_guard_prune_is_lfs_only_by_default(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    repo_root = Path(__file__).resolve().parents[2]
+    guard = _load_guard(repo_root)
+    calls: list[tuple[str, ...]] = []
+
+    def fake_run_git(
+        _repo: Path,
+        args: list[str],
+        *,
+        check: bool = True,
+        capture: bool = False,
+    ) -> subprocess.CompletedProcess[str]:
+        calls.append(tuple(args))
+        return subprocess.CompletedProcess(args, 0, stdout="", stderr="")
+
+    monkeypatch.setattr(guard, "_run_git", fake_run_git)
+
+    guard._prune(tmp_path, include_lfs=True, include_git_prune=False)
+
+    assert ("lfs", "prune", "--verbose") in calls
+    assert not any(call[:1] == ("prune",) for call in calls)
+
+
+def test_graph_artifact_guard_prune_requires_explicit_git_prune(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    repo_root = Path(__file__).resolve().parents[2]
+    guard = _load_guard(repo_root)
+    calls: list[tuple[str, ...]] = []
+
+    def fake_run_git(
+        _repo: Path,
+        args: list[str],
+        *,
+        check: bool = True,
+        capture: bool = False,
+    ) -> subprocess.CompletedProcess[str]:
+        calls.append(tuple(args))
+        return subprocess.CompletedProcess(args, 0, stdout="", stderr="")
+
+    monkeypatch.setattr(guard, "_run_git", fake_run_git)
+
+    guard._prune(tmp_path, include_lfs=False, include_git_prune=True)
+
+    assert ("prune", "--expire=now", "--verbose") in calls
+    assert not any(call[:2] == ("lfs", "prune") for call in calls)

src/tests/test_harness_install.py

@@ -258,6 +258,33 @@ def test_remote_install_requires_pinned_commit_by_default(tmp_path: Path) -> Non
     assert not (tmp_path / "installs" / "text-to-cad").exists()
 
 
+@pytest.mark.parametrize(
+    "repo_url",
+    [
+        "ssh://github.com/earthtojake/text-to-cad",
+        "https://token@example.test/private/repo",
+        "-c.helper=!calc",
+    ],
+)
+def test_remote_install_rejects_unsafe_repo_urls(
+    tmp_path: Path,
+    repo_url: str,
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_harness_page(wiki, repo_url=repo_url, commit_sha="a" * 40)
+
+    result = harness_install.install_harness(
+        "text-to-cad",
+        wiki_path=wiki,
+        installs_root=tmp_path / "installs",
+        manifest_dir=tmp_path / "manifests",
+    )
+
+    assert result.status == "install-failed"
+    assert "repo_url" in result.message
+    assert not (tmp_path / "installs" / "text-to-cad").exists()
+
+
 def test_remote_install_fetches_pinned_commit_and_records_manifest(
     tmp_path: Path,
     monkeypatch: Any,
@@ -288,6 +315,7 @@ def test_remote_install_fetches_pinned_commit_and_records_manifest(
 
     assert result.status == "installed"
     assert git_calls[0][:2] == ["clone", "--no-checkout"]
+    assert git_calls[0][2] == "--"
     assert any(
         call[0] == "-C"
         and call[2:6] == ["fetch", "--depth", "1", "origin"]

src/tests/test_harness_recommendations.py

@@ -258,6 +258,7 @@ def test_ctx_init_keeps_domain_goal_strong_with_install_requirements(
     }
     assert "windows" not in results[0]["missing_signals"]
     assert "mcp" not in results[0]["missing_signals"]
+    assert "gpt" not in results[0]["missing_signals"]
     assert "gpt-5" not in results[0]["fit_signals"]
 
 

src/tests/test_import_skills_sh_catalog.py

@@ -1160,8 +1160,12 @@ def test_hydration_falls_back_to_github_raw_skill_md(monkeypatch) -> None:
         ),
     )
     fetched_urls: list[str] = []
+    branch_sha = "0123456789abcdef0123456789abcdef01234567"
 
     class FakeResponse:
+        def __init__(self, payload: bytes) -> None:
+            self._payload = payload
+
         def __enter__(self) -> "FakeResponse":
             return self
 
@@ -1169,14 +1173,17 @@ def test_hydration_falls_back_to_github_raw_skill_md(monkeypatch) -> None:
             return None
 
         def read(self, size: int = -1) -> bytes:
-            return b"# Brand Identity\n\nUse this skill for brand strategy.\n"
+            return self._payload
 
     def fake_urlopen(req: object, timeout: int) -> FakeResponse:
         url = req.full_url  # type: ignore[attr-defined]
         fetched_urls.append(url)
+        if url.endswith("/repos/travisjneuman/.claude/branches/main"):
+            return FakeResponse(json.dumps({"commit": {"sha": branch_sha}}).encode())
         if "/skills/brand-identity/" not in url:
             raise OSError("not found")
-        return FakeResponse()
+        assert f"/{branch_sha}/" in url
+        return FakeResponse(b"# Brand Identity\n\nUse this skill for brand strategy.\n")
 
     monkeypatch.setattr(importer.urllib.request, "urlopen", fake_urlopen)
     catalog: dict[str, Any] = {
@@ -1199,11 +1206,33 @@ def test_hydration_falls_back_to_github_raw_skill_md(monkeypatch) -> None:
     assert skill["skill_body"].startswith("# Brand Identity")
     assert skill["body_source_url"] == (
         "https://raw.githubusercontent.com/travisjneuman/.claude/"
-        "main/skills/brand-identity/SKILL.md"
+        f"{branch_sha}/skills/brand-identity/SKILL.md"
     )
     assert fetched_urls[-1] == skill["body_source_url"]
 
 
+def test_github_raw_fallback_requires_pinned_branch_sha(monkeypatch) -> None:
+    fetched_urls: list[str] = []
+
+    def fake_urlopen(req: object, timeout: int) -> object:
+        fetched_urls.append(req.full_url)  # type: ignore[attr-defined]
+        raise OSError("branch lookup failed")
+
+    monkeypatch.setattr(importer.urllib.request, "urlopen", fake_urlopen)
+
+    body, url, error = importer._fetch_github_raw_skill_body(
+        {
+            "source": "owner/repo",
+            "skill_id": "danger",
+        },
+    )
+
+    assert body is None
+    assert url is None
+    assert "found no pinned SKILL.md candidates" in str(error)
+    assert all("raw.githubusercontent.com" not in candidate for candidate in fetched_urls)
+
+
 def test_hydration_rejects_non_skills_sh_detail_urls(monkeypatch) -> None:
     def fail_fetch(url: str, timeout: int = 30) -> tuple[str | None, str | None]:
         raise AssertionError(f"unexpected fetch for {url}")

src/tests/test_incremental_attach_calibration.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import json
+
 import networkx as nx
 import numpy as np
 import pytest
@@ -47,7 +49,7 @@ def test_calibrate_attach_defaults_ignores_missing_semantic_scores() -> None:
 
     assert summary.semantic_score_percentiles == {}
     assert summary.final_weight_percentiles[50] == pytest.approx(0.4)
-    assert summary.recommended_min_semantic_score == pytest.approx(0.75)
+    assert summary.recommended_min_semantic_score == pytest.approx(0.80)
     assert summary.recommended_max_edges_per_node == 1
 
 
@@ -172,7 +174,14 @@ def test_main_attach_writes_idempotent_overlay_used_by_resolver(tmp_path) -> Non
 
     assert overlay.read_text(encoding="utf-8").count("\n") == 1
     assert loaded.has_edge("skill:new-python", "skill:python-testing")
-    assert loaded.edges["skill:new-python", "skill:python-testing"]["semantic_sim"] == pytest.approx(1.0)
+    edge = loaded.edges["skill:new-python", "skill:python-testing"]
+    assert edge["semantic_sim"] == pytest.approx(1.0)
+    assert edge["type_affinity"] == pytest.approx(0.35)
+    assert edge["score_components"] == {
+        "semantic": pytest.approx(0.7),
+        "type_affinity": pytest.approx(0.0105),
+    }
+    assert edge["final_weight"] == pytest.approx(0.7105)
 
     changed_args = [
         "attach",
@@ -194,3 +203,32 @@ def test_main_attach_writes_idempotent_overlay_used_by_resolver(tmp_path) -> Non
     assert overlay.read_text(encoding="utf-8").count("\n") == 2
     assert loaded_after_change.has_edge("skill:new-python", "skill:ruby-testing")
     assert not loaded_after_change.has_edge("skill:new-python", "skill:python-testing")
+
+
+def test_main_attach_default_min_score_matches_build_floor(tmp_path) -> None:
+    index_dir = tmp_path / "vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-a",
+        node_ids=["skill:almost-python"],
+        content_hashes=["ha"],
+        vectors=np.asarray([[0.76, 0.65]], dtype="float32"),
+    ).save(index_dir)
+    overlay = tmp_path / "entity-overlays.jsonl"
+
+    assert main([
+        "attach",
+        "--index-dir", str(index_dir),
+        "--overlay", str(overlay),
+        "--node-id", "skill:new-python",
+        "--label", "new-python",
+        "--type", "skill",
+        "--text", "new python testing helper",
+        "--model-id", "model-a",
+        "--vector-json", "[1.0, 0.0]",
+        "--top-k", "1",
+    ]) == 0
+
+    payload = json.loads(overlay.read_text(encoding="utf-8"))
+    assert payload["edges"][0]["target"] == "skill:almost-python"
+    assert payload["edges"][0]["semantic_sim"] == pytest.approx(0.76, abs=0.001)

src/tests/test_inject_hooks_security.py

@@ -21,8 +21,8 @@ _SRC = Path(__file__).resolve().parent.parent
 if str(_SRC) not in sys.path:
     sys.path.insert(0, str(_SRC))
 
-from ctx.adapters.claude_code import inject_hooks  # noqa: E402
-from ctx.adapters.claude_code.inject_hooks import make_hooks, merge_hooks, write_settings_atomic  # noqa: E402
+from ctx.adapters.claude_code import inject_hooks  # noqa: E402
+from ctx.adapters.claude_code.inject_hooks import make_hooks, merge_hooks, write_settings_atomic  # noqa: E402
 
 
 # ---------------------------------------------------------------------------
@@ -128,6 +128,29 @@ class TestNoShellInjectionVars:
             f"{cmds_with_stdin}"
         )
 
+    def test_merge_hooks_repairs_partial_posttooluse_matcher(
+        self,
+        tmp_path: Path,
+    ) -> None:
+        new_hooks = make_hooks(str(tmp_path / "ctx"))
+        existing = {
+            "hooks": {
+                "PostToolUse": [
+                    {
+                        "matcher": ".*",
+                        "hooks": [new_hooks["PostToolUse"][0]["hooks"][0]],
+                    },
+                ],
+            },
+        }
+
+        merged = merge_hooks(existing, new_hooks)
+
+        commands = _all_commands({"PostToolUse": merged["hooks"]["PostToolUse"]})
+        assert any("context_monitor" in command for command in commands)
+        assert any("skill_add_detector" in command for command in commands)
+        assert any("bundle_orchestrator" in command for command in commands)
+
 
 # ---------------------------------------------------------------------------
 # Fix 2 — Stop array contains both usage_tracker and quality_on_session_end
@@ -199,7 +222,7 @@ class TestStopHooks:
 # ---------------------------------------------------------------------------
 
 
-class TestCtxDirQuoting:
+class TestCtxDirQuoting:
     def test_path_with_spaces_is_quoted(self, tmp_path: Path) -> None:
         ctx_dir = str(tmp_path / "my ctx dir")
         hooks = make_hooks(ctx_dir)
@@ -213,35 +236,35 @@ class TestCtxDirQuoting:
                     f"Path with space is not quoted in: {cmd!r}"
                 )
 
-    def test_path_with_dollar_is_safe(self, tmp_path: Path) -> None:
-        """A ctx_dir with a literal $ must be quoted so the shell doesn't expand it."""
-        import shlex as _shlex
-        ctx_dir = "/home/user/$HOME/ctx"
+    def test_path_with_dollar_is_safe(self, tmp_path: Path) -> None:
+        """A ctx_dir with a literal $ must be quoted so the shell doesn't expand it."""
+        import shlex as _shlex
+        ctx_dir = "/home/user/$HOME/ctx"
         hooks = make_hooks(ctx_dir)
         cmds = _all_commands(hooks)
         quoted = _shlex.quote(ctx_dir)
         for cmd in cmds:
             if ctx_dir in cmd or quoted in cmd:
                 # The raw unquoted path must not appear unless it's the quoted form
-                assert f" {ctx_dir}/" not in cmd, (
-                    f"Unquoted $ path found in: {cmd!r}"
-                )
-
-    def test_windows_python_path_with_spaces_uses_windows_quoting(
-        self,
-        monkeypatch: pytest.MonkeyPatch,
-    ) -> None:
-        monkeypatch.setattr(
-            inject_hooks.sys,
-            "executable",
-            r"C:\Program Files\Python311\python.exe",
-        )
-        monkeypatch.setattr(inject_hooks.os, "name", "nt")
-
-        cmd = inject_hooks._module_cmd("usage_tracker", "--sync")
-
-        assert cmd == r'"C:\Program Files\Python311\python.exe" -m usage_tracker --sync'
-        assert "'" not in cmd
+                assert f" {ctx_dir}/" not in cmd, (
+                    f"Unquoted $ path found in: {cmd!r}"
+                )
+
+    def test_windows_python_path_with_spaces_uses_windows_quoting(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setattr(
+            inject_hooks.sys,
+            "executable",
+            r"C:\Program Files\Python311\python.exe",
+        )
+        monkeypatch.setattr(inject_hooks.os, "name", "nt")
+
+        cmd = inject_hooks._module_cmd("usage_tracker", "--sync")
+
+        assert cmd == r'"C:\Program Files\Python311\python.exe" -m usage_tracker --sync'
+        assert "'" not in cmd
 
 
 class TestPackagedHookCommands:

src/tests/test_kpi_dashboard.py

@@ -193,6 +193,66 @@ class TestCollectRows:
             ("filesystem", "mcp-server")
         ]
 
+    def test_mcp_rows_do_not_probe_skill_or_agent_sources(
+        self, sources: cl.LifecycleSources, monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        _write_quality(
+            sources.sidecar_dir / "mcp",
+            "filesystem",
+            subject_type="mcp-server",
+            grade="A",
+            score=0.88,
+        )
+
+        def fail_source_probe(*args: object, **kwargs: object) -> Path | None:
+            raise AssertionError("MCP rows should not stat skill/agent source paths")
+
+        monkeypatch.setattr(kd, "_skill_source_path", fail_source_probe)
+
+        rows = kd.collect_rows(sources=sources)
+
+        assert rows[0].category == "uncategorized"
+
+    def test_lifecycle_only_mcp_keeps_subject_type(
+        self, sources: cl.LifecycleSources,
+    ) -> None:
+        _write_lifecycle(
+            sources.sidecar_dir,
+            "filesystem",
+            subject_type="mcp-server",
+            state=cl.STATE_ARCHIVE,
+        )
+
+        rows = kd.collect_rows(sources=sources)
+
+        assert [(r.slug, r.subject_type, r.lifecycle_state) for r in rows] == [
+            ("filesystem", "mcp-server", cl.STATE_ARCHIVE)
+        ]
+
+    def test_lifecycle_only_mcp_is_not_dropped_by_same_slug_skill_quality(
+        self, sources: cl.LifecycleSources,
+    ) -> None:
+        _write_quality(
+            sources.sidecar_dir,
+            "langgraph",
+            subject_type="skill",
+            grade="B",
+            score=0.65,
+        )
+        _write_lifecycle(
+            sources.sidecar_dir,
+            "langgraph",
+            subject_type="mcp-server",
+            state=cl.STATE_ARCHIVE,
+        )
+
+        rows = kd.collect_rows(sources=sources)
+
+        assert sorted((r.slug, r.subject_type, r.grade, r.lifecycle_state) for r in rows) == [
+            ("langgraph", "mcp-server", "", cl.STATE_ARCHIVE),
+            ("langgraph", "skill", "B", cl.STATE_ACTIVE),
+        ]
+
     def test_duplicate_skill_and_mcp_slugs_are_distinct_rows(
         self, sources: cl.LifecycleSources,
     ) -> None:

src/tests/test_mcp_add.py

@@ -272,6 +272,8 @@ class TestAddMcpExistingReview:
         assert result["merged_sources"] == ["awesome-mcp", "pulsemcp"]
         assert fm["sources"] == ["awesome-mcp", "pulsemcp"]
         assert fm["description"] == record_b.description
+        assert record_b.description in text
+        assert "- pulsemcp" in text
 
 
 # ---------------------------------------------------------------------------

src/tests/test_mcp_install.py

@@ -274,6 +274,28 @@ class TestInstallMcp:
         )
         assert r.status == "skipped-existing"
 
+    def test_already_installed_reconciles_missing_manifest(
+        self,
+        wiki_dir: Path,
+        isolated_manifest: Path,
+    ) -> None:
+        _write_entity(
+            wiki_dir,
+            "gh",
+            {"status": "installed", "install_cmd": "npx -y old-pkg"},
+        )
+
+        r = mcp_install.install_mcp("gh", wiki_dir=wiki_dir, auto=True)
+
+        assert r.status == "skipped-existing"
+        manifest = install_utils.load_manifest()
+        assert manifest["load"] == [{
+            "skill": "gh",
+            "entity_type": "mcp-server",
+            "source": "ctx-mcp-install",
+            "command": "npx -y old-pkg",
+        }]
+
     def test_force_overrides_skip(
         self,
         wiki_dir: Path,
@@ -287,6 +309,41 @@ class TestInstallMcp:
         )
         assert r.status == "installed"
 
+    def test_force_reinstall_updates_existing_manifest_command(
+        self,
+        wiki_dir: Path,
+        fake_claude: dict[str, Any],
+        isolated_manifest: Path,
+    ) -> None:
+        _write_entity(
+            wiki_dir,
+            "gh",
+            {"status": "installed", "install_cmd": "npx -y old-pkg"},
+        )
+        install_utils.record_install(
+            "gh",
+            entity_type="mcp-server",
+            source="ctx-mcp-install",
+            extra={"command": "npx -y old-pkg"},
+        )
+
+        r = mcp_install.install_mcp(
+            "gh",
+            wiki_dir=wiki_dir,
+            command="npx -y new-pkg",
+            auto=True,
+            force=True,
+        )
+
+        assert r.status == "installed"
+        manifest = install_utils.load_manifest()
+        assert manifest["load"] == [{
+            "skill": "gh",
+            "entity_type": "mcp-server",
+            "source": "ctx-mcp-install",
+            "command": "npx -y new-pkg",
+        }]
+
     def test_no_command_no_json(self, wiki_dir: Path) -> None:
         _write_entity(wiki_dir, "gh", {"status": "cataloged"})
         r = mcp_install.install_mcp("gh", wiki_dir=wiki_dir, auto=True)
@@ -395,6 +452,38 @@ class TestInstallMcp:
             "two words",
         ]
 
+    @pytest.mark.parametrize("cmd", ["npx.cmd -y pkg", "python.exe server.py"])
+    def test_windows_wrapper_executables_are_allowlisted(
+        self,
+        wiki_dir: Path,
+        fake_claude: dict[str, Any],
+        isolated_manifest: Path,
+        cmd: str,
+    ) -> None:
+        _write_entity(wiki_dir, "srv", {"status": "cataloged"})
+
+        r = mcp_install.install_mcp("srv", wiki_dir=wiki_dir, command=cmd, auto=True)
+
+        assert r.status == "installed"
+
+    def test_windows_wrapper_still_rejects_code_execution_args(
+        self,
+        wiki_dir: Path,
+        fake_claude: dict[str, Any],
+        isolated_manifest: Path,
+    ) -> None:
+        _write_entity(wiki_dir, "srv", {"status": "cataloged"})
+
+        r = mcp_install.install_mcp(
+            "srv",
+            wiki_dir=wiki_dir,
+            command='python.exe -c "print(1)"',
+            auto=True,
+        )
+
+        assert r.status == "invalid-cmd"
+        assert fake_claude["calls"] == []
+
     # Strix vuln-0002 regression: even when the first token is allowlisted,
     # code-execution argument forms must be rejected. A tampered frontmatter
     # install_cmd could otherwise invoke arbitrary interpreter-controlled
@@ -451,6 +540,47 @@ class TestInstallMcp:
             f"legitimate launcher {cmd!r} falsely rejected (msg={r.message})"
         )
 
+    @pytest.mark.parametrize(
+        "cmd",
+        [
+            "npx -y pkg GITHUB_TOKEN=ghp_supersecret123456789012345",
+            "npx -y pkg --api-key sk-supersecret123456789012345",
+            "npx -y pkg --client-secret=plain-secret-value",
+        ],
+    )
+    def test_install_cmd_rejects_inline_secret_arguments(
+        self,
+        wiki_dir: Path,
+        fake_claude: dict[str, Any],
+        isolated_manifest: Path,
+        cmd: str,
+    ) -> None:
+        _write_entity(wiki_dir, "srv", {"status": "cataloged"})
+
+        r = mcp_install.install_mcp("srv", wiki_dir=wiki_dir, command=cmd, auto=True)
+
+        assert r.status == "invalid-cmd"
+        assert "inline secret" in r.message
+        assert fake_claude["calls"] == []
+
+    def test_install_cmd_allows_secret_env_reference(
+        self,
+        wiki_dir: Path,
+        fake_claude: dict[str, Any],
+        isolated_manifest: Path,
+    ) -> None:
+        _write_entity(wiki_dir, "srv", {"status": "cataloged"})
+
+        r = mcp_install.install_mcp(
+            "srv",
+            wiki_dir=wiki_dir,
+            command="npx -y pkg --api-key $API_KEY",
+            auto=True,
+        )
+
+        assert r.status == "installed"
+        assert fake_claude["calls"]
+
     def test_empty_command_tokens_rejected(
         self, wiki_dir: Path, fake_claude: dict[str, Any], isolated_manifest: Path
     ) -> None:
@@ -620,13 +750,47 @@ class TestUninstallMcp:
         assert r.status == "not-installed"
 
     def test_not_installed_short_circuits(
-        self, wiki_dir: Path, fake_claude: dict[str, Any]
+        self,
+        wiki_dir: Path,
+        fake_claude: dict[str, Any],
+        isolated_manifest: Path,
     ) -> None:
         _write_entity(wiki_dir, "gh", {"status": "cataloged"})
         r = mcp_install.uninstall_mcp("gh", wiki_dir=wiki_dir)
         assert r.status == "not-installed"
         assert fake_claude["calls"] == []
 
+    def test_manifest_loaded_cataloged_entity_can_uninstall(
+        self,
+        wiki_dir: Path,
+        fake_claude: dict[str, Any],
+        isolated_manifest: Path,
+    ) -> None:
+        entity = _write_entity(
+            wiki_dir,
+            "gh",
+            {"status": "cataloged", "install_cmd": "npx -y pkg"},
+        )
+        install_utils.record_install(
+            "gh",
+            entity_type="mcp-server",
+            source="ctx-mcp-install",
+            extra={"command": "npx -y pkg"},
+        )
+
+        result = mcp_install.uninstall_mcp("gh", wiki_dir=wiki_dir)
+
+        assert result.status == "uninstalled"
+        assert "status: cataloged" in entity.read_text(encoding="utf-8")
+        manifest = install_utils.load_manifest()
+        assert manifest["load"] == []
+        assert manifest["unload"] == [{
+            "skill": "gh",
+            "entity_type": "mcp-server",
+            "source": "ctx-mcp-uninstall",
+            "command": "npx -y pkg",
+        }]
+
     def test_dry_run(
         self, wiki_dir: Path, fake_claude: dict[str, Any]
     ) -> None:
@@ -847,6 +1011,7 @@ class TestInstallMain:
         self,
         wiki_dir: Path,
         fake_claude: dict[str, Any],
+        isolated_manifest: Path,
         monkeypatch: pytest.MonkeyPatch,
     ) -> None:
         _write_entity(wiki_dir, "gh", {"status": "cataloged"})

src/tests/test_overlay_wiki_entities.py

@@ -1,119 +1,172 @@
-from __future__ import annotations
-
-import json
-import sqlite3
-import tarfile
-from datetime import datetime, timezone
-from pathlib import Path
-
-from scripts.overlay_wiki_entities import overlay_entities
-
-
-def _add_text(tf: tarfile.TarFile, name: str, text: str) -> None:
-    data = text.encode("utf-8")
-    info = tarfile.TarInfo(name)
-    info.size = len(data)
-    info.mtime = 0
-    tf.addfile(info, __import__("io").BytesIO(data))
-
-
-def _read_json(tf: tarfile.TarFile, name: str) -> dict:
-    member = tf.getmember(name)
-    f = tf.extractfile(member)
-    assert f is not None
-    return json.loads(f.read().decode("utf-8"))
-
-
-def test_overlay_entities_preserves_existing_graph_and_adds_selected_pages(tmp_path: Path) -> None:
-    source_wiki = tmp_path / "wiki"
-    (source_wiki / "graphify-out").mkdir(parents=True)
-    (source_wiki / "entities" / "skills").mkdir(parents=True)
-    (source_wiki / "entities" / "harnesses").mkdir(parents=True)
-    skills_root = tmp_path / "skills"
-    (skills_root / "new-skill" / "references").mkdir(parents=True)
-    (source_wiki / "entities" / "skills" / "new-skill.md").write_text("# New skill\n")
-    (source_wiki / "entities" / "harnesses" / "new-harness.md").write_text("# Harness\n")
-    body = skills_root / "new-skill" / "SKILL.md"
-    body.write_text("# body\n", encoding="utf-8")
-    (skills_root / "new-skill" / "references" / "guide.md").write_text("# guide\n", encoding="utf-8")
-    source_graph = {
-        "graph": {"export_id": "source"},
-        "nodes": [
-            {"id": "skill:old", "label": "old", "type": "skill"},
-            {"id": "skill:new-skill", "label": "new", "type": "skill"},
-            {"id": "harness:new-harness", "label": "harness", "type": "harness"},
-        ],
-        "edges": [
-            {"source": "skill:old", "target": "skill:new-skill", "weight": 0.5},
-            {"source": "skill:old", "target": "harness:new-harness", "weight": 0.7},
-        ],
-    }
-    (source_wiki / "graphify-out" / "graph.json").write_text(json.dumps(source_graph))
-
-    tarball = tmp_path / "wiki-graph.tar.gz"
-    graph = {
-        "graph": {"export_id": "old"},
-        "nodes": [{"id": "skill:old", "label": "old", "type": "skill"}],
-        "edges": [{"source": "skill:old", "target": "skill:other", "weight": 0.1}],
-    }
-    communities = {
-        "export_id": "old",
-        "communities": {"0": {"label": "Core", "members": ["skill:old"]}},
-        "total_communities": 1,
-        "generated": "old",
-    }
-    manifest = {
-        "version": 1,
-        "export_id": "old",
-        "artifacts": {
-            "graph": "graph.json",
-            "delta": "graph-delta.json",
-            "communities": "communities.json",
-            "report": "graph-report.md",
-        },
-        "counts": {"nodes": 1, "edges": 1, "communities": 1},
-    }
-    with tarfile.open(tarball, "w:gz") as tf:
-        _add_text(tf, "./graphify-out/graph.json", json.dumps(graph))
-        _add_text(tf, "./graphify-out/communities.json", json.dumps(communities))
-        _add_text(tf, "./graphify-out/graph-delta.json", json.dumps({"version": 1, "export_id": "old"}))
-        _add_text(tf, "./graphify-out/graph-report.md", "> Export ID: old\n")
-        _add_text(tf, "./graphify-out/graph-export-manifest.json", json.dumps(manifest))
-        _add_text(tf, "./keep.md", "keep")
-
-    root_communities = tmp_path / "communities.json"
-    stats = overlay_entities(
-        source_wiki=source_wiki,
-        tarball=tarball,
-        entity_ids=["skill:new-skill", "harness:new-harness"],
-        skills_root=skills_root,
-        root_communities=root_communities,
-        now=datetime(2026, 5, 13, tzinfo=timezone.utc),
-    )
-
-    assert stats.node_count == 3
-    assert stats.edge_count == 3
-    assert stats.added_nodes == 2
-    assert stats.added_edges == 2
-    with tarfile.open(tarball, "r:gz") as tf:
-        graph_out = _read_json(tf, "./graphify-out/graph.json")
-        manifest_out = _read_json(tf, "./graphify-out/graph-export-manifest.json")
-        communities_out = _read_json(tf, "./graphify-out/communities.json")
-        assert graph_out["graph"]["export_id"] == stats.export_id
-        assert manifest_out["export_id"] == stats.export_id
-        assert communities_out["export_id"] == stats.export_id
-        assert tf.extractfile("./keep.md") is not None
-        assert tf.extractfile("./entities/skills/new-skill.md") is not None
-        assert tf.extractfile("./entities/harnesses/new-harness.md") is not None
-        assert tf.extractfile("./converted/new-skill/SKILL.md") is not None
-        assert tf.extractfile("./converted/new-skill/references/guide.md") is not None
-        index_member = tf.extractfile("./graphify-out/dashboard-neighborhoods.sqlite3")
-        assert index_member is not None
-        index_path = tmp_path / "dashboard-neighborhoods.sqlite3"
-        index_path.write_bytes(index_member.read())
-    with sqlite3.connect(index_path) as conn:
-        assert conn.execute(
-            "SELECT node_id FROM slug_index WHERE slug = ?",
-            ("new-skill",),
-        ).fetchone() == ("skill:new-skill",)
-    assert json.loads(root_communities.read_text())["export_id"] == stats.export_id
+from __future__ import annotations
+
+import json
+import sqlite3
+import subprocess
+import sys
+import tarfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+import pytest
+
+from scripts.overlay_wiki_entities import _entity_page, _skill_replacements, overlay_entities
+
+ROOT = Path(__file__).resolve().parents[2]
+
+
+def _add_text(tf: tarfile.TarFile, name: str, text: str) -> None:
+    data = text.encode("utf-8")
+    info = tarfile.TarInfo(name)
+    info.size = len(data)
+    info.mtime = 0
+    tf.addfile(info, __import__("io").BytesIO(data))
+
+
+def _read_json(tf: tarfile.TarFile, name: str) -> dict:
+    member = tf.getmember(name)
+    f = tf.extractfile(member)
+    assert f is not None
+    return json.loads(f.read().decode("utf-8"))
+
+
+def test_overlay_entities_preserves_existing_graph_and_adds_selected_pages(tmp_path: Path) -> None:
+    source_wiki = tmp_path / "wiki"
+    (source_wiki / "graphify-out").mkdir(parents=True)
+    (source_wiki / "entities" / "skills").mkdir(parents=True)
+    (source_wiki / "entities" / "harnesses").mkdir(parents=True)
+    skills_root = tmp_path / "skills"
+    (skills_root / "new-skill" / "references").mkdir(parents=True)
+    (source_wiki / "entities" / "skills" / "new-skill.md").write_text("# New skill\n")
+    (source_wiki / "entities" / "harnesses" / "new-harness.md").write_text("# Harness\n")
+    body = skills_root / "new-skill" / "SKILL.md"
+    body.write_text("# body\n", encoding="utf-8")
+    (skills_root / "new-skill" / "references" / "guide.md").write_text("# guide\n", encoding="utf-8")
+    source_graph = {
+        "graph": {"export_id": "source"},
+        "nodes": [
+            {"id": "skill:old", "label": "old", "type": "skill"},
+            {"id": "skill:new-skill", "label": "new", "type": "skill"},
+            {"id": "harness:new-harness", "label": "harness", "type": "harness"},
+        ],
+        "edges": [
+            {"source": "skill:old", "target": "skill:new-skill", "weight": 0.5},
+            {"source": "skill:old", "target": "harness:new-harness", "weight": 0.7},
+        ],
+    }
+    (source_wiki / "graphify-out" / "graph.json").write_text(json.dumps(source_graph))
+
+    tarball = tmp_path / "wiki-graph.tar.gz"
+    graph = {
+        "graph": {"export_id": "old"},
+        "nodes": [{"id": "skill:old", "label": "old", "type": "skill"}],
+        "edges": [{"source": "skill:old", "target": "skill:other", "weight": 0.1}],
+    }
+    communities = {
+        "export_id": "old",
+        "communities": {"0": {"label": "Core", "members": ["skill:old"]}},
+        "total_communities": 1,
+        "generated": "old",
+    }
+    manifest = {
+        "version": 1,
+        "export_id": "old",
+        "artifacts": {
+            "graph": "graph.json",
+            "delta": "graph-delta.json",
+            "communities": "communities.json",
+            "report": "graph-report.md",
+        },
+        "counts": {"nodes": 1, "edges": 1, "communities": 1},
+    }
+    with tarfile.open(tarball, "w:gz") as tf:
+        _add_text(tf, "./graphify-out/graph.json", json.dumps(graph))
+        _add_text(tf, "./graphify-out/communities.json", json.dumps(communities))
+        _add_text(tf, "./graphify-out/graph-delta.json", json.dumps({"version": 1, "export_id": "old"}))
+        _add_text(tf, "./graphify-out/graph-report.md", "> Export ID: old\n")
+        _add_text(tf, "./graphify-out/graph-export-manifest.json", json.dumps(manifest))
+        _add_text(tf, "./keep.md", "keep")
+
+    root_communities = tmp_path / "communities.json"
+    stats = overlay_entities(
+        source_wiki=source_wiki,
+        tarball=tarball,
+        entity_ids=["skill:new-skill", "harness:new-harness"],
+        skills_root=skills_root,
+        root_communities=root_communities,
+        now=datetime(2026, 5, 13, tzinfo=timezone.utc),
+    )
+
+    assert stats.node_count == 3
+    assert stats.edge_count == 3
+    assert stats.added_nodes == 2
+    assert stats.added_edges == 2
+    with tarfile.open(tarball, "r:gz") as tf:
+        graph_out = _read_json(tf, "./graphify-out/graph.json")
+        manifest_out = _read_json(tf, "./graphify-out/graph-export-manifest.json")
+        communities_out = _read_json(tf, "./graphify-out/communities.json")
+        assert graph_out["graph"]["export_id"] == stats.export_id
+        assert manifest_out["export_id"] == stats.export_id
+        assert communities_out["export_id"] == stats.export_id
+        assert tf.extractfile("./keep.md") is not None
+        assert tf.extractfile("./entities/skills/new-skill.md") is not None
+        assert tf.extractfile("./entities/harnesses/new-harness.md") is not None
+        assert tf.extractfile("./converted/new-skill/SKILL.md") is not None
+        assert tf.extractfile("./converted/new-skill/references/guide.md") is not None
+        index_member = tf.extractfile("./graphify-out/dashboard-neighborhoods.sqlite3")
+        assert index_member is not None
+        index_path = tmp_path / "dashboard-neighborhoods.sqlite3"
+        index_path.write_bytes(index_member.read())
+    with sqlite3.connect(index_path) as conn:
+        assert conn.execute(
+            "SELECT node_id FROM slug_index WHERE slug = ?",
+            ("new-skill",),
+        ).fetchone() == ("skill:new-skill",)
+    assert json.loads(root_communities.read_text())["export_id"] == stats.export_id
+
+
+def test_script_direct_invocation_help_works() -> None:
+    proc = subprocess.run(
+        [sys.executable, str(ROOT / "scripts" / "overlay_wiki_entities.py"), "--help"],
+        cwd=str(ROOT),
+        capture_output=True,
+        text=True,
+        check=False,
+        timeout=30,
+    )
+
+    assert proc.returncode == 0
+    assert "Overlay explicit local wiki entities" in proc.stdout
+
+
+def test_overlay_rejects_symlinked_entity_page(tmp_path: Path) -> None:
+    source_wiki = tmp_path / "wiki"
+    (source_wiki / "entities" / "skills").mkdir(parents=True)
+    outside = tmp_path / "outside.md"
+    outside.write_text("secret", encoding="utf-8")
+    link = source_wiki / "entities" / "skills" / "new-skill.md"
+    try:
+        link.symlink_to(outside)
+    except OSError as exc:
+        pytest.skip(f"symlinks unavailable in this environment: {exc}")
+
+    with pytest.raises(ValueError, match="symlinked path"):
+        _entity_page(source_wiki, "skill", "new-skill")
+
+
+def test_overlay_rejects_symlinked_skill_reference(tmp_path: Path) -> None:
+    source_wiki = tmp_path / "wiki"
+    skills_root = tmp_path / "skills"
+    skill_dir = skills_root / "new-skill"
+    (skill_dir / "references").mkdir(parents=True)
+    (skill_dir / "SKILL.md").write_text("# body\n", encoding="utf-8")
+    outside = tmp_path / "outside.md"
+    outside.write_text("secret", encoding="utf-8")
+    link = skill_dir / "references" / "leak.md"
+    try:
+        link.symlink_to(outside)
+    except OSError as exc:
+        pytest.skip(f"symlinks unavailable in this environment: {exc}")
+
+    with pytest.raises(ValueError, match="symlinked path"):
+        _skill_replacements(source_wiki, "new-skill", skills_root=skills_root)

src/update_repo_stats.py

@@ -6,10 +6,11 @@ Run by the pre-commit hook so README/docs badges and inline counts never drift
 from reality. Reads only committed files and a live pytest collection.
 
 Sources of truth:
-  - graph/communities.json      -> total_communities
-  - ~/.claude/skill-wiki/graphify-out/graph.json  -> nodes, edges, skill/agent counts
-  - ~/.claude/skill-wiki/entities/{skills,agents}/  -> fallback entity counts
-  - pytest --collect-only -q    -> collected test count
+  - graph/wiki-graph.tar.gz              -> graph/report/entity counts
+  - graph/wiki-graph-runtime.tar.gz      -> runtime graph/report counts
+  - graph/communities.json               -> current community export
+  - graph/skills-sh-catalog.json.gz      -> hydrated skill body counts
+  - pytest --collect-only -q             -> collected test count
 
 Usage:
   python src/update_repo_stats.py          # patch README/docs in place
@@ -25,11 +26,13 @@ import re
 import subprocess
 import sys
 import tarfile
+from collections.abc import Mapping
 from pathlib import Path
 
 REPO_ROOT = Path(__file__).resolve().parent.parent
 README = REPO_ROOT / "README.md"
 DOCS_INDEX = REPO_ROOT / "docs" / "index.md"
+DOCS_KNOWLEDGE_GRAPH = REPO_ROOT / "docs" / "knowledge-graph.md"
 _MAX_TAR_JSON_BYTES = 512 * 1024 * 1024
 _MAX_TAR_TEXT_BYTES = 2 * 1024 * 1024
 _GRAPH_JSON_MEMBER = "graphify-out/graph.json"
@@ -115,6 +118,63 @@ def _parse_graph_report(text: str) -> dict[str, int]:
     }
 
 
+def _read_edge_source_stats(tf: tarfile.TarFile) -> dict[str, int]:
+    matches = [
+        member for member in tf.getmembers() if _safe_tar_name(member.name) == _GRAPH_JSON_MEMBER
+    ]
+    if len(matches) != 1 or not matches[0].isfile():
+        return {}
+    graph_stream = tf.extractfile(matches[0])
+    if graph_stream is None:
+        return {}
+    try:
+        graph = json.load(graph_stream)
+    except json.JSONDecodeError:
+        return {}
+    finally:
+        graph_stream.close()
+    edges = graph.get("edges", []) if isinstance(graph, dict) else []
+    totals = {
+        "semantic_edges": 0,
+        "tag_edges": 0,
+        "token_edges": 0,
+        "hydrated_incident_edges": 0,
+        "hydrated_semantic_incident_edges": 0,
+        "cross_skill_agent_edges": 0,
+        "cross_skill_mcp_edges": 0,
+        "cross_agent_mcp_edges": 0,
+        "harness_edges": 0,
+    }
+    for edge in edges:
+        if not isinstance(edge, dict):
+            continue
+        source = str(edge.get("source") or "")
+        target = str(edge.get("target") or "")
+        semantic = float(edge.get("semantic_sim") or 0.0) != 0.0
+        if semantic:
+            totals["semantic_edges"] += 1
+        if float(edge.get("tag_sim") or 0.0) != 0.0:
+            totals["tag_edges"] += 1
+        if float(edge.get("token_sim") or 0.0) != 0.0:
+            totals["token_edges"] += 1
+        if "skills-sh-" in source or "skills-sh-" in target:
+            totals["hydrated_incident_edges"] += 1
+            if semantic:
+                totals["hydrated_semantic_incident_edges"] += 1
+        source_type = source.split(":", 1)[0]
+        target_type = target.split(":", 1)[0]
+        edge_types = {source_type, target_type}
+        if edge_types == {"skill", "agent"}:
+            totals["cross_skill_agent_edges"] += 1
+        elif edge_types == {"skill", "mcp-server"}:
+            totals["cross_skill_mcp_edges"] += 1
+        elif edge_types == {"agent", "mcp-server"}:
+            totals["cross_agent_mcp_edges"] += 1
+        if source_type == "harness" or target_type == "harness":
+            totals["harness_edges"] += 1
+    return totals
+
+
 def _read_skills_sh_catalog_stats() -> dict[str, int]:
     catalog_path = REPO_ROOT / "graph" / "skills-sh-catalog.json.gz"
     if not catalog_path.exists():
@@ -233,6 +293,7 @@ def _read_graph_from_tarball() -> dict[str, int | None] | None:
                 for key in ("nodes", "edges", "communities"):
                     if key in parsed:
                         stats[key] = parsed[key]
+                stats.update(_read_edge_source_stats(tf))
 
             if stats["nodes"] is None or stats["edges"] is None:
                 body = _read_json_member(tf, _GRAPH_JSON_MEMBER)
@@ -425,7 +486,11 @@ def format_edges(n: int) -> str:
     return str(n)
 
 
-def build_replacements(stats: dict, tests: int | None, converted: int | None) -> list[tuple[re.Pattern, str]]:
+def build_replacements(
+    stats: Mapping[str, int | None],
+    tests: int | None,
+    converted: int | None,
+) -> list[tuple[re.Pattern, str]]:
     """Return (regex, replacement) pairs for every stat."""
     reps: list[tuple[re.Pattern, str]] = []
 
@@ -446,6 +511,16 @@ def build_replacements(stats: dict, tests: int | None, converted: int | None) ->
                 f"{stats['mcps']:,} MCP servers, and "
                 f"{stats['harnesses']:,} harnesses**",
             ))
+            reps.append((
+                re.compile(
+                    r"\*\*[\d,]+\s+skill pages,\s+[\d,]+\s+agents,\s+"
+                    r"[\d,]+\s+MCP\s+servers,\s+and\s+[\d,]+\s+"
+                    r"(?:cataloged\s+)?harnesses\*\*"
+                ),
+                f"**{s:,} skill pages, {stats['agents']:,} agents, "
+                f"{stats['mcps']:,} MCP servers, and "
+                f"{stats['harnesses']:,} cataloged harnesses**",
+            ))
         # 3-type pattern: "1,789 skills, 464 agents, and 10,786 MCP servers"
         # Order matters — this regex is more specific than the 2-type one
         # below, so match it first. Handles the MCP-aware tagline that
@@ -491,6 +566,10 @@ def build_replacements(stats: dict, tests: int | None, converted: int | None) ->
             re.compile(r"\*\*[\d,]+-node\*\*\s+graph"),
             f"**{n:,}-node** graph",
         ))
+        reps.append((
+            re.compile(r"\*\*[\d,]+\s+graph nodes\*\*"),
+            f"**{n:,} graph nodes**",
+        ))
         # "A pre-built knowledge graph of 2,211 nodes and 642K edges"
         # style phrasing. Caught a stale v0.6.0 README sentence that
         # the older regex only matched on "nodes, edges, communities".
@@ -498,11 +577,23 @@ def build_replacements(stats: dict, tests: int | None, converted: int | None) ->
             re.compile(r"([\d,]+)\s+nodes\s+and\s+[\d,.]+[KM]?\s+edges"),
             f"{n:,} nodes and {e_fmt} edges",
         ))
+        reps.append((
+            re.compile(r"\(([\d,]+)\s+nodes,\s+[\d,]+\s+edges\)"),
+            f"({n:,} nodes, {e:,} edges)",
+        ))
+        reps.append((
+            re.compile(r"\*\*[\d,]+\s+nodes\s*/\s*[\d,]+\s+edges\s*/\s*[\d,]+\s+Louvain communities\*\*"),
+            f"**{n:,} nodes / {e:,} edges / {stats['communities']:,} Louvain communities**",
+        ))
         # Graph.json inline Python example: "# 2,211 nodes, 642,468 edges"
         reps.append((
             re.compile(r"#\s*([\d,]+)\s+nodes,\s*([\d,]+)\s+edges"),
             f"# {n:,} nodes, {e:,} edges",
         ))
+        reps.append((
+            re.compile(r"[\d,]+ weighted edges and [\d,]+ Louvain communities"),
+            f"{e:,} weighted edges and {stats['communities']:,} Louvain communities",
+        ))
         # "2,211 nodes, 642K edges, 865 communities"
         reps.append((re.compile(r"([\d,]+)\s+nodes,\s+[\w.]+\s+edges,\s+([\d,]+)\s+communities"),
                      f"{n:,} nodes, {e_fmt} edges, {stats['communities']:,} communities"))
@@ -520,9 +611,151 @@ def build_replacements(stats: dict, tests: int | None, converted: int | None) ->
                 f"**{n:,} entity pages** ({stats['skills']:,} skills + {stats['agents']:,} agents)",
             ))
 
-    if stats.get("skills_sh_entries") and stats.get("skills_sh_bodies"):
-        entries = int(stats["skills_sh_entries"])
-        bodies = int(stats["skills_sh_bodies"])
+        bodies_for_core = stats.get("skills_sh_bodies")
+        if (
+            bodies_for_core is not None
+            and stats.get("skills")
+            and stats.get("agents")
+            and stats.get("mcps")
+            and stats.get("harnesses")
+        ):
+            core_nodes = int(n) - int(bodies_for_core)
+            curated_skills = int(stats["skills"] or 0) - int(bodies_for_core)
+            reps.append((
+                re.compile(
+                    r"[\d,]+-node core plus [\d,]+ body-backed skill nodes"
+                ),
+                f"{core_nodes:,}-node core plus {int(bodies_for_core):,} "
+                "body-backed skill nodes",
+            ))
+            reps.append((
+                re.compile(
+                    r"[\d,]+ shipped graph nodes: [\d,]+ curated "
+                    r"skill/agent/MCP/harness\s+nodes plus [\d,]+ "
+                    r"body-backed skill nodes"
+                ),
+                f"{n:,} shipped graph nodes: {core_nodes:,} curated "
+                "skill/agent/MCP/harness nodes plus "
+                f"{int(bodies_for_core):,} body-backed skill nodes",
+            ))
+            reps.append((
+                re.compile(
+                    r"\*\*[\d,]+\*\* \([\d,]+ skills \+ [\d,]+ agents "
+                    r"\+ [\d,]+ MCP servers \+ [\d,]+ harnesses\)"
+                ),
+                f"**{core_nodes:,}** ({curated_skills:,} skills + "
+                f"{stats['agents']:,} agents + {stats['mcps']:,} MCP servers "
+                f"+ {stats['harnesses']:,} harnesses)",
+            ))
+            reps.append((
+                re.compile(r"including [\d,]+ skill pages"),
+                f"including {stats['skills']:,} skill pages",
+            ))
+            reps.append((
+                re.compile(
+                    r"is \*\*[\d,]+ nodes\*\* \([\d,]+ curated skills "
+                    r"\+ [\d,]+ agents \+ [\d,]+ MCP servers\s+\+ "
+                    r"[\d,]+ harnesses\)"
+                ),
+                f"is **{core_nodes:,} nodes** ({curated_skills:,} curated skills "
+                f"+ {stats['agents']:,} agents + {stats['mcps']:,} MCP servers "
+                f"+ {stats['harnesses']:,} harnesses)",
+            ))
+
+        table_values = {
+            "Total nodes": n,
+            "Total edges": e,
+            "Harness edges": stats.get("harness_edges"),
+        }
+        for label, value in table_values.items():
+            if value is not None:
+                reps.append((
+                    re.compile(rf"\| {re.escape(label)} \| \*\*[\d,]+\*\* \|"),
+                    f"| {label} | **{int(value):,}** |",
+                ))
+
+        if stats.get("semantic_edges") and stats.get("tag_edges") and stats.get("token_edges"):
+            reps.append((
+                re.compile(
+                    r"semantic [\d,]+ - tag [\d,]+ - token [\d,]+"
+                ),
+                f"semantic {stats['semantic_edges']:,} - "
+                f"tag {stats['tag_edges']:,} - token {stats['token_edges']:,}",
+            ))
+
+        for label, key in (
+            ("Hydrated skill incident edges", "hydrated_incident_edges"),
+            ("Hydrated skill semantic incident edges", "hydrated_semantic_incident_edges"),
+        ):
+            value = stats.get(key)
+            if value is not None:
+                reps.append((
+                    re.compile(rf"\| {re.escape(label)} \| \*\*?[\d,]+\*?\*? \|"),
+                    f"| {label} | **{int(value):,}** |",
+                ))
+
+        for label, key in (
+            ("Cross-type edges \\(skill <-> agent\\)", "cross_skill_agent_edges"),
+            ("Cross-type edges \\(skill <-> MCP\\)", "cross_skill_mcp_edges"),
+            ("Cross-type edges \\(agent <-> MCP\\)", "cross_agent_mcp_edges"),
+        ):
+            value = stats.get(key)
+            if value is not None:
+                display_label = label.replace("\\", "")
+                reps.append((
+                    re.compile(rf"\| {label} \| ~?[\d,.]+[KM]? \|"),
+                    f"| {display_label} | ~{int(value):,} |",
+                ))
+
+    skills_sh_entries = stats.get("skills_sh_entries")
+    skills_sh_bodies = stats.get("skills_sh_bodies")
+    if skills_sh_entries is not None and skills_sh_bodies is not None:
+        entries = int(skills_sh_entries)
+        bodies = int(skills_sh_bodies)
+        skill_pages = int(stats.get("skills") or entries)
+        reps.append((
+            re.compile(
+                r"\*\*[\d,]+\s+(?:skills|skill entity pages)\*\*"
+                r"(?:,\s+with\s+\*\*[\d,]+\*\*)?\s+hydrated installable "
+                r"`SKILL\.md` bodies\."
+            ),
+            f"**{skill_pages:,} skill entity pages**, with **{bodies:,}** "
+            "hydrated installable `SKILL.md` bodies.",
+        ))
+        reps.append((
+            re.compile(
+                r"[\d,]+ skill entity pages under `entities/skills/`, "
+                r"[\d,]+ hydrated"
+            ),
+            f"{skill_pages:,} skill entity pages under `entities/skills/`, "
+            f"{bodies:,} hydrated",
+        ))
+        reps.append((
+            re.compile(r"\*\*[\d,]+ skill pages\*\*; \*\*[\d,]+\*\*"),
+            f"**{skill_pages:,} skill pages**; **{bodies:,}**",
+        ))
+        reps.append((
+            re.compile(
+                r"\*\*[\d,]+\*\*\s+hydrated installable skill entries"
+            ),
+            f"**{bodies:,}** hydrated installable skill entries",
+        ))
+        reps.append((
+            re.compile(
+                r"\| Body-backed skill nodes \| \*\*[\d,]+\*\* "
+                r"hydrated installable skill entries \|"
+            ),
+            f"| Body-backed skill nodes | **{bodies:,}** "
+            "hydrated installable skill entries |",
+        ))
+        reps.append((
+            re.compile(r"\*\*[\d,]+\*\*\s+observed body-backed skill entries"),
+            f"**{bodies:,}** observed body-backed skill entries",
+        ))
+        reps.append((
+            re.compile(r"\*\*[\d,]+\*\*\s+have hydrated catalog bodies"),
+            f"**{bodies:,}** have hydrated catalog bodies",
+        ))
         reps.append((
             re.compile(
                 r"The shipped wiki includes [\d,]+(?: Skills\.sh)? entries, "
@@ -560,13 +793,19 @@ def build_replacements(stats: dict, tests: int | None, converted: int | None) ->
     return reps
 
 
-def build_docs_replacements(tests: int | None) -> list[tuple[re.Pattern[str], str]]:
+def build_docs_replacements(
+    stats: Mapping[str, int | None],
+    tests: int | None,
+    converted: int | None,
+) -> list[tuple[re.Pattern[str], str]]:
+    reps = build_replacements(stats, tests, converted)
     if tests is None:
-        return []
-    return [(
+        return reps
+    reps.append((
         re.compile(r"[\d,]+\s+tests collected"),
         f"{tests:,} tests collected",
-    )]
+    ))
+    return reps
 
 
 def patch_readme(check_only: bool = False) -> int:
@@ -579,12 +818,12 @@ def patch_readme(check_only: bool = False) -> int:
         print(f"warning: could not resolve {missing}; those fields will be left untouched", file=sys.stderr)
 
     changes: list[tuple[Path, str, str]] = []
-    for target in (README, DOCS_INDEX):
+    for target in (README, DOCS_INDEX, DOCS_KNOWLEDGE_GRAPH):
         if not target.exists():
             continue
         replacements = (
             build_replacements(stats, tests, converted)
-            if target == README else build_docs_replacements(tests)
+            if target == README else build_docs_replacements(stats, tests, converted)
         )
         original = target.read_text(encoding="utf-8")
         patched = original

src/validate_graph_artifacts.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 import argparse
 import gzip
 import json
+import math
 import re
 import sqlite3
 import tarfile
@@ -43,9 +44,45 @@ _PREVIEW_EXPORT_ID_RE = re.compile(
     r'<meta\s+name=["\']ctx-graph-export-id["\']\s+content=["\']([^"\']+)["\']',
     re.IGNORECASE,
 )
+_SKILL_BUNDLE_REF_RE = re.compile(
+    r"""(?:^|[\s`'"\[(])(?:\./)?"""
+    r"""((?:references|reference|resources|scripts|assets)/[^\s`'"\])<>]+)""",
+    re.IGNORECASE,
+)
+_SKILL_BUNDLE_REF_MARKERS = (
+    b"references/",
+    b"reference/",
+    b"resources/",
+    b"scripts/",
+    b"assets/",
+)
 _SEMANTIC_SIM_RE = re.compile(
     rb'"semantic_sim"\s*:\s*(-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)',
 )
+_EDGE_SCORE_VALUE_RE = re.compile(
+    rb'"(weight|final_weight|similarity_score|semantic_sim|tag_sim|token_sim)"'
+    rb'\s*:\s*("[^"]*"|-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)',
+)
+_SCORE_COMPONENTS_RE = re.compile(
+    rb'"score_components"\s*:\s*\{(?P<body>[^{}]*)\}',
+    re.DOTALL,
+)
+_SCORE_COMPONENT_VALUE_RE = re.compile(
+    rb'"[^"]+"\s*:\s*("[^"]*"|-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?)',
+)
+_EDGE_SEGMENT_RE = re.compile(
+    rb'"source"\s*:\s*"[^"]+"\s*,\s*"target"\s*:\s*"[^"]+"'
+    rb'(?P<body>.*?)(?=(?:\{\s*"source"\s*:)|(?:\]\s*(?:,|\})))',
+    re.DOTALL,
+)
+_EDGE_SCORE_FIELDS = (
+    "weight",
+    "final_weight",
+    "similarity_score",
+    "semantic_sim",
+    "tag_sim",
+    "token_sim",
+)
 _WINDOWS_DRIVE_RE = re.compile(r"^[A-Za-z]:")
 _PREVIEW_HTML_FILES = (
     "sample-top60.html",
@@ -54,6 +91,7 @@ _PREVIEW_HTML_FILES = (
     "viz-python.html",
     "viz-security.html",
 )
+_SCORE_COMPONENT_TOLERANCE = 0.001
 _GRAPH_RUNTIME_REQUIRED_NAMES = {
     "index.md",
     "graphify-out/graph.json",
@@ -122,6 +160,78 @@ def _load_gzip_json(path: Path) -> dict[str, Any]:
     return data
 
 
+def _validate_root_entity_overlay(path: Path) -> None:
+    records = 0
+    for lineno, raw_line in enumerate(path.read_text(encoding="utf-8").splitlines(), 1):
+        line = raw_line.strip()
+        if not line:
+            continue
+        try:
+            payload = json.loads(line)
+        except json.JSONDecodeError as exc:
+            raise GraphArtifactError(
+                f"graph/entity-overlays.jsonl line {lineno} is invalid JSON: {exc}",
+            ) from exc
+        if not isinstance(payload, dict):
+            raise GraphArtifactError(
+                f"graph/entity-overlays.jsonl line {lineno} must be a JSON object",
+            )
+        nodes = payload.get("nodes", [])
+        edges = payload.get("edges", [])
+        if not isinstance(nodes, list) or not isinstance(edges, list):
+            raise GraphArtifactError(
+                f"graph/entity-overlays.jsonl line {lineno} must contain nodes/edges lists",
+            )
+        for index, node in enumerate(nodes, 1):
+            if not isinstance(node, dict) or not isinstance(node.get("id"), str):
+                raise GraphArtifactError(
+                    f"graph/entity-overlays.jsonl line {lineno} node {index} "
+                    "must contain id",
+                )
+        for index, edge in enumerate(edges, 1):
+            if not isinstance(edge, dict):
+                raise GraphArtifactError(
+                    f"graph/entity-overlays.jsonl line {lineno} edge {index} "
+                    "must be an object",
+                )
+            if not isinstance(edge.get("source"), str) or not isinstance(
+                edge.get("target"), str
+            ):
+                raise GraphArtifactError(
+                    f"graph/entity-overlays.jsonl line {lineno} edge {index} "
+                    "must contain source/target",
+                )
+            numeric_scores: dict[str, float] = {}
+            for field in _EDGE_SCORE_FIELDS:
+                value = edge.get(field)
+                if value is not None and (
+                    not isinstance(value, int | float) or not 0 <= float(value) <= 1
+                ):
+                    raise GraphArtifactError(
+                        f"graph/entity-overlays.jsonl line {lineno} edge {index} "
+                        f"{field} must be 0..1",
+                    )
+                if value is not None:
+                    numeric_scores[field] = float(value)
+            if (
+                "weight" in numeric_scores
+                and "final_weight" in numeric_scores
+                and abs(numeric_scores["weight"] - numeric_scores["final_weight"]) > 1e-9
+            ):
+                raise GraphArtifactError(
+                    f"graph/entity-overlays.jsonl line {lineno} edge {index} "
+                    "weight must equal final_weight",
+                )
+            _validate_score_component_mapping(
+                edge.get("final_weight"),
+                edge.get("score_components"),
+                context=f"graph/entity-overlays.jsonl line {lineno} edge {index}",
+            )
+        records += 1
+    if records == 0:
+        raise GraphArtifactError("graph/entity-overlays.jsonl has no overlay records")
+
+
 def _require_real_file(path: Path) -> None:
     if not path.is_file() or path.stat().st_size == 0:
         raise GraphArtifactError(f"missing or empty graph artifact: {path}")
@@ -230,6 +340,29 @@ def _count_lines(payload: bytes) -> int:
     return len(payload.decode("utf-8", errors="replace").splitlines())
 
 
+def _is_converted_skill_page(name: str) -> bool:
+    return name.startswith("converted/") and name.endswith("/SKILL.md")
+
+
+def _iter_skill_bundle_refs(payload: bytes) -> list[str]:
+    lower_payload = payload.lower()
+    if not any(marker in lower_payload for marker in _SKILL_BUNDLE_REF_MARKERS):
+        return []
+    text = payload.decode("utf-8", errors="replace")
+    refs: set[str] = set()
+    for match in _SKILL_BUNDLE_REF_RE.finditer(text):
+        ref = match.group(1).replace("\\", "/")
+        ref = ref.split("#", 1)[0].split("?", 1)[0].rstrip(".,;:")
+        parts = ref.split("/")
+        if ref and all(part not in ("", ".", "..") for part in parts):
+            refs.add(ref)
+    return sorted(refs)
+
+
+def _skill_bundle_target_name(skill_page: str, ref: str) -> str:
+    return f"{skill_page.rsplit('/', 1)[0]}/{ref}"
+
+
 def _scan_graph_json(stream: IO[bytes]) -> tuple[int, int, int, int, int, str | None]:
     nodes = edges = semantic_edges = skills_sh_nodes = harness_nodes = 0
     export_id: str | None = None
@@ -238,6 +371,8 @@ def _scan_graph_json(stream: IO[bytes]) -> tuple[int, int, int, int, int, str |
     while chunk := stream.read(1024 * 1024):
         old_tail = tail
         data = tail + chunk
+        _validate_graph_edge_score_fields(data)
+        _validate_graph_edge_weight_drift(data)
         if export_id is None:
             graph_probe = (graph_probe + chunk)[-1024 * 1024:]
             export_id = _extract_graph_export_id(graph_probe)
@@ -255,7 +390,7 @@ def _scan_graph_json(stream: IO[bytes]) -> tuple[int, int, int, int, int, str |
             len(_HARNESS_TYPE_RE.findall(data))
             - len(_HARNESS_TYPE_RE.findall(old_tail))
         )
-        tail = data[-512:]
+        tail = data[-65536:]
     return nodes, edges, semantic_edges, skills_sh_nodes, harness_nodes, export_id
 
 
@@ -322,6 +457,135 @@ def _count_nonzero_semantic_matches(data: bytes) -> int:
     return count
 
 
+def _validate_graph_edge_score_fields(data: bytes) -> None:
+    for match in _EDGE_SCORE_VALUE_RE.finditer(data):
+        field = match.group(1).decode("ascii")
+        raw_value = match.group(2)
+        try:
+            value = float(raw_value)
+        except ValueError as exc:
+            raise GraphArtifactError(f"graph.json edge {field} must be numeric") from exc
+        if not math.isfinite(value):
+            raise GraphArtifactError(f"graph.json edge {field} must be finite")
+        if not 0 <= value <= 1:
+            raise GraphArtifactError(f"graph.json edge {field} must be 0..1")
+    _validate_graph_edge_score_objects(data)
+
+
+def _validate_graph_edge_score_objects(data: bytes) -> None:
+    try:
+        graph = json.loads(data)
+    except json.JSONDecodeError:
+        return
+    edges = graph.get("edges") if isinstance(graph, dict) else None
+    if not isinstance(edges, list):
+        return
+    for edge in edges:
+        if not isinstance(edge, dict):
+            continue
+        for field in _EDGE_SCORE_FIELDS:
+            if field not in edge:
+                continue
+            value = edge[field]
+            if not isinstance(value, int | float):
+                raise GraphArtifactError(f"graph.json edge {field} must be numeric")
+            numeric = float(value)
+            if not math.isfinite(numeric):
+                raise GraphArtifactError(f"graph.json edge {field} must be finite")
+            if not 0 <= numeric <= 1:
+                raise GraphArtifactError(f"graph.json edge {field} must be 0..1")
+
+
+def _validate_graph_edge_weight_drift(data: bytes) -> None:
+    for match in _EDGE_SEGMENT_RE.finditer(data):
+        edge = match.group(0)
+        values: dict[str, float] = {}
+        for field_match in _EDGE_SCORE_VALUE_RE.finditer(edge):
+            field = field_match.group(1).decode("ascii")
+            if field in {"weight", "final_weight"}:
+                values[field] = float(field_match.group(2))
+        if (
+            "weight" in values
+            and "final_weight" in values
+            and abs(values["weight"] - values["final_weight"]) > 1e-9
+        ):
+            raise GraphArtifactError("graph.json edge weight must equal final_weight")
+        if "final_weight" in values:
+            _validate_score_component_bytes(
+                edge,
+                final_weight=values["final_weight"],
+                context="graph.json edge",
+            )
+
+
+def _validate_score_component_mapping(
+    final_weight: object,
+    components: object,
+    *,
+    context: str,
+) -> None:
+    if components is None:
+        return
+    if not isinstance(final_weight, int | float) or not isinstance(components, dict):
+        raise GraphArtifactError(f"{context} score_components must sum to final_weight")
+    if not math.isfinite(float(final_weight)):
+        raise GraphArtifactError(f"{context} final_weight must be finite")
+    numeric_components: list[float] = []
+    for value in components.values():
+        if not isinstance(value, int | float):
+            raise GraphArtifactError(f"{context} score_components must be numeric")
+        numeric = float(value)
+        if not math.isfinite(numeric):
+            raise GraphArtifactError(f"{context} score_components must be finite")
+        if numeric < 0.0 or numeric > 1.0:
+            raise GraphArtifactError(f"{context} score_components must be 0..1")
+        numeric_components.append(numeric)
+    _validate_score_component_sum(
+        float(final_weight),
+        numeric_components,
+        context=context,
+    )
+
+
+def _validate_score_component_bytes(
+    edge: bytes,
+    *,
+    final_weight: float,
+    context: str,
+) -> None:
+    components_match = _SCORE_COMPONENTS_RE.search(edge)
+    if components_match is None:
+        return
+    raw_components = components_match.group("body")
+    component_values: list[float] = []
+    for field_match in _SCORE_COMPONENT_VALUE_RE.finditer(raw_components):
+        try:
+            component = float(field_match.group(1))
+        except ValueError as exc:
+            raise GraphArtifactError(f"{context} score_components must be numeric") from exc
+        if not math.isfinite(component):
+            raise GraphArtifactError(f"{context} score_components must be finite")
+        if component < 0.0 or component > 1.0:
+            raise GraphArtifactError(f"{context} score_components must be 0..1")
+        component_values.append(component)
+    if not component_values:
+        raise GraphArtifactError(f"{context} score_components must sum to final_weight")
+    _validate_score_component_sum(final_weight, component_values, context=context)
+
+
+def _validate_score_component_sum(
+    final_weight: float,
+    component_values: list[float],
+    *,
+    context: str,
+) -> None:
+    if not math.isfinite(final_weight):
+        raise GraphArtifactError(f"{context} final_weight must be finite")
+    component_total = min(sum(component_values), 1.0)
+    if abs(component_total - final_weight) > _SCORE_COMPONENT_TOLERANCE:
+        raise GraphArtifactError(f"{context} score_components must sum to final_weight")
+
+
 def _catalog_skills(catalog: dict[str, Any]) -> list[dict[str, Any]]:
     raw = catalog.get("skills", [])
     return [item for item in raw if isinstance(item, dict)]
@@ -355,7 +619,8 @@ def validate_graph_artifacts(
     runtime_tarball = graph_dir / "wiki-graph-runtime.tar.gz"
     catalog_path = graph_dir / "skills-sh-catalog.json.gz"
     communities_path = graph_dir / "communities.json"
-    for path in (tarball, runtime_tarball, catalog_path, communities_path):
+    overlay_path = graph_dir / "entity-overlays.jsonl"
+    for path in (tarball, runtime_tarball, catalog_path, communities_path, overlay_path):
         _require_real_file(path)
 
     expected_harnesses = DEFAULT_HARNESSES if expected_harnesses is None else expected_harnesses
@@ -363,6 +628,7 @@ def validate_graph_artifacts(
         runtime_tarball,
         expected_harnesses=expected_harnesses,
     )
+    _validate_root_entity_overlay(overlay_path)
     catalog = _load_gzip_json(catalog_path)
     root_communities = _load_json(communities_path)
     if not isinstance(root_communities, dict):
@@ -397,6 +663,7 @@ def validate_graph_artifacts(
     manifest: dict[str, Any] | None = None
     archive_communities: dict[str, Any] | None = None
     dashboard_index_path: Path | None = None
+    skill_bundle_refs: list[tuple[str, str, str]] = []
 
     with tarfile.open(tarball, "r:gz") as tf:
         for member in tf:
@@ -422,6 +689,20 @@ def validate_graph_artifacts(
                 harness_pages += 1
             if name.startswith("converted/skills-sh-") and name.endswith("/SKILL.md"):
                 skills_sh_converted += 1
+            if member.isfile() and _is_converted_skill_page(name):
+                f = tf.extractfile(member)
+                if f is None:
+                    raise GraphArtifactError(f"{member.name} could not be read")
+                payload = f.read()
+                for ref in _iter_skill_bundle_refs(payload):
+                    skill_bundle_refs.append((name, ref, _skill_bundle_target_name(name, ref)))
+                if deep and name.startswith("converted/skills-sh-"):
+                    lines = _count_lines(payload)
+                    if lines > line_threshold:
+                        raise GraphArtifactError(
+                            f"{member.name} has {lines} lines, above limit {line_threshold}",
+                        )
+                continue
             if member.isfile() and name == "graphify-out/graph.json":
                 f = tf.extractfile(member)
                 if f is None:
@@ -478,6 +759,18 @@ def validate_graph_artifacts(
                             f"{member.name} has {lines} lines, above limit {limit}",
                         )
 
+    missing_bundle_refs = [
+        (skill_page, ref, target)
+        for skill_page, ref, target in skill_bundle_refs
+        if target not in names
+    ]
+    if missing_bundle_refs:
+        sample = "; ".join(
+            f"{skill_page} references {ref} but {target} is absent"
+            for skill_page, ref, target in missing_bundle_refs[:5]
+        )
+        raise GraphArtifactError(f"missing bundled skill file: {sample}")
+
     required_names = _GRAPH_RUNTIME_REQUIRED_NAMES
     missing_required = sorted(required_names - names)
     if missing_required: