Sync ctx 03af985 (part 3)

GitHub commit: 03af985401f8dd95b559ecb86c10322a86d14af5

src/link_conversions.py

@@ -22,6 +22,7 @@ from dataclasses import dataclass, field
 from datetime import datetime, timezone
 from pathlib import Path
 
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_active_wiki_overlay_pack
 from ctx_config import cfg
 from ctx.core.wiki.wiki_utils import get_field as _find_field
 
@@ -58,6 +59,36 @@ _FM_PATTERN = re.compile(r"^---\r?\n(.*?\r?\n)---\r?\n", re.DOTALL)
 _FIELD_PATTERN_TMPL = r"^{key}:\s*(.+)$"
 
 
+def _read_wiki_page(wiki: Path, relpath: str) -> str | None:
+    """Read a wiki page from active packs when installed, else from disk."""
+    packs_dir = wiki / "wiki-packs"
+    path = wiki / relpath
+    if packs_dir.is_dir():
+        pages = load_merged_wiki_pages(packs_dir)
+        if relpath in pages:
+            return pages[relpath]
+        if path.exists():
+            return path.read_text(encoding="utf-8", errors="replace")
+        return None
+    if not path.exists():
+        return None
+    return path.read_text(encoding="utf-8", errors="replace")
+
+
+def _write_wiki_page(wiki: Path, relpath: str, content: str) -> None:
+    """Write a wiki page, mirroring into overlay packs when installed."""
+    packs_dir = wiki / "wiki-packs"
+    path = wiki / relpath
+    if path.exists() or not packs_dir.is_dir():
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(content, encoding="utf-8")
+    if packs_dir.is_dir():
+        write_active_wiki_overlay_pack(
+            packs_dir=packs_dir,
+            pages={relpath: content},
+            tombstones=[],
+        )
+
 
 def _set_field(content: str, key: str, value: str) -> str:
     """Set or add a frontmatter field. Adds before the closing --- if not present."""
@@ -202,13 +233,15 @@ def upsert_entity_page(
     skills_dir: Path,
 ) -> bool:
     """Create or update a skill entity page. Returns True if a new page was created."""
-    page_path = wiki / "entities" / "skills" / f"{skill.name}.md"
-    is_new = not page_path.exists()
+    relpath = f"entities/skills/{skill.name}.md"
+    existing = _read_wiki_page(wiki, relpath)
 
-    if is_new:
+    if existing is None:
+        is_new = True
         content = _build_new_entity_page(skill, skills_dir)
     else:
-        content = page_path.read_text(encoding="utf-8", errors="replace")
+        is_new = False
+        content = existing
         content = _inject_pipeline_fields(content, skill.pipeline_path)
         # Bump updated date
         old_updated = _find_field(content, "updated")
@@ -220,7 +253,7 @@ def upsert_entity_page(
                 flags=re.MULTILINE,
             )
 
-    page_path.write_text(content, encoding="utf-8")
+    _write_wiki_page(wiki, relpath, content)
     return is_new
 
 
@@ -234,8 +267,9 @@ def update_index(wiki: Path, new_skills: list[str]) -> None:
     if not new_skills:
         return
 
-    index_path = wiki / "index.md"
-    content = index_path.read_text(encoding="utf-8", errors="replace")
+    content = _read_wiki_page(wiki, "index.md")
+    if content is None:
+        return
     lines = content.split("\n")
 
     # Locate the ## Skills insertion point
@@ -273,7 +307,7 @@ def update_index(wiki: Path, new_skills: list[str]) -> None:
             lines[i] = re.sub(r"Last updated: [\d-]+", f"Last updated: {TODAY}", lines[i])
             break
 
-    index_path.write_text("\n".join(lines), encoding="utf-8")
+    _write_wiki_page(wiki, "index.md", "\n".join(lines))
 
 
 # ---------------------------------------------------------------------------
@@ -283,13 +317,12 @@ def update_index(wiki: Path, new_skills: list[str]) -> None:
 
 def append_log(wiki: Path, action: str, subject: str, details: list[str]) -> None:
     """Append a structured entry to log.md."""
-    log_path = wiki / "log.md"
     lines = [f"\n## [{TODAY}] {action} | {subject}"]
     lines.extend(f"- {d}" for d in details)
     entry = "\n".join(lines) + "\n"
 
-    with open(log_path, "a", encoding="utf-8") as fh:
-        fh.write(entry)
+    content = _read_wiki_page(wiki, "log.md") or ""
+    _write_wiki_page(wiki, "log.md", content + entry)
 
 
 # ---------------------------------------------------------------------------
@@ -299,8 +332,6 @@ def append_log(wiki: Path, action: str, subject: str, details: list[str]) -> Non
 
 def generate_converted_index(wiki: Path, skills: list[ConvertedSkill]) -> None:
     """Generate converted-index.md listing every converted skill."""
-    out_path = wiki / "converted-index.md"
-
     header = (
         f"# Converted Micro-Skill Pipelines Index\n"
         f"\n"
@@ -320,7 +351,7 @@ def generate_converted_index(wiki: Path, skills: list[ConvertedSkill]) -> None:
         rows.append(f"| {skill.name} | {entity_link} | {pipeline_link} |")
 
     content = header + "\n".join(rows) + "\n"
-    out_path.write_text(content, encoding="utf-8")
+    _write_wiki_page(wiki, "converted-index.md", content)
     print(f"  converted-index.md written ({len(skills)} entries)")
 
 

src/mcp_add.py

@@ -39,6 +39,10 @@ import mcp_canonical_index
 from mcp_entity import McpRecord
 from wiki_batch_entities import generate_mcp_page
 from ctx.core.wiki.wiki_sync import append_log, ensure_wiki, update_index
+from ctx.core.wiki.wiki_packs import (
+    load_merged_wiki_pages,
+    write_active_wiki_overlay_pack,
+)
 from ctx.core.wiki.wiki_queue import enqueue_entity_upsert
 from ctx.core.wiki.wiki_utils import validate_skill_name
 from ctx.utils._fs_utils import reject_symlink_path, safe_atomic_write_text
@@ -286,6 +290,111 @@ def _find_existing_by_github_url(
     return None
 
 
+def _entity_relpath(entity_rel: Path | str) -> str:
+    return f"{_MCP_ENTITY_SUBDIR}/{Path(entity_rel).as_posix()}"
+
+
+def _read_entity_page(wiki_path: Path, relpath: str) -> str | None:
+    packs_dir = wiki_path / "wiki-packs"
+    if packs_dir.is_dir():
+        pages = load_merged_wiki_pages(packs_dir)
+        if relpath in pages:
+            return pages[relpath]
+    target_path = wiki_path / relpath
+    if target_path.exists():
+        return target_path.read_text(encoding="utf-8", errors="replace")
+    return None
+
+
+def _find_indexed_entity_page_by_github_url(
+    *,
+    wiki_path: Path,
+    target: str,
+    index: mcp_canonical_index.CanonicalIndex,
+) -> Path | None:
+    """Return a canonical-index hit after confirming it in the merged wiki view."""
+    mcp_dir = wiki_path / _MCP_ENTITY_SUBDIR
+    entry = index["by_github_url"].get(target)
+    if entry is None:
+        return None
+
+    relpath = entry["relpath"]
+    text = _read_entity_page(wiki_path, _entity_relpath(relpath))
+    if text is None:
+        return None
+    fm = _parse_frontmatter(text)
+    if _normalize_github_url(fm.get("github_url")) != target:
+        return None
+    return mcp_dir / relpath
+
+
+def _find_existing_by_github_url_in_wiki(
+    wiki_path: Path,
+    target_github_url: str | None,
+) -> Path | None:
+    target = _normalize_github_url(target_github_url)
+    if target is None:
+        return None
+
+    mcp_dir = wiki_path / _MCP_ENTITY_SUBDIR
+    index = mcp_canonical_index.load_index(mcp_dir)
+    indexed_hit = _find_indexed_entity_page_by_github_url(
+        wiki_path=wiki_path,
+        target=target,
+        index=index,
+    )
+    if indexed_hit is not None:
+        return indexed_hit
+
+    physical_hit = _find_existing_by_github_url(mcp_dir, target)
+    if physical_hit is not None:
+        return physical_hit
+
+    packs_dir = wiki_path / "wiki-packs"
+    if not packs_dir.is_dir():
+        return None
+    prefix = f"{_MCP_ENTITY_SUBDIR}/"
+    for relpath, text in sorted(load_merged_wiki_pages(packs_dir).items()):
+        if not relpath.startswith(prefix) or not relpath.endswith(".md"):
+            continue
+        if target not in text.lower():
+            continue
+        fm = _parse_frontmatter(text)
+        if _normalize_github_url(fm.get("github_url")) == target:
+            if mcp_dir.is_dir():
+                try:
+                    entity_relpath = relpath[len(prefix) :]
+                    mcp_canonical_index.upsert(
+                        mcp_dir,
+                        target,
+                        slug=Path(entity_relpath).stem,
+                        relpath=entity_relpath,
+                        index=index,
+                    )
+                except (OSError, ValueError):
+                    pass
+            return wiki_path / relpath
+    return None
+
+
+def _write_entity_page(
+    *,
+    wiki_path: Path,
+    relpath: str,
+    target_path: Path,
+    content: str,
+) -> None:
+    packs_dir = wiki_path / "wiki-packs"
+    if target_path.exists() or not packs_dir.is_dir():
+        safe_atomic_write_text(target_path, content, encoding="utf-8")
+    if packs_dir.is_dir():
+        write_active_wiki_overlay_pack(
+            packs_dir=packs_dir,
+            pages={relpath: content},
+            tombstones=[],
+        )
+
+
 def add_mcp(
     *,
     record: McpRecord,
@@ -328,6 +437,7 @@ def add_mcp(
     entity_rel = record.entity_relpath()  # e.g. "f/fetch-mcp.md"
     mcp_dir = wiki_path / _MCP_ENTITY_SUBDIR
     target_path = mcp_dir / entity_rel
+    target_relpath = _entity_relpath(entity_rel)
 
     # Phase 3.6: cross-source dedup by canonical github_url before the
     # slug-based check. When awesome-mcp and pulsemcp both catalog the
@@ -337,9 +447,10 @@ def add_mcp(
     # listing-page records currently have only homepage_url (Phase 6
     # detail-page enrichment will populate github_url so this dedup
     # path becomes meaningful for them too).
-    canonical_match = _find_existing_by_github_url(mcp_dir, record.github_url)
+    canonical_match = _find_existing_by_github_url_in_wiki(wiki_path, record.github_url)
     if canonical_match is not None and canonical_match != target_path:
         target_path = canonical_match
+        target_relpath = target_path.relative_to(wiki_path).as_posix()
 
     reject_symlink_path(target_path)
     target_path.parent.mkdir(parents=True, exist_ok=True)
@@ -354,13 +465,13 @@ def add_mcp(
     # Phase 1 of branching: compute the read-side state. No serialization
     # work happens here so dry-run cannot fail on a malformed existing
     # page — that's deferred to the write-gate below.
-    if target_path.exists():
+    existing_text = _read_entity_page(wiki_path, target_relpath)
+    if existing_text is not None:
         # Existing entity → straight to merge. No intake call: the gate
         # would reject this as DUPLICATE against the cached embedding
         # of the original ingest, blocking the source-merge that's the
         # whole point of re-fetching. Phase 3b made this concrete.
         is_new_page = False
-        existing_text = target_path.read_text(encoding="utf-8")
         existing_fm = _parse_frontmatter(existing_text)
         merged_sources = _merge_sources(existing_fm, record.sources)
         kept_description = _keep_longer_description(existing_fm, record)
@@ -411,7 +522,12 @@ def add_mcp(
     if not dry_run:
         # Phase 2 of branching: render and write. Any YAML serialization
         # failure now is a real error, not a dry-run side-effect.
-        safe_atomic_write_text(target_path, final_text, encoding="utf-8")
+        _write_entity_page(
+            wiki_path=wiki_path,
+            relpath=target_relpath,
+            target_path=target_path,
+            content=final_text,
+        )
         queue_job = enqueue_entity_upsert(
             wiki_path=wiki_path,
             entity_type="mcp-server",
@@ -502,7 +618,6 @@ def _process_batch(
     dry_run: bool,
     skip_existing: bool,
     update_existing: bool,
-    mcp_entity_dir: Path,
 ) -> tuple[int, int, int, int, int]:
     """Process records. Returns (added, merged, reviewed, rejected, errors)."""
     added = merged = reviewed = rejected = errors = 0
@@ -518,9 +633,9 @@ def _process_batch(
             continue
 
         entity_rel = record.entity_relpath()
-        target_path = mcp_entity_dir / entity_rel
+        target_relpath = _entity_relpath(entity_rel)
 
-        if skip_existing and target_path.exists():
+        if skip_existing and _read_entity_page(wiki_path, target_relpath) is not None:
             merged += 1
             print(f"  [{i}/{total}] [skipped] {record.slug}")
             continue
@@ -595,7 +710,6 @@ def main() -> None:
 
     wiki_path = Path(os.path.expanduser(args.wiki))
     ensure_wiki(str(wiki_path))
-    mcp_entity_dir = wiki_path / _MCP_ENTITY_SUBDIR
 
     raw_records: list[dict[str, Any]] = []
 
@@ -605,7 +719,7 @@ def main() -> None:
             print(f"Error: {json_path} does not exist.", file=sys.stderr)
             sys.exit(1)
         try:
-            raw_records = [json.loads(json_path.read_text(encoding="utf-8"))]
+            raw_records = [json.loads(json_path.read_text(encoding="utf-8-sig"))]
         except json.JSONDecodeError as exc:
             print(f"Error: failed to parse JSON: {exc}", file=sys.stderr)
             sys.exit(1)
@@ -616,9 +730,9 @@ def main() -> None:
             print(f"Error: {jsonl_path} does not exist.", file=sys.stderr)
             sys.exit(1)
         for lineno, line in enumerate(
-            jsonl_path.read_text(encoding="utf-8").splitlines(), 1
+            jsonl_path.read_text(encoding="utf-8-sig").splitlines(), 1
         ):
-            line = line.strip()
+            line = line.lstrip("\ufeff").strip()
             if not line:
                 continue
             try:
@@ -628,7 +742,7 @@ def main() -> None:
 
     elif args.from_stdin:
         for lineno, line in enumerate(sys.stdin, 1):
-            line = line.strip()
+            line = line.lstrip("\ufeff").strip()
             if not line:
                 continue
             try:
@@ -646,7 +760,6 @@ def main() -> None:
         dry_run=args.dry_run,
         skip_existing=args.skip_existing,
         update_existing=args.update_existing,
-        mcp_entity_dir=mcp_entity_dir,
     )
 
     dry_label = " (dry-run)" if args.dry_run else ""
@@ -654,6 +767,8 @@ def main() -> None:
         f"\nDone{dry_label}: {added} added, {merged} updated, "
         f"{reviewed} reviewed, {rejected} rejected, {errors} errors"
     )
+    if rejected or errors:
+        sys.exit(1)
 
 
 if __name__ == "__main__":

src/mcp_canonical_index.py

@@ -56,6 +56,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import TypedDict
 
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages
 from ctx.utils._fs_utils import atomic_write_json
 
 __all__ = [
@@ -253,7 +254,37 @@ def remove(
     return idx
 
 
-def rebuild_from_scan(mcp_dir: Path) -> tuple[CanonicalIndex, int, int]:
+def _wiki_packs_dir_for_mcp_dir(mcp_dir: Path) -> Path:
+    if mcp_dir.name != "mcp-servers" or mcp_dir.parent.name != "entities":
+        return mcp_dir / ".no-wiki-packs"
+    return mcp_dir.parent.parent / "wiki-packs"
+
+
+def _iter_entity_pages(mcp_dir: Path) -> list[tuple[str, str, str | None]]:
+    packs_dir = _wiki_packs_dir_for_mcp_dir(mcp_dir)
+    if packs_dir.is_dir():
+        prefix = "entities/mcp-servers/"
+        rows: list[tuple[str, str, str | None]] = []
+        for full_relpath, text in sorted(load_merged_wiki_pages(packs_dir).items()):
+            if not full_relpath.startswith(prefix) or not full_relpath.endswith(".md"):
+                continue
+            relpath = full_relpath[len(prefix):]
+            rows.append((relpath, Path(relpath).stem, text))
+        return rows
+
+    if not mcp_dir.is_dir():
+        return []
+    rows = []
+    for page in sorted(mcp_dir.rglob("*.md")):
+        rows.append((page.relative_to(mcp_dir).as_posix(), page.stem, None))
+    return rows
+
+
+def rebuild_from_scan(
+    mcp_dir: Path,
+    *,
+    persist: bool = True,
+) -> tuple[CanonicalIndex, int, int]:
     """Scan every entity page, rebuild the index from scratch.
 
     Returns ``(index, indexed, skipped)`` where *indexed* counts pages
@@ -273,19 +304,22 @@ def rebuild_from_scan(mcp_dir: Path) -> tuple[CanonicalIndex, int, int]:
     indexed = 0
     skipped = 0
 
-    if not mcp_dir.is_dir():
+    rows = _iter_entity_pages(mcp_dir)
+    if not rows:
         return index, indexed, skipped
 
-    for page in mcp_dir.rglob("*.md"):
+    for relpath, slug, text in rows:
         # Skip non-entity files that might land under the tree later.
-        if page.name.startswith("."):
-            skipped += 1
-            continue
-        try:
-            text = page.read_text(encoding="utf-8", errors="replace")
-        except OSError:
+        if Path(relpath).name.startswith("."):
             skipped += 1
             continue
+        if text is None:
+            page = mcp_dir / relpath
+            try:
+                text = page.read_text(encoding="utf-8", errors="replace")
+            except OSError:
+                skipped += 1
+                continue
         fm = _parse_frontmatter(text)
         normalized = _normalize_github_url(fm.get("github_url"))
         if normalized is None:
@@ -296,8 +330,6 @@ def rebuild_from_scan(mcp_dir: Path) -> tuple[CanonicalIndex, int, int]:
         # ``McpRecord.slug``, whereas the ``name`` field may store the
         # original upstream display name (e.g. ``1mcp/agent`` for a
         # file at ``0-9/1mcp-agent.md``).
-        slug = page.stem
-        relpath = page.relative_to(mcp_dir).as_posix()
         upsert(
             mcp_dir,
             normalized,
@@ -308,5 +340,6 @@ def rebuild_from_scan(mcp_dir: Path) -> tuple[CanonicalIndex, int, int]:
         )
         indexed += 1
 
-    save_index(mcp_dir, index)
+    if persist:
+        save_index(mcp_dir, index)
     return index, indexed, skipped

src/mcp_enrich.py

@@ -48,7 +48,8 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Iterable
 
-from ctx.utils._fs_utils import atomic_write_json, atomic_write_text
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_active_wiki_overlay_pack
+from ctx.utils._fs_utils import atomic_write_json, reject_symlink_path, safe_atomic_write_text
 from ctx_config import cfg
 from mcp_sources import SOURCES
 
@@ -183,6 +184,15 @@ def _iter_entities(wiki_path: Path) -> Iterable[Path]:
     at entity #5,000 might skip ahead or rewind depending on platform
     shard-iteration order.
     """
+    packs_dir = wiki_path / "wiki-packs"
+    if packs_dir.is_dir():
+        prefix = f"{_MCP_ENTITY_SUBDIR.as_posix()}/"
+        return [
+            wiki_path / relpath
+            for relpath in sorted(load_merged_wiki_pages(packs_dir))
+            if relpath.startswith(prefix) and relpath.endswith(".md")
+        ]
+
     root = wiki_path / _MCP_ENTITY_SUBDIR
     if not root.is_dir():
         return []
@@ -211,8 +221,62 @@ _SOURCE_SLUG_PATTERNS: dict[str, re.Pattern[str]] = {
 }
 
 
+def _entity_relpath(wiki_path: Path, entity_path: Path) -> str:
+    return entity_path.relative_to(wiki_path).as_posix()
+
+
+def _load_active_wiki_pack_pages(wiki_path: Path) -> dict[str, str] | None:
+    packs_dir = wiki_path / "wiki-packs"
+    if not packs_dir.is_dir():
+        return None
+    return load_merged_wiki_pages(packs_dir)
+
+
+def _read_entity_text(
+    wiki_path: Path,
+    entity_path: Path,
+    *,
+    pages: dict[str, str] | None = None,
+) -> str | None:
+    relpath = _entity_relpath(wiki_path, entity_path)
+    packs_dir = wiki_path / "wiki-packs"
+    if packs_dir.is_dir():
+        page_map = pages if pages is not None else load_merged_wiki_pages(packs_dir)
+        if relpath in page_map:
+            return page_map[relpath]
+    if entity_path.exists():
+        reject_symlink_path(entity_path)
+        return entity_path.read_text(encoding="utf-8", errors="replace")
+    return None
+
+
+def _write_entity_text(
+    wiki_path: Path,
+    entity_path: Path,
+    text: str,
+    *,
+    pages: dict[str, str] | None = None,
+) -> None:
+    relpath = _entity_relpath(wiki_path, entity_path)
+    packs_dir = wiki_path / "wiki-packs"
+    if entity_path.exists() or not packs_dir.is_dir():
+        safe_atomic_write_text(entity_path, text, encoding="utf-8")
+    if packs_dir.is_dir():
+        write_active_wiki_overlay_pack(
+            packs_dir=packs_dir,
+            pages={relpath: text},
+            tombstones=[],
+        )
+        if pages is not None:
+            pages[relpath] = text
+
+
 def _source_slug_from_entity(
-    entity_path: Path, source_name: str
+    entity_path: Path,
+    source_name: str,
+    *,
+    wiki_path: Path | None = None,
+    pages: dict[str, str] | None = None,
 ) -> str | None:
     """Pull the upstream slug out of the entity's frontmatter.
 
@@ -228,9 +292,16 @@ def _source_slug_from_entity(
     pattern = _SOURCE_SLUG_PATTERNS.get(source_name)
     if pattern is None:
         return None
-    try:
-        text = entity_path.read_text(encoding="utf-8", errors="replace")
-    except OSError:
+    text: str | None
+    if wiki_path is None:
+        try:
+            reject_symlink_path(entity_path)
+            text = entity_path.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            return None
+    else:
+        text = _read_entity_text(wiki_path, entity_path, pages=pages)
+    if text is None:
         return None
     fm_match = _FRONTMATTER_RE.match(text)
     if fm_match is None:
@@ -343,7 +414,12 @@ def _render_scalar(value: Any) -> str:
 
 
 def apply_enrichment(
-    entity_path: Path, enrichment: dict, *, dry_run: bool
+    entity_path: Path,
+    enrichment: dict,
+    *,
+    dry_run: bool,
+    wiki_path: Path | None = None,
+    pages: dict[str, str] | None = None,
 ) -> dict:
     """Write ``enrichment`` fields into the entity's frontmatter.
 
@@ -355,7 +431,14 @@ def apply_enrichment(
     if not enrichment:
         return {}
 
-    text = entity_path.read_text(encoding="utf-8", errors="replace")
+    if wiki_path is None:
+        reject_symlink_path(entity_path)
+        text = entity_path.read_text(encoding="utf-8", errors="replace")
+    else:
+        read_text = _read_entity_text(wiki_path, entity_path, pages=pages)
+        if read_text is None:
+            return {}
+        text = read_text
     fm_match = _FRONTMATTER_RE.match(text)
     if fm_match is None:
         return {}
@@ -382,7 +465,10 @@ def apply_enrichment(
     if diff and not dry_run:
         today = datetime.now(timezone.utc).strftime("%Y-%m-%d")
         text = _set_frontmatter_field(text, "updated", today)
-        atomic_write_text(entity_path, text)
+        if wiki_path is None:
+            safe_atomic_write_text(entity_path, text, encoding="utf-8")
+        else:
+            _write_entity_text(wiki_path, entity_path, text, pages=pages)
     return diff
 
 
@@ -420,6 +506,7 @@ def enrich_entities(
 
     processed = checkpoint["processed"]
     failures = checkpoint["failures"]
+    pages = _load_active_wiki_pack_pages(wiki_path)
 
     attempted = enriched = unchanged = failed = skipped = 0
     for path in entity_paths:
@@ -439,7 +526,12 @@ def enrich_entities(
         attempted += 1
         checkpoint["total_seen"] += 1
 
-        source_slug = _source_slug_from_entity(path, source_name)
+        source_slug = _source_slug_from_entity(
+            path,
+            source_name,
+            wiki_path=wiki_path,
+            pages=pages,
+        )
         if source_slug is None:
             # Entity has no homepage_url for this source (e.g. ingested
             # from a different source). Record a skip so we don't
@@ -478,7 +570,13 @@ def enrich_entities(
             continue
 
         try:
-            diff = apply_enrichment(path, enrichment, dry_run=dry_run)
+            diff = apply_enrichment(
+                path,
+                enrichment,
+                dry_run=dry_run,
+                wiki_path=wiki_path,
+                pages=pages,
+            )
         except Exception as exc:  # noqa: BLE001
             failed += 1
             failures[wiki_slug] = {
@@ -647,7 +745,7 @@ def main() -> None:
         # Shard lookup mirrors McpRecord.entity_relpath.
         shard = args.slug[0] if args.slug and args.slug[0].isalpha() else "0-9"
         entity_paths = [root / shard / f"{args.slug}.md"]
-        if not entity_paths[0].is_file():
+        if _read_entity_text(wiki_path, entity_paths[0]) is None:
             print(
                 f"Error: no entity at {entity_paths[0]} — has it been ingested?",
                 file=sys.stderr,

src/mcp_quality.py

@@ -46,7 +46,9 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Mapping
 
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_active_wiki_overlay_pack
 from ctx.utils._fs_utils import atomic_write_text as _atomic_write
+from ctx.utils._fs_utils import reject_symlink_path, safe_atomic_write_text
 from mcp_entity import MCP_SLUG_RE, McpRecord
 from ctx.core.quality.quality_signals import SignalResult
 from ctx.core.wiki.wiki_utils import parse_frontmatter_and_body
@@ -286,8 +288,65 @@ def _resolve_mcp_entity_path(slug: str, wiki_dir: Path) -> Path:
     return wiki_dir / "entities" / "mcp-servers" / shard / f"{slug}.md"
 
 
+def _mcp_entity_relpath(slug: str) -> str:
+    path = _resolve_mcp_entity_path(slug, Path("."))
+    return path.as_posix()
+
+
+def _load_active_wiki_pack_pages(wiki_dir: Path) -> dict[str, str] | None:
+    packs_dir = wiki_dir / "wiki-packs"
+    if not packs_dir.is_dir():
+        return None
+    return load_merged_wiki_pages(packs_dir)
+
+
+def _read_mcp_entity_text(
+    slug: str,
+    wiki_dir: Path,
+    *,
+    pages: dict[str, str] | None = None,
+) -> str | None:
+    relpath = _mcp_entity_relpath(slug)
+    packs_dir = wiki_dir / "wiki-packs"
+    if packs_dir.is_dir():
+        page_map = pages if pages is not None else load_merged_wiki_pages(packs_dir)
+        if relpath in page_map:
+            return page_map[relpath]
+    path = _resolve_mcp_entity_path(slug, wiki_dir)
+    if path.is_file():
+        reject_symlink_path(path)
+        return path.read_text(encoding="utf-8", errors="replace")
+    return None
+
+
+def _write_mcp_entity_text(
+    slug: str,
+    wiki_dir: Path,
+    text: str,
+    *,
+    pages: dict[str, str] | None = None,
+) -> Path:
+    relpath = _mcp_entity_relpath(slug)
+    path = _resolve_mcp_entity_path(slug, wiki_dir)
+    packs_dir = wiki_dir / "wiki-packs"
+    if path.exists() or not packs_dir.is_dir():
+        safe_atomic_write_text(path, text, encoding="utf-8")
+    if packs_dir.is_dir():
+        write_active_wiki_overlay_pack(
+            packs_dir=packs_dir,
+            pages={relpath: text},
+            tombstones=[],
+        )
+        if pages is not None:
+            pages[relpath] = text
+    return path
+
+
 def _read_mcp_entity(
-    slug: str, wiki_dir: Path
+    slug: str,
+    wiki_dir: Path,
+    *,
+    pages: dict[str, str] | None = None,
 ) -> tuple[McpRecord, dict[str, Any]]:
     """Read entity .md, parse frontmatter, reconstruct McpRecord.
 
@@ -304,11 +363,11 @@ def _read_mcp_entity(
         ValueError: If the frontmatter cannot produce a valid McpRecord.
     """
     path = _resolve_mcp_entity_path(slug, wiki_dir)
-    if not path.is_file():
+    raw = _read_mcp_entity_text(slug, wiki_dir, pages=pages)
+    if raw is None:
         raise FileNotFoundError(
             f"MCP entity not found: {path}"
         )
-    raw = path.read_text(encoding="utf-8", errors="replace")
     fm, _body = parse_frontmatter_and_body(raw)
     # McpRecord.from_dict is tolerant of missing optional fields.
     record = McpRecord.from_dict({**fm, "slug": slug})
@@ -321,47 +380,31 @@ def _read_mcp_entity(
 
 
 def load_graph_index(wiki_dir: Path) -> dict[str, dict[str, Any]]:
-    """Load ``<wiki>/graphify-out/graph.json`` and build a degree index.
+    """Load the merged wiki graph and build a degree index.
 
     Returns a mapping of ``{node_id: {"degree": int, "cross_type_degree": int}}``.
     Cross-type degree counts neighbours whose ``node_id`` starts with a
     different type prefix (e.g. ``skill:`` or ``agent:`` vs ``mcp-server:``).
-    Returns an empty dict if the file is missing or malformed.
+    Returns an empty dict if graph packs and legacy ``graph.json`` are both
+    missing or malformed.
     """
     graph_path = wiki_dir / "graphify-out" / "graph.json"
-    if not graph_path.is_file():
+    packs_dir = graph_path.parent / "packs"
+    if not graph_path.is_file() and not packs_dir.is_dir():
         return {}
     try:
-        data = json.loads(graph_path.read_text(encoding="utf-8"))
-    except (json.JSONDecodeError, OSError):
-        _logger.warning("load_graph_index: could not parse %s", graph_path)
-        return {}
+        from ctx.core.graph.resolve_graph import load_graph  # noqa: PLC0415
 
-    if not isinstance(data, dict) or "nodes" not in data:
+        graph = load_graph(graph_path)
+    except Exception as exc:  # noqa: BLE001 - quality recompute must keep going.
+        _logger.warning("load_graph_index: could not load %s: %s", graph_path, exc)
         return {}
 
-    # Build neighbour lists from links/edges.
-    edge_key = "links" if "links" in data else "edges"
-    raw_edges = data.get(edge_key) or []
-
-    # adjacency: node_id -> set of neighbour node_ids
-    adjacency: dict[str, set[str]] = {}
-    for node in data.get("nodes", []):
-        nid = node.get("id")
-        if isinstance(nid, str):
-            adjacency[nid] = set()
-
-    for edge in raw_edges:
-        if not isinstance(edge, dict):
-            continue
-        src = edge.get("source") or edge.get("from")
-        tgt = edge.get("target") or edge.get("to")
-        if isinstance(src, str) and isinstance(tgt, str):
-            adjacency.setdefault(src, set()).add(tgt)
-            adjacency.setdefault(tgt, set()).add(src)
-
     index: dict[str, dict[str, Any]] = {}
-    for node_id, neighbours in adjacency.items():
+    for node_id in graph.nodes:
+        if not isinstance(node_id, str):
+            continue
+        neighbours = {str(neighbour) for neighbour in graph.neighbors(node_id)}
         # Derive this node's type prefix (e.g. "skill", "mcp-server").
         node_prefix = node_id.split(":")[0] if ":" in node_id else ""
         cross_type = sum(
@@ -409,6 +452,7 @@ def extract_signals_for_slug(
     wiki_dir: Path,
     config: McpQualityConfig | None = None,
     graph_index: Mapping[str, dict[str, Any]] | None = None,
+    pages: dict[str, str] | None = None,
 ) -> Mapping[str, SignalResult]:
     """Read entity, compute graph degrees, call all six signal functions.
 
@@ -441,7 +485,7 @@ def extract_signals_for_slug(
     _ensure_safe_slug(slug)
     cfg = config or McpQualityConfig()
 
-    record, fm = _read_mcp_entity(slug, wiki_dir)
+    record, fm = _read_mcp_entity(slug, wiki_dir, pages=pages)
 
     # Graph degrees.
     node_id = f"{_MCP_NODE_PREFIX}{slug}"
@@ -623,6 +667,7 @@ def persist_quality(
     wiki_dir: Path,
     sidecar_dir: Path | None = None,
     update_frontmatter: bool = True,
+    pages: dict[str, str] | None = None,
 ) -> dict[str, Path]:
     """Write the quality result to the three on-disk sinks atomically.
 
@@ -649,15 +694,14 @@ def persist_quality(
 
     # Sinks 2 + 3 — entity .md (frontmatter + body).
     entity_path = _resolve_mcp_entity_path(score.slug, wiki_dir)
-    if not entity_path.is_file():
+    raw = _read_mcp_entity_text(score.slug, wiki_dir, pages=pages)
+    if raw is None:
         _logger.info(
             "mcp_quality: no entity page at %s; frontmatter/body sinks skipped",
             entity_path,
         )
         return written
 
-    raw = entity_path.read_text(encoding="utf-8", errors="replace")
-
     # Sink 2 — frontmatter.
     updated = _update_frontmatter_quality(raw, score)
 
@@ -671,7 +715,7 @@ def persist_quality(
             new_body = _inject_quality_section(body, _render_quality_section(score))
             updated = header + new_body
 
-    _atomic_write(entity_path, updated)
+    entity_path = _write_mcp_entity_text(score.slug, wiki_dir, updated, pages=pages)
     written["frontmatter"] = entity_path
     written["wiki_body"] = entity_path
 
@@ -726,6 +770,7 @@ def recompute_slug(
     graph_index: Mapping[str, dict[str, Any]] | None = None,
     sidecar_dir: Path | None = None,
     update_frontmatter: bool = True,
+    pages: dict[str, str] | None = None,
 ) -> McpQualityScore:
     """End-to-end recompute: extract signals → compute → persist."""
     signals = extract_signals_for_slug(
@@ -733,6 +778,7 @@ def recompute_slug(
         wiki_dir=wiki_dir,
         config=config,
         graph_index=graph_index,
+        pages=pages,
     )
     score = compute_quality(
         slug=slug,
@@ -745,16 +791,32 @@ def recompute_slug(
         wiki_dir=wiki_dir,
         sidecar_dir=sidecar_dir,
         update_frontmatter=update_frontmatter,
+        pages=pages,
     )
     return score
 
 
-def discover_mcp_slugs(wiki_dir: Path) -> list[str]:
+def discover_mcp_slugs(
+    wiki_dir: Path,
+    *,
+    pages: dict[str, str] | None = None,
+) -> list[str]:
     """Enumerate every MCP server slug in the wiki entity tree.
 
     Walks ``<wiki>/entities/mcp-servers/`` shards, collecting ``*.md``
     stems that pass ``MCP_SLUG_RE``. Returns sorted list.
     """
+    page_map = pages if pages is not None else _load_active_wiki_pack_pages(wiki_dir)
+    if page_map is not None:
+        prefix = "entities/mcp-servers/"
+        return sorted(
+            Path(relpath).stem
+            for relpath in page_map
+            if relpath.startswith(prefix)
+            and relpath.endswith(".md")
+            and MCP_SLUG_RE.match(Path(relpath).stem)
+        )
+
     mcp_root = wiki_dir / "entities" / "mcp-servers"
     if not mcp_root.is_dir():
         return []
@@ -782,7 +844,8 @@ def recompute_all(
         ``(successes, failures)`` where failures is a list of
         ``(slug, exception)`` pairs.
     """
-    slugs = discover_mcp_slugs(wiki_dir)
+    pages = _load_active_wiki_pack_pages(wiki_dir)
+    slugs = discover_mcp_slugs(wiki_dir, pages=pages)
     graph_index = load_graph_index(wiki_dir)
 
     successes: list[McpQualityScore] = []
@@ -796,6 +859,7 @@ def recompute_all(
                 graph_index=graph_index,
                 sidecar_dir=sidecar_dir,
                 update_frontmatter=update_frontmatter,
+                pages=pages,
             )
             successes.append(score)
         except (FileNotFoundError, ValueError, OSError, ImportError) as exc:

src/mcp_rebuild_index.py

@@ -1,25 +1,19 @@
 #!/usr/bin/env python3
 """
-mcp_rebuild_index.py -- Rebuild the canonical-key sidecar index from disk.
+mcp_rebuild_index.py -- Rebuild the canonical-key sidecar index for MCP entities.
 
 Usage
 -----
     ctx-mcp-rebuild-index [--wiki PATH] [--dry-run]
 
-Reads every ``*.md`` under ``<wiki>/entities/mcp-servers/``, parses its
-YAML frontmatter, and writes
-``<wiki>/entities/mcp-servers/.canonical-index.json`` with a fresh
-``github_url -> {slug, relpath}`` map.
+Reads MCP entity markdown from either:
 
-Intended to be run:
+- ``<wiki>/wiki-packs`` when modular wiki packs are active, or
+- ``<wiki>/entities/mcp-servers/`` for an extracted/editable wiki tree.
 
-- Once, to backfill the sidecar for the entities that existed before
-  Phase 6b (the ``add_mcp`` hot-path upsert only covers records added
-  after the feature landed).
-- Any time the index is suspected stale (manual edits, restored from
-  backup, cross-wiki merge). The normal scan-and-repair fallback in
-  ``_find_existing_by_github_url`` handles one-off drift, but a full
-  rebuild is cheap (~1 s at 15k entities) and gives a clean baseline.
+It writes ``<wiki>/entities/mcp-servers/.canonical-index.json`` with a fresh
+``github_url -> {slug, relpath}`` map. The sidecar is a cache; the merged wiki
+page set remains authoritative.
 
 Exit codes: 0 on success, 2 on missing wiki path, 1 on unexpected error.
 """
@@ -60,52 +54,31 @@ def main() -> None:
 
     wiki_path = Path(os.path.expanduser(args.wiki))
     mcp_dir = wiki_path / _MCP_ENTITY_SUBDIR
+    packs_dir = wiki_path / "wiki-packs"
 
-    if not mcp_dir.is_dir():
+    if not mcp_dir.is_dir() and not packs_dir.is_dir():
         print(
-            f"Error: MCP entity directory does not exist: {mcp_dir}",
+            f"Error: MCP entity directory or wiki-packs do not exist under: {wiki_path}",
             file=sys.stderr,
         )
         sys.exit(2)
 
+    try:
+        _, indexed, skipped = rebuild_from_scan(mcp_dir, persist=not args.dry_run)
+    except Exception as exc:  # noqa: BLE001 - surface any failure to operator.
+        print(f"Error: rebuild failed: {exc}", file=sys.stderr)
+        sys.exit(1)
+
     if args.dry_run:
-        # Dry-run uses the same traversal but discards the write. Easiest
-        # way is to call the real rebuild, then overwrite the file back
-        # — but that's still a write. Instead, walk inline and count.
-        indexed = 0
-        skipped = 0
-        for page in mcp_dir.rglob("*.md"):
-            if page.name.startswith("."):
-                skipped += 1
-                continue
-            # Lazy import to match the module pattern.
-            from mcp_add import _normalize_github_url, _parse_frontmatter  # noqa: PLC0415
-            try:
-                text = page.read_text(encoding="utf-8", errors="replace")
-            except OSError:
-                skipped += 1
-                continue
-            fm = _parse_frontmatter(text)
-            if _normalize_github_url(fm.get("github_url")) is None:
-                skipped += 1
-            else:
-                indexed += 1
         print(
             f"[dry-run] would index {indexed} entities, "
             f"skip {skipped} (no github_url or unreadable)."
         )
-        sys.exit(0)
-
-    try:
-        _, indexed, skipped = rebuild_from_scan(mcp_dir)
-    except Exception as exc:  # noqa: BLE001 — surface any failure to operator
-        print(f"Error: rebuild failed: {exc}", file=sys.stderr)
-        sys.exit(1)
-
-    print(
-        f"Canonical index rebuilt: {indexed} entities indexed, "
-        f"{skipped} skipped (no github_url)."
-    )
+    else:
+        print(
+            f"Canonical index rebuilt: {indexed} entities indexed, "
+            f"{skipped} skipped (no github_url)."
+        )
     sys.exit(0)
 
 

src/scan_repo.py

@@ -125,19 +125,22 @@ def scan_directory(repo_path: str, max_depth: int = MAX_DEPTH) -> dict:
 def read_json_safe(path: str) -> dict | None:
     """Read a JSON file, return None on failure."""
     try:
-        with open(path) as f:
+        with open(path, encoding="utf-8-sig") as f:
             return json.load(f)
     except Exception as exc:
         print(f"Warning: failed to read JSON file {path}: {exc}", file=sys.stderr)
         return None
 
 
-def read_toml_deps(path: str) -> list[str]:
+def read_toml_deps(path: str, *, include_optional: bool = True) -> list[str]:
     """Extract dependency names from pyproject.toml.
 
     Covers PEP 621 ``[project].dependencies`` / ``optional-dependencies`` and
     Poetry-style ``[tool.poetry].dependencies`` / ``dev-dependencies``. Version
-    specifiers and extras are stripped via PEP 508 splitting.
+    specifiers and extras are stripped via PEP 508 splitting. Callers can set
+    ``include_optional=False`` when deciding the primary project type; optional
+    extras should remain searchable signals but should not make a docs/tooling
+    repo look like an ML project just because it offers an embeddings extra.
     """
     try:
         data = tomllib.loads(Path(path).read_text(encoding="utf-8-sig"))
@@ -152,15 +155,17 @@ def read_toml_deps(path: str) -> list[str]:
         deps = project.get("dependencies", [])
         if isinstance(deps, list):
             raw.extend(d for d in deps if isinstance(d, str))
-        opt = project.get("optional-dependencies", {})
-        if isinstance(opt, dict):
-            for group in opt.values():
-                if isinstance(group, list):
-                    raw.extend(d for d in group if isinstance(d, str))
+        if include_optional:
+            opt = project.get("optional-dependencies", {})
+            if isinstance(opt, dict):
+                for group in opt.values():
+                    if isinstance(group, list):
+                        raw.extend(d for d in group if isinstance(d, str))
 
     poetry = data.get("tool", {}).get("poetry", {}) if isinstance(data.get("tool"), dict) else {}
     if isinstance(poetry, dict):
-        for key in ("dependencies", "dev-dependencies"):
+        keys = ("dependencies", "dev-dependencies") if include_optional else ("dependencies",)
+        for key in keys:
             deps = poetry.get(key, {})
             if isinstance(deps, dict):
                 raw.extend(k for k in deps.keys() if isinstance(k, str) and k.lower() != "python")
@@ -222,6 +227,7 @@ def detect_stack(repo_path: str, signals: dict) -> dict:
 
     # Collect all deps from Python and JS configs
     all_py_deps: list[str] = []
+    core_py_deps: list[str] = []
     all_js_deps: list[str] = []
     pkg_json = None
 
@@ -229,10 +235,15 @@ def detect_stack(repo_path: str, signals: dict) -> dict:
         base = os.path.basename(cfg)
         if base == "pyproject.toml":
             all_py_deps.extend(read_toml_deps(cfg))
+            core_py_deps.extend(read_toml_deps(cfg, include_optional=False))
         elif base == "requirements.txt":
-            all_py_deps.extend(read_requirements(cfg))
+            deps = read_requirements(cfg)
+            all_py_deps.extend(deps)
+            core_py_deps.extend(deps)
         elif base == "Pipfile":
-            all_py_deps.extend(read_requirements(cfg))
+            deps = read_requirements(cfg)
+            all_py_deps.extend(deps)
+            core_py_deps.extend(deps)
         elif base == "package.json":
             data = read_json_safe(cfg)
             if data:
@@ -242,6 +253,7 @@ def detect_stack(repo_path: str, signals: dict) -> dict:
                         all_js_deps.extend(k.lower() for k in data[section])
 
     py_dep_set = set(all_py_deps)
+    py_core_dep_set = set(core_py_deps)
     js_dep_set = set(all_js_deps)
 
     # --- LANGUAGES ---
@@ -540,6 +552,14 @@ def detect_stack(repo_path: str, signals: dict) -> dict:
 
     # --- PROJECT TYPE ---
     fw_names = {f["name"] for f in profile["frameworks"]}
+    core_ml_deps = py_core_dep_set & {"torch", "pytorch", "tensorflow", "transformers"}
+    core_ai_deps = py_core_dep_set & {
+        "langchain",
+        "langchain-core",
+        "llama-index",
+        "crewai",
+        "dspy-ai",
+    }
     if fw_names & {"react", "vue", "angular", "svelte", "nextjs", "nuxt"}:
         if fw_names & {"fastapi", "django", "flask", "express", "nestjs"}:
             profile["project_type"] = "fullstack"
@@ -547,9 +567,9 @@ def detect_stack(repo_path: str, signals: dict) -> dict:
             profile["project_type"] = "frontend"
     elif fw_names & {"fastapi", "django", "flask", "express", "nestjs", "gin", "actix"}:
         profile["project_type"] = "api-service"
-    elif fw_names & {"pytorch", "tensorflow", "huggingface"}:
+    elif (fw_names & {"pytorch", "tensorflow", "huggingface"}) and core_ml_deps:
         profile["project_type"] = "ml-project"
-    elif fw_names & {"langchain", "llamaindex", "crewai"}:
+    elif (fw_names & {"langchain", "llamaindex", "crewai"}) and core_ai_deps:
         profile["project_type"] = "ai-agent"
     elif profile["infrastructure"]:
         profile["project_type"] = "infrastructure"
@@ -588,8 +608,6 @@ def _shared_recommendations(profile: dict) -> list[dict[str, Any]] | None:
     from ctx_config import cfg  # noqa: PLC0415
 
     graph_path = cfg.wiki_dir / "graphify-out" / "graph.json"
-    if not graph_path.is_file():
-        return None
     graph = load_graph(graph_path)
     if graph.number_of_nodes() == 0:
         return None

src/skill_add.py

@@ -22,10 +22,18 @@ from pathlib import Path
 
 from batch_convert import convert_skill
 from ctx.core.entity_update import build_update_review, render_update_review
+from ctx.core.quality.skillspector_service import SkillSpectorResult
+from ctx.core.quality.skillspector_service import render_scan_report
+from ctx.core.quality.skillspector_service import run_skillspector_scan
+from ctx.core.quality.skillspector_service import skill_scan_target
 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_packs import (
+    load_merged_wiki_pages,
+    write_active_wiki_overlay_pack,
+)
 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
@@ -104,6 +112,7 @@ def build_entity_page(
     original_path: Path,
     related: list[str],
     scan_sources: list[str],
+    security_scan: SkillSpectorResult | None = None,
 ) -> str:
     """Render the full entity page markdown for a skill."""
     pipeline_path_str = (
@@ -131,6 +140,11 @@ def build_entity_page(
     }
     if scan_sources:
         fm_dict["sources"] = scan_sources
+    if security_scan is not None:
+        fm_dict["skillspector_checked"] = True
+        fm_dict["skillspector_status"] = security_scan.status
+        fm_dict["skillspector_exit_code"] = security_scan.exit_code
+        fm_dict["skillspector_note"] = "ctx-run SkillSpector check; not NVIDIA endorsement"
 
     frontmatter_body = yaml.safe_dump(fm_dict, default_flow_style=False, allow_unicode=True, sort_keys=False)
     frontmatter_block = f"---\n{frontmatter_body}---"
@@ -145,6 +159,16 @@ def build_entity_page(
         else f"Skill is {line_count} lines — under the {cfg.line_threshold}-line threshold, no pipeline generated."
     )
 
+    security_section = ""
+    if security_scan is not None:
+        security_section = f"""
+
+## Security Check
+
+SkillSpector status: `{security_scan.status}`.
+This is a ctx-run check, not NVIDIA endorsement or certification.
+"""
+
     return frontmatter_block + f"""
 
 # {name}
@@ -166,18 +190,67 @@ def build_entity_page(
 | Date | Action | Notes |
 |------|--------|-------|
 | {TODAY} | Added | Ingested via skill_add.py |
+{security_section}
 """
 
 
 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")
+    is_new = _read_entity_page_text(wiki_path, name) is None
+    _write_entity_page_text(wiki_path, name, content)
     return is_new
 
 
+def _skill_relpath(name: str) -> str:
+    return f"entities/skills/{name}.md"
+
+
+def _read_entity_page_text(wiki_path: Path, name: str) -> str | None:
+    relpath = _skill_relpath(name)
+    page = wiki_path / relpath
+    if page.exists():
+        reject_symlink_path(page)
+    packs_dir = wiki_path / "wiki-packs"
+    if packs_dir.is_dir():
+        pages = load_merged_wiki_pages(packs_dir)
+        if relpath in pages:
+            return pages[relpath]
+    if page.exists():
+        return page.read_text(encoding="utf-8", errors="replace")
+    return None
+
+
+def _write_entity_page_text(wiki_path: Path, name: str, content: str) -> None:
+    relpath = _skill_relpath(name)
+    page = wiki_path / relpath
+    packs_dir = wiki_path / "wiki-packs"
+    if page.exists() or not packs_dir.is_dir():
+        reject_symlink_path(page)
+        safe_atomic_write_text(page, content, encoding="utf-8")
+    if packs_dir.is_dir():
+        write_active_wiki_overlay_pack(
+            packs_dir=packs_dir,
+            pages={relpath: content},
+            tombstones=[],
+        )
+
+
+def _load_skill_pages(wiki_path: Path) -> dict[str, str]:
+    packs_dir = wiki_path / "wiki-packs"
+    if packs_dir.is_dir():
+        return {
+            Path(relpath).stem: text
+            for relpath, text in load_merged_wiki_pages(packs_dir).items()
+            if relpath.startswith("entities/skills/") and relpath.endswith(".md")
+        }
+    skills_dir = wiki_path / "entities" / "skills"
+    pages: dict[str, str] = {}
+    for page in sorted(skills_dir.glob("*.md")):
+        reject_symlink_path(page)
+        pages[page.stem] = page.read_text(encoding="utf-8", errors="replace")
+    return pages
+
+
 # ── Wikilink backfill ─────────────────────────────────────────────────────────
 
 def _tag_set_from_frontmatter(raw: object) -> set[str]:
@@ -194,9 +267,12 @@ def _tag_set_from_frontmatter(raw: object) -> set[str]:
 
 
 def _existing_skill_review_text(entity_page: Path, installed_path: Path) -> str:
+    wiki_path = entity_page.parents[2]
     if entity_page.exists():
         reject_symlink_path(entity_page)
-        existing = entity_page.read_text(encoding="utf-8", errors="replace")
+    existing_page = _read_entity_page_text(wiki_path, entity_page.stem)
+    if existing_page is not None:
+        existing = existing_page
         if installed_path.exists():
             reject_symlink_path(installed_path)
             installed = installed_path.read_text(encoding="utf-8", errors="replace")
@@ -229,28 +305,24 @@ def _proposed_skill_review_text(
 
 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"
     related: list[str] = []
     tag_set = set(tags) - {"uncategorized"}
 
-    for page in sorted(skills_dir.glob("*.md")):
-        if page.stem == name:
+    for slug, content in sorted(_load_skill_pages(wiki_path).items()):
+        if slug == name:
             continue
-        content = page.read_text(encoding="utf-8", errors="replace")
         page_tags = _tag_set_from_frontmatter(parse_frontmatter(content).get("tags"))
         if tag_set & page_tags:
-            related.append(page.stem)
+            related.append(slug)
 
     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():
+    content = _read_entity_page_text(wiki_path, target_name)
+    if content is None:
         return
-    content = page.read_text(encoding="utf-8", errors="replace")
     link = f"[[entities/skills/{source_name}]]"
     if link in content:
         return
@@ -263,7 +335,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")
+    _write_entity_page_text(wiki_path, target_name, content)
 
 
 def wire_backlinks(wiki_path: Path, name: str, related: list[str]) -> None:
@@ -300,6 +372,12 @@ def add_skill(
     skills_dir: Path,
     review_existing: bool = False,
     update_existing: bool = False,
+    security_scan: bool = False,
+    security_scan_required: bool = False,
+    security_scan_use_llm: bool = False,
+    security_scan_command: list[str] | None = None,
+    skillspector_bin: str | None = None,
+    security_scan_timeout: int = 120,
 ) -> dict:
     """Add a single skill: install, convert if needed, ingest into wiki.
 
@@ -316,17 +394,15 @@ def add_skill(
             f"Split the skill or trim content before ingestion."
         )
 
-    content = source_path.read_text(encoding="utf-8", errors="replace")
+    content = source_path.read_text(encoding="utf-8-sig", 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 = (
+        installed_path.exists()
+        or _read_entity_page_text(wiki_path, name) is not None
     )
-    has_existing = existing_path is not None
     tags = infer_tags(name, content)
 
     if review_existing and has_existing and not update_existing:
@@ -353,6 +429,21 @@ def add_skill(
             "update_review": render_update_review(review),
         }
 
+    scan_result = None
+    if security_scan:
+        scan_result = run_skillspector_scan(
+            skill_scan_target(source_path),
+            command=security_scan_command,
+            binary=skillspector_bin,
+            use_llm=security_scan_use_llm,
+            timeout_seconds=security_scan_timeout,
+        )
+        if security_scan_required and scan_result.status != "passed":
+            raise ValueError(
+                "SkillSpector security scan did not pass: "
+                f"{scan_result.status}\n\n{render_scan_report(scan_result)}"
+            )
+
     if not has_existing:
         # Intake gate: reject broken/duplicate candidates before we touch
         # skills-dir. Existing updates bypass similarity intake because
@@ -388,7 +479,7 @@ def add_skill(
 
     # Ensure at least 2 wikilinks (pad with first two related even if no tag match)
     all_entity_pages = sorted(
-        (p.stem for p in (wiki_path / "entities" / "skills").glob("*.md") if p.stem != name)
+        slug for slug in _load_skill_pages(wiki_path) if slug != name
     )
     while len(related) < 2 and len(all_entity_pages) > len(related):
         candidate = all_entity_pages[len(related)]
@@ -404,6 +495,7 @@ def add_skill(
         original_path=installed_path,
         related=related,
         scan_sources=scan_sources,
+        security_scan=scan_result,
     )
     is_new = write_entity_page(wiki_path, name, page_content)
 
@@ -451,6 +543,9 @@ def add_skill(
                 "converted": converted,
                 "tags": tags,
                 "related": related,
+                "skillspector_status": (
+                    scan_result.status if scan_result is not None else None
+                ),
             },
         )
         if converted:
@@ -469,6 +564,7 @@ def add_skill(
         "skipped": False,
         "update_required": False,
         "queued_job_id": queue_job.id,
+        "security_scan": scan_result.to_json() if scan_result is not None else None,
     }
 
 
@@ -485,6 +581,32 @@ def main() -> None:
         action="store_true",
         help="Apply the reviewed replacement when a skill already exists",
     )
+    parser.add_argument(
+        "--no-security-scan",
+        action="store_true",
+        help="Do not run SkillSpector before adding or updating a skill",
+    )
+    parser.add_argument(
+        "--security-scan-optional",
+        action="store_true",
+        help="Run SkillSpector but do not fail the add when it reports findings or is missing",
+    )
+    parser.add_argument(
+        "--security-scan-use-llm",
+        action="store_true",
+        help="Allow SkillSpector LLM analysis instead of static-only --no-llm",
+    )
+    parser.add_argument(
+        "--skillspector-bin",
+        default=None,
+        help="SkillSpector executable. Defaults to CTX_SKILLSPECTOR_BIN or 'skillspector' on PATH.",
+    )
+    parser.add_argument(
+        "--security-scan-timeout",
+        type=int,
+        default=120,
+        help="SkillSpector timeout in seconds (default: 120)",
+    )
     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()
@@ -533,7 +655,10 @@ def main() -> None:
     total = len(candidates)
     for i, (source_path, name) in enumerate(candidates, 1):
         # Skip if already installed and --skip-existing is set
-        if args.skip_existing and (skills_dir / name / "SKILL.md").exists():
+        if args.skip_existing and (
+            (skills_dir / name / "SKILL.md").exists()
+            or _read_entity_page_text(wiki_path, name) is not None
+        ):
             skipped += 1
             if skipped <= 5 or skipped % 100 == 0:
                 print(f"  [{i}/{total}] [skipped] {name}")
@@ -546,6 +671,13 @@ def main() -> None:
                 skills_dir=skills_dir,
                 review_existing=True,
                 update_existing=args.update_existing,
+                security_scan=not args.no_security_scan,
+                security_scan_required=(
+                    not args.no_security_scan and not args.security_scan_optional
+                ),
+                security_scan_use_llm=args.security_scan_use_llm,
+                skillspector_bin=args.skillspector_bin,
+                security_scan_timeout=args.security_scan_timeout,
             )
             if result.get("skipped"):
                 skipped += 1
@@ -564,7 +696,13 @@ def main() -> None:
                 if not result["is_new_page"]
                 else "converted" if result["converted"] else "installed"
             )
-            print(f"  [{i}/{total}] [{status}] {name}")
+            scan = result.get("security_scan")
+            scan_suffix = (
+                f"; SkillSpector: {scan.get('status')}"
+                if isinstance(scan, dict)
+                else ""
+            )
+            print(f"  [{i}/{total}] [{status}] {name}{scan_suffix}")
         except Exception as exc:
             errors += 1
             print(f"  [{i}/{total}] ERROR: {name}: {exc}", file=sys.stderr)
@@ -573,6 +711,8 @@ def main() -> None:
         f"\nDone: {added} added, {updated} updated, {converted} converted, "
         f"{skipped} skipped, {errors} errors"
     )
+    if errors:
+        sys.exit(1)
 
 
 if __name__ == "__main__":

src/skill_telemetry.py

@@ -36,11 +36,15 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Iterator, Mapping
 
+from ctx.telemetry import hash_identifier
 from ctx.utils._file_lock import file_lock
+from ctx.utils._secret_scan import redact_secret_text, secret_key_like
 
 _logger = logging.getLogger(__name__)
 
+SCHEMA_VERSION = "ctx.skill_telemetry.v1"
 EVENT_TYPES = frozenset({"load", "unload", "override", "switch_away"})
+ENTITY_TYPES = frozenset({"skill", "agent", "mcp-server"})
 
 # Same policy as wiki_utils.SAFE_NAME_RE: alnum start, alnum / _ / - / .
 # inside, bounded length. Dots are allowed intentionally for names like
@@ -56,6 +60,8 @@ _ALLOWED_EVENTS_DIR = DEFAULT_EVENTS_PATH.parent.resolve()
 _TRUSTED_ROOT = DEFAULT_EVENTS_PATH.parent.resolve()
 DEFAULT_SESSION_FRACTION = 0.20
 DEFAULT_MIN_RETENTION_MIN = 20.0
+_PRIVATE_DIR_MODE = 0o700
+_PRIVATE_FILE_MODE = 0o600
 
 # Bounds on caller-supplied meta dicts. Keeps the log line small and
 # prevents inadvertent leakage of large mappings like ``os.environ``
@@ -64,6 +70,26 @@ DEFAULT_MIN_RETENTION_MIN = 20.0
 _MAX_META_KEYS = 20
 _MAX_META_VALUE_LEN = 512
 _META_SCALAR_TYPES: tuple[type, ...] = (str, int, float, bool, type(None))
+_HASHED_META_KEYS = frozenset({
+    "command",
+    "cwd",
+    "goal",
+    "input",
+    "output",
+    "path",
+    "prompt",
+    "query",
+    "raw_input",
+    "raw_prompt",
+    "repo",
+    "response",
+    "stderr",
+    "stdout",
+    "task",
+    "tool_args",
+    "tool_input",
+    "tool_output",
+})
 
 
 @dataclass(frozen=True)
@@ -76,8 +102,14 @@ class TelemetryEvent:
     session_id: str
     event_id: str
     meta: Mapping[str, Any] = field(default_factory=dict)
+    skill_hash: str | None = None
+    session_hash: str | None = None
+    entity_type: str | None = None
+    schema_version: str = SCHEMA_VERSION
 
     def __post_init__(self) -> None:
+        if self.schema_version != SCHEMA_VERSION:
+            raise ValueError(f"unsupported telemetry schema: {self.schema_version!r}")
         if self.event not in EVENT_TYPES:
             raise ValueError(
                 f"invalid event type {self.event!r}; expected one of {sorted(EVENT_TYPES)}"
@@ -88,6 +120,12 @@ class TelemetryEvent:
             raise ValueError("session_id must be a non-empty string")
         if not isinstance(self.event_id, str) or not self.event_id:
             raise ValueError("event_id must be a non-empty string")
+        if self.skill_hash is not None and not str(self.skill_hash).startswith("sha256:"):
+            raise ValueError("skill_hash must be a sha256 identifier")
+        if self.session_hash is not None and not str(self.session_hash).startswith("sha256:"):
+            raise ValueError("session_hash must be a sha256 identifier")
+        if self.entity_type is not None and self.entity_type not in ENTITY_TYPES:
+            raise ValueError(f"entity_type must be one of: {sorted(ENTITY_TYPES)}")
         # timestamp must parse as ISO-8601 so downstream readers don't choke
         try:
             datetime.fromisoformat(self.timestamp)
@@ -130,6 +168,51 @@ def _validate_meta(meta: Mapping[str, Any]) -> None:
             )
 
 
+def _sanitize_meta(meta: Mapping[str, Any]) -> dict[str, Any]:
+    """Return bounded metadata without raw secrets, prompts, paths, or command text."""
+
+    safe: dict[str, Any] = {}
+    for key, value in meta.items():
+        if not isinstance(value, str):
+            safe[key] = value
+            continue
+        normalized_key = key.lower()
+        if secret_key_like(key):
+            safe[key] = "[redacted]"
+            continue
+        if normalized_key in _HASHED_META_KEYS:
+            safe[f"{key}_hash"] = hash_identifier(value)
+            continue
+        redacted = redact_secret_text(value)
+        if redacted != value:
+            safe[key] = redacted
+            continue
+        safe[key] = value
+    return safe
+
+
+def ensure_private_events_file(path: Path) -> None:
+    """Create or tighten the legacy local event file to owner read/write only."""
+
+    path.parent.mkdir(parents=True, exist_ok=True, mode=_PRIVATE_DIR_MODE)
+    try:
+        os.chmod(path.parent, _PRIVATE_DIR_MODE)
+    except OSError:
+        pass
+    if path.exists():
+        try:
+            os.chmod(path, _PRIVATE_FILE_MODE)
+        except OSError:
+            pass
+        return
+    fd = os.open(path, os.O_APPEND | os.O_CREAT | os.O_WRONLY, _PRIVATE_FILE_MODE)
+    os.close(fd)
+    try:
+        os.chmod(path, _PRIVATE_FILE_MODE)
+    except OSError:
+        pass
+
+
 def _resolve_events_path(
     path: Path | None,
     *,
@@ -171,6 +254,7 @@ def log_event(
     session_id: str,
     *,
     meta: Mapping[str, Any] | None = None,
+    entity_type: str | None = None,
     path: Path | None = None,
     trusted_root: Path = _TRUSTED_ROOT,
 ) -> TelemetryEvent:
@@ -183,10 +267,11 @@ def log_event(
     write to ``tmp_path`` should pass ``trusted_root=tmp_path``.
     """
     target = _resolve_events_path(path, trusted_root=trusted_root)
-    target.parent.mkdir(parents=True, exist_ok=True)
+    ensure_private_events_file(target)
 
-    safe_meta: dict[str, Any] = dict(meta or {})
+    safe_meta = _sanitize_meta(dict(meta or {}))
     _validate_meta(safe_meta)
+    resolved_entity_type = entity_type or "skill"
 
     record = TelemetryEvent(
         event=event,
@@ -195,6 +280,9 @@ def log_event(
         session_id=session_id,
         event_id=_new_event_id(),
         meta=safe_meta,
+        skill_hash=hash_identifier(skill),
+        session_hash=hash_identifier(session_id),
+        entity_type=resolved_entity_type,
     )
     line = json.dumps(asdict(record), ensure_ascii=False, sort_keys=True) + "\n"
 
@@ -240,6 +328,12 @@ def read_events(
                     session_id=obj["session_id"],
                     event_id=obj["event_id"],
                     meta=obj.get("meta", {}),
+                    skill_hash=obj.get("skill_hash") or hash_identifier(str(obj["skill"])),
+                    session_hash=obj.get("session_hash") or hash_identifier(
+                        str(obj["session_id"])
+                    ),
+                    entity_type=obj.get("entity_type"),
+                    schema_version=obj.get("schema_version", SCHEMA_VERSION),
                 )
             except (json.JSONDecodeError, KeyError, ValueError, TypeError) as exc:
                 msg = (

src/tests/conftest.py

@@ -65,6 +65,35 @@ def project_root() -> Path:
     return _PROJECT_ROOT
 
 
+@pytest.fixture(autouse=True)
+def disable_enterprise_telemetry_side_effects(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    """Keep telemetry-enabled product code from writing to real user paths in tests."""
+
+    def _noop_record_event(*args: object, **kwargs: object) -> None:
+        return None
+
+    import ctx.telemetry as telemetry  # noqa: PLC0415
+
+    monkeypatch.setattr(telemetry, "record_event", _noop_record_event)
+    for module_name in (
+        "ctx.adapters.generic.ctx_core_tools",
+        "ctx.adapters.generic.runtime_lifecycle",
+        "ctx.api",
+        "ctx.cli.run",
+        "ctx.mcp_server.server",
+    ):
+        module = sys.modules.get(module_name)
+        if module is not None:
+            monkeypatch.setattr(
+                module,
+                "record_event",
+                _noop_record_event,
+                raising=False,
+            )
+
+
 @pytest.fixture()
 def tmp_wiki(tmp_path: Path) -> Path:
     """

src/tests/test_agent_add.py

@@ -14,6 +14,7 @@ if str(SRC_DIR) not in sys.path:
     sys.path.insert(0, str(SRC_DIR))
 
 import agent_add  # noqa: E402
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_wiki_base_pack  # noqa: E402
 
 
 class _Decision:
@@ -205,6 +206,25 @@ def test_new_agent_add_writes_converted_agent_mirror(
     assert mirror.read_text(encoding="utf-8") == source_text
 
 
+def test_bom_prefixed_agent_frontmatter_is_accepted(
+    tmp_path: Path,
+    monkeypatch: Any,
+) -> None:
+    wiki, agents_dir, source = _setup_paths(tmp_path)
+    source.write_text("\ufeff" + _agent_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,
+    )
+
+    assert result["is_new_page"] is True
+    assert (wiki / "entities" / "agents" / "reviewer-agent.md").exists()
+
+
 def test_existing_agent_update_refreshes_converted_agent_mirror(
     tmp_path: Path,
     monkeypatch: Any,
@@ -212,11 +232,20 @@ def test_existing_agent_update_refreshes_converted_agent_mirror(
     wiki, agents_dir, source = _setup_paths(tmp_path)
     installed = agents_dir / "reviewer-agent.md"
     installed.write_text(_agent_text(), encoding="utf-8")
+    packs_dir = wiki / "wiki-packs"
+    write_wiki_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="wiki-export-1",
+        pages={
+            "entities/agents/reviewer-agent.md": (
+                "# reviewer-agent\n\nExisting packed agent page.\n"
+            )
+        },
+    )
     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)
@@ -232,6 +261,10 @@ def test_existing_agent_update_refreshes_converted_agent_mirror(
 
     assert result["is_new_page"] is False
     assert mirror.read_text(encoding="utf-8") == updated_text
+    entity = wiki / "entities" / "agents" / "reviewer-agent.md"
+    merged = load_merged_wiki_pages(packs_dir)
+    assert not entity.exists()
+    assert "Updated mirrored agent." in merged["entities/agents/reviewer-agent.md"]
 
 
 def test_main_existing_agent_prints_update_review(

src/tests/test_catalog_builder.py

@@ -17,6 +17,7 @@ from unittest.mock import MagicMock
 import pytest
 
 import catalog_builder
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_wiki_base_pack
 
 
 # ── Helpers ───────────────────────────────────────────────────────────────────
@@ -520,6 +521,39 @@ class TestBuildCatalog:
         for i in range(3):
             assert f"agent-{i}" in content
 
+    def test_pack_only_wiki_writes_catalog_overlay(
+        self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+    ) -> None:
+        _patched_cfg(monkeypatch, threshold=180)
+        wiki_dir = tmp_path / "wiki"
+        write_wiki_base_pack(
+            pack_dir=wiki_dir / "wiki-packs" / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="wiki-export-1",
+            pages={
+                "index.md": "# Index\n\nTotal pages: 0\n\n## Skills\n",
+                "log.md": "# Log\n",
+            },
+        )
+        skills_dir = tmp_path / "skills"
+        agents_dir = tmp_path / "agents"
+        _make_skill(skills_dir, "pack-skill", 12)
+        _make_agent(agents_dir, "pack-agent", 5)
+
+        stats = catalog_builder.build_catalog(wiki_dir, skills_dir, agents_dir, [])
+        catalog_builder.update_wiki_index(wiki_dir, stats)
+        catalog_builder.append_log(wiki_dir, stats)
+
+        assert not (wiki_dir / "catalog.md").exists()
+        assert not (wiki_dir / "index.md").exists()
+        assert not (wiki_dir / "log.md").exists()
+        merged = load_merged_wiki_pages(wiki_dir / "wiki-packs")
+        assert "pack-skill" in merged["catalog.md"]
+        assert "pack-agent" in merged["catalog.md"]
+        assert "[[catalog]]" in merged["index.md"]
+        assert "Total pages: 2" in merged["index.md"]
+        assert "catalog-build" in merged["log.md"]
+
 
 # ── update_wiki_index ─────────────────────────────────────────────────────────
 

src/tests/test_ci_classifier.py

@@ -37,6 +37,7 @@ def test_docs_only_classification() -> None:
         "package_changed": False,
         "similarity_changed": False,
         "source_changed": False,
+        "telemetry_changed": False,
     }
 
 
@@ -147,6 +148,7 @@ def test_workflow_change_fails_open_for_future_gates() -> None:
     assert flags["package_changed"] is True
     assert flags["similarity_changed"] is True
     assert flags["source_changed"] is True
+    assert flags["telemetry_changed"] is True
     assert flags["docs_changed"] is False
     assert flags["docs_only"] is False
 
@@ -186,6 +188,19 @@ def test_graph_artifact_job_uses_release_asset_fallback_for_lfs_budget() -> None
     assert "validating pointer metadata only" not in workflow
 
 
+def test_similarity_gate_caches_and_predownloads_real_model() -> None:
+    workflow = Path(".github/workflows/test.yml").read_text(encoding="utf-8")
+
+    assert "actions/cache@v4" not in workflow
+    assert "actions/cache@v5" in workflow
+    assert "Cache MiniLM model" in workflow
+    assert "hf-sentence-transformers-all-MiniLM-L6-v2-v1" in workflow
+    assert "Pre-download MiniLM model" in workflow
+    assert "sentence-transformers/all-MiniLM-L6-v2" in workflow
+    assert "CTX_REQUIRE_SIMILARITY_EVAL" in workflow
+    assert "src/tests/test_similarity_precision_recall.py" in workflow
+
+
 def test_publish_oidc_permission_is_limited_to_publish_job() -> None:
     workflow = Path(".github/workflows/publish.yml").read_text(encoding="utf-8")
     header = workflow.split("\njobs:\n", maxsplit=1)[0]
@@ -203,6 +218,21 @@ def test_publish_workflow_rejects_existing_pypi_versions() -> None:
     assert "already exists on PyPI" in workflow
 
 
+def test_publish_static_gate_uses_canonical_python_target() -> None:
+    workflow = Path(".github/workflows/publish.yml").read_text(encoding="utf-8")
+    setup_match = re.search(
+        r"- name: Set up Python\n"
+        r"\s+uses: actions/setup-python@v6\n"
+        r"\s+with:\n"
+        r'\s+python-version: "([^"]+)"',
+        workflow,
+    )
+
+    assert setup_match is not None
+    assert setup_match.group(1) == "3.11"
+    assert "python -m mypy src" in workflow
+
+
 def test_publish_workflow_validates_and_uploads_graph_assets() -> None:
     workflow = Path(".github/workflows/publish.yml").read_text(encoding="utf-8")
 
@@ -225,6 +255,20 @@ def test_publish_workflow_validates_and_uploads_graph_assets() -> None:
     assert "graph_assets_available" in workflow
 
 
+def test_publish_workflow_runs_installed_wheel_telemetry_smoke() -> None:
+    workflow = Path(".github/workflows/publish.yml").read_text(encoding="utf-8")
+
+    assert "Telemetry release smoke" in workflow
+    assert "record_event(" in workflow
+    assert "record_counter(" in workflow
+    assert "ctx-telemetry-export --dry-run --json" in workflow
+    assert "ctx-telemetry-export \\" in workflow
+    assert "--signal metrics" in workflow
+    assert "ctx-telemetry-retention plan --signal all --json" in workflow
+    assert "raw-release-telemetry-sentinel" in workflow
+    assert "raw telemetry sentinel leaked into exported telemetry" in workflow
+
+
 def test_changelog_defines_current_release_link() -> None:
     pyproject = Path("pyproject.toml").read_text(encoding="utf-8")
     version_match = re.search(r'^version = "([^"]+)"', pyproject, re.MULTILINE)
@@ -404,6 +448,19 @@ def test_similarity_paths_are_classified() -> None:
     assert flags["source_changed"] is True
 
 
+def test_telemetry_paths_are_classified() -> None:
+    for path in (
+        "docs/telemetry.md",
+        "src/config.json",
+        "src/ctx/telemetry/__init__.py",
+        "src/ctx/adapters/generic/runtime_lifecycle.py",
+        "src/tests/test_enterprise_telemetry.py",
+    ):
+        flags = classify_paths([path])
+
+        assert flags["telemetry_changed"] is True
+
+
 def test_embedding_backend_change_runs_similarity_gate() -> None:
     flags = classify_paths(["src/embedding_backend.py"])
 
@@ -422,6 +479,7 @@ def test_main_writes_github_outputs(tmp_path: Path, monkeypatch) -> None:
     written = output.read_text(encoding="utf-8").splitlines()
     assert "package_changed=true" in written
     assert "source_changed=true" in written
+    assert "telemetry_changed=false" in written
     assert "docs_changed=false" in written
     assert "docs_only=false" in written
 
@@ -671,6 +729,29 @@ def test_ci_required_rejects_browser_skip_when_classifier_requests_it() -> None:
     }
 
 
+def test_ci_required_rejects_telemetry_skip_when_classifier_requests_it() -> None:
+    needs = _required_needs(
+        classify={"result": "success", "outputs": {"telemetry_changed": "true"}},
+        **{"telemetry-enterprise": {"result": "skipped"}},
+    )
+
+    assert failed_required_jobs(needs, event_name="pull_request") == {
+        "telemetry-enterprise": "skipped",
+    }
+
+
+def test_ci_required_allows_telemetry_skip_for_unrelated_pr_only() -> None:
+    needs = _required_needs(
+        classify={"result": "success", "outputs": {"telemetry_changed": "false"}},
+        **{"telemetry-enterprise": {"result": "skipped"}},
+    )
+
+    assert failed_required_jobs(needs, event_name="pull_request") == {}
+    assert failed_required_jobs(needs, event_name="push") == {
+        "telemetry-enterprise": "skipped",
+    }
+
+
 def test_ci_required_rejects_missing_docs_check_on_mixed_docs_pr() -> None:
     needs = _required_needs(
         classify={
@@ -697,3 +778,14 @@ def test_ci_required_rejects_missing_graph_check_on_mixed_artifact_pr() -> None:
     assert failed_required_jobs(needs, event_name="pull_request") == {
         "graph-check": "skipped",
     }
+
+
+def test_workflow_runs_focused_telemetry_enterprise_gate() -> None:
+    workflow = Path(".github/workflows/test.yml").read_text(encoding="utf-8")
+
+    assert "telemetry_changed: ${{ steps.classify.outputs.telemetry_changed }}" in workflow
+    assert "telemetry-enterprise:" in workflow
+    assert "needs.classify.outputs.telemetry_changed == 'true'" in workflow
+    assert "src/tests/test_enterprise_telemetry.py" in workflow
+    assert "src/tests/test_harness_cli_run.py" in workflow
+    assert '-k "telemetry or runtime_lifecycle"' in workflow

src/tests/test_clean_host_contract.py

@@ -167,6 +167,7 @@ def test_isolated_env_does_not_inherit_caller_secrets(
     assert "GITHUB_TOKEN" not in env
     assert "CTX_WIKI_DIR" not in env
     assert "CLAUDE_HOME" not in env
+    assert env["CTX_ALLOW_MISSING_GRAPH"] == "1"
 
 
 def test_assert_inside_rejects_escape(tmp_path: Path) -> None:

src/tests/test_context_monitor.py

@@ -18,6 +18,7 @@ import sys
 from datetime import datetime, timezone
 from pathlib import Path
 
+import networkx as nx
 import pytest
 
 sys.path.insert(0, str(Path(__file__).parents[1]))
@@ -32,6 +33,7 @@ from ctx.adapters.claude_code.hooks.context_monitor import (
     load_recent_unmatched_count,
     write_pending_skills,
 )
+from ctx.core.graph.graph_packs import write_base_pack
 
 TODAY = datetime.now(timezone.utc).strftime("%Y-%m-%d")
 
@@ -245,6 +247,41 @@ class TestWritePendingSkills:
         assert _cm.graph_suggest(["fastapi"]) == [{"name": "fastapi-pro", "type": "skill"}]
         assert calls["entity_types"] == ("skill", "agent", "mcp-server")
 
+    def test_graph_suggest_reads_active_packs_without_legacy_graph_json(self, tmp_path, monkeypatch):
+        graph_out = tmp_path / "skill-wiki" / "graphify-out"
+        graph = nx.Graph()
+        graph.add_node("skill:fastapi-pro", type="skill", label="fastapi-pro", tags=["fastapi"])
+        write_base_pack(
+            pack_dir=graph_out / "packs" / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="export-1",
+            config_hash="config-1",
+            model_id="model-1",
+            graph=graph,
+        )
+        assert not (graph_out / "graph.json").exists()
+        monkeypatch.setattr(_cm, "CLAUDE_DIR", tmp_path)
+        calls = {}
+
+        def fake_recommend_by_tags(graph, tags, **kwargs):
+            calls["nodes"] = sorted(graph.nodes)
+            calls["tags"] = tags
+            return [{"name": "fastapi-pro", "type": "skill"}]
+
+        fake_recommend_module = type(
+            "FakeRecommendModule",
+            (),
+            {"recommend_by_tags": staticmethod(fake_recommend_by_tags)},
+        )
+        monkeypatch.setitem(
+            sys.modules,
+            "ctx.core.resolve.recommendations",
+            fake_recommend_module,
+        )
+
+        assert _cm.graph_suggest(["fastapi"]) == [{"name": "fastapi-pro", "type": "skill"}]
+        assert calls == {"nodes": ["skill:fastapi-pro"], "tags": ["fastapi"]}
+
 
 # ---------------------------------------------------------------------------
 # load_recent_unmatched_count

src/tests/test_ctx_init.py

@@ -16,6 +16,9 @@ from types import SimpleNamespace
 import networkx as nx
 import pytest
 import ctx_init as ci
+from ctx.core.graph.graph_packs import write_base_pack
+from ctx.core.graph.graph_store import validate_graph_store
+from ctx.core.wiki.wiki_packs import write_wiki_base_pack
 
 
 def _write_dashboard_index(path: Path, *, export_id: str = "test-export") -> None:
@@ -230,6 +233,7 @@ def test_main_auto_wizard_in_terminal_configures_custom_model(
         "verification": "pytest ruff",
         "privacy": "private repo",
         "attach_mode": "mcp",
+        "api_key_env": "OPENAI_API_KEY",
     }
     user_config = json.loads((tmp_path / "skill-system-config.json").read_text())
     assert user_config["knowledge"]["mode"] == "enriched"
@@ -302,7 +306,14 @@ def test_main_with_hooks_flag_invokes_inject(tmp_path: Path, monkeypatch) -> Non
     assert not any(c == "inject_hooks" for call in calls for c in call)
 
 
-def _write_graph_archive(tmp_path: Path) -> Path:
+def _write_graph_archive(
+    tmp_path: Path,
+    *,
+    include_graph_pack: bool = False,
+    graph_pack_export_id: str = "test-export",
+    include_wiki_pack: bool = False,
+    wiki_pack_export_id: str = "test-export",
+) -> Path:
     source = tmp_path / "archive-source"
     graph_out = source / "graphify-out"
     graph_out.mkdir(parents=True)
@@ -343,6 +354,27 @@ def _write_graph_archive(tmp_path: Path) -> Path:
     entities.mkdir(parents=True)
     (entities / "current.md").write_text("# Current\n", encoding="utf-8")
     (source / "index.md").write_text("# Wiki\n", encoding="utf-8")
+    if include_graph_pack:
+        graph = nx.Graph()
+        graph.add_node("skill:current", label="current", type="skill")
+        write_base_pack(
+            pack_dir=graph_out / "packs" / f"base-{graph_pack_export_id}",
+            pack_id=f"base-{graph_pack_export_id}",
+            base_export_id=graph_pack_export_id,
+            config_hash="config-1",
+            model_id="model-1",
+            graph=graph,
+        )
+    if include_wiki_pack:
+        write_wiki_base_pack(
+            pack_dir=source / "wiki-packs" / f"base-{wiki_pack_export_id}",
+            pack_id=f"base-{wiki_pack_export_id}",
+            base_export_id=wiki_pack_export_id,
+            pages={
+                "index.md": "# Wiki\n",
+                "entities/skills/current.md": "# Current\n",
+            },
+        )
     archive = tmp_path / "wiki-graph.tar.gz"
     with tarfile.open(archive, "w:gz") as tf:
         for path in sorted(source.rglob("*")):
@@ -430,8 +462,8 @@ def test_lfs_pointer_graph_archive_is_ignored(
     graph_dir.mkdir()
     (graph_dir / "wiki-graph-runtime.tar.gz").write_text(
         "version https://git-lfs.github.com/spec/v1\n"
-        "oid sha256:334fb19bace3fd6e4b92087850f17297fb248032957d123f3f1432dfde2e36c0\n"
-        "size 175773376\n",
+        "oid sha256:993fc08377fdb09edcff4414c59b10fc121189b4a161bf796e3f8f6600907bb1\n"
+        "size 122141091\n",
         encoding="utf-8",
     )
     cwd = tmp_path / "cwd"
@@ -820,9 +852,213 @@ def test_graph_install_validation_does_not_parse_full_graph_json(
     ci._validate_graph_install_tree(wiki)
 
 
+def test_graph_json_outline_scans_middle_for_edges_key(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(ci, "_GRAPH_JSON_OUTLINE_BYTES", 32)
+    filler = "x" * 256
+    graph_json = tmp_path / "graph.json"
+    graph_json.write_text(
+        '{"nodes":["' + filler + '"],"edges":[],"graph":"' + filler + '"}',
+        encoding="utf-8",
+    )
+
+    ci._validate_graph_json_outline(graph_json)
+
+
+def test_graph_install_validation_accepts_base_pack_without_graph_json(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    graph_out = wiki / "graphify-out"
+    graph_out.mkdir(parents=True)
+    (wiki / "index.md").write_text("# Wiki\n", encoding="utf-8")
+    graph = nx.Graph()
+    graph.add_node("skill:pack-only", label="pack-only", type="skill")
+    write_base_pack(
+        pack_dir=graph_out / "packs" / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="test-export",
+        config_hash="config-1",
+        model_id="model-1",
+        graph=graph,
+    )
+    (graph_out / "graph-delta.json").write_text(
+        json.dumps({"export_id": "test-export", "nodes": [], "edges": []}),
+        encoding="utf-8",
+    )
+    (graph_out / "communities.json").write_text(
+        json.dumps({"export_id": "test-export", "total_communities": 0}),
+        encoding="utf-8",
+    )
+    (graph_out / "graph-report.md").write_text(
+        "# Graph Report\n\n> Export ID: test-export\n",
+        encoding="utf-8",
+    )
+    (graph_out / "graph-export-manifest.json").write_text(
+        json.dumps({
+            "version": 1,
+            "export_id": "test-export",
+            "artifacts": {
+                "graph": "graph.json",
+                "delta": "graph-delta.json",
+                "communities": "communities.json",
+                "report": "graph-report.md",
+            },
+        }),
+        encoding="utf-8",
+    )
+    _write_dashboard_index(graph_out / "dashboard-neighborhoods.sqlite3")
+    external = wiki / "external-catalogs" / "skills-sh"
+    external.mkdir(parents=True)
+    (external / "catalog.json").write_text("{}", encoding="utf-8")
+
+    ci._validate_graph_install_tree(wiki)
+
+
+def test_runtime_graph_install_extracts_and_validates_wiki_packs(
+    tmp_path: Path,
+) -> None:
+    archive = _write_graph_archive(tmp_path, include_wiki_pack=True)
+    wiki = tmp_path / "installed-wiki"
+
+    ci._extract_graph_archive(archive, wiki, install_mode="runtime")
+
+    assert (wiki / "wiki-packs" / "base-test-export" / "wiki-pack-manifest.json").is_file()
+    assert not (wiki / "entities" / "skills" / "current.md").exists()
+    ci._validate_graph_install_tree(wiki)
+    assert ci._graph_full_install_complete(wiki) is True
+
+
+def test_runtime_graph_install_extracts_and_validates_graph_packs(
+    tmp_path: Path,
+) -> None:
+    archive = _write_graph_archive(tmp_path, include_graph_pack=True)
+    wiki = tmp_path / "installed-wiki"
+
+    ci._extract_graph_archive(archive, wiki, install_mode="runtime")
+
+    assert (
+        wiki / "graphify-out" / "packs" / "base-test-export" / "graph-pack-manifest.json"
+    ).is_file()
+    ci._validate_graph_install_tree(wiki)
+
+
+def test_build_graph_refreshes_operational_graph_store(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    archive = _write_graph_archive(tmp_path, include_graph_pack=True)
+    claude = tmp_path / "home"
+    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) == 0
+    graph_dir = claude / "skill-wiki" / "graphify-out"
+    store = graph_dir / "graph-store.sqlite3"
+    assert validate_graph_store(store, graph_dir)["ok"] is True
+
+    store.unlink()
+    assert ci.build_graph(claude) == 0
+    assert validate_graph_store(store, graph_dir)["ok"] is True
+
+
+def test_graph_install_rejects_mismatched_graph_pack_export_id(
+    tmp_path: Path,
+) -> None:
+    archive = _write_graph_archive(
+        tmp_path,
+        include_graph_pack=True,
+        graph_pack_export_id="wrong-export",
+    )
+
+    with pytest.raises(ValueError, match="graphify-out/packs export_id mismatch"):
+        ci._extract_graph_archive(archive, tmp_path / "installed-wiki", install_mode="runtime")
+
+
+def test_graph_install_rejects_mismatched_wiki_pack_export_id(
+    tmp_path: Path,
+) -> None:
+    archive = _write_graph_archive(
+        tmp_path,
+        include_wiki_pack=True,
+        wiki_pack_export_id="wrong-export",
+    )
+
+    with pytest.raises(ValueError, match="wiki-packs export_id mismatch"):
+        ci._extract_graph_archive(archive, tmp_path / "installed-wiki", install_mode="runtime")
+
+
+def test_runtime_graph_install_without_full_entities_is_not_full_install(
+    tmp_path: Path,
+) -> None:
+    archive = _write_graph_archive(tmp_path)
+    wiki = tmp_path / "installed-wiki"
+
+    ci._extract_graph_archive(archive, wiki, install_mode="runtime")
+
+    assert ci._graph_install_complete(wiki) is True
+    assert ci._graph_full_install_complete(wiki) is False
+
+
+def test_full_graph_install_uses_system_tar_after_validation(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    archive = _write_graph_archive(tmp_path)
+    wiki = tmp_path / "installed-wiki"
+    calls: list[list[str]] = []
+
+    def fake_run(cmd: list[str], **_kwargs: object) -> SimpleNamespace:
+        calls.append(list(cmd))
+        target = Path(cmd[cmd.index("-C") + 1])
+        with tarfile.open(archive, "r:gz") as tf:
+            tf.extractall(target)
+        return SimpleNamespace(returncode=0, stdout="", stderr="")
+
+    monkeypatch.setattr(ci.shutil, "which", lambda _name: "tar")
+    monkeypatch.setattr(ci.subprocess, "run", fake_run)
+
+    ci._extract_graph_archive(archive, wiki, install_mode="full")
+
+    assert len(calls) == 1
+    assert calls[0][:3] == ["tar", "-xzf", str(archive)]
+    assert calls[0][3] == "-C"
+    assert Path(calls[0][4]).name.startswith(".installed-wiki-stage-")
+    assert ci._graph_full_install_complete(wiki) is True
+    assert (wiki / "entities" / "skills" / "current.md").is_file()
+
+
+def test_full_graph_install_prefers_wiki_packs_over_expanded_entities(
+    tmp_path: Path,
+    monkeypatch,
+) -> None:
+    archive = _write_graph_archive(tmp_path, include_wiki_pack=True)
+    wiki = tmp_path / "installed-wiki"
+
+    def fail_if_system_tar_is_used(*_args: object, **_kwargs: object) -> SimpleNamespace:
+        pytest.fail("packed full install should use filtered extraction")
+
+    monkeypatch.setattr(ci.shutil, "which", lambda _name: "tar")
+    monkeypatch.setattr(ci.subprocess, "run", fail_if_system_tar_is_used)
+
+    ci._extract_graph_archive(archive, wiki, install_mode="full")
+
+    assert (wiki / "wiki-packs" / "base-test-export" / "wiki-pack-manifest.json").is_file()
+    assert not (wiki / "entities" / "skills" / "current.md").exists()
+    assert ci._graph_full_install_complete(wiki) is True
+
+
 def test_graph_install_force_prunes_stale_generated_files(
     tmp_path: Path,
     monkeypatch,
+    capsys,
 ) -> None:
     archive = _write_graph_archive(tmp_path)
     claude = tmp_path / "home"
@@ -844,6 +1080,9 @@ def test_graph_install_force_prunes_stale_generated_files(
         "--force",
         "--model-mode", "skip",
     ]) == 0
+    out = capsys.readouterr().out
+    assert "full graph install expands the markdown LLM-wiki" in out
+    assert "runtime mode is enough for recommendations" in out
     assert not stale.exists()
     assert (claude / "skill-wiki" / "entities" / "skills" / "current.md").is_file()
 
@@ -1278,7 +1517,7 @@ def test_recommend_harnesses_avoids_semantic_model_load_by_default(
 ) -> None:
     graph = nx.Graph()
     graph.add_node("harness:langgraph", label="langgraph", type="harness")
-    monkeypatch.setattr(ci, "_load_recommendation_graph", lambda: graph)
+    monkeypatch.setattr(ci, "_load_harness_recommendation_graph", lambda: graph)
     monkeypatch.setattr(ci, "_harness_supports_provider", lambda *args, **kwargs: True)
     monkeypatch.setattr(ci, "_installed_harness_slugs", lambda _path: set())
     monkeypatch.setattr(

src/tests/test_ctx_monitor_3type.py

@@ -24,13 +24,17 @@ from __future__ import annotations
 import json
 import sys
 from pathlib import Path
+from typing import Any, cast
 
 import networkx as nx
 import pytest
 
 sys.path.insert(0, str(Path(__file__).parents[1]))
 
-import ctx_monitor as _cm
+from ctx.core import entity_types as _entity_types
+from ctx.core.wiki.wiki_packs import write_wiki_base_pack
+from ctx.monitor import testing as _mt
+from ctx.monitor.services import wiki as _wiki_service
 
 
 # ────────────────────────────────────────────────────────────────────
@@ -40,7 +44,8 @@ import ctx_monitor as _cm
 
 @pytest.fixture()
 def wiki_3type(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
-    """Build a minimal wiki and point ctx_monitor at it via ``_wiki_dir``."""
+    """Build a minimal wiki and point monitor compat at it via ``_wiki_dir``."""
+    _wiki_service.reset_caches()
     wiki = tmp_path / "skill-wiki"
     for sub in ("skills", "agents", "harnesses"):
         (wiki / "entities" / sub).mkdir(parents=True)
@@ -78,8 +83,8 @@ def wiki_3type(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
         encoding="utf-8",
     )
 
-    monkeypatch.setattr(_cm, "_wiki_dir", lambda: wiki)
-    monkeypatch.setattr(_cm, "_dashboard_graph_index_archives", lambda: [])
+    monkeypatch.setattr(_mt, "wiki_dir", lambda: wiki)
+    monkeypatch.setattr(_mt, "dashboard_graph_index_archives", lambda: [])
     return wiki
 
 
@@ -90,17 +95,24 @@ def wiki_3type(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
 
 class TestWikiStats:
     def test_counts_include_mcps(self, wiki_3type):
-        s = _cm._wiki_stats()
+        s = _mt.wiki_stats()
+        direct = _wiki_service.wiki_stats(
+            wiki_3type,
+            _mt.dashboard_graph_index_path(),
+            index_matches_manifest=_mt.dashboard_index_matches_manifest,
+            graph_node_total=0,
+        )
         assert s["skills"] == 2
         assert s["agents"] == 1
         assert s["mcps"] == 3
         assert s["harnesses"] == 1
         assert s["total"] == 7
+        assert direct == s
 
     def test_mcps_sharded_dirs_scanned_recursively(self, wiki_3type):
         """MCPs live under entities/mcp-servers/<first-char>/<slug>.md —
         the scan must walk the shard dirs, not just the top level."""
-        s = _cm._wiki_stats()
+        s = _mt.wiki_stats()
         assert s["mcps"] == 3  # 2 under a/, 1 under p/
 
     def test_no_mcp_dir_gracefully_zero(self, tmp_path, monkeypatch):
@@ -108,8 +120,8 @@ class TestWikiStats:
         users who have only ingested skills."""
         wiki = tmp_path / "wiki"
         (wiki / "entities" / "skills").mkdir(parents=True)
-        monkeypatch.setattr(_cm, "_wiki_dir", lambda: wiki)
-        s = _cm._wiki_stats()
+        monkeypatch.setattr(_mt, "wiki_dir", lambda: wiki)
+        s = _mt.wiki_stats()
         assert s["mcps"] == 0
         assert s["harnesses"] == 0
         assert "mcps" in s  # key present even at zero
@@ -127,14 +139,14 @@ class TestGraphStats:
             "> Nodes: 102,697 | Edges: 2,900,910 | Communities: 52\n",
             encoding="utf-8",
         )
-        monkeypatch.setattr(_cm, "_wiki_dir", lambda: wiki)
+        monkeypatch.setattr(_mt, "wiki_dir", lambda: wiki)
         monkeypatch.setattr(
-            _cm,
-            "_load_dashboard_graph",
+            _mt,
+            "load_dashboard_graph",
             lambda: (_ for _ in ()).throw(AssertionError("loaded graph.json")),
         )
 
-        assert _cm._graph_stats() == {
+        assert _mt.graph_stats() == {
             "nodes": 102697,
             "edges": 2900910,
             "available": True,
@@ -148,7 +160,7 @@ class TestGraphStats:
 
 class TestWikiIndexEntries:
     def test_entries_include_mcp_servers(self, wiki_3type):
-        entries = _cm._wiki_index_entries()
+        entries = _mt.wiki_index_entries()
         types = {e["type"] for e in entries}
         assert "mcp-server" in types
         assert "harness" in types
@@ -156,20 +168,97 @@ class TestWikiIndexEntries:
         assert "agent" in types
 
     def test_mcp_slugs_surfaced_from_both_shards(self, wiki_3type):
-        entries = _cm._wiki_index_entries()
+        entries = _mt.wiki_index_entries()
         slugs = {e["slug"] for e in entries if e["type"] == "mcp-server"}
         assert slugs == {"anthropic-python-sdk", "atlassian-cloud", "pulsemcp-meta"}
 
     def test_wiki_entity_path_resolves_sharded_mcp_pages(self, wiki_3type):
-        path = _cm._wiki_entity_path("anthropic-python-sdk")
+        assert _entity_types.normalize_entity_type("mcp") == "mcp-server"
+        assert _mt.DASHBOARD_ENTITY_SOURCES == _entity_types.entity_source_specs()
+        path = _mt.wiki_entity_path("anthropic-python-sdk")
         assert path == (
             wiki_3type / "entities" / "mcp-servers" / "a" / "anthropic-python-sdk.md"
         )
 
     def test_wiki_entity_path_resolves_harness_pages(self, wiki_3type):
-        path = _cm._wiki_entity_path("langgraph", entity_type="harness")
+        path = _mt.wiki_entity_path("langgraph", entity_type="harness")
         assert path == wiki_3type / "entities" / "harnesses" / "langgraph.md"
 
+    def test_wiki_pack_pages_override_physical_entity_pages(
+        self,
+        wiki_3type: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        _wiki_service.reset_caches()
+        monkeypatch.setattr(_mt, "render_entity_subgraph", lambda *_, **__: "")
+        (wiki_3type / "entities" / "skills" / "python-patterns.md").write_text(
+            "---\n"
+            "title: Stale Physical Page\n"
+            "type: skill\n"
+            "tags: [stale]\n"
+            "description: stale physical description\n"
+            "---\n"
+            "# Stale Physical Page\n",
+            encoding="utf-8",
+        )
+        write_wiki_base_pack(
+            pack_dir=wiki_3type / "wiki-packs" / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="export-1",
+            pages={
+                "entities/skills/python-patterns.md": (
+                    "---\n"
+                    "title: Fresh Pack Page\n"
+                    "type: skill\n"
+                    "tags: [pack, merged]\n"
+                    "description: fresh pack description\n"
+                    "---\n"
+                    "# Fresh Pack Page\n\n"
+                    "Merged wiki pack body.\n"
+                ),
+                "entities/mcp-servers/g/github.md": (
+                    "---\n"
+                    "title: GitHub MCP\n"
+                    "type: mcp-server\n"
+                    "tags: [github, merged]\n"
+                    "description: pack-only mcp\n"
+                    "---\n"
+                    "# GitHub MCP\n"
+                ),
+            },
+        )
+
+        entries = _mt.wiki_index_entries(limit_per_type=None)
+        slugs = {entry["slug"] for entry in entries}
+        service_detail = _wiki_service.entity_detail(
+            wiki_3type,
+            "python-patterns",
+            entity_type="skill",
+        )
+        detail = _mt.wiki_entity_detail("python-patterns", entity_type="skill")
+        search = _mt.search_wiki_entities("merged body", entity_type="skill")
+        html = _mt.render_wiki_entity("python-patterns", entity_type="skill")
+        stats = _mt.wiki_stats()
+
+        assert slugs == {"python-patterns", "github"}
+        assert service_detail is not None
+        assert service_detail["frontmatter"]["title"] == "Fresh Pack Page"
+        assert "Merged wiki pack body" in service_detail["body"]
+        assert detail is not None
+        assert detail["frontmatter"]["title"] == "Fresh Pack Page"
+        assert "Merged wiki pack body" in detail["body"]
+        assert [row["slug"] for row in search] == ["python-patterns"]
+        assert "Fresh Pack Page" in html
+        assert "Stale Physical Page" not in html
+        assert stats == {
+            "skills": 1,
+            "agents": 0,
+            "mcps": 1,
+            "harnesses": 0,
+            "total": 2,
+            "split_known": True,
+        }
+
     def test_wiki_search_indexes_tags_beyond_preview_limit(self, wiki_3type):
         page = wiki_3type / "entities" / "skills" / "many-tags.md"
         page.write_text(
@@ -181,14 +270,14 @@ class TestWikiIndexEntries:
             encoding="utf-8",
         )
 
-        entries = _cm._wiki_index_entries()
+        entries = _mt.wiki_index_entries()
         entry = next(e for e in entries if e["slug"] == "many-tags")
 
         assert entry["tags"] == ["one", "two", "three", "four", "five", "six"]
         assert "seventh" in entry["search_tags"]
 
     def test_index_entries_can_sample_per_entity_type(self, wiki_3type):
-        entries = _cm._wiki_index_entries(limit_per_type=1)
+        entries = _mt.wiki_index_entries(limit_per_type=1)
         counts: dict[str, int] = {}
         for entry in entries:
             counts[entry["type"]] = counts.get(entry["type"], 0) + 1
@@ -212,7 +301,7 @@ def test_wiki_index_sampling_is_sorted_by_slug(wiki_3type: Path) -> None:
         encoding="utf-8",
     )
 
-    entries = _cm._wiki_index_entries(limit_per_type=1)
+    entries = _mt.wiki_index_entries(limit_per_type=1)
     skill_entries = [entry for entry in entries if entry["type"] == "skill"]
 
     assert [entry["slug"] for entry in skill_entries] == ["aaa-first"]
@@ -222,7 +311,7 @@ def test_wiki_entity_page_marks_truncated_body_and_frontmatter(
     wiki_3type: Path,
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    monkeypatch.setattr(_cm, "_render_entity_subgraph", lambda *_, **__: "")
+    monkeypatch.setattr(_mt, "render_entity_subgraph", lambda *_, **__: "")
     long_description = "x" * 160
     long_body = "body-line\n" * 1400
     (wiki_3type / "entities" / "skills" / "long-page.md").write_text(
@@ -234,7 +323,7 @@ def test_wiki_entity_page_marks_truncated_body_and_frontmatter(
         encoding="utf-8",
     )
 
-    html = _cm._render_wiki_entity("long-page", entity_type="skill")
+    html = _mt.render_wiki_entity("long-page", entity_type="skill")
 
     assert "Body preview truncated at 12,000 characters." in html
     assert "(truncated)" in html
@@ -244,14 +333,14 @@ class TestRenderHome3Type:
     def test_wiki_card_shows_mcp_count(self, wiki_3type, monkeypatch):
         # Other dependencies of _render_home need shims that don't touch
         # the real user dir. Empty manifests + empty audit log are fine.
-        monkeypatch.setattr(_cm, "_read_manifest", lambda: {"load": [], "unload": []})
-        monkeypatch.setattr(_cm, "_summarize_sessions", lambda: [])
-        monkeypatch.setattr(_cm, "_grade_distribution", lambda: {})
-        monkeypatch.setattr(_cm, "_graph_stats", lambda: {"nodes": 0, "edges": 0, "available": False})
-        monkeypatch.setattr(_cm, "_audit_log_path", lambda: wiki_3type / "no-audit.log")
-        monkeypatch.setattr(_cm, "_read_jsonl", lambda *a, **k: [])
-
-        html = _cm._render_home()
+        monkeypatch.setattr(_mt, "read_manifest", lambda: {"load": [], "unload": []})
+        monkeypatch.setattr(_mt, "summarize_sessions", lambda: [])
+        monkeypatch.setattr(_mt, "grade_distribution", lambda: {})
+        monkeypatch.setattr(_mt, "graph_stats", lambda: {"nodes": 0, "edges": 0, "available": False})
+        monkeypatch.setattr(_mt, "audit_log_path", lambda: wiki_3type / "no-audit.log")
+        monkeypatch.setattr(_mt, "read_jsonl", lambda *a, **k: [])
+
+        html = _mt.render_home()
         # The detail line inside the Wiki entities card must name MCPs.
         assert "MCPs" in html
         assert "2 skills" in html or "2 skill" in html
@@ -264,7 +353,7 @@ class TestSessionSummaries3Type:
     def test_agent_unload_and_mcp_actions_get_own_buckets(self, tmp_path, monkeypatch):
         claude = tmp_path / ".claude"
         claude.mkdir()
-        monkeypatch.setattr(_cm, "_claude_dir", lambda: claude)
+        monkeypatch.setattr(_mt, "claude_dir", lambda: claude)
         records = [
             {
                 "ts": "2026-05-02T10:00:00Z",
@@ -307,7 +396,7 @@ class TestSessionSummaries3Type:
             encoding="utf-8",
         )
 
-        session = _cm._summarize_sessions()[0]
+        session = _mt.summarize_sessions()[0]
 
         assert session["agents_loaded"] == ["code-reviewer"]
         assert session["skills_loaded"] == []
@@ -317,7 +406,7 @@ class TestSessionSummaries3Type:
         assert session["mcps_unloaded"] == ["anthropic-python-sdk"]
 
     def test_sessions_index_renders_agent_and_mcp_columns(self, monkeypatch):
-        monkeypatch.setattr(_cm, "_summarize_sessions", lambda: [{
+        monkeypatch.setattr(_mt, "summarize_sessions", lambda: [{
             "session_id": "S1",
             "first_seen": "2026-05-02T10:00:00Z",
             "last_seen": "2026-05-02T10:02:00Z",
@@ -330,7 +419,7 @@ class TestSessionSummaries3Type:
             "lifecycle_transitions": 0,
         }])
 
-        html = _cm._render_sessions_index()
+        html = _mt.render_sessions_index()
 
         assert "Agents↓" in html
         assert "MCPs↑" in html
@@ -345,8 +434,8 @@ class TestSessionSummaries3Type:
 
 class TestRenderWikiIndex3Type:
     def test_mcp_server_checkbox_present(self, wiki_3type, monkeypatch):
-        monkeypatch.setattr(_cm, "_all_sidecars", lambda: [])
-        html = _cm._render_wiki_index()
+        monkeypatch.setattr(_mt, "all_sidecars", lambda: [])
+        html = _mt.render_wiki_index()
         assert "value='mcp-server' checked" in html
         assert "value='harness' checked" in html
         # Count for the mcp-server bucket should render.
@@ -359,9 +448,9 @@ class TestRenderWikiIndex3Type:
             "---\ntype: skill\ntags: [one, two, three, four, five, six, seventh]\n---\n# many-tags\n",
             encoding="utf-8",
         )
-        monkeypatch.setattr(_cm, "_all_sidecars", lambda: [])
+        monkeypatch.setattr(_mt, "all_sidecars", lambda: [])
 
-        html = _cm._render_wiki_index()
+        html = _mt.render_wiki_index()
 
         assert "data-tags='one two three four five six seventh'" in html
 
@@ -373,9 +462,9 @@ class TestRenderWikiIndex3Type:
 
 class TestRenderLoaded3Type:
     def test_heading_names_all_three_types(self, monkeypatch):
-        monkeypatch.setattr(_cm, "_read_manifest",
+        monkeypatch.setattr(_mt, "read_manifest",
                             lambda: {"load": [], "unload": []})
-        html = _cm._render_loaded()
+        html = _mt.render_loaded()
         assert "skills, agents, MCPs &amp; harnesses" in html or (
             "skills, agents, MCPs & harnesses" in html
         )
@@ -394,8 +483,8 @@ class TestRenderLoaded3Type:
             ],
             "unload": [],
         }
-        monkeypatch.setattr(_cm, "_read_manifest", lambda: manifest)
-        html = _cm._render_loaded()
+        monkeypatch.setattr(_mt, "read_manifest", lambda: manifest)
+        html = _mt.render_loaded()
         # Four section headers render — one per type.
         assert "<h3" in html
         assert "Skills " in html or "Skills</h3" in html or "Skills " in html
@@ -420,8 +509,8 @@ class TestRenderLoaded3Type:
             ],
             "unload": [],
         }
-        monkeypatch.setattr(_cm, "_read_manifest", lambda: manifest)
-        html = _cm._render_loaded()
+        monkeypatch.setattr(_mt, "read_manifest", lambda: manifest)
+        html = _mt.render_loaded()
         assert "data-etype='skill'" in html
         assert "data-etype='agent'" in html
         assert "data-etype='mcp-server'" in html
@@ -432,9 +521,9 @@ class TestRenderLoaded3Type:
         """Pre-install_utils manifest entries had no entity_type field.
         Those must default to skill (what the implicit contract was)
         and still render in the Skills section without crashing."""
-        monkeypatch.setattr(_cm, "_read_manifest",
+        monkeypatch.setattr(_mt, "read_manifest",
                             lambda: {"load": [{"skill": "legacy"}], "unload": []})
-        html = _cm._render_loaded()
+        html = _mt.render_loaded()
         assert "legacy" in html
         assert "data-etype='skill'" in html
 
@@ -450,8 +539,8 @@ class TestRenderLoaded3Type:
                 },
             ],
         }
-        monkeypatch.setattr(_cm, "_read_manifest", lambda: manifest)
-        html = _cm._render_loaded()
+        monkeypatch.setattr(_mt, "read_manifest", lambda: manifest)
+        html = _mt.render_loaded()
         assert "data-slug='code-reviewer' data-etype='agent'" in html
         assert (
             "data-slug='anthropic-python-sdk' data-etype='mcp-server'"
@@ -478,7 +567,7 @@ class TestPerformUnloadByEntityType:
         from ctx.adapters.claude_code.install import skill_unload
         monkeypatch.setattr(skill_unload, "unload_from_session",
                             fake_unload_from_session)
-        ok, msg = _cm._perform_unload("python-patterns", entity_type="skill")
+        ok, msg = _mt.perform_unload("python-patterns", entity_type="skill")
         assert ok
         assert calls["slugs"] == ["python-patterns"]
         assert calls["entity_type"] == "skill"
@@ -504,7 +593,7 @@ class TestPerformUnloadByEntityType:
         from ctx.adapters.claude_code.install import mcp_install
         monkeypatch.setattr(mcp_install, "uninstall_mcp", fake_uninstall)
 
-        ok, msg = _cm._perform_unload("anthropic-python-sdk",
+        ok, msg = _mt.perform_unload("anthropic-python-sdk",
                                        entity_type="mcp-server")
         assert ok
         assert calls["slug"] == "anthropic-python-sdk"
@@ -517,7 +606,7 @@ class TestPerformUnloadByEntityType:
     ):
         claude = tmp_path / ".claude"
         claude.mkdir()
-        monkeypatch.setattr(_cm, "_claude_dir", lambda: claude)
+        monkeypatch.setattr(_mt, "claude_dir", lambda: claude)
         (claude / "skill-manifest.json").write_text(
             json.dumps({
                 "load": [{
@@ -531,7 +620,7 @@ class TestPerformUnloadByEntityType:
             encoding="utf-8",
         )
 
-        ok, msg = _cm._perform_unload("code-reviewer", entity_type="agent")
+        ok, msg = _mt.perform_unload("code-reviewer", entity_type="agent")
 
         assert ok, msg
         manifest = json.loads(
@@ -558,7 +647,7 @@ class TestPerformUnloadByEntityType:
                                            message="claude mcp remove failed"),
         )
 
-        ok, msg = _cm._perform_unload("bad-mcp", entity_type="mcp-server")
+        ok, msg = _mt.perform_unload("bad-mcp", entity_type="mcp-server")
         assert not ok
         assert "claude mcp remove failed" in msg
 
@@ -573,7 +662,7 @@ class TestPerformUnloadByEntityType:
 
         claude = tmp_path / ".claude"
         claude.mkdir()
-        monkeypatch.setattr(_cm, "_claude_dir", lambda: claude)
+        monkeypatch.setattr(_mt, "claude_dir", lambda: claude)
         from ctx.adapters.claude_code.install import mcp_install
         monkeypatch.setattr(
             mcp_install,
@@ -581,7 +670,7 @@ class TestPerformUnloadByEntityType:
             lambda slug, **kw: _FakeResult(slug=slug, status="uninstalled"),
         )
 
-        ok, msg = _cm._perform_unload("anthropic-python-sdk", "mcp-server")
+        ok, msg = _mt.perform_unload("anthropic-python-sdk", "mcp-server")
 
         assert ok, msg
         audit = json.loads((claude / "ctx-audit.jsonl").read_text(encoding="utf-8"))
@@ -591,7 +680,7 @@ class TestPerformUnloadByEntityType:
         assert audit["meta"]["action"] == "unloaded"
 
     def test_invalid_slug_rejected(self):
-        ok, msg = _cm._perform_unload("../etc/passwd", entity_type="skill")
+        ok, msg = _mt.perform_unload("../etc/passwd", entity_type="skill")
         assert not ok
         assert "invalid slug" in msg
 
@@ -603,7 +692,7 @@ class TestPerformUnloadByEntityType:
 
         monkeypatch.setattr(skill_unload, "unload_from_session", fail_if_called)
 
-        ok, msg = _cm._perform_unload("python-patterns", entity_type="weird")
+        ok, msg = _mt.perform_unload("python-patterns", entity_type="weird")
 
         assert not ok
         assert "unsupported entity_type" in msg
@@ -612,8 +701,8 @@ class TestPerformUnloadByEntityType:
 class TestRenderSidecarDetail3Type:
     def test_sidecar_timeline_filters_duplicate_slug_by_entity_type(self, monkeypatch):
         monkeypatch.setattr(
-            _cm,
-            "_load_sidecar",
+            _mt,
+            "load_sidecar",
             lambda slug, entity_type=None: {
                 "slug": slug,
                 "subject_type": "harness",
@@ -622,8 +711,8 @@ class TestRenderSidecarDetail3Type:
             },
         )
         monkeypatch.setattr(
-            _cm,
-            "_read_jsonl",
+            _mt,
+            "read_jsonl",
             lambda *args, **kwargs: [
                 {
                     "ts": "t1",
@@ -649,7 +738,7 @@ class TestRenderSidecarDetail3Type:
             ],
         )
 
-        html = _cm._render_skill_detail("langgraph", entity_type="harness")
+        html = _mt.render_skill_detail("langgraph", entity_type="harness")
 
         assert "harness.installed" in html
         assert "Audit timeline (1 entries)" in html
@@ -677,12 +766,12 @@ class TestPerformLoadByEntityType:
         from ctx.adapters.claude_code.install import skill_install
         monkeypatch.setattr(skill_install, "install_skill", fake_install)
 
-        ok, msg = _cm._perform_load("python-patterns", entity_type="skill")
+        ok, msg = _mt.perform_load("python-patterns", entity_type="skill")
 
         assert ok
         assert msg == "ok"
         assert calls["slug"] == "python-patterns"
-        assert calls["kw"]["wiki_dir"] == _cm._wiki_dir()
+        assert calls["kw"]["wiki_dir"] == _mt.wiki_dir()
 
     def test_agent_type_calls_agent_install(self, monkeypatch):
         from dataclasses import dataclass
@@ -703,12 +792,12 @@ class TestPerformLoadByEntityType:
         from ctx.adapters.claude_code.install import agent_install
         monkeypatch.setattr(agent_install, "install_agent", fake_install)
 
-        ok, msg = _cm._perform_load("code-reviewer", entity_type="agent")
+        ok, msg = _mt.perform_load("code-reviewer", entity_type="agent")
 
         assert ok
         assert msg == "ok"
         assert calls["slug"] == "code-reviewer"
-        assert calls["kw"]["agents_dir"] == _cm._claude_dir() / "agents"
+        assert calls["kw"]["agents_dir"] == _mt.claude_dir() / "agents"
 
     def test_mcp_type_calls_mcp_install_auto(self, monkeypatch):
         from dataclasses import dataclass
@@ -729,7 +818,7 @@ class TestPerformLoadByEntityType:
         from ctx.adapters.claude_code.install import mcp_install
         monkeypatch.setattr(mcp_install, "install_mcp", fake_install)
 
-        ok, msg = _cm._perform_load("anthropic-python-sdk",
+        ok, msg = _mt.perform_load("anthropic-python-sdk",
                                     entity_type="mcp-server")
 
         assert ok
@@ -756,7 +845,7 @@ class TestPerformLoadByEntityType:
         from ctx.adapters.claude_code.install import mcp_install
         monkeypatch.setattr(mcp_install, "install_mcp", fake_install)
 
-        ok, msg = _cm._perform_load(
+        ok, msg = _mt.perform_load(
             "anthropic-python-sdk",
             entity_type="mcp-server",
             command="npx -y @anthropic/sdk",
@@ -778,7 +867,7 @@ class TestPerformLoadByEntityType:
 
         claude = tmp_path / ".claude"
         claude.mkdir()
-        monkeypatch.setattr(_cm, "_claude_dir", lambda: claude)
+        monkeypatch.setattr(_mt, "claude_dir", lambda: claude)
         from ctx.adapters.claude_code.install import mcp_install
         monkeypatch.setattr(
             mcp_install,
@@ -786,7 +875,7 @@ class TestPerformLoadByEntityType:
             lambda slug, **kw: _FakeResult(slug=slug, status="installed"),
         )
 
-        ok, msg = _cm._perform_load("anthropic-python-sdk", "mcp-server")
+        ok, msg = _mt.perform_load("anthropic-python-sdk", "mcp-server")
 
         assert ok, msg
         audit = json.loads((claude / "ctx-audit.jsonl").read_text(encoding="utf-8"))
@@ -795,7 +884,7 @@ class TestPerformLoadByEntityType:
         assert audit["meta"]["action"] == "loaded"
 
     def test_harness_type_hands_off_to_cli(self):
-        ok, msg = _cm._perform_load("langgraph", entity_type="harness")
+        ok, msg = _mt.perform_load("langgraph", entity_type="harness")
         assert not ok
         assert "ctx-harness-install langgraph --dry-run" in msg
 
@@ -807,10 +896,10 @@ class TestPerformLoadByEntityType:
 
 class TestRenderGraphSidebar:
     def test_sidebar_type_checkboxes_include_mcp_server(self, monkeypatch):
-        monkeypatch.setattr(_cm, "_graph_stats",
+        monkeypatch.setattr(_mt, "graph_stats",
                             lambda: {"nodes": 10, "edges": 20, "available": True})
-        monkeypatch.setattr(_cm, "_top_degree_seeds", lambda **_: [])
-        html = _cm._render_graph()
+        monkeypatch.setattr(_mt, "top_degree_seeds", lambda **_: [])
+        html = _mt.render_graph()
         # Four type checkboxes: skill, agent, mcp-server, harness.
         assert "class='graph-type-filter' value='skill'" in html
         assert "class='graph-type-filter' value='agent'" in html
@@ -818,20 +907,20 @@ class TestRenderGraphSidebar:
         assert "class='graph-type-filter' value='harness'" in html
 
     def test_sidebar_has_tag_filter(self, monkeypatch):
-        monkeypatch.setattr(_cm, "_graph_stats",
+        monkeypatch.setattr(_mt, "graph_stats",
                             lambda: {"nodes": 0, "edges": 0, "available": False})
-        monkeypatch.setattr(_cm, "_top_degree_seeds", lambda **_: [])
-        html = _cm._render_graph()
+        monkeypatch.setattr(_mt, "top_degree_seeds", lambda **_: [])
+        html = _mt.render_graph()
         assert "id='tag-filter'" in html
         assert "filter_tokens" in html
         assert "isFocus || !tagQ" in html
 
     def test_graph_list_styles_mcp_and_harness_nodes_distinctly(self, monkeypatch):
         """The graph list view shows four types; each must be visually distinct."""
-        monkeypatch.setattr(_cm, "_graph_stats",
+        monkeypatch.setattr(_mt, "graph_stats",
                             lambda: {"nodes": 0, "edges": 0, "available": False})
-        monkeypatch.setattr(_cm, "_top_degree_seeds", lambda **_: [])
-        html = _cm._render_graph()
+        monkeypatch.setattr(_mt, "top_degree_seeds", lambda **_: [])
+        html = _mt.render_graph()
         assert ".entity-type-skill" in html
         assert ".entity-type-agent" in html
         assert ".entity-type-mcp-server" in html
@@ -842,10 +931,10 @@ class TestRenderGraphSidebar:
         )
 
     def test_graph_filters_fallback_rows_and_connected_edges(self, monkeypatch):
-        monkeypatch.setattr(_cm, "_graph_stats",
+        monkeypatch.setattr(_mt, "graph_stats",
                             lambda: {"nodes": 0, "edges": 0, "available": False})
-        monkeypatch.setattr(_cm, "_top_degree_seeds", lambda **_: [])
-        html = _cm._render_graph()
+        monkeypatch.setattr(_mt, "top_degree_seeds", lambda **_: [])
+        html = _mt.render_graph()
 
         assert "document.querySelectorAll('[data-testid=\"graph-fallback-node\"]')" in html
         assert "n.style.display = hidden ? 'none' : 'flex'" in html
@@ -855,10 +944,10 @@ class TestRenderGraphSidebar:
     def test_tap_handler_strips_mcp_server_prefix(self, monkeypatch):
         """Clicking an MCP node must route to /wiki/<slug> — the
         prefix-stripping regex has to know all four types."""
-        monkeypatch.setattr(_cm, "_graph_stats",
+        monkeypatch.setattr(_mt, "graph_stats",
                             lambda: {"nodes": 0, "edges": 0, "available": False})
-        monkeypatch.setattr(_cm, "_top_degree_seeds", lambda **_: [])
-        html = _cm._render_graph()
+        monkeypatch.setattr(_mt, "top_degree_seeds", lambda **_: [])
+        html = _mt.render_graph()
         # Regex should include mcp-server and harness in the prefix alternation.
         assert "(skill|agent|mcp-server|harness)" in html
 
@@ -868,9 +957,9 @@ class TestRenderGraphSidebar:
         graph.add_node("harness:langgraph", label="langgraph", type="harness", tags=["agent"])
         graph.add_node("skill:agent-patterns", label="agent-patterns", type="skill", tags=["agent"])
         graph.add_edge("harness:langgraph", "skill:agent-patterns", weight=2, shared_tags=["agent"])
-        monkeypatch.setattr(_cm, "_load_dashboard_graph", lambda: graph)
+        monkeypatch.setattr(_mt, "load_dashboard_graph", lambda: graph)
 
-        out = _cm._graph_neighborhood("langgraph", entity_type="harness")
+        out = _mt.graph_neighborhood("langgraph", entity_type="harness")
 
         assert out["center"] == "harness:langgraph"
         assert any(n["data"]["type"] == "harness" for n in out["nodes"])
@@ -882,9 +971,9 @@ class TestRenderGraphSidebar:
         graph.add_node("skill:c", label="c", type="skill", tags=[])
         graph.add_edge("skill:a", "skill:b", weight=2)
         graph.add_edge("skill:b", "skill:c", weight=1)
-        monkeypatch.setattr(_cm, "_load_dashboard_graph", lambda: graph)
+        monkeypatch.setattr(_mt, "load_dashboard_graph", lambda: graph)
 
-        out = _cm._graph_neighborhood("a", hops=2, entity_type="skill")
+        out = _mt.graph_neighborhood("a", hops=2, entity_type="skill")
 
         edge_ids = [edge["data"]["id"] for edge in out["edges"]]
         assert len(edge_ids) == len(set(edge_ids))
@@ -898,9 +987,9 @@ class TestRenderGraphSidebar:
         graph.add_node("skill:a", label="a", type="skill", tags=[])
         graph.add_node("skill:b", label="b", type="skill", tags=[])
         graph.add_edge("skill:a", "skill:b", weight=1, shared_tags=["security"])
-        monkeypatch.setattr(_cm, "_load_dashboard_graph", lambda: graph)
+        monkeypatch.setattr(_mt, "load_dashboard_graph", lambda: graph)
 
-        out = _cm._graph_neighborhood("a", entity_type="skill")
+        out = _mt.graph_neighborhood("a", entity_type="skill")
 
         by_id = {node["data"]["id"]: node["data"] for node in out["nodes"]}
         assert "security" in by_id["skill:a"]["filter_tokens"]
@@ -922,11 +1011,16 @@ class TestMonitorRoutesPreserveEntityType:
         handler._send_500 = lambda exc: sent.setdefault("500", exc)
         handler._api_reads_enabled = lambda: True
         handler._mutations_enabled = lambda: True
+        monitor_handler = cast(Any, _mt.MonitorHandler)
+        handler._handle_get_route = monitor_handler._handle_get_route.__get__(
+            handler,
+            type(handler),
+        )
         if html_fn is not None:
             handler._send_html = html_fn
         if json_fn is not None:
             handler._send_json = json_fn
-        _cm._MonitorHandler.do_GET(handler)
+        monitor_handler.do_GET(handler)
         return sent
 
     def test_graph_route_passes_type_query(self, monkeypatch):
@@ -937,7 +1031,7 @@ class TestMonitorRoutesPreserveEntityType:
             calls["focus_type"] = focus_type
             return "graph"
 
-        monkeypatch.setattr(_cm, "_render_graph", fake_render_graph)
+        monkeypatch.setattr(_mt, "render_graph", fake_render_graph)
 
         sent = self._run_get("/graph?slug=langgraph&type=harness")
 
@@ -953,7 +1047,7 @@ class TestMonitorRoutesPreserveEntityType:
             calls["mutations_enabled"] = mutations_enabled
             return "wiki"
 
-        monkeypatch.setattr(_cm, "_render_wiki_entity", fake_render_wiki_entity)
+        monkeypatch.setattr(_mt, "render_wiki_entity", fake_render_wiki_entity)
 
         sent = self._run_get("/wiki/langgraph?type=harness")
 
@@ -974,7 +1068,7 @@ class TestMonitorRoutesPreserveEntityType:
             calls["entity_type"] = entity_type
             return {"center": "harness:langgraph", "nodes": [], "edges": []}
 
-        monkeypatch.setattr(_cm, "_graph_neighborhood", fake_graph_neighborhood)
+        monkeypatch.setattr(_mt, "graph_neighborhood", fake_graph_neighborhood)
 
         sent = self._run_get("/api/graph/langgraph.json?type=harness&hops=2&limit=55")
 
@@ -993,7 +1087,7 @@ class TestMonitorRoutesPreserveEntityType:
             calls.append((args, kwargs))
             return {"center": "skill:langgraph", "nodes": [], "edges": []}
 
-        monkeypatch.setattr(_cm, "_graph_neighborhood", fake_graph_neighborhood)
+        monkeypatch.setattr(_mt, "graph_neighborhood", fake_graph_neighborhood)
 
         sent = self._run_get("/api/graph/langgraph.json?type=bogus")
 

src/tests/test_ctx_monitor_browser.py

@@ -13,7 +13,9 @@ from typing import Any, Iterator
 import networkx as nx
 import pytest
 
-import ctx_monitor as cm
+from ctx.monitor import testing as mt
+from ctx.monitor.services import kpi as kpi_service
+from ctx.monitor.services import sidecars as sidecar_service
 
 playwright_sync: Any = pytest.importorskip("playwright.sync_api")
 
@@ -38,8 +40,10 @@ class MonitorHarness:
 def fake_claude(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
     claude = tmp_path / ".claude"
     (claude / "skill-quality").mkdir(parents=True)
-    monkeypatch.setattr(cm, "_claude_dir", lambda: claude)
-    monkeypatch.setattr(cm, "_dashboard_graph_index_archives", lambda: [])
+    monkeypatch.setattr(mt, "claude_dir", lambda: claude)
+    monkeypatch.setattr(mt, "dashboard_graph_index_archives", lambda: [])
+    sidecar_service.reset_caches()
+    kpi_service.reset_cache()
     return claude
 
 
@@ -64,16 +68,16 @@ def _start_monitor(
     *,
     fake_load: bool,
 ) -> MonitorHarness:
-    monkeypatch.setattr(cm, "_MONITOR_TOKEN", "browser-token")
+    monkeypatch.setattr(mt, "MONITOR_TOKEN", "browser-token")
     calls: list[tuple[str, str]] = []
     if fake_load:
         def perform_load(slug: str, entity_type: str = "skill") -> tuple[bool, str]:
             calls.append((slug, entity_type))
             return True, "loaded"
 
-        monkeypatch.setattr(cm, "_perform_load", perform_load)
+        monkeypatch.setattr(mt, "perform_load", perform_load)
 
-    server = cm._make_monitor_server("127.0.0.1", 0)
+    server = mt.make_monitor_server("127.0.0.1", 0)
     thread = threading.Thread(target=server.serve_forever, daemon=True)
     thread.start()
     port = int(server.server_port)
@@ -98,6 +102,20 @@ def _write_wiki_entity(root: Path, entity_type: str, slug: str, body: str) -> No
     path.write_text(body, encoding="utf-8")
 
 
+def _write_quality_sidecar(root: Path, slug: str, body: dict[str, Any]) -> None:
+    path = root / "skill-quality" / f"{slug}.json"
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(body), encoding="utf-8")
+
+
+def _write_runtime_events(path: Path, records: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(
+        "\n".join(json.dumps(record) for record in records) + "\n",
+        encoding="utf-8",
+    )
+
+
 def _wait_for_browser_state(page: Any, expression: str, *, timeout: float = 5.0) -> None:
     deadline = time.monotonic() + timeout
     while time.monotonic() < deadline:
@@ -112,6 +130,7 @@ def test_graph_page_uses_builtin_svg_renderer(
     monkeypatch: pytest.MonkeyPatch,
     page: Any,
 ) -> None:
+    monkeypatch.setattr(mt, "graph_match_default_min_percent", lambda: 3)
     G = nx.Graph()
     G.add_node("skill:python-patterns", label="python-patterns", type="skill", tags=["python"])
     G.add_node(
@@ -119,9 +138,23 @@ def test_graph_page_uses_builtin_svg_renderer(
         label="code-reviewer",
         type="agent",
         tags=["review"],
-        quality_score=0.95,
+        quality_score=18.0,
         usage_score=0.8,
     )
+    G.add_node(
+        "skill:weak-graph-link",
+        label="weak-graph-link",
+        type="skill",
+        tags=["noise"],
+        quality_score=0.2,
+    )
+    G.add_node(
+        "skill:medium-graph-link",
+        label="medium-graph-link",
+        type="skill",
+        tags=["noise"],
+        quality_score=0.2,
+    )
     G.add_node(
         "mcp-server:github-mcp-server",
         label="github-mcp-server",
@@ -131,10 +164,12 @@ def test_graph_page_uses_builtin_svg_renderer(
         usage_score=0.0,
     )
     G.add_node("harness:langgraph", label="langgraph", type="harness", tags=["agent"])
-    G.add_edge("skill:python-patterns", "agent:code-reviewer", weight=0.9, shared_tags=["review"])
+    G.add_edge("skill:python-patterns", "agent:code-reviewer", weight=0.9, shared_tags=["review"], tag_sim=0.3333)
     G.add_edge("skill:python-patterns", "mcp-server:github-mcp-server", weight=0.8, shared_tags=["github"])
     G.add_edge("skill:python-patterns", "harness:langgraph", weight=0.7, shared_tags=["agent"])
-    monkeypatch.setattr(cm, "_load_dashboard_graph", lambda: G)
+    G.add_edge("skill:python-patterns", "skill:medium-graph-link", weight=0.43, tag_sim=0.0)
+    G.add_edge("agent:code-reviewer", "skill:weak-graph-link", weight=0.05)
+    monkeypatch.setattr(mt, "load_dashboard_graph", lambda: G)
     _write_wiki_entity(fake_claude, "skill", "python-patterns", "# python-patterns\n")
     _write_wiki_entity(fake_claude, "agent", "code-reviewer", "# code-reviewer\n")
 
@@ -142,25 +177,237 @@ def test_graph_page_uses_builtin_svg_renderer(
     try:
         page.goto(f"{harness.base_url}/graph?slug=python-patterns&type=skill")
         page.wait_for_selector("[data-testid='graph-renderer']", timeout=5000)
-        assert "4 nodes" in page.locator("#msg").inner_text()
-        assert page.locator("[data-testid='graph-svg-node']").count() == 4
-        assert page.locator("[data-testid='graph-fallback-node']").count() == 4
+        assert "5 nodes" in page.locator("#msg").inner_text()
+        assert page.locator("[data-testid='graph-svg-node']").count() == 5
+        assert page.locator("[data-testid='graph-fallback-node']").count() == 0
+        assert page.locator("[data-testid='graph-list']").evaluate("node => node.hidden")
         assert "Graph renderer unavailable" not in page.locator("#cy").inner_text()
+        resize_handle = page.locator("[data-testid='graph-inspector-resize']")
+        assert resize_handle.count() == 1
+        assert page.locator("[data-testid='graph-node-detail']").evaluate(
+            "node => getComputedStyle(node).overflowY",
+        ) == "auto"
+        assert page.locator("[data-testid='graph-edge-detail']").evaluate(
+            "node => node.parentElement?.getAttribute('data-testid')",
+        ) == "graph-node-detail"
+        before_resize = page.locator(".graph-inspector-grid").bounding_box()
+        assert before_resize is not None
+        node_detail_box = page.locator("[data-testid='graph-node-detail']").bounding_box()
+        assert node_detail_box is not None
+        grid_padding = page.locator(".graph-inspector-grid").evaluate(
+            "node => parseFloat(getComputedStyle(node).paddingLeft) + parseFloat(getComputedStyle(node).paddingRight)",
+        )
+        assert abs(node_detail_box["width"] - (before_resize["width"] - grid_padding)) < 4
+        resize_handle.focus()
+        page.keyboard.press("ArrowUp")
+        _wait_for_browser_state(
+            page,
+            f"() => document.querySelector('.graph-inspector-grid')"
+            f"?.getBoundingClientRect().height > {before_resize['height'] + 10}",
+            timeout=5.0,
+        )
+        after_resize = page.locator(".graph-inspector-grid").bounding_box()
+        assert after_resize is not None
+        assert after_resize["height"] > before_resize["height"]
+        skill_shape = page.locator(
+            "[data-3d-node-id='skill:python-patterns'] [data-testid='graph-svg-node']",
+        )
+        agent_shape = page.locator(
+            "[data-3d-node-id='agent:code-reviewer'] [data-testid='graph-svg-node']",
+        )
+        mcp_shape = page.locator(
+            "[data-3d-node-id='mcp-server:github-mcp-server'] [data-testid='graph-svg-node']",
+        )
+        assert skill_shape.evaluate("node => node.tagName.toLowerCase()") == "circle"
+        assert agent_shape.evaluate("node => node.tagName.toLowerCase()") == "polygon"
+        assert mcp_shape.evaluate("node => node.tagName.toLowerCase()") == "rect"
+        assert skill_shape.get_attribute("data-node-shape") == "skill"
+        assert agent_shape.get_attribute("data-node-shape") == "agent"
+        assert mcp_shape.get_attribute("data-node-shape") == "mcp-server"
+
+        assert page.locator("[data-testid='match-range-control']").count() == 1
+        assert page.locator("#match-histogram .graph-match-bar").count() == 10
+        assert page.locator("#match-filter-min").get_attribute("max") == "100"
+        assert page.locator("#match-filter-max").get_attribute("max") == "100"
+        assert page.locator("#match-filter-min").input_value() == "3"
+        assert page.locator("#match-filter-min-value").inner_text() == "3%"
+        assert page.locator("#match-filter-max").input_value() == "100"
+        assert page.locator("#match-filter-max-value").inner_text() == "100%"
+        page.locator("#match-filter-min").evaluate(
+            "node => { node.value = '50'; node.dispatchEvent(new Event('input', {bubbles: true})); }",
+        )
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('match-filter-min-value').textContent === '50%'",
+            timeout=5.0,
+        )
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('graph-match-count').textContent === '4 visible'",
+            timeout=5.0,
+        )
+        assert page.locator("#match-histogram .graph-match-bar.active").count() >= 1
+        page.locator("#match-histogram [data-match-bin-min='70']").click()
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('match-filter-min-value').textContent === '70%'",
+            timeout=5.0,
+        )
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('match-filter-max-value').textContent === '79%'",
+            timeout=5.0,
+        )
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('graph-match-count').textContent === '2 visible'",
+            timeout=5.0,
+        )
+        page.locator("#match-filter-min").evaluate(
+            "node => { node.value = '50'; node.dispatchEvent(new Event('input', {bubbles: true})); }",
+        )
+        page.locator("#match-filter-max").evaluate(
+            "node => { node.value = '100'; node.dispatchEvent(new Event('input', {bubbles: true})); }",
+        )
+        assert page.locator("[data-3d-node-id='skill:medium-graph-link']").evaluate(
+            "node => getComputedStyle(node).display",
+        ) == "none"
+        assert page.locator("[data-testid='graph-svg-edge'][data-edge-weight='0.4300']").evaluate(
+            "node => getComputedStyle(node).display",
+        ) == "none"
+        page.locator("#match-filter-max").evaluate(
+            "node => { node.value = '80'; node.dispatchEvent(new Event('input', {bubbles: true})); }",
+        )
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('match-filter-max-value').textContent === '80%'",
+            timeout=5.0,
+        )
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('graph-match-count').textContent === '3 visible'",
+            timeout=5.0,
+        )
+        assert page.locator("[data-3d-node-id='agent:code-reviewer']").evaluate(
+            "node => getComputedStyle(node).display",
+        ) == "none"
+        assert page.locator("[data-testid='graph-svg-edge'][data-edge-weight='0.9000']").evaluate(
+            "node => getComputedStyle(node).display",
+        ) == "none"
+        page.locator("#match-filter-min").evaluate(
+            "node => { node.value = '0'; node.dispatchEvent(new Event('input', {bubbles: true})); }",
+        )
+        page.locator("#match-filter-max").evaluate(
+            "node => { node.value = '100'; node.dispatchEvent(new Event('input', {bubbles: true})); }",
+        )
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('graph-match-count').textContent === '5 visible'",
+            timeout=5.0,
+        )
+
         reviewer_radius = float(page.locator(
             "[data-3d-node-id='agent:code-reviewer'] [data-testid='graph-svg-node']",
-        ).get_attribute("r") or "0")
+        ).get_attribute("data-radius") or "0")
         mcp_radius = float(page.locator(
             "[data-3d-node-id='mcp-server:github-mcp-server'] [data-testid='graph-svg-node']",
-        ).get_attribute("r") or "0")
+        ).get_attribute("data-radius") or "0")
         assert reviewer_radius > mcp_radius
 
+        center_node = page.locator(
+            "[data-3d-node-id='skill:python-patterns'] [data-testid='graph-svg-node']",
+        )
+        center_node.click()
+        _wait_for_browser_state(
+            page,
+            "() => document.querySelector('[data-testid=\"graph-node-detail-tree\"]')"
+            "?.innerText.includes('python-patterns')",
+            timeout=5.0,
+        )
+        center_detail_text = page.locator("[data-testid='graph-node-detail-tree']").inner_text()
+        assert "medium-graph-link" in center_detail_text
+        assert "match 43%" in center_detail_text
+        assert "graph-only links hidden" not in center_detail_text
+        assert "tag 0.000" not in center_detail_text
+        assert "evidence: none" not in center_detail_text
+
+        graph_node = page.locator(
+            "[data-3d-node-id='agent:code-reviewer'] [data-testid='graph-svg-node']",
+        )
+        graph_node.click()
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('focus').value === 'code-reviewer'",
+            timeout=5.0,
+        )
+        _wait_for_browser_state(
+            page,
+            "() => document.querySelector('[data-3d-node-id=\"agent:code-reviewer\"]')"
+            "?.getAttribute('data-depth') === '0'",
+            timeout=5.0,
+        )
+        detail_text = page.locator("[data-testid='graph-node-detail-tree']").inner_text()
+        assert "Neighbors" in detail_text
+        assert "strength 90% relation strength" in detail_text
+        assert "tag 33%" in detail_text
+        assert "quality: 100%" in detail_text
+        assert "raw score clamped" not in detail_text
+        assert "graph-only links hidden" not in detail_text
+        assert "weak-graph-link" in detail_text
+        assert "match 5%" in detail_text
+        assert "tag 0.000" not in detail_text
+        assert "evidence: none" not in detail_text
+        assert "0.333" not in detail_text
+        assert page.locator("[data-3d-node-id='agent:code-reviewer']").evaluate(
+            "node => node.classList.contains('graph-node-selected')",
+        )
+        selected_fill = page.locator(
+            "[data-3d-node-id='agent:code-reviewer'] [data-testid='graph-svg-node']",
+        ).evaluate("node => getComputedStyle(node).fill")
+        assert selected_fill == "rgb(250, 204, 21)"
+        selected_visible_edges = page.locator(
+            "[data-testid='graph-svg-edge'].graph-edge-selected",
+        ).count()
+        selected_hit_edges = page.locator(
+            "[data-testid='graph-3d-edge'].graph-edge-selected",
+        ).count()
+        assert selected_visible_edges >= 1
+        assert selected_hit_edges == 0
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('focus').value === 'code-reviewer'",
+            timeout=5.0,
+        )
+        _wait_for_browser_state(
+            page,
+            "() => document.querySelector('[data-3d-node-id=\"agent:code-reviewer\"]')"
+            "?.getAttribute('data-depth') === '0'",
+            timeout=5.0,
+        )
+        page.locator("[data-3d-node-id='agent:code-reviewer']").dblclick()
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('focus').value === 'python-patterns'",
+            timeout=5.0,
+        )
+
+        page.select_option("#focus-type", "agent")
+        page.fill("#focus", "code")
+        page.wait_for_selector("[data-testid='graph-live-results'] [data-live-slug='code-reviewer']", timeout=5000)
+        page.locator("[data-live-slug='code-reviewer']").click()
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('focus').value === 'code-reviewer'",
+            timeout=5.0,
+        )
+
         page.fill("#tag-filter", "review")
         _wait_for_browser_state(
             page,
             "() => document.getElementById('graph-match-count').textContent === '2 visible'",
             timeout=5.0,
         )
-        page.locator("[data-testid='graph-fallback-node'][data-slug='code-reviewer']").click()
+        page.locator("[data-testid='graph-node-detail-tree'] a[href='/wiki/code-reviewer?type=agent']").click()
         page.wait_for_url("**/wiki/code-reviewer?type=agent", timeout=5000)
         assert "code-reviewer" in page.locator("h1").inner_text()
     finally:
@@ -187,10 +434,10 @@ def test_docs_page_search_jumps_to_cross_tab_result(
             "body": "# Graph Guide\n\n## Runtime Graph\n\nSearch the runtime graph.\n",
         },
     ]
-    monkeypatch.setattr(cm, "_docs_index_entries", lambda: entries)
+    monkeypatch.setattr(mt, "docs_index_entries", lambda: entries)
     monkeypatch.setattr(
-        cm,
-        "_docs_tabs",
+        mt,
+        "docs_tabs",
         lambda _entries: [
             {"label": "Home", "slug": "home", "pages": [entries[0]]},
             {"label": "Repo", "slug": "repo", "pages": [entries[1]]},
@@ -269,6 +516,213 @@ def test_wiki_page_autocomplete_and_type_filters_update_visible_tiles(
         harness.close()
 
 
+def test_manage_page_supports_create_search_update_and_delete(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    page: Any,
+) -> None:
+    harness = _start_monitor(monkeypatch, fake_load=False)
+    entity_path = fake_claude / "skill-wiki" / "entities" / "agents" / "custom-reviewer.md"
+    try:
+        page.goto(f"{harness.base_url}/manage")
+        page.wait_for_selector("#entity-editor-form", timeout=5000)
+
+        page.fill("input[name='slug']", "custom-reviewer")
+        page.select_option("select[name='entity_type']", "agent")
+        page.fill("input[name='title']", "Custom Reviewer")
+        page.fill("input[name='tags']", "python, review, policy")
+        page.fill("input[name='description']", "Reviews Python changes with local policy.")
+        page.fill("textarea[name='body']", "# Custom Reviewer\n\nUse before merging Python changes.\n")
+        page.locator("#entity-editor-form button[type='submit']").click()
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('entity-editor-status').textContent.includes('saved agent:custom-reviewer')",
+            timeout=5.0,
+        )
+        assert entity_path.is_file()
+
+        page.fill("#manage-search", "custom")
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('manage-search-status').textContent === '1 result'",
+            timeout=5.0,
+        )
+        page.locator(".manage-result[data-slug='custom-reviewer']").click()
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('entity-editor-status').textContent.includes('editing agent:custom-reviewer')",
+            timeout=5.0,
+        )
+        assert page.locator("input[name='title']").input_value() == "Custom Reviewer"
+
+        page.once("dialog", lambda dialog: dialog.accept())
+        page.fill("input[name='title']", "Custom Reviewer Updated")
+        page.locator("#entity-editor-form button[type='submit']").click()
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('entity-editor-status').textContent.includes('saved agent:custom-reviewer')",
+            timeout=5.0,
+        )
+        assert "title: Custom Reviewer Updated" in entity_path.read_text(encoding="utf-8")
+
+        page.once("dialog", lambda dialog: dialog.accept())
+        page.locator("[data-testid='entity-delete-button']").click()
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('entity-editor-status').textContent.includes('deleted agent:custom-reviewer')",
+            timeout=5.0,
+        )
+        assert not entity_path.exists()
+    finally:
+        harness.close()
+
+
+def test_config_and_harness_pages_support_browser_wizard_flows(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    page: Any,
+) -> None:
+    _write_wiki_entity(
+        fake_claude,
+        "harness",
+        "langgraph",
+        "---\n"
+        "title: LangGraph harness\n"
+        "type: harness\n"
+        "description: Durable Python agent workflows with tool routing.\n"
+        "tags: [python, api, local, verification]\n"
+        "repo_url: https://github.com/langchain-ai/langgraph\n"
+        "---\n"
+        "# LangGraph harness\n",
+    )
+    _write_quality_sidecar(fake_claude, "langgraph-harness", {
+        "slug": "langgraph",
+        "subject_type": "harness",
+        "grade": "A",
+        "raw_score": 0.93,
+    })
+
+    harness = _start_monitor(monkeypatch, fake_load=False)
+    try:
+        page.goto(f"{harness.base_url}/config")
+        page.wait_for_selector("#config-form", timeout=5000)
+        page.fill("input[name='skill_transformer.line_threshold']", "240")
+        page.locator("#config-form button[type='submit']").click()
+        _wait_for_browser_state(
+            page,
+            "() => document.getElementById('config-msg').textContent.includes('saved 1 config keys')",
+            timeout=5.0,
+        )
+        config = json.loads((fake_claude / "skill-system-config.json").read_text(encoding="utf-8"))
+        assert config["skill_transformer"]["line_threshold"] == 240
+
+        page.goto(f"{harness.base_url}/harness")
+        page.wait_for_selector("#harness-wizard-form", timeout=5000)
+        page.select_option("select[name='model_provider']", "huggingface")
+        page.fill("input[name='model']", "HuggingFaceTB/SmolLM2-135M-Instruct")
+        page.fill(
+            "textarea[name='goal']",
+            "Build a local Python code-review harness with pytest verification.",
+        )
+        page.fill("input[name='verify']", "pytest")
+        _wait_for_browser_state(
+            page,
+            "() => document.querySelector('[data-testid=\"harness-command-output\"]').textContent.includes('--model-provider \"huggingface\"')",
+            timeout=5.0,
+        )
+        command = page.locator("[data-testid='harness-command-output']").inner_text()
+        assert "--model \"HuggingFaceTB/SmolLM2-135M-Instruct\"" in command
+        assert "--plan-on-no-fit" in command
+        assert page.locator(".harness-card[data-harness-slug='langgraph']").count() == 1
+
+        page.locator("[data-select-harness='langgraph']").click()
+        selected = page.locator("#selected-harness-command").inner_text()
+        assert "ctx-harness-install langgraph --dry-run" in selected
+        assert "ctx-scan-repo --repo . --recommend" in selected
+    finally:
+        harness.close()
+
+
+def test_sessions_kpi_and_runtime_pages_render_populated_browser_data(
+    fake_claude: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    page: Any,
+    tmp_path: Path,
+) -> None:
+    (fake_claude / "ctx-audit.jsonl").write_text(
+        json.dumps({
+            "ts": "2026-06-16T10:00:00Z",
+            "event": "skill.loaded",
+            "subject": "python-patterns",
+            "subject_type": "skill",
+            "actor": "hook",
+            "session_id": "browser-session",
+        }) + "\n",
+        encoding="utf-8",
+    )
+    (fake_claude / "skill-events.jsonl").write_text(
+        json.dumps({
+            "timestamp": "2026-06-16T10:00:01Z",
+            "event": "load",
+            "skill": "python-patterns",
+            "session_id": "browser-session",
+        }) + "\n",
+        encoding="utf-8",
+    )
+    _write_quality_sidecar(fake_claude, "alpha", {
+        "slug": "alpha",
+        "subject_type": "skill",
+        "grade": "A",
+        "raw_score": 0.92,
+        "score": 0.92,
+        "computed_at": "2026-06-16T10:00:00Z",
+    })
+    runtime_path = tmp_path / "runtime" / "events.jsonl"
+    monkeypatch.setattr(mt, "runtime_lifecycle_path", lambda: runtime_path)
+    _write_runtime_events(runtime_path, [
+        {
+            "action": "validation",
+            "session_id": "browser-session",
+            "check_name": "pytest",
+            "status": "failed",
+            "summary": "one failing test",
+            "created_at": "2026-06-16T10:02:00Z",
+        },
+        {
+            "action": "escalation",
+            "session_id": "browser-session",
+            "trigger": "validation-failed",
+            "reason": "pytest failed",
+            "status": "open",
+            "severity": "blocking",
+            "created_at": "2026-06-16T10:03:00Z",
+        },
+    ])
+
+    harness = _start_monitor(monkeypatch, fake_load=False)
+    try:
+        page.goto(f"{harness.base_url}/sessions")
+        page.wait_for_selector("table", timeout=5000)
+        assert "browser-session" in page.locator("body").inner_text()
+        assert "1 unique sessions observed" in page.locator("body").inner_text()
+
+        page.goto(f"{harness.base_url}/kpi")
+        page.wait_for_selector("h1", timeout=5000)
+        kpi_text = page.locator("body").inner_text()
+        assert "Total entities: 1" in kpi_text
+        assert "Grade distribution" in kpi_text
+        assert "A: 1" in kpi_text
+
+        page.goto(f"{harness.base_url}/runtime")
+        page.wait_for_selector("h1", timeout=5000)
+        runtime_text = page.locator("body").inner_text()
+        assert "1 validations / 1 failed / 1 open escalations" in runtime_text
+        assert "pytest" in runtime_text
+        assert "validation-failed" in runtime_text
+    finally:
+        harness.close()
+
+
 def test_events_page_shows_backlog_and_appends_live_events(
     fake_claude: Path,
     monkeypatch: pytest.MonkeyPatch,

src/tests/test_dashboard_entities.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Literal
+
+from ctx import dashboard_entities
+from ctx.core.quality.skillspector_service import SkillSpectorResult
+from ctx.monitor import testing as monitor_testing
+
+
+class _NoopLock:
+    def __enter__(self) -> None:
+        return None
+
+    def __exit__(self, *_exc: object) -> Literal[False]:
+        return False
+
+
+def test_skill_upsert_requires_security_gate_before_write(tmp_path: Path) -> None:
+    writes: list[tuple[Path, str]] = []
+    queued: list[tuple[str, str, Path, str, str]] = []
+
+    def fail_scan(_slug: str, _content: str) -> tuple[bool, str]:
+        return False, "SkillSpector security scan did not pass: findings"
+
+    deps = dashboard_entities.EntityCrudDeps(
+        is_safe_slug=lambda value: value == "unsafe-skill",
+        normalize_entity_type=lambda value: "skill" if value == "skill" else None,
+        wiki_entity_detail=lambda _slug, _etype: None,
+        wiki_entity_target_path=lambda slug, _etype: tmp_path / f"{slug}.md",
+        wiki_entity_path=lambda _slug, _etype: None,
+        iter_wiki_entity_paths=lambda _etype: [],
+        read_manifest=lambda: {"load": []},
+        perform_unload=lambda _slug, _etype: (True, "unloaded"),
+        queue_entity_refresh=lambda *args: queued.append(args),  # type: ignore[arg-type]
+        file_lock=lambda _path: _NoopLock(),
+        write_entity_text=lambda path, content: writes.append((path, content)),
+        parse_frontmatter=lambda text: ({}, text),
+        frontmatter_tags=lambda _value: [],
+        frontmatter_text=lambda value: str(value or ""),
+        display_slug=lambda value: value,
+        display_label=lambda value: str(value),
+        entity_wiki_href=lambda slug, _etype: f"/wiki/{slug}?type=skill",
+        scan_skill_content=fail_scan,
+    )
+
+    ok, detail = dashboard_entities.upsert_wiki_entity(
+        {
+            "slug": "unsafe-skill",
+            "entity_type": "skill",
+            "title": "Unsafe Skill",
+            "body": "# Unsafe\n",
+        },
+        deps=deps,
+    )
+
+    assert ok is False
+    assert "SkillSpector" in detail
+    assert writes == []
+    assert queued == []
+
+
+def test_monitor_entity_deps_scan_manual_skill_upserts(monkeypatch) -> None:
+    seen: list[tuple[str, str]] = []
+
+    def fake_scan(slug: str, content: str) -> SkillSpectorResult:
+        seen.append((slug, content))
+        return SkillSpectorResult(
+            status="findings",
+            command=["skillspector", "scan"],
+            exit_code=1,
+            output="prompt injection",
+        )
+
+    monkeypatch.setattr(monitor_testing, "run_skillspector_scan_text", fake_scan)
+
+    ok, detail = monitor_testing.scan_skill_entity_content("unsafe-skill", "# Unsafe\n")
+
+    assert ok is False
+    assert "SkillSpector security scan did not pass: findings" in detail
+    assert seen == [("unsafe-skill", "# Unsafe\n")]

src/tests/test_dashboard_smoke.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Iterator
+
+import pytest
+
+from scripts import dashboard_smoke as smoke
+
+
+class FakeResponse:
+    def __init__(self, status: int, body: str) -> None:
+        self.status = status
+        self._body = body.encode("utf-8")
+
+    def __enter__(self) -> "FakeResponse":
+        return self
+
+    def __exit__(self, *args: object) -> None:
+        return None
+
+    def read(self) -> bytes:
+        return self._body
+
+
+def _urlopen_for(bodies: dict[str, str]):
+    def fake_urlopen(url: str, timeout: float) -> FakeResponse:
+        path = url.replace("http://127.0.0.1:8765", "")
+        return FakeResponse(200, bodies[path])
+
+    return fake_urlopen
+
+
+def test_run_smoke_checks_dashboard_routes(monkeypatch: pytest.MonkeyPatch) -> None:
+    bodies = {spec.path: spec.marker for spec in smoke.DEFAULT_CHECKS}
+    seen: list[str] = []
+
+    def fake_urlopen(url: str, timeout: float) -> FakeResponse:
+        path = url.replace("http://127.0.0.1:8765", "")
+        seen.append(path)
+        return FakeResponse(200, bodies[path])
+
+    times: Iterator[float] = iter(range(0, len(smoke.DEFAULT_CHECKS) * 2))
+    monkeypatch.setattr(smoke.urllib.request, "urlopen", fake_urlopen)
+    monkeypatch.setattr(smoke.time, "perf_counter", lambda: next(times))
+
+    results = smoke.run_smoke("http://127.0.0.1:8765", timeout=5)
+
+    assert seen == [spec.path for spec in smoke.DEFAULT_CHECKS]
+    assert all(result.ok for result in results)
+
+
+def test_run_smoke_fails_when_marker_is_missing(monkeypatch: pytest.MonkeyPatch) -> None:
+    bodies = {spec.path: spec.marker for spec in smoke.DEFAULT_CHECKS}
+    bodies["/manage"] = "wrong page"
+    times: Iterator[float] = iter(range(0, len(smoke.DEFAULT_CHECKS) * 2))
+    monkeypatch.setattr(smoke.urllib.request, "urlopen", _urlopen_for(bodies))
+    monkeypatch.setattr(smoke.time, "perf_counter", lambda: next(times))
+
+    results = smoke.run_smoke("http://127.0.0.1:8765", timeout=5)
+
+    failed = [result for result in results if not result.ok]
+    assert [result.name for result in failed] == ["manage"]
+    assert failed[0].reason == "missing marker 'Manage catalog'"
+
+
+def test_apply_latency_thresholds_marks_slow_warm_graph() -> None:
+    results = [
+        smoke.CheckResult(
+            name="graph-api-warm",
+            path="/api/graph/github.json?type=mcp-server&limit=20",
+            status=200,
+            elapsed=1.2,
+            ok=True,
+            reason="ok",
+            bytes_read=123,
+        ),
+    ]
+
+    smoke.apply_latency_thresholds(results, {"graph-api-warm": 0.5})
+
+    assert not results[0].ok
+    assert results[0].reason == "slow: 1.20s > 0.50s"
+
+
+def test_emit_jsonl_outputs_structured_rows() -> None:
+    result = smoke.CheckResult(
+        name="home",
+        path="/",
+        status=200,
+        elapsed=0.1,
+        ok=True,
+        reason="ok",
+        bytes_read=50,
+    )
+
+    rows = smoke.results_to_jsonl([result]).splitlines()
+
+    assert json.loads(rows[0]) == {
+        "name": "home",
+        "path": "/",
+        "status": 200,
+        "elapsed": 0.1,
+        "ok": True,
+        "reason": "ok",
+        "bytes": 50,
+    }

src/tests/test_dashboard_user_story_tracker.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import csv
+import sys
+from pathlib import Path
+
+repo_root = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(repo_root / "src"))
+
+from ctx.monitor import routes as monitor_routes  # noqa: E402
+
+TRACKER = repo_root / "docs" / "qa" / "dashboard-user-story-status.csv"
+PASS_STATUSES = {"Tested Pass", "Retested Pass"}
+VALIDATION_STATUSES = {"Needs Validation"}
+FIX_STATUSES = {"Needs Fix"}
+ACTIONABLE_STATUSES = PASS_STATUSES | VALIDATION_STATUSES | FIX_STATUSES
+
+
+def _tracker_rows() -> list[dict[str, str]]:
+    with TRACKER.open(newline="", encoding="utf-8") as f:
+        return list(csv.DictReader(f))
+
+
+def _tracker_text() -> str:
+    return "\n".join(" ".join(row.values()) for row in _tracker_rows())
+
+
+def test_dashboard_user_story_tracker_has_valid_rows() -> None:
+    rows = _tracker_rows()
+    assert rows
+    required = (
+        "dashboard_id",
+        "surface",
+        "page_or_api",
+        "route_or_control",
+        "source_evidence",
+        "user_story",
+        "expected_behavior",
+        "test_command_or_steps",
+        "status",
+        "first_test_result",
+        "last_verified_at",
+    )
+    for row in rows:
+        assert None not in row, f"{row.get('dashboard_id', '<unknown>')} has extra CSV columns"
+        for key in required:
+            assert row[key].strip(), f"{row.get('dashboard_id', '<unknown>')} missing {key}"
+        assert row["status"] in ACTIONABLE_STATUSES
+        if row["status"] in FIX_STATUSES:
+            for key in ("error_id", "error_summary", "fix_status"):
+                assert row[key].strip(), (
+                    f"{row.get('dashboard_id', '<unknown>')} has "
+                    f"{row['status']} without {key}"
+                )
+        if row["status"] in VALIDATION_STATUSES:
+            assert row["notes"].strip(), (
+                f"{row.get('dashboard_id', '<unknown>')} needs validation "
+                "without a validation note"
+            )
+
+
+def test_dashboard_user_story_tracker_covers_all_monitor_routes() -> None:
+    route_patterns: list[str] = []
+    route_patterns.extend(href for _key, _label, href in monitor_routes.NAV_ROUTES)
+    route_patterns.extend(sorted(monitor_routes.PAGE_ROUTES))
+    route_patterns.extend(sorted(monitor_routes.GET_API_ROUTES))
+    route_patterns.extend(monitor_routes.GET_API_PATTERNS)
+    route_patterns.extend(sorted(monitor_routes.POST_API_ROUTES))
+    route_patterns.extend(("/session/<session_id>", "/skill/<slug>", "/wiki/<slug>"))
+    route_patterns = list(dict.fromkeys(route_patterns))
+    tracker = _tracker_text()
+
+    assert route_patterns
+    assert [route for route in route_patterns if route not in tracker] == []
+
+
+def test_dashboard_user_story_tracker_records_verified_graph_counts() -> None:
+    rows = {row["dashboard_id"]: row for row in _tracker_rows()}
+    graph_count = rows["DASH-NUM-001"]
+
+    assert graph_count["status"] == "Tested Pass"
+    assert "79,958 nodes" in graph_count["first_test_result"]
+    assert "1,778,069 edges" in graph_count["first_test_result"]

src/tests/test_dedup_check.py

@@ -21,6 +21,7 @@ if str(SRC_DIR) not in sys.path:
     sys.path.insert(0, str(SRC_DIR))
 
 from ctx.core.quality import dedup_check as dc  # noqa: E402
+from ctx.core.wiki.wiki_packs import write_wiki_base_pack  # noqa: E402
 
 
 # ── Allowlist ──────────────────────────────────────────────────────────
@@ -58,6 +59,56 @@ def test_allowlist_skips_malformed_lines(tmp_path: Path) -> None:
     assert dc.load_allowlist(p) == set()
 
 
+def test_discover_entities_reads_wiki_packs_before_physical_pages(tmp_path: Path) -> None:
+    stale_dir = tmp_path / "entities" / "skills"
+    stale_dir.mkdir(parents=True)
+    (stale_dir / "stale.md").write_text(
+        "---\n"
+        "description: stale physical page\n"
+        "---\n"
+        "# stale\n",
+        encoding="utf-8",
+    )
+    write_wiki_base_pack(
+        pack_dir=tmp_path / "wiki-packs" / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        pages={
+            "entities/skills/pack-skill.md": (
+                "---\n"
+                "description: pack skill description\n"
+                "tags:\n"
+                "  - pack\n"
+                "---\n"
+                "# pack skill\n"
+            ),
+            "entities/agents/reviewer.md": (
+                "---\n"
+                "description: review agent\n"
+                "---\n"
+                "# reviewer\n"
+            ),
+            "entities/mcp-servers/g/github.md": (
+                "---\n"
+                "description: github mcp\n"
+                "---\n"
+                "# github\n"
+            ),
+        },
+    )
+
+    entities = dc.discover_entities(tmp_path)
+
+    assert [entity.node_id for entity in entities] == [
+        "agent:reviewer",
+        "mcp-server:github",
+        "skill:pack-skill",
+    ]
+    pack_skill = next(entity for entity in entities if entity.node_id == "skill:pack-skill")
+    assert pack_skill.description == "pack skill description"
+    assert pack_skill.tags == ("pack",)
+
+
 # ── State ──────────────────────────────────────────────────────────────
 
 

src/tests/test_docs_catalog_page.py

@@ -54,16 +54,16 @@ def test_public_catalog_page_does_not_link_to_local_dashboard() -> None:
     assert "../dashboard/#catalog-badge-links" in text
 
 
-def test_docs_pages_workflow_uploads_single_overwritable_pages_artifact() -> None:
+def test_docs_pages_workflow_uses_node24_pages_artifact_action() -> None:
     text = (repo_root / ".github" / "workflows" / "docs.yml").read_text(
         encoding="utf-8"
     )
 
-    assert "actions/upload-pages-artifact" not in text
-    assert "actions/upload-artifact@v4" in text
-    assert "name: github-pages" in text
-    assert "artifact.tar" in text
-    assert "overwrite: true" in text
+    assert "actions/upload-pages-artifact@v5" in text
+    assert "actions/upload-artifact@v4" not in text
+    assert "path: site" in text
+    assert "artifact.tar" not in text
+    assert "overwrite: true" not in text
 
 
 def test_public_docs_render_current_graph_contract_totals() -> None:

src/tests/test_enterprise_telemetry.py

@@ -0,0 +1,2000 @@
+from __future__ import annotations
+
+from dataclasses import asdict
+from io import BytesIO
+import json
+import os
+import stat
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+import ctx.api as ctx_api
+from ctx.cli import telemetry as telemetry_cli
+import ctx.telemetry as telemetry
+from ctx.adapters.generic.ctx_core_tools import CtxCoreToolbox
+from ctx.mcp_server import server as mcp_server
+from ctx.telemetry import (
+    EXPORT_STATUS_SCHEMA_VERSION,
+    METRIC_SCHEMA_VERSION,
+    RETENTION_STATUS_SCHEMA_VERSION,
+    SCHEMA_VERSION,
+    TelemetryEvent,
+    TelemetryMetric,
+    enforce_telemetry_retention,
+    exception_payload,
+    export_events,
+    export_metrics,
+    hash_identifier,
+    plan_telemetry_retention,
+    read_events,
+    read_metrics,
+    record_counter,
+    record_event,
+    record_exception,
+    record_histogram,
+)
+
+
+def _redirect_real_event_telemetry(
+    monkeypatch: pytest.MonkeyPatch,
+    path: Path,
+) -> None:
+    config = {"path": str(path), "export": {"enabled": False}}
+
+    def config_get(key: str, default: Any) -> Any:
+        return config if key == "telemetry" else default
+
+    monkeypatch.setattr(telemetry, "_config_get", config_get)
+    monkeypatch.setattr(telemetry, "record_event", record_event)
+
+
+def test_record_event_writes_local_redacted_envelope(tmp_path: Path) -> None:
+    path = tmp_path / "events.jsonl"
+
+    event = record_event(
+        "recommendation.returned",
+        source="ctx-core",
+        session_id="sess-1",
+        transport="python-api",
+        actor="cli",
+        duration_ms=12.5,
+        repo="/Users/example/private-repo",
+        cwd="/Users/example/private-repo/service",
+        payload={
+            "query": "debug failing checkout for customer acme",
+            "result_count": 2,
+            "token": "sk-secret-token-value",
+            "ranked": [{"slug": "python-patterns", "score": 0.91}],
+        },
+        path=path,
+        trusted_root=tmp_path,
+        config={"mode": "local_redacted", "path": str(path)},
+    )
+
+    assert event is not None
+    raw = json.loads(path.read_text(encoding="utf-8"))
+    assert raw["schema_version"] == SCHEMA_VERSION
+    assert raw["event_name"] == "recommendation.returned"
+    assert raw["source"] == "ctx-core"
+    assert raw["session_id"] == "sess-1"
+    assert raw["session_hash"].startswith("sha256:")
+    assert len(raw["trace_id"]) == 32
+    assert len(raw["span_id"]) == 16
+    assert raw["ctx_version"]
+    assert raw["privacy_mode"] == "local_redacted"
+    assert raw["repo_hash"].startswith("sha256:")
+    assert raw["cwd_hash"].startswith("sha256:")
+    assert raw["payload"]["result_count"] == 2
+    assert raw["payload"]["token"] == "[redacted]"
+    assert "query" not in raw["payload"]
+    assert raw["payload"]["query_hash"].startswith("sha256:")
+
+    got = list(read_events(path, trusted_root=tmp_path))
+    assert len(got) == 1
+    assert got[0].event_id == event.event_id
+    assert got[0].session_hash == event.session_hash
+    assert got[0].trace_id == event.trace_id
+    assert got[0].span_id == event.span_id
+    assert got[0].ctx_version == event.ctx_version
+
+
+def test_telemetry_span_propagates_trace_to_nested_events(tmp_path: Path) -> None:
+    path = tmp_path / "events.jsonl"
+
+    with telemetry.telemetry_span():
+        parent = record_event(
+            "ctx.api.recommend_bundle",
+            source="ctx-api",
+            path=path,
+            trusted_root=tmp_path,
+            config={"path": str(path), "export": {"enabled": False}},
+        )
+        with telemetry.telemetry_span():
+            child = record_event(
+                "ctx.core.recommend_bundle",
+                source="ctx-core",
+                path=path,
+                trusted_root=tmp_path,
+                config={"path": str(path), "export": {"enabled": False}},
+            )
+
+    assert parent is not None
+    assert child is not None
+    assert parent.trace_id == child.trace_id
+    assert parent.span_id != child.span_id
+    assert parent.parent_span_id is None
+    assert child.parent_span_id == parent.span_id
+
+
+def test_record_event_explicit_trace_ids_override_active_span(tmp_path: Path) -> None:
+    path = tmp_path / "events.jsonl"
+
+    with telemetry.telemetry_span():
+        event = record_event(
+            "ctx.api.recommend_bundle",
+            source="ctx-api",
+            trace_id="1" * 32,
+            span_id="2" * 16,
+            parent_span_id="3" * 16,
+            path=path,
+            trusted_root=tmp_path,
+            config={"path": str(path), "export": {"enabled": False}},
+        )
+
+    assert event is not None
+    assert event.trace_id == "1" * 32
+    assert event.span_id == "2" * 16
+    assert event.parent_span_id == "3" * 16
+
+
+def test_record_metrics_writes_local_redacted_spool(tmp_path: Path) -> None:
+    path = tmp_path / "metrics.jsonl"
+    config = {
+        "metrics": {
+            "enabled": True,
+            "path": str(path),
+            "export": {"enabled": False},
+        },
+        "privacy": {"hash_salt": "tenant-a"},
+    }
+
+    with telemetry.telemetry_span():
+        counter = record_counter(
+            "ctx.api.requests",
+            value=2,
+            attributes={"query": "private acme query", "ctx.operation": "recommend"},
+            source="ctx-api",
+            session_id="sess-private",
+            path=path,
+            trusted_root=tmp_path,
+            config=config,
+        )
+        histogram = record_histogram(
+            "ctx.api.duration",
+            value=42.5,
+            unit="ms",
+            attributes={"path": "/Users/example/private-repo", "ctx.operation": "recommend"},
+            source="ctx-api",
+            session_id="sess-private",
+            path=path,
+            trusted_root=tmp_path,
+            config=config,
+        )
+
+    assert counter is not None
+    assert histogram is not None
+    assert counter.schema_version == METRIC_SCHEMA_VERSION
+    assert counter.instrument == "counter"
+    assert histogram.instrument == "histogram"
+    assert counter.trace_id == histogram.trace_id
+    assert counter.session_hash == histogram.session_hash
+    assert counter.session_hash is not None
+    assert counter.session_hash.startswith("sha256:")
+    raw = path.read_text(encoding="utf-8")
+    assert "private acme query" not in raw
+    assert "/Users/example/private-repo" not in raw
+    assert "sess-private" not in raw
+    assert "query_hash" in raw
+    assert "path_hash" in raw
+    if os.name != "nt":
+        assert stat.S_IMODE(path.stat().st_mode) == 0o600
+
+    metrics = list(read_metrics(path, trusted_root=tmp_path))
+    assert [metric.name for metric in metrics] == [
+        "ctx.api.requests",
+        "ctx.api.duration",
+    ]
+
+
+def test_metrics_disabled_unless_metrics_config_present(tmp_path: Path) -> None:
+    path = tmp_path / "metrics.jsonl"
+
+    missing = record_counter(
+        "ctx.api.requests",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(tmp_path / "events.jsonl")},
+    )
+    disabled = record_counter(
+        "ctx.api.requests",
+        path=path,
+        trusted_root=tmp_path,
+        config={"metrics": {"enabled": False, "path": str(path)}},
+    )
+
+    assert missing is None
+    assert disabled is None
+    assert not path.exists()
+
+
+def test_export_metrics_posts_otlp_resource_metrics(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "metrics.jsonl"
+    config = {
+        "metrics": {
+            "enabled": True,
+            "path": str(path),
+            "export": {"enabled": False},
+        },
+        "privacy": {"hash_salt": "tenant-a"},
+    }
+    counter = record_counter(
+        "ctx.api.requests",
+        value=3,
+        attributes={"query": "private acme query"},
+        source="ctx-api",
+        session_id="sess-raw-private",
+        path=path,
+        trusted_root=tmp_path,
+        config=config,
+    )
+    histogram = record_histogram(
+        "ctx.api.duration",
+        value=42,
+        attributes={"ctx.operation": "recommend"},
+        source="ctx-api",
+        session_id="sess-raw-private",
+        path=path,
+        trusted_root=tmp_path,
+        config=config,
+    )
+    assert counter is not None
+    assert histogram is not None
+    calls: list[tuple[dict[str, Any], dict[str, Any]]] = []
+
+    def fake_post_otlp_http(
+        payload: dict[str, Any],
+        settings: dict[str, Any],
+    ) -> None:
+        calls.append((payload, settings))
+
+    monkeypatch.setattr(telemetry, "_post_otlp_http", fake_post_otlp_http)
+
+    result = export_metrics(
+        path,
+        trusted_root=tmp_path,
+        config={
+            "metrics": {
+                "enabled": True,
+                "path": str(path),
+                "export": {
+                    "enabled": True,
+                    "sink": "otlp_http",
+                    "otlp": {
+                        "endpoint": "https://collector.example:4318/v1/metrics",
+                        "allowed_hosts": ["collector.example"],
+                        "service_name": "ctx-test",
+                    },
+                },
+            },
+            "privacy": {"hash_salt": "tenant-a"},
+        },
+    )
+
+    assert result.exported == 2
+    assert result.failed == 0
+    assert result.status == "ok"
+    assert result.checkpoint_advanced is True
+    assert len(calls) == 1
+    payload, settings = calls[0]
+    assert settings["otlp_endpoint"] == "https://collector.example:4318/v1/metrics"
+    metric_records = payload["resourceMetrics"][0]["scopeMetrics"][0]["metrics"]
+    by_name = {record["name"]: record for record in metric_records}
+    assert by_name["ctx.api.requests"]["sum"]["aggregationTemporality"] == 1
+    assert by_name["ctx.api.requests"]["sum"]["isMonotonic"] is True
+    assert by_name["ctx.api.requests"]["sum"]["dataPoints"][0]["asInt"] == "3"
+    histogram_point = by_name["ctx.api.duration"]["histogram"]["dataPoints"][0]
+    assert by_name["ctx.api.duration"]["histogram"]["aggregationTemporality"] == 1
+    assert histogram_point["count"] == "1"
+    assert histogram_point["sum"] == 42.0
+    assert histogram_point["min"] == 42.0
+    assert histogram_point["max"] == 42.0
+    assert sum(int(count) for count in histogram_point["bucketCounts"]) == 1
+    text = json.dumps(payload)
+    assert "private acme query" not in text
+    assert "sess-raw-private" not in text
+    assert "ctx.session.hash" in text
+    assert "ctx.metric.query_hash" in text
+
+
+def test_metrics_export_checkpoint_is_independent_from_event_checkpoint(
+    tmp_path: Path,
+) -> None:
+    event_path = tmp_path / "events.jsonl"
+    metric_path = tmp_path / "metrics.jsonl"
+    event_export_path = tmp_path / "exported-events.jsonl"
+    metric_export_path = tmp_path / "exported-metrics.jsonl"
+    event = record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        path=event_path,
+        trusted_root=tmp_path,
+        config={"path": str(event_path), "export": {"enabled": False}},
+    )
+    metric = record_counter(
+        "ctx.api.requests",
+        path=metric_path,
+        trusted_root=tmp_path,
+        config={
+            "metrics": {
+                "enabled": True,
+                "path": str(metric_path),
+                "export": {"enabled": False},
+            },
+        },
+    )
+    assert event is not None
+    assert metric is not None
+
+    event_result = export_events(
+        event_path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(event_path),
+            "export": {
+                "enabled": True,
+                "sink": "local_jsonl",
+                "path": str(event_export_path),
+            },
+        },
+    )
+    metric_result = export_metrics(
+        metric_path,
+        trusted_root=tmp_path,
+        config={
+            "metrics": {
+                "enabled": True,
+                "path": str(metric_path),
+                "export": {
+                    "enabled": True,
+                    "sink": "local_jsonl",
+                    "path": str(metric_export_path),
+                },
+            },
+        },
+    )
+
+    assert event_result.checkpoint_path == str(event_path) + ".export-checkpoint.json"
+    assert metric_result.checkpoint_path == str(metric_path) + ".export-checkpoint.json"
+    event_checkpoint = json.loads(Path(event_result.checkpoint_path).read_text(encoding="utf-8"))
+    metric_checkpoint = json.loads(Path(metric_result.checkpoint_path).read_text(encoding="utf-8"))
+    assert event_checkpoint["last_event_id"] == event.event_id
+    assert "last_metric_id" not in event_checkpoint
+    assert metric_checkpoint["last_metric_id"] == metric.metric_id
+    assert "last_event_id" not in metric_checkpoint
+
+
+def test_export_metrics_degraded_on_malformed_pending_records(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    path = tmp_path / "metrics.jsonl"
+    export_path = tmp_path / "exported-metrics.jsonl"
+    metric = record_counter(
+        "ctx.api.requests",
+        path=path,
+        trusted_root=tmp_path,
+        config={
+            "metrics": {
+                "enabled": True,
+                "path": str(path),
+                "export": {"enabled": False},
+            },
+        },
+    )
+    assert metric is not None
+    with path.open("a", encoding="utf-8") as fh:
+        fh.write("{not valid json}\n")
+
+    result = export_metrics(
+        path,
+        trusted_root=tmp_path,
+        config={
+            "metrics": {
+                "enabled": True,
+                "path": str(path),
+                "export": {
+                    "enabled": True,
+                    "sink": "local_jsonl",
+                    "path": str(export_path),
+                },
+            },
+        },
+    )
+
+    assert result.attempted == 1
+    assert result.exported == 1
+    assert result.failed == 0
+    assert result.status == "degraded"
+    assert result.malformed_records == 1
+    assert result.malformed_pending_records == 1
+    assert result.checkpoint_advanced is False
+    assert not Path(str(path) + ".export-checkpoint.json").exists()
+    status = json.loads(Path(str(path) + ".export-status.json").read_text(encoding="utf-8"))
+    assert status["status"] == "degraded"
+    assert status["malformed_pending_records"] == 1
+    assert status["checkpoint_advanced"] is False
+    assert "skipping malformed metric" in capsys.readouterr().err
+
+
+def test_api_core_events_share_trace_context(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import ctx.adapters.generic.ctx_core_tools as core_tools
+
+    spans: dict[str, telemetry.TelemetrySpan] = {}
+
+    def capture_api_event(*args: Any, **kwargs: Any) -> None:
+        span = telemetry.current_telemetry_span()
+        assert span is not None
+        spans["api"] = span
+
+    def capture_core_event(*args: Any, **kwargs: Any) -> None:
+        span = telemetry.current_telemetry_span()
+        assert span is not None
+        spans["core"] = span
+
+    monkeypatch.setattr(ctx_api, "_record_api_event", capture_api_event)
+    monkeypatch.setattr(core_tools, "_record_core_tool_event", capture_core_event)
+    monkeypatch.setattr(
+        ctx_api,
+        "_get_toolbox",
+        lambda: CtxCoreToolbox(wiki_dir=tmp_path / "wiki", graph_path=tmp_path / "graph.json"),
+    )
+
+    with pytest.raises(ValueError, match="unknown ctx-core tool"):
+        ctx_api._call("ctx__missing", {})
+
+    assert set(spans) == {"api", "core"}
+    assert spans["core"].trace_id == spans["api"].trace_id
+    assert spans["core"].span_id != spans["api"].span_id
+    assert spans["core"].parent_span_id == spans["api"].span_id
+    assert spans["api"].parent_span_id is None
+
+
+def test_mcp_core_events_share_trace_context(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import ctx.adapters.generic.ctx_core_tools as core_tools
+
+    spans: dict[str, telemetry.TelemetrySpan] = {}
+
+    def capture_mcp_event(*args: Any, **kwargs: Any) -> None:
+        span = telemetry.current_telemetry_span()
+        assert span is not None
+        spans["mcp"] = span
+
+    def capture_core_event(*args: Any, **kwargs: Any) -> None:
+        span = telemetry.current_telemetry_span()
+        assert span is not None
+        spans["core"] = span
+
+    monkeypatch.setattr(mcp_server, "_record_mcp_request", capture_mcp_event)
+    monkeypatch.setattr(core_tools, "_record_core_tool_event", capture_core_event)
+    out = BytesIO()
+    frame = {
+        "jsonrpc": "2.0",
+        "id": 1,
+        "method": "tools/call",
+        "params": {"name": "ctx__missing", "arguments": {}},
+    }
+
+    mcp_server._process_line(json.dumps(frame), mcp_server._ServerState(), out)
+
+    response = json.loads(out.getvalue().decode("utf-8"))
+    assert response["result"]["isError"] is True
+    assert set(spans) == {"core", "mcp"}
+    assert spans["core"].trace_id == spans["mcp"].trace_id
+    assert spans["core"].span_id != spans["mcp"].span_id
+    assert spans["core"].parent_span_id == spans["mcp"].span_id
+    assert spans["mcp"].parent_span_id is None
+
+
+def test_record_event_returns_none_when_disabled(tmp_path: Path) -> None:
+    path = tmp_path / "events.jsonl"
+
+    event = record_event(
+        "session.started",
+        source="ctx-run",
+        path=path,
+        trusted_root=tmp_path,
+        config={"enabled": False, "path": str(path)},
+    )
+
+    assert event is None
+    assert not path.exists()
+
+
+def test_record_event_fails_closed_for_unknown_privacy_mode(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    path = tmp_path / "events.jsonl"
+
+    event = record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        payload={"query": "private acme query"},
+        path=path,
+        trusted_root=tmp_path,
+        config={"mode": "debug_raw", "path": str(path)},
+    )
+
+    assert event is None
+    assert not path.exists()
+    assert "telemetry.mode must be one of" in capsys.readouterr().err
+
+
+def test_record_event_can_export_to_local_jsonl(tmp_path: Path) -> None:
+    path = tmp_path / "events.jsonl"
+    export_path = tmp_path / "exported-events.jsonl"
+
+    event = record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        payload={"query": "private acme query", "ctx.result.count": 1},
+        path=path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "export": {
+                "enabled": True,
+                "sink": "local_jsonl",
+                "path": str(export_path),
+            },
+        },
+    )
+
+    assert event is not None
+    exported = json.loads(export_path.read_text(encoding="utf-8"))
+    assert exported["event_id"] == event.event_id
+    assert exported["event_name"] == "ctx.api.recommend_bundle"
+    assert "query" not in exported["payload"]
+    assert exported["payload"]["query_hash"].startswith("sha256:")
+
+
+def test_record_event_creates_owner_only_local_files(tmp_path: Path) -> None:
+    if os.name == "nt":
+        pytest.skip("POSIX mode bits are not portable on Windows")
+    path = tmp_path / "events.jsonl"
+    export_path = tmp_path / "exported-events.jsonl"
+
+    record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        path=path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "export": {
+                "enabled": True,
+                "sink": "local_jsonl",
+                "path": str(export_path),
+            },
+        },
+    )
+
+    assert stat.S_IMODE(path.stat().st_mode) == 0o600
+    assert stat.S_IMODE(export_path.stat().st_mode) == 0o600
+    checkpoint_path = Path(str(path) + ".export-checkpoint.json")
+    assert stat.S_IMODE(checkpoint_path.stat().st_mode) == 0o600
+    status_path = Path(str(path) + ".export-status.json")
+    assert stat.S_IMODE(status_path.stat().st_mode) == 0o600
+
+
+def test_telemetry_export_cli_rejects_unknown_privacy_mode(
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    monkeypatch.setattr(
+        telemetry_cli,
+        "_base_telemetry_config",
+        lambda: {"mode": "debug_raw", "export": {"enabled": True, "sink": "local_jsonl"}},
+    )
+
+    rc = telemetry_cli.main(["--dry-run", "--json"])
+
+    assert rc == 1
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["failed"] == 1
+    assert "telemetry.mode must be one of" in payload["error"]
+
+
+def test_export_events_posts_otlp_http_payload(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "events.jsonl"
+    record_event(
+        "ctx.mcp.request",
+        source="ctx-mcp-server",
+        outcome="error",
+        session_id="sess-otlp-private",
+        error_kind="method_not_found",
+        payload={"rpc.method": "tools/call", "query": "private acme query"},
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+    calls: list[tuple[dict[str, Any], dict[str, Any]]] = []
+
+    def fake_post_otlp_http(
+        payload: dict[str, Any],
+        settings: dict[str, Any],
+    ) -> None:
+        calls.append((payload, settings))
+
+    monkeypatch.setattr(telemetry, "_post_otlp_http", fake_post_otlp_http)
+
+    result = export_events(
+        path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "export": {
+                "enabled": True,
+                "sink": "otlp_http",
+                "otlp": {
+                    "endpoint": "https://collector.example:4318/v1/logs",
+                    "allowed_hosts": ["collector.example"],
+                    "headers": {"Authorization": "Bearer token"},
+                    "service_name": "ctx-test",
+                    "service_namespace": "ctx",
+                    "deployment_environment": "test",
+                },
+            },
+        },
+    )
+
+    assert result.exported == 1
+    assert result.failed == 0
+    assert result.sink == "otlp_http"
+    assert len(calls) == 1
+    payload, settings = calls[0]
+    assert settings["otlp_endpoint"] == "https://collector.example:4318/v1/logs"
+    assert settings["otlp_allowed_hosts"] == ["collector.example"]
+    resource_logs = payload["resourceLogs"]
+    assert isinstance(resource_logs, list)
+    log_record = resource_logs[0]["scopeLogs"][0]["logRecords"][0]
+    assert log_record["body"] == {"stringValue": "ctx.mcp.request"}
+    assert len(log_record["traceId"]) == 32
+    assert len(log_record["spanId"]) == 16
+    attributes = {
+        item["key"]: item["value"]
+        for item in log_record["attributes"]
+    }
+    assert attributes["event.name"] == {"stringValue": "ctx.mcp.request"}
+    assert attributes["ctx.outcome"] == {"stringValue": "error"}
+    assert attributes["error.type"] == {"stringValue": "method_not_found"}
+    assert "ctx.session_id" not in attributes
+    assert attributes["ctx.session.hash"]["stringValue"].startswith("sha256:")
+    assert attributes["ctx.version"]["stringValue"]
+    assert "ctx.payload.query_hash" in attributes
+    assert "private acme query" not in json.dumps(payload)
+    assert "sess-otlp-private" not in json.dumps(payload)
+
+
+def test_export_events_hashes_legacy_session_id_for_otlp(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "events.jsonl"
+    path.write_text(
+        json.dumps(
+            {
+                "schema_version": SCHEMA_VERSION,
+                "event_id": "legacy-event",
+                "ts": "2026-06-28T00:00:00Z",
+                "event_name": "ctx.mcp.request",
+                "source": "ctx-mcp-server",
+                "outcome": "ok",
+                "session_id": "legacy-session-private",
+                "privacy_mode": "local_redacted",
+                "payload": {},
+            }
+        )
+        + "\n",
+        encoding="utf-8",
+    )
+    calls: list[dict[str, Any]] = []
+
+    def fake_post_otlp_http(
+        payload: dict[str, Any],
+        settings: dict[str, Any],
+    ) -> None:
+        calls.append(payload)
+
+    monkeypatch.setattr(telemetry, "_post_otlp_http", fake_post_otlp_http)
+
+    result = export_events(
+        path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "privacy": {"hash_salt": "tenant-a"},
+            "export": {
+                "enabled": True,
+                "sink": "otlp_http",
+                "otlp": {
+                    "endpoint": "https://collector.example:4318/v1/logs",
+                    "allowed_hosts": ["collector.example"],
+                },
+            },
+        },
+    )
+
+    assert result.exported == 1
+    assert result.failed == 0
+    payload = calls[0]
+    log_record = payload["resourceLogs"][0]["scopeLogs"][0]["logRecords"][0]
+    attributes = {
+        item["key"]: item["value"]
+        for item in log_record["attributes"]
+    }
+    assert "ctx.session_id" not in attributes
+    assert attributes["ctx.session.hash"] == {
+        "stringValue": hash_identifier("legacy-session-private", salt="tenant-a")
+    }
+    assert "legacy-session-private" not in json.dumps(payload)
+
+
+@pytest.mark.parametrize(
+    ("endpoint", "match"),
+    [
+        ("http://collector.example:4318/v1/logs", "must use https"),
+        ("https://collector.example:4318/v1/logs", "allowed_hosts"),
+        ("https://user:pass@collector.example/v1/logs", "must not include userinfo"),
+        ("https://collector.example/v1/logs?token=x", "must not include query"),
+        ("https://collector.example/v1/logs#fragment", "must not include query"),
+        ("https://collector.example:bad/v1/logs", "invalid port"),
+        ("ftp://collector.example/v1/logs", "must use http or https"),
+        ("/v1/logs", "must use http or https"),
+        ("https:///v1/logs", "must include a host"),
+        ("https://169.254.169.254/v1/logs", "host is not allowed"),
+        ("https://10.0.0.1/v1/logs", "host is not allowed"),
+    ],
+)
+def test_export_events_rejects_unsafe_otlp_endpoints(
+    tmp_path: Path,
+    endpoint: str,
+    match: str,
+) -> None:
+    path = tmp_path / "events.jsonl"
+    record_event(
+        "ctx.mcp.request",
+        source="ctx-mcp-server",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+
+    with pytest.raises(ValueError, match=match):
+        export_events(
+            path,
+            trusted_root=tmp_path,
+            config={
+                "path": str(path),
+                "export": {
+                    "enabled": True,
+                    "sink": "otlp_http",
+                    "otlp": {"endpoint": endpoint},
+                },
+            },
+        )
+
+
+@pytest.mark.parametrize(
+    "endpoint",
+    [
+        "http://localhost:4318/v1/logs",
+        "http://127.0.0.1:4318/v1/logs",
+        "http://[::1]:4318/v1/logs",
+    ],
+)
+def test_export_events_allows_loopback_http_otlp(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    endpoint: str,
+) -> None:
+    path = tmp_path / "events.jsonl"
+    record_event(
+        "ctx.mcp.request",
+        source="ctx-mcp-server",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+    calls: list[tuple[dict[str, Any], dict[str, Any]]] = []
+
+    def fake_post_otlp_http(
+        payload: dict[str, Any],
+        settings: dict[str, Any],
+    ) -> None:
+        calls.append((payload, settings))
+
+    monkeypatch.setattr(telemetry, "_post_otlp_http", fake_post_otlp_http)
+
+    result = export_events(
+        path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "export": {
+                "enabled": True,
+                "sink": "otlp_http",
+                "otlp": {"endpoint": endpoint},
+            },
+        },
+    )
+
+    assert result.exported == 1
+    assert result.failed == 0
+    assert calls[0][1]["otlp_endpoint"] == endpoint
+
+
+def test_export_events_applies_otlp_policy_to_env_overrides(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "events.jsonl"
+    record_event(
+        "ctx.mcp.request",
+        source="ctx-mcp-server",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+
+    monkeypatch.setenv("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT", "http://collector.example/v1/logs")
+
+    with pytest.raises(ValueError, match="must use https"):
+        export_events(
+            path,
+            trusted_root=tmp_path,
+            config={
+                "path": str(path),
+                "export": {
+                    "enabled": True,
+                    "sink": "otlp_http",
+                    "otlp": {
+                        "endpoint": "https://collector.example/v1/logs",
+                        "allowed_hosts": ["collector.example"],
+                    },
+                },
+            },
+        )
+
+
+def test_export_events_appends_logs_path_for_otlp_base_env(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "events.jsonl"
+    record_event(
+        "ctx.mcp.request",
+        source="ctx-mcp-server",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+    calls: list[tuple[dict[str, Any], dict[str, Any]]] = []
+
+    def fake_post_otlp_http(
+        payload: dict[str, Any],
+        settings: dict[str, Any],
+    ) -> None:
+        calls.append((payload, settings))
+
+    monkeypatch.setattr(telemetry, "_post_otlp_http", fake_post_otlp_http)
+    monkeypatch.delenv("OTEL_EXPORTER_OTLP_LOGS_ENDPOINT", raising=False)
+    monkeypatch.setenv("OTEL_EXPORTER_OTLP_ENDPOINT", "https://collector.example")
+
+    result = export_events(
+        path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "export": {
+                "enabled": True,
+                "sink": "otlp_http",
+                "otlp": {"allowed_hosts": ["collector.example"]},
+            },
+        },
+    )
+
+    assert result.exported == 1
+    assert result.failed == 0
+    assert calls[0][1]["otlp_endpoint"] == "https://collector.example/v1/logs"
+
+
+def test_local_jsonl_export_ignores_unused_invalid_otlp_endpoint(tmp_path: Path) -> None:
+    path = tmp_path / "events.jsonl"
+    export_path = tmp_path / "exported-events.jsonl"
+    record_event(
+        "ctx.mcp.request",
+        source="ctx-mcp-server",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+
+    result = export_events(
+        path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "export": {
+                "enabled": True,
+                "sink": "local_jsonl",
+                "path": str(export_path),
+                "otlp": {"endpoint": "ftp://collector.example/v1/logs"},
+            },
+        },
+    )
+
+    assert result.exported == 1
+    assert result.failed == 0
+    assert export_path.is_file()
+
+
+def test_otlp_redirect_handler_rejects_redirects() -> None:
+    handler = telemetry._NoRedirectHandler()
+    redirect_request: Any = handler.redirect_request
+
+    assert redirect_request(None, None, 302, "Found", {}, "https://collector.example") is None
+
+
+def test_export_events_checkpoint_skips_already_exported_events(tmp_path: Path) -> None:
+    path = tmp_path / "events.jsonl"
+    export_path = tmp_path / "exported-events.jsonl"
+    checkpoint_path = tmp_path / "checkpoint.json"
+    config = {
+        "path": str(path),
+        "export": {
+            "enabled": True,
+            "sink": "local_jsonl",
+            "path": str(export_path),
+            "checkpoint_path": str(checkpoint_path),
+        },
+    }
+    for name in ("ctx.api.recommend_bundle", "ctx.mcp.request"):
+        record_event(
+            name,
+            source="ctx-test",
+            path=path,
+            trusted_root=tmp_path,
+            config={"path": str(path), "export": {"enabled": False}},
+        )
+
+    first = export_events(path, trusted_root=tmp_path, config=config)
+
+    assert first.attempted == 2
+    assert first.exported == 2
+    assert first.status == "ok"
+    assert first.checkpoint_advanced is True
+    assert first.last_event_id is not None
+    assert checkpoint_path.is_file()
+    assert len(export_path.read_text(encoding="utf-8").splitlines()) == 2
+
+    second = export_events(path, trusted_root=tmp_path, config=config)
+
+    assert second.attempted == 0
+    assert second.exported == 0
+    assert second.status == "noop"
+    assert second.checkpoint_advanced is False
+    assert second.checkpoint_before_event_id == first.last_event_id
+    assert second.checkpoint_after_event_id == first.last_event_id
+    assert second.last_event_id == first.last_event_id
+    assert len(export_path.read_text(encoding="utf-8").splitlines()) == 2
+    status_path = Path(str(path) + ".export-status.json")
+    status = json.loads(status_path.read_text(encoding="utf-8"))
+    assert status["schema_version"] == EXPORT_STATUS_SCHEMA_VERSION
+    assert status["status"] == "noop"
+    assert status["checkpoint_advanced"] is False
+    assert status["checkpoint_before_event_id"] == first.last_event_id
+    assert status["checkpoint_after_event_id"] == first.last_event_id
+
+    record_event(
+        "ctx.cli.run",
+        source="ctx-test",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+    third = export_events(path, trusted_root=tmp_path, config=config)
+
+    assert third.attempted == 1
+    assert third.exported == 1
+    assert third.last_event_id != first.last_event_id
+    assert len(export_path.read_text(encoding="utf-8").splitlines()) == 3
+
+    replay = export_events(
+        path,
+        trusted_root=tmp_path,
+        config=config,
+        include_exported=True,
+    )
+
+    assert replay.attempted == 3
+    assert replay.exported == 3
+    assert len(export_path.read_text(encoding="utf-8").splitlines()) == 6
+
+
+def test_export_events_ignores_checkpoint_for_different_destination(tmp_path: Path) -> None:
+    path = tmp_path / "events.jsonl"
+    export_path_a = tmp_path / "exported-a.jsonl"
+    export_path_b = tmp_path / "exported-b.jsonl"
+    checkpoint_path = tmp_path / "checkpoint.json"
+    record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+    config_a = {
+        "path": str(path),
+        "export": {
+            "enabled": True,
+            "sink": "local_jsonl",
+            "path": str(export_path_a),
+            "checkpoint_path": str(checkpoint_path),
+        },
+    }
+    config_b = {
+        "path": str(path),
+        "export": {
+            "enabled": True,
+            "sink": "local_jsonl",
+            "path": str(export_path_b),
+            "checkpoint_path": str(checkpoint_path),
+        },
+    }
+
+    first = export_events(path, trusted_root=tmp_path, config=config_a)
+    second = export_events(path, trusted_root=tmp_path, config=config_b)
+
+    assert first.exported == 1
+    assert second.attempted == 1
+    assert second.exported == 1
+    assert second.checkpoint_before_event_id is None
+    assert second.checkpoint_advanced is True
+    assert len(export_path_b.read_text(encoding="utf-8").splitlines()) == 1
+
+
+def test_export_events_writes_status_with_malformed_count(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    path = tmp_path / "events.jsonl"
+    export_path = tmp_path / "exported-events.jsonl"
+    event = record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+    assert event is not None
+    with path.open("a", encoding="utf-8") as fh:
+        fh.write("{not valid json}\n")
+    status_path = Path(str(path) + ".export-status.json")
+
+    result = export_events(
+        path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "export": {
+                "enabled": True,
+                "sink": "local_jsonl",
+                "path": str(export_path),
+            },
+        },
+    )
+
+    assert result.attempted == 1
+    assert result.exported == 1
+    assert result.failed == 0
+    assert result.status == "degraded"
+    assert result.malformed_records == 1
+    assert result.malformed_pending_records == 1
+    assert result.malformed_first_line == 2
+    assert result.malformed_last_line == 2
+    assert result.checkpoint_advanced is False
+    assert result.last_event_id is None
+    assert result.last_success_event_id == event.event_id
+    assert result.status_path == str(status_path)
+    assert not Path(str(path) + ".export-checkpoint.json").exists()
+    status = json.loads(status_path.read_text(encoding="utf-8"))
+    assert status["schema_version"] == EXPORT_STATUS_SCHEMA_VERSION
+    assert status["status"] == "degraded"
+    assert status["attempted"] == 1
+    assert status["exported"] == 1
+    assert status["failed"] == 0
+    assert status["malformed_records"] == 1
+    assert status["malformed_total_records"] == 1
+    assert status["malformed_pending_records"] == 1
+    assert status["malformed_first_line"] == 2
+    assert status["malformed_last_line"] == 2
+    assert status["checkpoint_advanced"] is False
+    assert status["checkpoint_before_event_id"] is None
+    assert status["checkpoint_after_event_id"] is None
+    assert status["last_success_event_id"] == event.event_id
+    assert status["destination_hash"].startswith("sha256:")
+    assert "skipping malformed event" in capsys.readouterr().err
+
+
+def test_export_events_writes_failure_status_without_checkpoint(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "events.jsonl"
+    event = record_event(
+        "ctx.mcp.request",
+        source="ctx-mcp-server",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+    assert event is not None
+    checkpoint_path = Path(str(path) + ".export-checkpoint.json")
+    status_path = Path(str(path) + ".export-status.json")
+
+    def fake_post_otlp_http(
+        payload: dict[str, Any],
+        settings: dict[str, Any],
+    ) -> None:
+        raise RuntimeError("collector unavailable")
+
+    monkeypatch.setattr(telemetry, "_post_otlp_http", fake_post_otlp_http)
+
+    result = export_events(
+        path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "export": {
+                "enabled": True,
+                "sink": "otlp_http",
+                "otlp": {"endpoint": "http://127.0.0.1:4318/v1/logs"},
+            },
+        },
+    )
+
+    assert result.attempted == 1
+    assert result.exported == 0
+    assert result.failed == 1
+    assert result.status == "failed"
+    assert result.error_kind == "RuntimeError"
+    assert result.checkpoint_advanced is False
+    assert result.malformed_pending_records == 0
+    assert result.status_path == str(status_path)
+    assert not checkpoint_path.exists()
+    status = json.loads(status_path.read_text(encoding="utf-8"))
+    assert status["schema_version"] == EXPORT_STATUS_SCHEMA_VERSION
+    assert status["status"] == "failed"
+    assert status["attempted"] == 1
+    assert status["exported"] == 0
+    assert status["failed"] == 1
+    assert status["error_kind"] == "RuntimeError"
+    assert status["last_event_id"] is None
+    assert status["checkpoint_advanced"] is False
+    assert status["malformed_pending_records"] == 0
+    assert status["destination_hash"].startswith("sha256:")
+
+
+def test_telemetry_export_cli_writes_local_jsonl(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    path = tmp_path / "events.jsonl"
+    export_path = tmp_path / "exported-events.jsonl"
+    record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        payload={"query": "private acme query", "ctx.result.count": 1},
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+
+    rc = telemetry_cli.main(
+        [
+            "--path",
+            str(path),
+            "--trusted-root",
+            str(tmp_path),
+            "--sink",
+            "local_jsonl",
+            "--output",
+            str(export_path),
+            "--json",
+        ]
+    )
+
+    assert rc == 0
+    summary = json.loads(capsys.readouterr().out)
+    assert summary["attempted"] == 1
+    assert summary["error_kind"] is None
+    assert summary["exported"] == 1
+    assert summary["failed"] == 0
+    assert summary["sink"] == "local_jsonl"
+    assert summary["status"] == "ok"
+    assert summary["checkpoint_path"] == str(path) + ".export-checkpoint.json"
+    assert summary["checkpoint_before_event_id"] is None
+    assert summary["checkpoint_after_event_id"] == summary["last_event_id"]
+    assert summary["checkpoint_advanced"] is True
+    assert summary["checkpoint_found"] is False
+    assert summary["malformed_records"] == 0
+    assert summary["malformed_pending_records"] == 0
+    assert summary["destination_hash"].startswith("sha256:")
+    assert summary["last_success_event_id"] == summary["last_event_id"]
+    assert summary["status_path"] == str(path) + ".export-status.json"
+    exported = json.loads(export_path.read_text(encoding="utf-8"))
+    assert summary["last_event_id"] == exported["event_id"]
+    assert exported["event_name"] == "ctx.api.recommend_bundle"
+    assert "query" not in exported["payload"]
+    assert "private acme query" not in json.dumps(exported)
+
+
+def test_telemetry_export_cli_writes_metric_local_jsonl(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    path = tmp_path / "metrics.jsonl"
+    export_path = tmp_path / "exported-metrics.jsonl"
+    metric = record_counter(
+        "ctx.api.requests",
+        attributes={"ctx.source": "api", "query": "private acme query"},
+        path=path,
+        trusted_root=tmp_path,
+        config={"metrics": {"enabled": True, "path": str(path)}},
+    )
+    assert metric is not None
+
+    rc = telemetry_cli.main(
+        [
+            "--signal",
+            "metrics",
+            "--path",
+            str(path),
+            "--trusted-root",
+            str(tmp_path),
+            "--sink",
+            "local_jsonl",
+            "--output",
+            str(export_path),
+            "--json",
+        ]
+    )
+
+    assert rc == 0
+    summary = json.loads(capsys.readouterr().out)
+    assert summary["signal"] == "metrics"
+    assert summary["attempted"] == 1
+    assert summary["exported"] == 1
+    assert summary["failed"] == 0
+    assert summary["status"] == "ok"
+    assert summary["checkpoint_path"] == str(path) + ".export-checkpoint.json"
+    assert summary["checkpoint_after_metric_id"] == summary["last_metric_id"]
+    assert summary["last_success_metric_id"] == summary["last_metric_id"]
+    assert summary["status_path"] == str(path) + ".export-status.json"
+    exported = json.loads(export_path.read_text(encoding="utf-8"))
+    assert exported["schema_version"] == METRIC_SCHEMA_VERSION
+    assert exported["metric_id"] == summary["last_metric_id"]
+    assert "query" not in exported["attributes"]
+    assert "private acme query" not in json.dumps(exported)
+
+
+def test_telemetry_export_cli_allows_remote_otlp_host(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    path = tmp_path / "events.jsonl"
+    record_event(
+        "ctx.mcp.request",
+        source="ctx-mcp-server",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+    calls: list[dict[str, Any]] = []
+
+    def fake_post_otlp_http(
+        payload: dict[str, Any],
+        settings: dict[str, Any],
+    ) -> None:
+        calls.append(settings)
+
+    monkeypatch.setattr(telemetry, "_post_otlp_http", fake_post_otlp_http)
+
+    rc = telemetry_cli.main(
+        [
+            "--path",
+            str(path),
+            "--trusted-root",
+            str(tmp_path),
+            "--sink",
+            "otlp_http",
+            "--otlp-endpoint",
+            "https://collector.example:4318/v1/logs",
+            "--otlp-allowed-host",
+            "collector.example",
+            "--json",
+        ]
+    )
+
+    assert rc == 0
+    summary = json.loads(capsys.readouterr().out)
+    assert summary["exported"] == 1
+    assert summary["failed"] == 0
+    assert summary["sink"] == "otlp_http"
+    assert summary["status"] == "ok"
+    assert len(calls) == 1
+    assert calls[0]["otlp_endpoint"] == "https://collector.example:4318/v1/logs"
+    assert calls[0]["otlp_allowed_hosts"] == ["collector.example"]
+
+
+def test_telemetry_export_cli_can_fail_on_degraded_status(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    path = tmp_path / "events.jsonl"
+    export_path = tmp_path / "exported-events.jsonl"
+    record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+    with path.open("a", encoding="utf-8") as fh:
+        fh.write("not-json\n")
+
+    rc = telemetry_cli.main(
+        [
+            "--path",
+            str(path),
+            "--trusted-root",
+            str(tmp_path),
+            "--sink",
+            "local_jsonl",
+            "--output",
+            str(export_path),
+            "--fail-on-degraded",
+            "--json",
+        ]
+    )
+
+    assert rc == 1
+    summary = json.loads(capsys.readouterr().out)
+    assert summary["exported"] == 1
+    assert summary["failed"] == 0
+    assert summary["status"] == "degraded"
+    assert summary["malformed_pending_records"] == 1
+    assert summary["checkpoint_advanced"] is False
+
+
+def test_telemetry_export_cli_dry_run_counts_events(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    path = tmp_path / "events.jsonl"
+    event = record_event(
+        "ctx.cli.run",
+        source="ctx-cli",
+        path=path,
+        trusted_root=tmp_path,
+        config={"path": str(path), "export": {"enabled": False}},
+    )
+    assert event is not None
+
+    rc = telemetry_cli.main(
+        [
+            "--path",
+            str(path),
+            "--trusted-root",
+            str(tmp_path),
+            "--sink",
+            "local_jsonl",
+            "--dry-run",
+            "--json",
+        ]
+    )
+
+    assert rc == 0
+    summary = json.loads(capsys.readouterr().out)
+    assert summary["attempted"] == 1
+    assert summary["dry_run"] is True
+    assert summary["exported"] == 0
+    assert summary["failed"] == 0
+    assert summary["sink"] == "local_jsonl"
+    assert summary["status"] == "ok"
+    assert summary["checkpoint_advanced"] is False
+    assert summary["last_event_id"] == event.event_id
+    assert summary["malformed_records"] == 0
+    assert summary["malformed_pending_records"] == 0
+    assert summary["destination_hash"].startswith("sha256:")
+    assert summary["status_path"] == str(path) + ".export-status.json"
+    assert not Path(summary["status_path"]).exists()
+
+
+def test_hash_identifier_is_stable_and_saltable(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("CTX_TELEMETRY_HASH_SALT", "tenant-a")
+
+    assert hash_identifier("repo") == hash_identifier("repo")
+    assert hash_identifier("repo") != hash_identifier("other")
+    assert hash_identifier("repo", salt="tenant-a") != hash_identifier("repo", salt="tenant-b")
+
+
+def test_hash_identifier_uses_env_salt(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setenv("CTX_TELEMETRY_HASH_SALT", "tenant-a")
+    tenant_a = hash_identifier("repo")
+
+    monkeypatch.setenv("CTX_TELEMETRY_HASH_SALT", "tenant-b")
+
+    assert hash_identifier("repo") != tenant_a
+    assert hash_identifier("repo", salt="explicit") == hash_identifier("repo", salt="explicit")
+
+
+def test_hash_identifier_generates_owner_only_local_salt(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    salt_path = tmp_path / "hash-salt"
+    monkeypatch.delenv("CTX_TELEMETRY_HASH_SALT", raising=False)
+    monkeypatch.setattr(
+        telemetry,
+        "_config_get",
+        lambda key, default: (
+            {"privacy": {"hash_salt_path": str(salt_path)}} if key == "telemetry" else default
+        ),
+    )
+
+    first = hash_identifier("repo")
+
+    assert salt_path.is_file()
+    assert salt_path.read_text(encoding="utf-8").strip()
+    assert hash_identifier("repo") == first
+    if os.name != "nt":
+        assert stat.S_IMODE(salt_path.stat().st_mode) == 0o600
+
+
+def test_record_event_hashes_with_configured_salt(tmp_path: Path) -> None:
+    path_a = tmp_path / "tenant-a.jsonl"
+    path_b = tmp_path / "tenant-b.jsonl"
+
+    event_a = record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        repo="/Users/example/private-repo",
+        payload={"query": "private acme query"},
+        path=path_a,
+        trusted_root=tmp_path,
+        config={"path": str(path_a), "privacy": {"hash_salt": "tenant-a"}},
+    )
+    event_b = record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        repo="/Users/example/private-repo",
+        payload={"query": "private acme query"},
+        path=path_b,
+        trusted_root=tmp_path,
+        config={"path": str(path_b), "privacy": {"hash_salt": "tenant-b"}},
+    )
+
+    assert event_a is not None
+    assert event_b is not None
+    assert event_a.repo_hash != event_b.repo_hash
+    assert event_a.payload["query_hash"] != event_b.payload["query_hash"]
+
+
+def test_nested_payload_hashing_uses_configured_salt(tmp_path: Path) -> None:
+    path_a = tmp_path / "tenant-a.jsonl"
+    path_b = tmp_path / "tenant-b.jsonl"
+
+    event_a = record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        payload={"nested": {"query": "private nested query"}},
+        path=path_a,
+        trusted_root=tmp_path,
+        config={"path": str(path_a), "privacy": {"hash_salt": "tenant-a"}},
+    )
+    event_b = record_event(
+        "ctx.api.recommend_bundle",
+        source="ctx-api",
+        payload={"nested": {"query": "private nested query"}},
+        path=path_b,
+        trusted_root=tmp_path,
+        config={"path": str(path_b), "privacy": {"hash_salt": "tenant-b"}},
+    )
+
+    assert event_a is not None
+    assert event_b is not None
+    assert event_a.payload["nested"]["query_hash"].startswith("sha256:")
+    assert event_b.payload["nested"]["query_hash"].startswith("sha256:")
+    assert event_a.payload["nested"]["query_hash"] != event_b.payload["nested"]["query_hash"]
+    assert "private nested query" not in path_a.read_text(encoding="utf-8")
+    assert "private nested query" not in path_b.read_text(encoding="utf-8")
+
+
+def test_record_exception_hashes_message_and_stack_for_otlp(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "events.jsonl"
+    config = {"path": str(path), "privacy": {"hash_salt": "tenant-a"}}
+    monkeypatch.setattr(telemetry, "record_event", record_event)
+
+    try:
+        raise RuntimeError("private acme failure at /Users/example/private-repo")
+    except RuntimeError as exc:
+        payload = exception_payload(exc, config=config)
+        event = record_exception(
+            "ctx.api.recommend_bundle",
+            source="ctx-api",
+            exc=exc,
+            payload={"query": "private acme query"},
+            path=path,
+            trusted_root=tmp_path,
+            config=config,
+        )
+
+    assert event is not None
+    assert payload["ctx.exception.message_hash"].startswith("sha256:")
+    assert payload["ctx.exception.stack_hash"].startswith("sha256:")
+    assert event.payload["ctx.exception.message_hash"] == payload["ctx.exception.message_hash"]
+    assert event.payload["ctx.exception.stack_hash"] == payload["ctx.exception.stack_hash"]
+    local_text = path.read_text(encoding="utf-8")
+    assert "private acme failure" not in local_text
+    assert "/Users/example/private-repo" not in local_text
+    assert "private acme query" not in local_text
+
+    calls: list[dict[str, Any]] = []
+
+    def fake_post_otlp_http(
+        otlp_payload: dict[str, Any],
+        settings: dict[str, Any],
+    ) -> None:
+        calls.append(otlp_payload)
+
+    monkeypatch.setattr(telemetry, "_post_otlp_http", fake_post_otlp_http)
+    result = export_events(
+        path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "privacy": {"hash_salt": "tenant-a"},
+            "export": {
+                "enabled": True,
+                "sink": "otlp_http",
+                "otlp": {
+                    "endpoint": "https://collector.example:4318/v1/logs",
+                    "allowed_hosts": ["collector.example"],
+                },
+            },
+        },
+    )
+
+    assert result.exported == 1
+    otlp_text = json.dumps(calls[0])
+    assert "private acme failure" not in otlp_text
+    assert "/Users/example/private-repo" not in otlp_text
+    assert "private acme query" not in otlp_text
+    assert "ctx.payload.ctx.exception.message_hash" in otlp_text
+    assert "ctx.payload.ctx.exception.stack_hash" in otlp_text
+
+
+def test_api_and_core_exceptions_record_hashed_payloads(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    import ctx.adapters.generic.ctx_core_tools as core_tools
+
+    path = tmp_path / "events.jsonl"
+    _redirect_real_event_telemetry(monkeypatch, path)
+
+    toolbox = CtxCoreToolbox(wiki_dir=tmp_path / "wiki", graph_path=tmp_path / "graph.json")
+
+    def fail_recommend(args: dict[str, Any]) -> dict[str, Any]:
+        raise RuntimeError("private core failure for /Users/example/private-repo")
+
+    monkeypatch.setattr(toolbox, "_dispatch_recommend", fail_recommend)
+    with pytest.raises(RuntimeError):
+        toolbox.dispatch(
+            core_tools.ToolCall(
+                id="core",
+                name="ctx__recommend_bundle",
+                arguments={"query": "private core query"},
+            )
+        )
+
+    class FailingToolbox:
+        def dispatch(self, call: Any) -> str:
+            raise RuntimeError("private api failure for /Users/example/private-repo")
+
+    monkeypatch.setattr(ctx_api, "_get_toolbox", lambda: FailingToolbox())
+    with pytest.raises(RuntimeError):
+        ctx_api._call("ctx__recommend_bundle", {"query": "private api query"})
+
+    events = list(read_events(path, trusted_root=tmp_path))
+    by_source = {event.source: event for event in events}
+    assert {"ctx-core", "ctx-api"} <= set(by_source)
+    for event in by_source.values():
+        assert event.payload["ctx.exception.message_hash"].startswith("sha256:")
+        assert event.payload["ctx.exception.stack_hash"].startswith("sha256:")
+        assert event.payload["ctx.exception.escaped"] is True
+    raw = path.read_text(encoding="utf-8")
+    assert "private core failure" not in raw
+    assert "private api failure" not in raw
+    assert "private core query" not in raw
+    assert "private api query" not in raw
+    assert "/Users/example/private-repo" not in raw
+
+
+def test_mcp_handler_exception_records_hashed_payload_and_sanitized_response(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    path = tmp_path / "events.jsonl"
+    _redirect_real_event_telemetry(monkeypatch, path)
+
+    def boom(state: Any, params: dict[str, Any]) -> dict[str, Any]:
+        raise RuntimeError("private mcp failure for /Users/example/private-repo")
+
+    monkeypatch.setitem(mcp_server._HANDLERS, "boom", boom)
+    out = BytesIO()
+    frame = {"jsonrpc": "2.0", "id": 1, "method": "boom", "params": {}}
+
+    mcp_server._process_line(json.dumps(frame), mcp_server._ServerState(), out)
+
+    response = json.loads(out.getvalue().decode("utf-8"))
+    assert response["error"]["code"] == -32603
+    assert response["error"]["message"] == "internal error: RuntimeError"
+    assert "private mcp failure" not in json.dumps(response)
+    event = next(read_events(path, trusted_root=tmp_path))
+    assert event.event_name == "ctx.mcp.request"
+    assert event.payload["ctx.exception.message_hash"].startswith("sha256:")
+    assert event.payload["ctx.exception.stack_hash"].startswith("sha256:")
+    raw = path.read_text(encoding="utf-8")
+    assert "private mcp failure" not in raw
+    assert "/Users/example/private-repo" not in raw
+
+
+def _write_event_record(path: Path, event_id: str, ts: str) -> None:
+    event = TelemetryEvent(
+        schema_version=SCHEMA_VERSION,
+        event_id=event_id,
+        ts=ts,
+        event_name="ctx.api.recommend_bundle",
+        source="ctx-api",
+        payload={"ctx.result.count": 1},
+    )
+    with path.open("a", encoding="utf-8") as fh:
+        fh.write(json.dumps(asdict(event), separators=(",", ":")) + "\n")
+
+
+def _write_metric_record(path: Path, metric_id: str, ts: str) -> None:
+    metric = TelemetryMetric(
+        schema_version=METRIC_SCHEMA_VERSION,
+        metric_id=metric_id,
+        ts=ts,
+        name="ctx.api.duration",
+        instrument="histogram",
+        value=42.0,
+        unit="ms",
+        attributes={"ctx.source": "api"},
+    )
+    with path.open("a", encoding="utf-8") as fh:
+        fh.write(json.dumps(asdict(metric), separators=(",", ":")) + "\n")
+
+
+def test_plan_telemetry_retention_does_not_mutate_spool(tmp_path: Path) -> None:
+    path = tmp_path / "events.jsonl"
+    status_path = tmp_path / "retention-status.json"
+    for index in range(4):
+        _write_event_record(path, f"event-{index}", f"2026-01-0{index + 1}T00:00:00Z")
+    before = path.read_text(encoding="utf-8")
+
+    results = plan_telemetry_retention(
+        signal="events",
+        event_path=path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "retention": {
+                "enabled": True,
+                "status_path": str(status_path),
+                "min_keep_records": 1,
+                "events": {"max_records": 2},
+            },
+        },
+    )
+
+    assert len(results) == 1
+    result = results[0]
+    assert result.signal == "events"
+    assert result.status == "planned"
+    assert result.dry_run is True
+    assert result.scanned_records == 4
+    assert result.retained_records == 2
+    assert result.dropped_records == 2
+    assert result.status_path == str(status_path)
+    assert path.read_text(encoding="utf-8") == before
+    assert not status_path.exists()
+
+
+def test_enforce_telemetry_retention_prunes_events_and_preserves_malformed(
+    tmp_path: Path,
+) -> None:
+    path = tmp_path / "events.jsonl"
+    status_path = tmp_path / "retention-status.json"
+    for index in range(3):
+        _write_event_record(path, f"event-{index}", f"2026-01-0{index + 1}T00:00:00Z")
+    with path.open("a", encoding="utf-8") as fh:
+        fh.write("not-json\n")
+
+    results = enforce_telemetry_retention(
+        signal="events",
+        event_path=path,
+        trusted_root=tmp_path,
+        config={
+            "path": str(path),
+            "retention": {
+                "enabled": True,
+                "status_path": str(status_path),
+                "min_keep_records": 1,
+                "drop_malformed": False,
+                "events": {"max_records": 2},
+            },
+        },
+    )
+
+    assert len(results) == 1
+    result = results[0]
+    assert result.status == "pruned"
+    assert result.dry_run is False
+    assert result.scanned_records == 3
+    assert result.retained_records == 2
+    assert result.dropped_records == 1
+    assert result.malformed_records == 1
+    assert result.malformed_dropped_records == 0
+    assert [event.event_id for event in read_events(path, trusted_root=tmp_path)] == [
+        "event-1",
+        "event-2",
+    ]
+    assert "not-json" in path.read_text(encoding="utf-8")
+    status = json.loads(status_path.read_text(encoding="utf-8"))
+    assert status["schema_version"] == RETENTION_STATUS_SCHEMA_VERSION
+    assert status["results"][0]["signal"] == "events"
+    assert status["results"][0]["status"] == "pruned"
+    if os.name != "nt":
+        assert stat.S_IMODE(status_path.stat().st_mode) == 0o600
+
+
+def test_enforce_telemetry_retention_prunes_metrics_and_can_drop_malformed(
+    tmp_path: Path,
+) -> None:
+    path = tmp_path / "metrics.jsonl"
+    status_path = tmp_path / "retention-status.json"
+    _write_metric_record(path, "metric-1", "2026-01-01T00:00:00Z")
+    _write_metric_record(path, "metric-2", "2026-01-02T00:00:00Z")
+    with path.open("a", encoding="utf-8") as fh:
+        fh.write("not-json\n")
+
+    results = enforce_telemetry_retention(
+        signal="metrics",
+        metrics_path=path,
+        trusted_root=tmp_path,
+        drop_malformed=True,
+        config={
+            "metrics": {"enabled": True, "path": str(path)},
+            "retention": {
+                "enabled": True,
+                "status_path": str(status_path),
+                "min_keep_records": 0,
+                "metrics": {"max_records": 1},
+            },
+        },
+    )
+
+    assert len(results) == 1
+    result = results[0]
+    assert result.signal == "metrics"
+    assert result.status == "pruned"
+    assert result.retained_records == 1
+    assert result.dropped_records == 1
+    assert result.malformed_records == 1
+    assert result.malformed_dropped_records == 1
+    assert [metric.metric_id for metric in read_metrics(path, trusted_root=tmp_path)] == [
+        "metric-2"
+    ]
+    assert "not-json" not in path.read_text(encoding="utf-8")
+    status = json.loads(status_path.read_text(encoding="utf-8"))
+    assert status["results"][0]["signal"] == "metrics"
+
+
+def test_telemetry_retention_cli_plans_then_enforces(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    path = tmp_path / "events.jsonl"
+    status_path = tmp_path / "retention-status.json"
+    _write_event_record(path, "event-1", "2026-01-01T00:00:00Z")
+    _write_event_record(path, "event-2", "2026-01-02T00:00:00Z")
+    monkeypatch.setattr(
+        telemetry_cli,
+        "_base_telemetry_config",
+        lambda: {
+            "path": str(path),
+            "retention": {
+                "enabled": True,
+                "status_path": str(status_path),
+                "min_keep_records": 0,
+                "events": {"max_records": 1},
+            },
+        },
+    )
+
+    plan_rc = telemetry_cli.retention_main(
+        [
+            "plan",
+            "--signal",
+            "events",
+            "--event-path",
+            str(path),
+            "--trusted-root",
+            str(tmp_path),
+            "--json",
+        ]
+    )
+
+    assert plan_rc == 0
+    plan = json.loads(capsys.readouterr().out)
+    assert plan["dry_run"] is True
+    assert plan["results"][0]["status"] == "planned"
+    assert [event.event_id for event in read_events(path, trusted_root=tmp_path)] == [
+        "event-1",
+        "event-2",
+    ]
+
+    enforce_rc = telemetry_cli.retention_main(
+        [
+            "enforce",
+            "--signal",
+            "events",
+            "--event-path",
+            str(path),
+            "--trusted-root",
+            str(tmp_path),
+            "--json",
+        ]
+    )
+
+    assert enforce_rc == 0
+    enforced = json.loads(capsys.readouterr().out)
+    assert enforced["dry_run"] is False
+    assert enforced["results"][0]["status"] == "pruned"
+    assert enforced["results"][0]["dropped_records"] == 1
+    assert [event.event_id for event in read_events(path, trusted_root=tmp_path)] == [
+        "event-2"
+    ]
+    assert json.loads(status_path.read_text(encoding="utf-8"))["schema_version"] == (
+        RETENTION_STATUS_SCHEMA_VERSION
+    )
+
+
+def test_event_rejects_invalid_schema_and_negative_duration() -> None:
+    with pytest.raises(ValueError, match="unsupported telemetry schema"):
+        TelemetryEvent(
+            schema_version="wrong",
+            event_id="e1",
+            ts="2026-06-28T00:00:00Z",
+            event_name="session.started",
+            source="ctx-run",
+        )
+    with pytest.raises(ValueError, match="duration_ms"):
+        TelemetryEvent(
+            schema_version=SCHEMA_VERSION,
+            event_id="e1",
+            ts="2026-06-28T00:00:00Z",
+            event_name="session.started",
+            source="ctx-run",
+            duration_ms=-1,
+        )
+    with pytest.raises(ValueError, match="privacy_mode"):
+        TelemetryEvent(
+            schema_version=SCHEMA_VERSION,
+            event_id="e1",
+            ts="2026-06-28T00:00:00Z",
+            event_name="session.started",
+            source="ctx-run",
+            privacy_mode="debug_raw",
+        )
+    with pytest.raises(ValueError, match="session_hash"):
+        TelemetryEvent(
+            schema_version=SCHEMA_VERSION,
+            event_id="e1",
+            ts="2026-06-28T00:00:00Z",
+            event_name="session.started",
+            source="ctx-run",
+            session_hash="sess-raw",
+        )
+
+
+def test_path_containment_rejects_escape(tmp_path: Path) -> None:
+    with pytest.raises(ValueError, match="escapes"):
+        record_event(
+            "session.started",
+            source="ctx-run",
+            path=tmp_path / ".." / "events.jsonl",
+            trusted_root=tmp_path,
+            config={"path": str(tmp_path / "events.jsonl")},
+        )
+
+
+def test_default_config_declares_local_only_export_disabled() -> None:
+    for path in (Path("src/config.json"), Path("src/ctx/config.json")):
+        data = json.loads(path.read_text(encoding="utf-8"))
+        telemetry = data["telemetry"]
+        assert telemetry["enabled"] is True
+        assert telemetry["mode"] == "local_redacted"
+        assert telemetry["path"] == "~/.ctx/telemetry/events.jsonl"
+        assert telemetry["export"]["enabled"] is False
+        assert telemetry["export"]["sink"] == "otlp_http"
+        assert telemetry["export"]["path"] == "~/.ctx/telemetry/exported-events.jsonl"
+        assert telemetry["export"]["otlp"]["endpoint"] == "http://localhost:4318/v1/logs"
+        assert telemetry["export"]["otlp"]["allowed_hosts"] == []
+        assert telemetry["metrics"]["enabled"] is True
+        assert telemetry["metrics"]["path"] == "~/.ctx/telemetry/metrics.jsonl"
+        assert telemetry["metrics"]["export"]["enabled"] is False
+        assert telemetry["metrics"]["export"]["sink"] == "otlp_http"
+        assert telemetry["metrics"]["export"]["path"] == "~/.ctx/telemetry/exported-metrics.jsonl"
+        assert telemetry["metrics"]["export"]["otlp"]["endpoint"] == (
+            "http://localhost:4318/v1/metrics"
+        )
+        assert telemetry["metrics"]["export"]["otlp"]["allowed_hosts"] == []
+        assert telemetry["privacy"]["store_raw_inputs"] is False
+        assert telemetry["privacy"]["hash_identifiers"] is True
+        assert telemetry["privacy"]["hash_salt_env"] == "CTX_TELEMETRY_HASH_SALT"
+        assert telemetry["privacy"]["hash_salt_path"] == "~/.ctx/telemetry/hash-salt"
+        assert telemetry["retention"]["enabled"] is True
+        assert telemetry["retention"]["status_path"] == (
+            "~/.ctx/telemetry/retention-status.json"
+        )
+        assert telemetry["retention"]["min_keep_records"] == 1000
+        assert telemetry["retention"]["drop_malformed"] is False
+        assert telemetry["retention"]["events"]["max_age_days"] == 90
+        assert telemetry["retention"]["events"]["max_records"] == 100000
+        assert telemetry["retention"]["metrics"]["max_age_days"] == 30
+        assert telemetry["retention"]["metrics"]["max_records"] == 200000

src/tests/test_feature_user_story_tracker.py

@@ -0,0 +1,235 @@
+from __future__ import annotations
+
+import csv
+import sys
+import tomllib
+from pathlib import Path
+
+import yaml
+from yaml.nodes import ScalarNode
+
+repo_root = Path(__file__).resolve().parents[2]
+sys.path.insert(0, str(repo_root / "src"))
+
+import ctx  # noqa: E402
+import ctx.api as ctx_api  # noqa: E402
+from ctx.monitor import routes as monitor_routes  # noqa: E402
+
+TRACKER = repo_root / "docs" / "qa" / "feature-user-story-status.csv"
+DASHBOARD_TRACKER = repo_root / "docs" / "qa" / "dashboard-user-story-status.csv"
+MKDOCS = repo_root / "mkdocs.yml"
+README = repo_root / "README.md"
+PASS_STATUSES = {"Tested Pass", "Retested Pass"}
+VALIDATION_STATUSES = {"Needs Validation"}
+FIX_STATUSES = {"Needs Fix"}
+ACTIONABLE_STATUSES = PASS_STATUSES | VALIDATION_STATUSES | FIX_STATUSES
+
+
+def _tracker_rows() -> list[dict[str, str]]:
+    with TRACKER.open(newline="", encoding="utf-8") as f:
+        return list(csv.DictReader(f))
+
+
+def _tracker_text() -> str:
+    return "\n".join(" ".join(row.values()) for row in _tracker_rows())
+
+
+def _row_text(row: dict[str, str]) -> str:
+    return " ".join(value for value in row.values() if value)
+
+
+def _rows_for_surface(rows: list[dict[str, str]], surface: str) -> list[dict[str, str]]:
+    return [row for row in rows if row["surface"] == surface]
+
+
+class _MkDocsNavLoader(yaml.SafeLoader):
+    pass
+
+
+def _mkdocs_python_name(
+    loader: _MkDocsNavLoader,
+    suffix: str,  # noqa: ARG001
+    node: yaml.Node,
+) -> str:
+    if not isinstance(node, ScalarNode):
+        raise TypeError(f"Expected scalar YAML node, got {type(node).__name__}")
+    return loader.construct_scalar(node)
+
+
+_MkDocsNavLoader.add_multi_constructor(
+    "tag:yaml.org,2002:python/name:",
+    _mkdocs_python_name,
+)
+
+
+def _nav_markdown_paths(nav_items: list[object]) -> list[str]:
+    paths: list[str] = []
+    for item in nav_items:
+        if isinstance(item, str):
+            paths.append(item)
+        elif isinstance(item, dict):
+            for value in item.values():
+                if isinstance(value, str):
+                    paths.append(value)
+                elif isinstance(value, list):
+                    paths.extend(_nav_markdown_paths(value))
+    return [path for path in paths if path.endswith(".md")]
+
+
+def _mkdocs_nav_markdown_paths() -> list[str]:
+    config = yaml.load(
+        MKDOCS.read_text(encoding="utf-8"),
+        Loader=_MkDocsNavLoader,
+    )
+    docs_dir = config.get("docs_dir", "docs")
+    nav = config["nav"]
+    return list(dict.fromkeys(f"{docs_dir}/{path}" for path in _nav_markdown_paths(nav)))
+
+
+def test_feature_user_story_tracker_has_no_empty_core_fields() -> None:
+    rows = _tracker_rows()
+    assert rows
+    required = (
+        "feature_id",
+        "surface",
+        "feature",
+        "entrypoint_or_route",
+        "user_story",
+        "expected_behavior",
+        "test_command_or_steps",
+        "status",
+        "first_test_result",
+        "last_verified_at",
+    )
+    for row in rows:
+        for key in required:
+            assert row[key].strip(), f"{row.get('feature_id', '<unknown>')} missing {key}"
+        assert row["status"] in ACTIONABLE_STATUSES
+        if row["status"] in FIX_STATUSES:
+            for key in ("error_id", "error_summary", "fix_status"):
+                assert row[key].strip(), (
+                    f"{row.get('feature_id', '<unknown>')} has {row['status']} without {key}"
+                )
+        if row["status"] in VALIDATION_STATUSES:
+            assert row["notes"].strip(), (
+                f"{row.get('feature_id', '<unknown>')} needs validation without a validation note"
+            )
+
+
+def test_feature_user_story_tracker_covers_all_console_scripts() -> None:
+    pyproject = tomllib.loads((repo_root / "pyproject.toml").read_text(encoding="utf-8"))
+    scripts = sorted(pyproject["project"]["scripts"])
+    tracker = _tracker_text()
+
+    assert scripts
+    assert [script for script in scripts if script not in tracker] == []
+
+
+def test_feature_user_story_tracker_covers_monitor_route_inventory() -> None:
+    route_patterns: list[str] = []
+    route_patterns.extend(href for _key, _label, href in monitor_routes.NAV_ROUTES)
+    route_patterns.extend(sorted(monitor_routes.PAGE_ROUTES))
+    route_patterns.extend(sorted(monitor_routes.GET_API_ROUTES))
+    route_patterns.extend(monitor_routes.GET_API_PATTERNS)
+    route_patterns.extend(sorted(monitor_routes.POST_API_ROUTES))
+    route_patterns.extend(("/session/<session_id>", "/skill/<slug>"))
+    route_patterns = list(dict.fromkeys(route_patterns))
+    tracker = _tracker_text()
+
+    assert route_patterns
+    assert [route for route in route_patterns if route not in tracker] == []
+
+
+def test_feature_user_story_tracker_covers_distribution_workflows() -> None:
+    workflows = (
+        ".github/workflows/test.yml",
+        ".github/workflows/docs.yml",
+        ".github/workflows/huggingface-sync.yml",
+        ".github/workflows/publish.yml",
+        ".github/workflows/clean-host-contract.yml",
+        ".github/workflows/xdist-experiment.yml",
+    )
+    tracker = _tracker_text()
+
+    assert [workflow for workflow in workflows if workflow not in tracker] == []
+
+
+def test_feature_user_story_tracker_covers_maintainer_scripts() -> None:
+    scripts = sorted((repo_root / "scripts").glob("*.py"))
+    tracker = _tracker_text()
+    script_paths = [script.relative_to(repo_root).as_posix() for script in scripts]
+
+    assert scripts
+    assert [path for path in script_paths if path not in tracker] == []
+
+
+def test_feature_user_story_tracker_covers_public_docs_assets() -> None:
+    assets = sorted((repo_root / "docs" / "assets" / "javascripts").glob("*.js"))
+    tracker_rows = _tracker_rows()
+    tracker = "\n".join(_row_text(row) for row in tracker_rows)
+    asset_paths = [asset.relative_to(repo_root).as_posix() for asset in assets]
+    nav_doc_paths = _mkdocs_nav_markdown_paths()
+
+    assert assets
+    assert [path for path in asset_paths if path not in tracker] == []
+    assert nav_doc_paths
+    assert [
+        path
+        for path in nav_doc_paths
+        if not any(row["entrypoint_or_route"] == path for row in tracker_rows)
+    ] == []
+
+
+def test_readme_shows_user_story_examples_from_tracker() -> None:
+    readme = README.read_text(encoding="utf-8")
+    tracker_rows = _tracker_rows()
+    with DASHBOARD_TRACKER.open(newline="", encoding="utf-8") as f:
+        dashboard_rows = list(csv.DictReader(f))
+    tracker_ids = {row["feature_id"] for row in tracker_rows}
+
+    assert "## Example user stories" in readme
+    assert "docs/qa/feature-user-story-status.csv" in readme
+    assert "docs/qa/dashboard-user-story-status.csv" in readme
+    assert "supporting detail ledger" in readme
+    for feature_id in ("CLI-002", "CLI-026", "API-011"):
+        assert feature_id in readme
+    assert dashboard_rows
+    assert {row["status"] for row in dashboard_rows} <= PASS_STATUSES
+    required_ids = ("DASH-001", "DASH-007", "API-011")
+    assert [row_id for row_id in required_ids if row_id not in tracker_ids] == []
+
+    required_surface_markers = (
+        "ctx.api and ctx top-level re-exports",
+        "ctx__recommend_bundle, ctx__graph_query, ctx__wiki_search, ctx__wiki_get",
+        "ctx__observe_dev_event, ctx__load_entity, ctx__mark_entity_used",
+        "McpClient and McpRouter",
+        "output_format and _response_format",
+    )
+    tracker = _tracker_text()
+
+    assert [marker for marker in required_surface_markers if marker not in tracker] == []
+    python_api_rows = _rows_for_surface(tracker_rows, "Python API")
+    python_api_text = " ".join(_row_text(row) for row in python_api_rows)
+    public_api_names = sorted(
+        set(ctx_api.__all__)
+        | {
+            name
+            for name in ctx.__all__
+            if name != "__version__"
+            and hasattr(ctx_api, name)
+            and getattr(ctx, name) is getattr(ctx_api, name)
+        }
+    )
+    assert python_api_rows
+    assert [name for name in public_api_names if name not in python_api_text] == []
+    for marker in ("src/ctx/api.py", "src/ctx/__init__.py", "src/tests/test_public_api.py"):
+        assert marker in python_api_text
+
+    mcp_core_rows = _rows_for_surface(tracker_rows, "MCP/Core Tools")
+    assert mcp_core_rows
+    tool_names = sorted(
+        definition.name for definition in ctx_api.CtxCoreToolbox().tool_definitions()
+    )
+    assert [
+        name for name in tool_names if not any(name in _row_text(row) for row in mcp_core_rows)
+    ] == []

src/tests/test_graph_packs.py

@@ -0,0 +1,830 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import networkx as nx
+import pytest
+
+from ctx.core.graph.graph_packs import (
+    GraphPackManifest,
+    GraphPackManifestError,
+    build_pack_manifest,
+    compact_graph_packs,
+    discover_pack_manifests,
+    load_merged_pack_graph,
+    promote_graph_pack_set,
+    read_pack_manifest,
+    sha256_file,
+    main,
+    write_base_pack,
+    write_overlay_pack,
+    write_pack_manifest,
+)
+
+
+def test_base_pack_manifest_round_trips_with_file_checksums(tmp_path: Path) -> None:
+    pack_dir = tmp_path / "graph" / "packs" / "base-export-1"
+    pack_dir.mkdir(parents=True)
+    (pack_dir / "graph.json").write_text('{"nodes":[],"edges":[]}\n', encoding="utf-8")
+    (pack_dir / "communities.json").write_text('{"communities":[]}\n', encoding="utf-8")
+
+    manifest = build_pack_manifest(
+        pack_dir=pack_dir,
+        pack_id="base-export-1",
+        pack_type="base",
+        base_export_id="export-1",
+        parent_export_id=None,
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        node_count=0,
+        edge_count=0,
+        artifact_paths=["graph.json", "communities.json"],
+    )
+
+    assert manifest.checksums["graph.json"] == sha256_file(pack_dir / "graph.json")
+
+    manifest_path = pack_dir / "graph-pack-manifest.json"
+    write_pack_manifest(manifest_path, manifest)
+
+    assert read_pack_manifest(manifest_path) == manifest
+    assert json.loads(manifest_path.read_text(encoding="utf-8"))["schema_version"] == 1
+
+
+def test_overlay_pack_manifest_requires_parent_export_id() -> None:
+    with pytest.raises(GraphPackManifestError, match="parent_export_id"):
+        GraphPackManifest.from_mapping({
+            "schema_version": 1,
+            "pack_id": "overlay-1",
+            "pack_type": "overlay",
+            "base_export_id": "export-1",
+            "parent_export_id": None,
+            "config_hash": "config-sha",
+            "model_id": "bge-small-en-v1.5",
+            "node_count": 1,
+            "edge_count": 2,
+            "tombstone_count": 0,
+            "checksums": {"entity-overlays.jsonl": "a" * 64},
+        })
+
+
+def test_manifest_rejects_unsafe_artifact_paths(tmp_path: Path) -> None:
+    pack_dir = tmp_path / "pack"
+    pack_dir.mkdir()
+    (tmp_path / "graph.json").write_text("{}", encoding="utf-8")
+
+    with pytest.raises(GraphPackManifestError, match="unsafe"):
+        build_pack_manifest(
+            pack_dir=pack_dir,
+            pack_id="base-export-1",
+            pack_type="base",
+            base_export_id="export-1",
+            parent_export_id=None,
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=0,
+            edge_count=0,
+            artifact_paths=["../graph.json"],
+        )
+
+
+def test_manifest_rejects_bad_checksum_shape() -> None:
+    payload = {
+        "schema_version": 1,
+        "pack_id": "base-export-1",
+        "pack_type": "base",
+        "base_export_id": "export-1",
+        "parent_export_id": None,
+        "config_hash": "config-sha",
+        "model_id": "bge-small-en-v1.5",
+        "node_count": 0,
+        "edge_count": 0,
+        "tombstone_count": 0,
+        "checksums": {"graph.json": "not-a-digest"},
+    }
+
+    with pytest.raises(GraphPackManifestError, match="SHA-256"):
+        GraphPackManifest.from_mapping(payload)
+
+
+def test_discover_pack_manifests_orders_base_then_overlays(tmp_path: Path) -> None:
+    packs_dir = tmp_path / "graph" / "packs"
+    base_dir = packs_dir / "base-export-1"
+    overlay_dir = packs_dir / "overlay-review-skill"
+    base_dir.mkdir(parents=True)
+    overlay_dir.mkdir()
+    (base_dir / "graph.json").write_text('{"nodes":[],"edges":[]}\n', encoding="utf-8")
+    (overlay_dir / "nodes.jsonl").write_text('{"id":"skill:review"}\n', encoding="utf-8")
+    write_pack_manifest(
+        base_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=base_dir,
+            pack_id="base-export-1",
+            pack_type="base",
+            base_export_id="export-1",
+            parent_export_id=None,
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=0,
+            edge_count=0,
+            artifact_paths=["graph.json"],
+        ),
+    )
+    write_pack_manifest(
+        overlay_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=overlay_dir,
+            pack_id="overlay-review-skill",
+            pack_type="overlay",
+            base_export_id="export-1",
+            parent_export_id="export-1",
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=1,
+            edge_count=0,
+            artifact_paths=["nodes.jsonl"],
+            tombstone_count=2,
+        ),
+    )
+
+    discovered = discover_pack_manifests(packs_dir)
+
+    assert [entry.manifest.pack_id for entry in discovered] == [
+        "base-export-1",
+        "overlay-review-skill",
+    ]
+    assert discovered[1].manifest.tombstone_count == 2
+
+
+def test_discover_pack_manifests_rejects_overlay_parent_mismatch(tmp_path: Path) -> None:
+    packs_dir = tmp_path / "packs"
+    base_dir = packs_dir / "base-export-1"
+    overlay_dir = packs_dir / "overlay-stale"
+    base_dir.mkdir(parents=True)
+    overlay_dir.mkdir()
+    (base_dir / "graph.json").write_text("{}", encoding="utf-8")
+    (overlay_dir / "nodes.jsonl").write_text("{}", encoding="utf-8")
+    write_pack_manifest(
+        base_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=base_dir,
+            pack_id="base-export-1",
+            pack_type="base",
+            base_export_id="export-1",
+            parent_export_id=None,
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=0,
+            edge_count=0,
+            artifact_paths=["graph.json"],
+        ),
+    )
+    write_pack_manifest(
+        overlay_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=overlay_dir,
+            pack_id="overlay-stale",
+            pack_type="overlay",
+            base_export_id="export-1",
+            parent_export_id="old-export",
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=1,
+            edge_count=0,
+            artifact_paths=["nodes.jsonl"],
+        ),
+    )
+
+    with pytest.raises(GraphPackManifestError, match="parent_export_id"):
+        discover_pack_manifests(packs_dir)
+
+
+def test_discover_pack_manifests_rejects_checksum_drift(tmp_path: Path) -> None:
+    packs_dir = tmp_path / "packs"
+    base_dir = packs_dir / "base-export-1"
+    base_dir.mkdir(parents=True)
+    graph_path = base_dir / "graph.json"
+    graph_path.write_text("{}", encoding="utf-8")
+    write_pack_manifest(
+        base_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=base_dir,
+            pack_id="base-export-1",
+            pack_type="base",
+            base_export_id="export-1",
+            parent_export_id=None,
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=0,
+            edge_count=0,
+            artifact_paths=["graph.json"],
+        ),
+    )
+    graph_path.write_text('{"changed":true}', encoding="utf-8")
+
+    with pytest.raises(GraphPackManifestError, match="checksum mismatch"):
+        discover_pack_manifests(packs_dir)
+
+
+def test_load_merged_pack_graph_applies_overlay_nodes_and_edges(tmp_path: Path) -> None:
+    packs_dir = tmp_path / "packs"
+    base_dir = packs_dir / "base-export-1"
+    overlay_dir = packs_dir / "overlay-review"
+    base_dir.mkdir(parents=True)
+    overlay_dir.mkdir()
+    (base_dir / "graph.json").write_text(
+        json.dumps({
+            "graph": {"export_id": "export-1"},
+            "nodes": [
+                {"id": "skill:python", "type": "skill", "tags": ["python"]},
+                {"id": "mcp-server:github", "type": "mcp-server", "tags": ["github"]},
+            ],
+            "edges": [
+                {"source": "skill:python", "target": "mcp-server:github", "weight": 0.4},
+            ],
+        }),
+        encoding="utf-8",
+    )
+    (overlay_dir / "nodes.jsonl").write_text(
+        json.dumps({"id": "skill:review", "type": "skill", "tags": ["review"]}) + "\n",
+        encoding="utf-8",
+    )
+    (overlay_dir / "edges.jsonl").write_text(
+        json.dumps({
+            "source": "skill:review",
+            "target": "mcp-server:github",
+            "weight": 0.8,
+            "provenance": "overlay-test",
+        }) + "\n",
+        encoding="utf-8",
+    )
+    write_pack_manifest(
+        base_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=base_dir,
+            pack_id="base-export-1",
+            pack_type="base",
+            base_export_id="export-1",
+            parent_export_id=None,
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=2,
+            edge_count=1,
+            artifact_paths=["graph.json"],
+        ),
+    )
+    write_pack_manifest(
+        overlay_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=overlay_dir,
+            pack_id="overlay-review",
+            pack_type="overlay",
+            base_export_id="export-1",
+            parent_export_id="export-1",
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=1,
+            edge_count=1,
+            artifact_paths=["nodes.jsonl", "edges.jsonl"],
+        ),
+    )
+
+    graph = load_merged_pack_graph(packs_dir)
+
+    assert graph.number_of_nodes() == 3
+    assert graph.has_edge("skill:review", "mcp-server:github")
+    assert graph.edges["skill:review", "mcp-server:github"]["weight"] == 0.8
+    assert graph.graph["ctx_pack_ids"] == ["base-export-1", "overlay-review"]
+
+
+def test_load_merged_pack_graph_applies_overlays_by_created_at(tmp_path: Path) -> None:
+    packs_dir = tmp_path / "packs"
+    base_graph = nx.Graph()
+    base_graph.add_node("skill:docs", title="base", type="skill")
+    write_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-sha",
+        model_id="model-a",
+        graph=base_graph,
+    )
+    write_overlay_pack(
+        pack_dir=packs_dir / "overlay-z-old",
+        pack_id="overlay-z-old",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-sha",
+        model_id="model-a",
+        nodes=[{"id": "skill:docs", "title": "old"}],
+        edges=[],
+        tombstones=[],
+        created_at="2026-01-01T00:00:00+00:00",
+    )
+    write_overlay_pack(
+        pack_dir=packs_dir / "overlay-a-new",
+        pack_id="overlay-a-new",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-sha",
+        model_id="model-a",
+        nodes=[{"id": "skill:docs", "title": "new"}],
+        edges=[],
+        tombstones=[],
+        created_at="2026-01-02T00:00:00+00:00",
+    )
+
+    graph = load_merged_pack_graph(packs_dir)
+
+    assert graph.nodes["skill:docs"]["title"] == "new"
+    assert graph.graph["ctx_pack_ids"] == [
+        "base-export-1",
+        "overlay-z-old",
+        "overlay-a-new",
+    ]
+
+
+def test_load_merged_pack_graph_applies_tombstones(tmp_path: Path) -> None:
+    packs_dir = tmp_path / "packs"
+    base_dir = packs_dir / "base-export-1"
+    overlay_dir = packs_dir / "overlay-delete"
+    base_dir.mkdir(parents=True)
+    overlay_dir.mkdir()
+    (base_dir / "graph.json").write_text(
+        json.dumps({
+            "nodes": [
+                {"id": "skill:python"},
+                {"id": "skill:old"},
+            ],
+            "edges": [
+                {"source": "skill:python", "target": "skill:old", "weight": 0.4},
+            ],
+        }),
+        encoding="utf-8",
+    )
+    (overlay_dir / "tombstones.jsonl").write_text(
+        json.dumps({"node_id": "skill:old", "reason": "deleted"}) + "\n",
+        encoding="utf-8",
+    )
+    write_pack_manifest(
+        base_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=base_dir,
+            pack_id="base-export-1",
+            pack_type="base",
+            base_export_id="export-1",
+            parent_export_id=None,
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=2,
+            edge_count=1,
+            artifact_paths=["graph.json"],
+        ),
+    )
+    write_pack_manifest(
+        overlay_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=overlay_dir,
+            pack_id="overlay-delete",
+            pack_type="overlay",
+            base_export_id="export-1",
+            parent_export_id="export-1",
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=0,
+            edge_count=0,
+            artifact_paths=["tombstones.jsonl"],
+            tombstone_count=1,
+        ),
+    )
+
+    graph = load_merged_pack_graph(packs_dir)
+
+    assert "skill:old" not in graph
+    assert graph.number_of_edges() == 0
+
+
+def test_load_merged_pack_graph_rejects_base_count_drift(tmp_path: Path) -> None:
+    packs_dir = tmp_path / "packs"
+    base_dir = packs_dir / "base-export-1"
+    base_dir.mkdir(parents=True)
+    (base_dir / "graph.json").write_text(
+        json.dumps({
+            "nodes": [{"id": "skill:python"}],
+            "edges": [],
+        }),
+        encoding="utf-8",
+    )
+    write_pack_manifest(
+        base_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=base_dir,
+            pack_id="base-export-1",
+            pack_type="base",
+            base_export_id="export-1",
+            parent_export_id=None,
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=2,
+            edge_count=0,
+            artifact_paths=["graph.json"],
+        ),
+    )
+
+    with pytest.raises(GraphPackManifestError, match="node_count mismatch"):
+        load_merged_pack_graph(packs_dir)
+
+
+def test_load_merged_pack_graph_rejects_overlay_count_drift(tmp_path: Path) -> None:
+    packs_dir = tmp_path / "packs"
+    base_graph = nx.Graph()
+    base_graph.add_node("skill:python")
+    write_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        graph=base_graph,
+    )
+    overlay_dir = packs_dir / "overlay-review"
+    overlay_dir.mkdir()
+    (overlay_dir / "nodes.jsonl").write_text(
+        json.dumps({"id": "skill:review"}) + "\n",
+        encoding="utf-8",
+    )
+    write_pack_manifest(
+        overlay_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=overlay_dir,
+            pack_id="overlay-review",
+            pack_type="overlay",
+            base_export_id="export-1",
+            parent_export_id="export-1",
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            node_count=2,
+            edge_count=0,
+            artifact_paths=["nodes.jsonl"],
+        ),
+    )
+
+    with pytest.raises(GraphPackManifestError, match="node_count mismatch"):
+        load_merged_pack_graph(packs_dir)
+
+
+def test_write_overlay_pack_creates_jsonl_artifacts_and_manifest(tmp_path: Path) -> None:
+    pack_dir = tmp_path / "packs" / "overlay-review"
+
+    manifest = write_overlay_pack(
+        pack_dir=pack_dir,
+        pack_id="overlay-review",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        nodes=[{"id": "skill:review", "type": "skill"}],
+        edges=[{"source": "skill:review", "target": "skill:python", "weight": 0.7}],
+        tombstones=[{"node_id": "skill:old"}],
+    )
+
+    assert manifest.pack_type == "overlay"
+    assert manifest.node_count == 1
+    assert manifest.edge_count == 1
+    assert manifest.tombstone_count == 1
+    assert (pack_dir / "nodes.jsonl").read_text(encoding="utf-8").count("\n") == 1
+    assert (pack_dir / "edges.jsonl").read_text(encoding="utf-8").count("\n") == 1
+    assert (pack_dir / "tombstones.jsonl").read_text(encoding="utf-8").count("\n") == 1
+    assert read_pack_manifest(pack_dir / "graph-pack-manifest.json") == manifest
+
+
+def test_write_overlay_pack_rejects_empty_pack(tmp_path: Path) -> None:
+    with pytest.raises(GraphPackManifestError, match="empty overlay pack"):
+        write_overlay_pack(
+            pack_dir=tmp_path / "overlay-empty",
+            pack_id="overlay-empty",
+            base_export_id="export-1",
+            parent_export_id="export-1",
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            nodes=[],
+            edges=[],
+            tombstones=[],
+        )
+
+
+def test_write_overlay_pack_rejects_existing_manifest(tmp_path: Path) -> None:
+    pack_dir = tmp_path / "packs" / "overlay-review"
+    write_overlay_pack(
+        pack_dir=pack_dir,
+        pack_id="overlay-review",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        nodes=[{"id": "skill:review"}],
+        edges=[],
+        tombstones=[],
+    )
+
+    with pytest.raises(GraphPackManifestError, match="already exists"):
+        write_overlay_pack(
+            pack_dir=pack_dir,
+            pack_id="overlay-review",
+            base_export_id="export-1",
+            parent_export_id="export-1",
+            config_hash="config-sha",
+            model_id="bge-small-en-v1.5",
+            nodes=[{"id": "skill:changed"}],
+            edges=[],
+            tombstones=[],
+        )
+
+
+def test_write_base_pack_creates_graph_json_and_manifest(tmp_path: Path) -> None:
+    graph = nx.Graph()
+    graph.add_node("skill:python", type="skill")
+    graph.add_node("agent:review", type="agent")
+    graph.add_edge("skill:python", "agent:review", weight=0.6)
+
+    manifest = write_base_pack(
+        pack_dir=tmp_path / "base-export-2",
+        pack_id="base-export-2",
+        base_export_id="export-2",
+        config_hash="config-sha",
+        model_id="model-a",
+        graph=graph,
+    )
+
+    payload = json.loads((tmp_path / "base-export-2" / "graph.json").read_text(encoding="utf-8"))
+    assert payload["graph"]["export_id"] == "export-2"
+    assert "edges" in payload
+    assert manifest.pack_type == "base"
+    assert manifest.node_count == 2
+    assert manifest.edge_count == 1
+    assert read_pack_manifest(tmp_path / "base-export-2" / "graph-pack-manifest.json") == manifest
+
+
+def test_pack_writers_reject_unsafe_pack_id_before_payload_write(tmp_path: Path) -> None:
+    graph = nx.Graph()
+    graph.add_node("skill:python", type="skill")
+
+    with pytest.raises(GraphPackManifestError, match="pack_id is unsafe"):
+        write_base_pack(
+            pack_dir=tmp_path / "base-bad",
+            pack_id="../base-bad",
+            base_export_id="export-2",
+            config_hash="config-sha",
+            model_id="model-a",
+            graph=graph,
+        )
+    assert not (tmp_path / "base-bad" / "graph.json").exists()
+
+    with pytest.raises(GraphPackManifestError, match="pack_id is unsafe"):
+        write_overlay_pack(
+            pack_dir=tmp_path / "overlay-bad",
+            pack_id="../overlay-bad",
+            base_export_id="export-1",
+            parent_export_id="export-1",
+            config_hash="config-sha",
+            model_id="model-a",
+            nodes=[{"id": "skill:review"}],
+            edges=[],
+            tombstones=[],
+        )
+    assert not (tmp_path / "overlay-bad" / "nodes.jsonl").exists()
+
+
+def test_compact_graph_packs_writes_staged_base_without_mutating_active_packs(
+    tmp_path: Path,
+) -> None:
+    active_packs = tmp_path / "active" / "packs"
+    base_dir = active_packs / "base-export-1"
+    overlay_dir = active_packs / "overlay-review"
+    base_dir.mkdir(parents=True)
+    overlay_dir.mkdir()
+    (base_dir / "graph.json").write_text(
+        json.dumps({
+            "graph": {"export_id": "export-1"},
+            "nodes": [
+                {"id": "skill:python", "type": "skill"},
+                {"id": "agent:review", "type": "agent"},
+            ],
+            "edges": [],
+        }),
+        encoding="utf-8",
+    )
+    write_pack_manifest(
+        base_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=base_dir,
+            pack_id="base-export-1",
+            pack_type="base",
+            base_export_id="export-1",
+            parent_export_id=None,
+            config_hash="config-sha",
+            model_id="model-a",
+            node_count=2,
+            edge_count=0,
+            artifact_paths=["graph.json"],
+        ),
+    )
+    write_overlay_pack(
+        pack_dir=overlay_dir,
+        pack_id="overlay-review",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-sha",
+        model_id="model-a",
+        nodes=[{"id": "skill:review", "type": "skill"}],
+        edges=[{"source": "skill:review", "target": "agent:review", "weight": 0.8}],
+        tombstones=[{"node_id": "skill:python"}],
+    )
+
+    staged_pack = tmp_path / "staged" / "base-export-2"
+    manifest = compact_graph_packs(
+        packs_dir=active_packs,
+        compacted_pack_dir=staged_pack,
+        base_export_id="export-2",
+    )
+
+    assert manifest.pack_type == "base"
+    assert manifest.base_export_id == "export-2"
+    assert [entry.manifest.pack_id for entry in discover_pack_manifests(active_packs)] == [
+        "base-export-1",
+        "overlay-review",
+    ]
+    staged_packs_root = tmp_path / "staged"
+    compacted = load_merged_pack_graph(staged_packs_root)
+    assert "skill:python" not in compacted
+    assert compacted.has_edge("skill:review", "agent:review")
+    assert compacted.graph["export_id"] == "export-2"
+    assert compacted.graph["ctx_compacted_from_base_export_id"] == "export-1"
+    assert compacted.graph["ctx_compacted_overlay_count"] == 1
+
+
+def test_main_compact_writes_json_report_and_staged_pack(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    active_packs = tmp_path / "active" / "packs"
+    base_dir = active_packs / "base-export-1"
+    overlay_dir = active_packs / "overlay-review"
+    base_dir.mkdir(parents=True)
+    (base_dir / "graph.json").write_text(
+        json.dumps({
+            "graph": {"export_id": "export-1"},
+            "nodes": [{"id": "skill:python"}, {"id": "skill:review"}],
+            "edges": [],
+        }),
+        encoding="utf-8",
+    )
+    write_pack_manifest(
+        base_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=base_dir,
+            pack_id="base-export-1",
+            pack_type="base",
+            base_export_id="export-1",
+            parent_export_id=None,
+            config_hash="config-sha",
+            model_id="model-a",
+            node_count=2,
+            edge_count=0,
+            artifact_paths=["graph.json"],
+        ),
+    )
+    write_overlay_pack(
+        pack_dir=overlay_dir,
+        pack_id="overlay-review",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-sha",
+        model_id="model-a",
+        nodes=[],
+        edges=[{"source": "skill:review", "target": "skill:python", "weight": 0.8}],
+        tombstones=[],
+    )
+    staged_pack = tmp_path / "staged" / "base-export-2"
+
+    rc = main([
+        "compact",
+        "--packs-dir", str(active_packs),
+        "--staged-pack-dir", str(staged_pack),
+        "--base-export-id", "export-2",
+        "--json",
+    ])
+
+    assert rc == 0
+    output = json.loads(capsys.readouterr().out)
+    assert output["pack_id"] == "base-export-2"
+    assert output["base_export_id"] == "export-2"
+    graph = load_merged_pack_graph(tmp_path / "staged")
+    assert graph.has_edge("skill:review", "skill:python")
+
+
+def test_promote_graph_pack_set_replaces_active_and_writes_rollback_metadata(
+    tmp_path: Path,
+) -> None:
+    active_packs = tmp_path / "graph" / "packs"
+    old_graph = nx.Graph()
+    old_graph.add_node("skill:old")
+    write_base_pack(
+        pack_dir=active_packs / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-sha",
+        model_id="model-a",
+        graph=old_graph,
+    )
+    write_overlay_pack(
+        pack_dir=active_packs / "overlay-review",
+        pack_id="overlay-review",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-sha",
+        model_id="model-a",
+        nodes=[{"id": "skill:review"}],
+        edges=[{"source": "skill:old", "target": "skill:review", "weight": 0.8}],
+        tombstones=[],
+    )
+
+    staged_packs = tmp_path / "staged-packs"
+    new_graph = nx.Graph()
+    new_graph.add_node("skill:new")
+    write_base_pack(
+        pack_dir=staged_packs / "base-export-2",
+        pack_id="base-export-2",
+        base_export_id="export-2",
+        config_hash="config-sha",
+        model_id="model-a",
+        graph=new_graph,
+    )
+    backup_packs = tmp_path / "graph" / "packs.rollback"
+
+    result = promote_graph_pack_set(
+        staged_packs_dir=staged_packs,
+        active_packs_dir=active_packs,
+        backup_packs_dir=backup_packs,
+    )
+
+    assert result.promoted_pack_ids == ["base-export-2"]
+    assert result.replaced_pack_ids == ["base-export-1", "overlay-review"]
+    assert not staged_packs.exists()
+    assert [entry.manifest.pack_id for entry in discover_pack_manifests(active_packs)] == [
+        "base-export-2",
+    ]
+    assert [entry.manifest.pack_id for entry in discover_pack_manifests(backup_packs)] == [
+        "base-export-1",
+        "overlay-review",
+    ]
+    promoted_graph = load_merged_pack_graph(active_packs)
+    assert list(promoted_graph.nodes) == ["skill:new"]
+    rollback_metadata = json.loads(result.rollback_metadata_path.read_text(encoding="utf-8"))
+    assert rollback_metadata["backup_packs_dir"] == str(backup_packs)
+    assert rollback_metadata["promoted_pack_ids"] == ["base-export-2"]
+    assert rollback_metadata["replaced_pack_ids"] == ["base-export-1", "overlay-review"]
+
+
+def test_main_promote_writes_json_report_and_uses_default_backup(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    active_packs = tmp_path / "graph" / "packs"
+    old_graph = nx.Graph()
+    old_graph.add_node("skill:old")
+    write_base_pack(
+        pack_dir=active_packs / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-sha",
+        model_id="model-a",
+        graph=old_graph,
+    )
+    staged_packs = tmp_path / "staged-packs"
+    new_graph = nx.Graph()
+    new_graph.add_node("skill:new")
+    write_base_pack(
+        pack_dir=staged_packs / "base-export-2",
+        pack_id="base-export-2",
+        base_export_id="export-2",
+        config_hash="config-sha",
+        model_id="model-a",
+        graph=new_graph,
+    )
+
+    rc = main([
+        "promote",
+        "--staged-packs-dir", str(staged_packs),
+        "--active-packs-dir", str(active_packs),
+        "--json",
+    ])
+
+    assert rc == 0
+    output = json.loads(capsys.readouterr().out)
+    assert output["promoted_pack_ids"] == ["base-export-2"]
+    assert output["replaced_pack_ids"] == ["base-export-1"]
+    assert output["backup_packs_dir"] == str(tmp_path / "graph" / "packs.rollback")
+    assert [entry.manifest.pack_id for entry in discover_pack_manifests(active_packs)] == [
+        "base-export-2",
+    ]

src/tests/test_graph_store.py

@@ -0,0 +1,611 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from pathlib import Path
+
+import networkx as nx
+import pytest
+
+from ctx.core.graph.graph_store import (
+    build_graph_store,
+    build_graph_store_from_graph_dir,
+    ensure_graph_store,
+    graph_store_metadata,
+    graph_store_is_fresh,
+    graph_store_stats,
+    validate_graph_store,
+    load_neighborhood,
+    main,
+    search_nodes,
+)
+from ctx.core.graph.graph_packs import write_base_pack, write_overlay_pack
+
+
+def _sample_graph() -> nx.Graph:
+    graph = nx.Graph()
+    graph.add_node(
+        "skill:python-testing",
+        label="python-testing",
+        title="Python Testing",
+        type="skill",
+        tags=["python", "testing"],
+        quality_score=0.9,
+    )
+    graph.add_node(
+        "mcp-server:github",
+        label="github",
+        title="GitHub",
+        type="mcp-server",
+        tags=["github", "repos"],
+    )
+    graph.add_node(
+        "agent:reviewer",
+        label="reviewer",
+        title="Code Reviewer",
+        type="agent",
+        tags=["review", "testing"],
+    )
+    graph.add_edge(
+        "skill:python-testing",
+        "mcp-server:github",
+        weight=0.72,
+        shared_tags=["testing"],
+    )
+    graph.add_edge(
+        "skill:python-testing",
+        "agent:reviewer",
+        weight=0.81,
+        shared_tags=["testing"],
+    )
+    return graph
+
+
+def test_build_graph_store_persists_counts(tmp_path: Path) -> None:
+    db_path = tmp_path / "graph.sqlite3"
+
+    build_graph_store(db_path, _sample_graph())
+
+    assert graph_store_stats(db_path) == {"nodes": 3, "edges": 2}
+
+
+def test_search_nodes_matches_label_title_and_tags(tmp_path: Path) -> None:
+    db_path = tmp_path / "graph.sqlite3"
+    build_graph_store(db_path, _sample_graph())
+
+    results = search_nodes(db_path, "testing", limit=10)
+
+    assert [row["id"] for row in results] == [
+        "skill:python-testing",
+        "agent:reviewer",
+    ]
+    assert results[0]["type"] == "skill"
+
+
+def test_load_neighborhood_returns_center_and_edges(tmp_path: Path) -> None:
+    db_path = tmp_path / "graph.sqlite3"
+    build_graph_store(db_path, _sample_graph())
+
+    neighborhood = load_neighborhood(db_path, "skill:python-testing", limit=10)
+
+    assert {node["id"] for node in neighborhood["nodes"]} == {
+        "skill:python-testing",
+        "mcp-server:github",
+        "agent:reviewer",
+    }
+    assert {edge["target"] for edge in neighborhood["edges"]} == {
+        "mcp-server:github",
+        "agent:reviewer",
+    }
+
+
+def test_build_graph_store_from_graph_dir_prefers_active_packs(tmp_path: Path) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    packs_dir = graph_dir / "packs"
+    base_graph = nx.Graph()
+    base_graph.add_node(
+        "skill:base",
+        label="base",
+        title="Base",
+        type="skill",
+        tags=["base"],
+    )
+    base_graph.add_node(
+        "mcp-server:github",
+        label="github",
+        title="GitHub",
+        type="mcp-server",
+        tags=["github"],
+    )
+    base_graph.add_edge("skill:base", "mcp-server:github", weight=0.2)
+    write_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        graph=base_graph,
+    )
+    write_overlay_pack(
+        pack_dir=packs_dir / "overlay-review",
+        pack_id="overlay-review",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        nodes=[
+            {
+                "id": "skill:review",
+                "label": "review",
+                "title": "Code Review",
+                "type": "skill",
+                "tags": ["review"],
+            }
+        ],
+        edges=[
+            {
+                "source": "skill:review",
+                "target": "mcp-server:github",
+                "weight": 0.9,
+            }
+        ],
+        tombstones=[],
+    )
+    db_path = tmp_path / "graph.sqlite3"
+
+    build_graph_store_from_graph_dir(graph_dir, db_path)
+
+    assert graph_store_stats(db_path) == {"nodes": 3, "edges": 2}
+    assert [row["id"] for row in search_nodes(db_path, "review")] == ["skill:review"]
+    neighborhood = load_neighborhood(db_path, "skill:review")
+    assert {edge["target"] for edge in neighborhood["edges"]} == {"mcp-server:github"}
+    metadata = graph_store_metadata(db_path)
+    assert metadata["ctx_graph_pack_source"] == "packs"
+    assert json.loads(metadata["ctx_pack_ids"]) == ["base-export-1", "overlay-review"]
+    assert metadata["ctx_pack_base_export_id"] == "export-1"
+    assert metadata["node_count"] == "3"
+    assert metadata["edge_count"] == "2"
+    assert graph_store_is_fresh(db_path, graph_dir) is True
+    write_overlay_pack(
+        pack_dir=packs_dir / "overlay-docs",
+        pack_id="overlay-docs",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        nodes=[
+            {
+                "id": "skill:docs",
+                "label": "docs",
+                "title": "Docs",
+                "type": "skill",
+                "tags": ["docs"],
+            }
+        ],
+        edges=[],
+        tombstones=[],
+    )
+    assert graph_store_is_fresh(db_path, graph_dir) is False
+
+
+def test_graph_store_freshness_tracks_full_pack_manifest_drift(
+    tmp_path: Path,
+) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    packs_dir = graph_dir / "packs"
+    base_graph = nx.Graph()
+    base_graph.add_node("skill:base", label="base", type="skill", tags=["base"])
+    write_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        graph=base_graph,
+    )
+    db_path = tmp_path / "graph.sqlite3"
+    ensure_graph_store(graph_dir, db_path)
+
+    manifest_path = packs_dir / "base-export-1" / "graph-pack-manifest.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    manifest["node_count"] = 2
+    manifest_path.write_text(
+        json.dumps(manifest, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+    assert graph_store_is_fresh(db_path, graph_dir) is False
+
+
+def test_graph_store_freshness_tracks_entity_overlay_file_with_packs(
+    tmp_path: Path,
+) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    packs_dir = graph_dir / "packs"
+    base_graph = nx.Graph()
+    base_graph.add_node(
+        "skill:base",
+        label="base",
+        title="Base",
+        type="skill",
+        tags=["base"],
+    )
+    base_graph.add_node(
+        "mcp-server:github",
+        label="github",
+        title="GitHub",
+        type="mcp-server",
+        tags=["github"],
+    )
+    base_graph.add_edge("skill:base", "mcp-server:github", weight=0.2)
+    write_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        graph=base_graph,
+    )
+    db_path = tmp_path / "graph.sqlite3"
+
+    assert ensure_graph_store(graph_dir, db_path) == {
+        "rebuilt": True,
+        "nodes": 2,
+        "edges": 1,
+    }
+    metadata = graph_store_metadata(db_path)
+    assert metadata["ctx_graph_store_entity_overlay"] == "absent"
+    assert graph_store_is_fresh(db_path, graph_dir) is True
+
+    (graph_dir / "entity-overlays.jsonl").write_text(
+        json.dumps({
+            "overlay_id": "overlay-docs",
+            "nodes": [{
+                "id": "skill:docs",
+                "label": "docs",
+                "title": "Docs",
+                "type": "skill",
+                "tags": ["docs"],
+            }],
+            "edges": [{
+                "source": "skill:docs",
+                "target": "mcp-server:github",
+                "weight": 0.8,
+            }],
+        })
+        + "\n",
+        encoding="utf-8",
+    )
+
+    assert graph_store_is_fresh(db_path, graph_dir) is False
+    assert ensure_graph_store(graph_dir, db_path) == {
+        "rebuilt": True,
+        "nodes": 3,
+        "edges": 2,
+    }
+    metadata = graph_store_metadata(db_path)
+    assert metadata["ctx_graph_store_entity_overlay"] == "present"
+    assert [row["id"] for row in search_nodes(db_path, "docs")] == ["skill:docs"]
+    neighborhood = load_neighborhood(db_path, "skill:docs")
+    assert {edge["target"] for edge in neighborhood["edges"]} == {"mcp-server:github"}
+    assert graph_store_is_fresh(db_path, graph_dir) is True
+
+
+def test_build_graph_store_from_graph_dir_falls_back_to_legacy_graph_json(tmp_path: Path) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    graph_dir.mkdir()
+    graph = _sample_graph()
+    payload = nx.node_link_data(graph, edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+    db_path = tmp_path / "graph.sqlite3"
+
+    build_graph_store_from_graph_dir(graph_dir, db_path)
+
+    assert graph_store_stats(db_path) == {"nodes": 3, "edges": 2}
+    assert search_nodes(db_path, "github")[0]["id"] == "mcp-server:github"
+    assert graph_store_is_fresh(db_path, graph_dir) is True
+    graph.add_node("skill:docs", label="docs", type="skill", tags=["docs"])
+    payload = nx.node_link_data(graph, edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+    assert graph_store_is_fresh(db_path, graph_dir) is False
+
+
+def test_cli_builds_graph_store_from_graph_dir(tmp_path: Path) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    graph_dir.mkdir()
+    payload = nx.node_link_data(_sample_graph(), edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+    db_path = tmp_path / "graph.sqlite3"
+
+    assert main(["build", "--graph-dir", str(graph_dir), "--db", str(db_path)]) == 0
+
+    assert graph_store_stats(db_path) == {"nodes": 3, "edges": 2}
+
+
+def test_cli_validates_fresh_graph_store(tmp_path: Path) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    graph_dir.mkdir()
+    payload = nx.node_link_data(_sample_graph(), edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+    db_path = tmp_path / "graph.sqlite3"
+    ensure_graph_store(graph_dir, db_path)
+
+    result = main(["validate", "--graph-dir", str(graph_dir), "--db", str(db_path)])
+
+    assert result == 0
+
+
+def test_cli_validate_returns_1_for_stale_graph_store(tmp_path: Path) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    graph_dir.mkdir()
+    graph = _sample_graph()
+    payload = nx.node_link_data(graph, edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+    db_path = tmp_path / "graph.sqlite3"
+    ensure_graph_store(graph_dir, db_path)
+    graph.add_node("skill:docs", label="docs", type="skill", tags=["docs"])
+    payload = nx.node_link_data(graph, edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+
+    result = main(["validate", "--graph-dir", str(graph_dir), "--db", str(db_path)])
+
+    assert result == 1
+
+
+def test_cli_search_reads_built_pack_backed_store(tmp_path: Path, capsys) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    packs_dir = graph_dir / "packs"
+    base_graph = nx.Graph()
+    base_graph.add_node("skill:base", label="base", type="skill", tags=["base"])
+    write_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        graph=base_graph,
+    )
+    write_overlay_pack(
+        pack_dir=packs_dir / "overlay-review",
+        pack_id="overlay-review",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        nodes=[{
+            "id": "agent:reviewer",
+            "label": "reviewer",
+            "title": "Code Reviewer",
+            "type": "agent",
+            "tags": ["review"],
+        }],
+        edges=[],
+        tombstones=[],
+    )
+    db_path = tmp_path / "graph.sqlite3"
+    ensure_graph_store(graph_dir, db_path)
+
+    result = main([
+        "search",
+        "--db", str(db_path),
+        "--graph-dir", str(graph_dir),
+        "--query", "review",
+    ])
+
+    assert result == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert [row["id"] for row in payload["results"]] == ["agent:reviewer"]
+
+
+def test_cli_search_rejects_stale_store_when_graph_dir_is_required(
+    tmp_path: Path,
+    capsys,
+) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    graph_dir.mkdir()
+    graph = _sample_graph()
+    (graph_dir / "graph.json").write_text(
+        json.dumps(nx.node_link_data(graph, edges="edges")),
+        encoding="utf-8",
+    )
+    db_path = tmp_path / "graph.sqlite3"
+    ensure_graph_store(graph_dir, db_path)
+    graph.add_node("skill:docs", label="docs", type="skill", tags=["docs"])
+    (graph_dir / "graph.json").write_text(
+        json.dumps(nx.node_link_data(graph, edges="edges")),
+        encoding="utf-8",
+    )
+
+    result = main([
+        "search",
+        "--db", str(db_path),
+        "--graph-dir", str(graph_dir),
+        "--query", "docs",
+    ])
+
+    assert result == 1
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["ok"] is False
+    assert "source fingerprint is stale" in payload["errors"]
+
+
+def test_cli_neighborhood_reads_built_pack_backed_store(tmp_path: Path, capsys) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    packs_dir = graph_dir / "packs"
+    base_graph = nx.Graph()
+    base_graph.add_node("skill:base", label="base", type="skill", tags=["base"])
+    base_graph.add_node("mcp-server:github", label="github", type="mcp-server", tags=["github"])
+    write_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        graph=base_graph,
+    )
+    write_overlay_pack(
+        pack_dir=packs_dir / "overlay-review-edge",
+        pack_id="overlay-review-edge",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-sha",
+        model_id="bge-small-en-v1.5",
+        nodes=[],
+        edges=[{
+            "source": "skill:base",
+            "target": "mcp-server:github",
+            "weight": 0.9,
+        }],
+        tombstones=[],
+    )
+    db_path = tmp_path / "graph.sqlite3"
+    ensure_graph_store(graph_dir, db_path)
+
+    result = main([
+        "neighborhood",
+        "--db", str(db_path),
+        "--graph-dir", str(graph_dir),
+        "--node-id", "skill:base",
+    ])
+
+    assert result == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert {node["id"] for node in payload["nodes"]} == {
+        "skill:base",
+        "mcp-server:github",
+    }
+    assert payload["edges"] == [{
+        "attrs": {"weight": 0.9},
+        "source": "skill:base",
+        "target": "mcp-server:github",
+        "weight": 0.9,
+    }]
+
+
+def test_ensure_graph_store_reuses_fresh_store_and_rebuilds_stale_store(
+    tmp_path: Path,
+) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    graph_dir.mkdir()
+    graph = _sample_graph()
+    payload = nx.node_link_data(graph, edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+    db_path = tmp_path / "graph.sqlite3"
+
+    first = ensure_graph_store(graph_dir, db_path)
+    second = ensure_graph_store(graph_dir, db_path)
+
+    assert first == {"rebuilt": True, "nodes": 3, "edges": 2}
+    assert second == {"rebuilt": False, "nodes": 3, "edges": 2}
+
+    graph.add_node("skill:docs", label="docs", type="skill", tags=["docs"])
+    payload = nx.node_link_data(graph, edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+
+    third = ensure_graph_store(graph_dir, db_path)
+
+    assert third == {"rebuilt": True, "nodes": 4, "edges": 2}
+    assert search_nodes(db_path, "docs")[0]["id"] == "skill:docs"
+
+
+def test_validate_graph_store_reports_fresh_store(tmp_path: Path) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    graph_dir.mkdir()
+    payload = nx.node_link_data(_sample_graph(), edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+    db_path = tmp_path / "graph.sqlite3"
+    ensure_graph_store(graph_dir, db_path)
+
+    report = validate_graph_store(db_path, graph_dir)
+
+    assert report == {
+        "ok": True,
+        "fresh": True,
+        "nodes": 3,
+        "edges": 2,
+        "errors": [],
+    }
+
+
+def test_validate_graph_store_reports_stale_source(tmp_path: Path) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    graph_dir.mkdir()
+    graph = _sample_graph()
+    payload = nx.node_link_data(graph, edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+    db_path = tmp_path / "graph.sqlite3"
+    ensure_graph_store(graph_dir, db_path)
+    graph.add_node("skill:docs", label="docs", type="skill", tags=["docs"])
+    payload = nx.node_link_data(graph, edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+
+    report = validate_graph_store(db_path, graph_dir)
+
+    assert report["ok"] is False
+    assert report["fresh"] is False
+    errors = report["errors"]
+    assert isinstance(errors, list)
+    assert "source fingerprint is stale" in errors
+
+
+def test_validate_graph_store_rejects_missing_source_graph(tmp_path: Path) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    graph_dir.mkdir()
+    payload = nx.node_link_data(_sample_graph(), edges="edges")
+    graph_json = graph_dir / "graph.json"
+    graph_json.write_text(json.dumps(payload), encoding="utf-8")
+    db_path = tmp_path / "graph.sqlite3"
+    build_graph_store_from_graph_dir(graph_dir, db_path)
+    graph_json.unlink()
+
+    assert graph_store_is_fresh(db_path, graph_dir) is False
+    report = validate_graph_store(db_path, graph_dir)
+
+    assert report == {
+        "ok": False,
+        "fresh": False,
+        "nodes": 3,
+        "edges": 2,
+        "errors": ["source graph is missing"],
+    }
+
+
+def test_build_graph_store_from_graph_dir_rejects_missing_source_graph(tmp_path: Path) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    db_path = tmp_path / "graph.sqlite3"
+
+    with pytest.raises(ValueError, match="source graph is missing"):
+        build_graph_store_from_graph_dir(graph_dir, db_path)
+
+    assert not db_path.exists()
+
+
+def test_cli_build_returns_1_for_missing_source_graph(tmp_path: Path, capsys) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    db_path = tmp_path / "graph.sqlite3"
+
+    result = main(["build", "--graph-dir", str(graph_dir), "--db", str(db_path)])
+
+    assert result == 1
+    assert not db_path.exists()
+    payload = json.loads(capsys.readouterr().out)
+    assert payload == {"error": "source graph is missing", "ok": False}
+
+
+def test_validate_graph_store_reports_corrupt_count_metadata(tmp_path: Path) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    graph_dir.mkdir()
+    payload = nx.node_link_data(_sample_graph(), edges="edges")
+    (graph_dir / "graph.json").write_text(json.dumps(payload), encoding="utf-8")
+    db_path = tmp_path / "graph.sqlite3"
+    ensure_graph_store(graph_dir, db_path)
+    with sqlite3.connect(db_path) as conn:
+        conn.execute("UPDATE metadata SET value = '99' WHERE key = 'node_count'")
+
+    report = validate_graph_store(db_path, graph_dir)
+
+    assert report["ok"] is False
+    assert report["fresh"] is True
+    errors = report["errors"]
+    assert isinstance(errors, list)
+    assert "metadata node_count 99 != actual 3" in errors

src/tests/test_harness_add.py

@@ -10,6 +10,7 @@ import yaml  # type: ignore[import-untyped]
 import pytest
 
 import harness_add
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_wiki_base_pack
 
 
 def _record(**overrides: Any) -> harness_add.HarnessRecord:
@@ -31,6 +32,10 @@ def _record(**overrides: Any) -> harness_add.HarnessRecord:
 
 def _frontmatter(path: Path) -> dict[str, Any]:
     text = path.read_text(encoding="utf-8")
+    return _frontmatter_from_text(text)
+
+
+def _frontmatter_from_text(text: str) -> dict[str, Any]:
     _, fm_block, _ = text.split("---", 2)
     parsed = yaml.safe_load(fm_block)
     assert isinstance(parsed, dict)
@@ -152,7 +157,18 @@ def test_existing_harness_update_existing_applies_reviewed_change(
     tmp_path: Path,
 ) -> None:
     wiki = tmp_path / "wiki"
-    harness_add.add_harness(record=_record(sources=["manual"]), wiki_path=wiki)
+    existing = _record(sources=["manual"])
+    packs_dir = wiki / "wiki-packs"
+    write_wiki_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="wiki-export-1",
+        pages={
+            "entities/harnesses/text-to-cad.md": harness_add.generate_harness_page(
+                existing
+            )
+        },
+    )
 
     result = harness_add.add_harness(
         record=_record(
@@ -166,10 +182,12 @@ def test_existing_harness_update_existing_applies_reviewed_change(
     )
 
     page = wiki / "entities" / "harnesses" / "text-to-cad.md"
-    fm = _frontmatter(page)
+    merged = load_merged_wiki_pages(packs_dir)
+    fm = _frontmatter_from_text(merged["entities/harnesses/text-to-cad.md"])
     assert result["is_new_page"] is False
     assert result["skipped"] is False
     assert result["sources"] == ["external-review", "manual"]
+    assert not page.exists()
     assert fm["sources"] == ["external-review", "manual"]
     assert fm["verify_commands"] == ["pytest", "python smoke.py"]
 
@@ -212,3 +230,27 @@ def test_cli_from_json_adds_harness(
 
     assert (wiki / "entities" / "harnesses" / "text-to-cad.md").exists()
     assert "added: text-to-cad" in capsys.readouterr().out
+
+
+def test_cli_from_bom_json_adds_harness(
+    tmp_path: Path,
+    capsys: Any,
+) -> None:
+    record_path = tmp_path / "harness.json"
+    record_path.write_text(
+        "\ufeff"
+        + json.dumps(
+            {
+                "repo_url": "https://github.com/example/bom-harness",
+                "description": "Harness loaded from a Windows UTF-8 BOM JSON file.",
+                "tags": ["llm", "testing"],
+            }
+        ),
+        encoding="utf-8",
+    )
+    wiki = tmp_path / "wiki"
+
+    harness_add.main(["--from-json", str(record_path), "--wiki", str(wiki)])
+
+    assert (wiki / "entities" / "harnesses" / "bom-harness.md").exists()
+    assert "added: bom-harness" in capsys.readouterr().out

src/tests/test_harness_cli_run.py

@@ -28,7 +28,9 @@ from typing import Any
 
 import pytest
 
+import ctx.adapters.generic.runtime_lifecycle as runtime_lifecycle
 import ctx.cli.run as run_cli
+import ctx.telemetry as telemetry
 from ctx.cli.run import (
     _apply_mcp_env_overlays,
     _compile_tool_policy,
@@ -39,6 +41,7 @@ from ctx.cli.run import (
     main,
 )
 from ctx.adapters.generic.providers import ToolCall, Usage
+from ctx.telemetry import read_events, record_event as real_record_event
 
 
 # ── Fixture: fake litellm so --provider ollama (no key) works ───────────────
@@ -93,6 +96,28 @@ def _tool_call_completion(name: str) -> dict[str, Any]:
     }
 
 
+def _enable_real_telemetry(
+    monkeypatch: pytest.MonkeyPatch,
+    tmp_path: Path,
+) -> Path:
+    path = tmp_path / "telemetry" / "events.jsonl"
+    config = {
+        "enabled": True,
+        "mode": "local_redacted",
+        "path": str(path),
+        "export": {"enabled": False},
+    }
+
+    def config_get(key: str, default: Any) -> Any:
+        return config if key == "telemetry" else default
+
+    monkeypatch.setattr(telemetry, "_config_get", config_get)
+    monkeypatch.setattr(telemetry, "record_event", real_record_event)
+    monkeypatch.setattr(run_cli, "record_event", real_record_event)
+    monkeypatch.setattr(runtime_lifecycle, "record_event", real_record_event)
+    return path
+
+
 # ── _model_provider_prefix ─────────────────────────────────────────────────
 
 
@@ -124,9 +149,11 @@ class TestResolveApiKeyEnv:
     def test_inferred_from_model_prefix(self) -> None:
         assert _resolve_api_key_env(None, "openrouter/x", None) == "OPENROUTER_API_KEY"
         assert _resolve_api_key_env(None, "anthropic/claude", None) == "ANTHROPIC_API_KEY"
+        assert _resolve_api_key_env(None, "huggingface/org-model", None) == "HF_TOKEN"
 
     def test_inferred_from_provider_flag(self) -> None:
         assert _resolve_api_key_env(None, "custom-x", "openai") == "OPENAI_API_KEY"
+        assert _resolve_api_key_env(None, "custom-x", "huggingface") == "HF_TOKEN"
 
     def test_ollama_returns_none(self) -> None:
         assert _resolve_api_key_env(None, "ollama/llama3", None) is None
@@ -749,6 +776,12 @@ class TestRunCommand:
         capsys: pytest.CaptureFixture[str],
         monkeypatch: pytest.MonkeyPatch,
     ) -> None:
+        telemetry_events: list[dict[str, Any]] = []
+
+        def capture_record_event(event_name: str, **kwargs: Any) -> None:
+            telemetry_events.append({"event_name": event_name, **kwargs})
+
+        monkeypatch.setattr(run_cli, "record_event", capture_record_event)
         lifecycle_dir = tmp_path / "runtime"
         monkeypatch.setenv("CTX_RUNTIME_LIFECYCLE_DIR", str(lifecycle_dir))
         exit_code = main(
@@ -775,7 +808,20 @@ class TestRunCommand:
             "session_end",
         ]
         assert events[0]["session_id"] == "lifecycle-run"
-        assert events[0]["payload"]["task"] == "hi"
+        assert "task" not in events[0]["payload"]
+        assert events[0]["payload"]["task_hash"].startswith("sha256:")
+        assert "hi" not in json.dumps(events[0])
+        cli_events = [
+            event for event in telemetry_events
+            if event["event_name"] == "ctx.cli.run"
+        ]
+        assert [event["payload"]["ctx.run.phase"] for event in cli_events] == [
+            "started",
+            "finished",
+        ]
+        assert cli_events[0]["payload"]["ctx.task.length"] == len("hi")
+        assert cli_events[-1]["payload"]["ctx.stop_reason"] == "completed"
+        assert "hi" not in json.dumps([event["payload"] for event in cli_events])
         tool = next(
             item for item in fake_litellm._calls[0]["tools"]
             if item["function"]["name"] == "ctx__load_entity"
@@ -783,6 +829,105 @@ class TestRunCommand:
         assert "session_id" not in tool["function"]["parameters"]["properties"]
         assert "session_id" not in tool["function"]["parameters"]["required"]
 
+    def test_run_telemetry_correlates_cli_and_runtime_lifecycle(
+        self,
+        fake_litellm: Any,
+        tmp_path: Path,
+        capsys: pytest.CaptureFixture[str],
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        telemetry_path = _enable_real_telemetry(monkeypatch, tmp_path)
+        lifecycle_dir = tmp_path / "runtime"
+        monkeypatch.setenv("CTX_RUNTIME_LIFECYCLE_DIR", str(lifecycle_dir))
+
+        exit_code = main(
+            [
+                "run",
+                "--model", "ollama/x",
+                "--task", "hi",
+                "--sessions-dir", str(tmp_path / "sessions"),
+                "--session-id", "trace-run",
+                "--quiet",
+            ]
+        )
+
+        assert exit_code == 0
+        capsys.readouterr()
+        events = list(read_events(telemetry_path, trusted_root=tmp_path))
+        cli_events = [event for event in events if event.event_name == "ctx.cli.run"]
+        lifecycle_events = [
+            event for event in events
+            if event.event_name == "ctx.runtime_lifecycle.record"
+        ]
+
+        assert [event.payload["ctx.run.phase"] for event in cli_events] == [
+            "started",
+            "finished",
+        ]
+        assert [event.payload["ctx.lifecycle.action"] for event in lifecycle_events] == [
+            "dev_event",
+            "session_end",
+        ]
+        assert cli_events[0].trace_id is not None
+        assert cli_events[0].span_id is not None
+        assert cli_events[1].trace_id == cli_events[0].trace_id
+        assert cli_events[1].span_id == cli_events[0].span_id
+        assert all(event.trace_id == cli_events[0].trace_id for event in lifecycle_events)
+        assert all(event.parent_span_id == cli_events[0].span_id for event in lifecycle_events)
+        assert {event.span_id for event in lifecycle_events}.isdisjoint(
+            {cli_events[0].span_id}
+        )
+        assert "hi" not in telemetry_path.read_text(encoding="utf-8")
+
+    def test_run_exception_telemetry_hashes_provider_error(
+        self,
+        fake_litellm: Any,
+        tmp_path: Path,
+        capsys: pytest.CaptureFixture[str],
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        telemetry_path = _enable_real_telemetry(monkeypatch, tmp_path)
+
+        def fail_run_loop(*_args: Any, **_kwargs: Any) -> None:
+            raise RuntimeError(
+                "private provider failure for /Users/example/private-repo"
+            )
+
+        monkeypatch.setattr(run_cli, "run_loop", fail_run_loop)
+
+        with pytest.raises(RuntimeError):
+            main(
+                [
+                    "run",
+                    "--model", "ollama/x",
+                    "--task", "private run task",
+                    "--sessions-dir", str(tmp_path / "sessions"),
+                    "--session-id", "trace-run-error",
+                    "--no-ctx-tools",
+                    "--quiet",
+                ]
+            )
+
+        capsys.readouterr()
+        events = [
+            event for event in read_events(telemetry_path, trusted_root=tmp_path)
+            if event.event_name == "ctx.cli.run"
+        ]
+        assert [event.payload["ctx.run.phase"] for event in events] == [
+            "started",
+            "failed",
+        ]
+        failed = events[-1]
+        assert failed.outcome == "error"
+        assert failed.error_kind == "RuntimeError"
+        assert failed.payload["ctx.exception.message_hash"].startswith("sha256:")
+        assert failed.payload["ctx.exception.stack_hash"].startswith("sha256:")
+        assert failed.payload["ctx.exception.escaped"] is True
+        raw = telemetry_path.read_text(encoding="utf-8")
+        assert "private provider failure" not in raw
+        assert "/Users/example/private-repo" not in raw
+        assert "private run task" not in raw
+
 
 # ── Subcommand: sessions ──────────────────────────────────────────────────
 
@@ -971,6 +1116,12 @@ class TestResumeCommand:
         capsys: pytest.CaptureFixture[str],
         monkeypatch: pytest.MonkeyPatch,
     ) -> None:
+        telemetry_events: list[dict[str, Any]] = []
+
+        def capture_record_event(event_name: str, **kwargs: Any) -> None:
+            telemetry_events.append({"event_name": event_name, **kwargs})
+
+        monkeypatch.setattr(run_cli, "record_event", capture_record_event)
         lifecycle_dir = tmp_path / "runtime"
         monkeypatch.setenv("CTX_RUNTIME_LIFECYCLE_DIR", str(lifecycle_dir))
         sessions_dir = tmp_path / "sessions"
@@ -1009,7 +1160,23 @@ class TestResumeCommand:
             "session_end",
         ]
         assert events[2]["event_type"] == "resume_task"
-        assert events[2]["payload"]["task"] == "follow-up"
+        assert "task" not in events[2]["payload"]
+        assert events[2]["payload"]["task_hash"].startswith("sha256:")
+        assert "follow-up" not in json.dumps(events[2])
+        resume_events = [
+            event for event in telemetry_events
+            if event["event_name"] == "ctx.cli.resume"
+        ]
+        assert [event["payload"]["ctx.run.phase"] for event in resume_events] == [
+            "started",
+            "finished",
+        ]
+        assert resume_events[0]["payload"]["ctx.messages.prior_count"] > 0
+        assert resume_events[0]["payload"]["ctx.task.length"] == len("follow-up")
+        assert resume_events[-1]["payload"]["ctx.stop_reason"] == "completed"
+        assert "follow-up" not in json.dumps(
+            [event["payload"] for event in resume_events]
+        )
         resume_call = fake_litellm._calls[-1]
         tool = next(
             item for item in resume_call["tools"]
@@ -1018,6 +1185,160 @@ class TestResumeCommand:
         assert "session_id" not in tool["function"]["parameters"]["properties"]
         assert "session_id" not in tool["function"]["parameters"]["required"]
 
+    def test_resume_telemetry_correlates_cli_and_runtime_lifecycle(
+        self,
+        fake_litellm: Any,
+        tmp_path: Path,
+        capsys: pytest.CaptureFixture[str],
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        telemetry_path = _enable_real_telemetry(monkeypatch, tmp_path)
+        lifecycle_dir = tmp_path / "runtime"
+        monkeypatch.setenv("CTX_RUNTIME_LIFECYCLE_DIR", str(lifecycle_dir))
+        sessions_dir = tmp_path / "sessions"
+        main(
+            [
+                "run",
+                "--model", "ollama/x",
+                "--task", "first",
+                "--sessions-dir", str(sessions_dir),
+                "--session-id", "trace-resume",
+                "--quiet",
+            ]
+        )
+        capsys.readouterr()
+
+        exit_code = main(
+            [
+                "resume", "trace-resume",
+                "--task", "follow-up",
+                "--sessions-dir", str(sessions_dir),
+                "--quiet",
+            ]
+        )
+
+        assert exit_code == 0
+        capsys.readouterr()
+        events = list(read_events(telemetry_path, trusted_root=tmp_path))
+        run_cli_events = [event for event in events if event.event_name == "ctx.cli.run"]
+        resume_cli_events = [
+            event for event in events if event.event_name == "ctx.cli.resume"
+        ]
+        lifecycle_events = [
+            event for event in events
+            if event.event_name == "ctx.runtime_lifecycle.record"
+        ]
+        resume_trace_id = resume_cli_events[0].trace_id
+        resume_span_id = resume_cli_events[0].span_id
+        resume_lifecycle_events = [
+            event for event in lifecycle_events
+            if event.trace_id == resume_trace_id
+        ]
+
+        assert [event.payload["ctx.run.phase"] for event in resume_cli_events] == [
+            "started",
+            "finished",
+        ]
+        assert [event.payload["ctx.lifecycle.action"] for event in resume_lifecycle_events] == [
+            "dev_event",
+            "session_end",
+        ]
+        assert resume_trace_id is not None
+        assert resume_span_id is not None
+        assert resume_cli_events[1].trace_id == resume_trace_id
+        assert resume_cli_events[1].span_id == resume_span_id
+        assert run_cli_events[0].trace_id != resume_trace_id
+        assert all(event.parent_span_id == resume_span_id for event in resume_lifecycle_events)
+        assert "follow-up" not in telemetry_path.read_text(encoding="utf-8")
+
+    def test_resume_exception_telemetry_hashes_provider_error(
+        self,
+        fake_litellm: Any,
+        tmp_path: Path,
+        capsys: pytest.CaptureFixture[str],
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        telemetry_path = _enable_real_telemetry(monkeypatch, tmp_path)
+        sessions_dir = tmp_path / "sessions"
+        main(
+            [
+                "run",
+                "--model", "ollama/x",
+                "--task", "first",
+                "--sessions-dir", str(sessions_dir),
+                "--session-id", "trace-resume-error",
+                "--no-ctx-tools",
+                "--quiet",
+            ]
+        )
+        capsys.readouterr()
+
+        def fail_run_loop(*_args: Any, **_kwargs: Any) -> None:
+            raise RuntimeError(
+                "private resume provider failure for /Users/example/private-repo"
+            )
+
+        monkeypatch.setattr(run_cli, "run_loop", fail_run_loop)
+
+        with pytest.raises(RuntimeError):
+            main(
+                [
+                    "resume",
+                    "trace-resume-error",
+                    "--task", "private resume task",
+                    "--sessions-dir", str(sessions_dir),
+                    "--quiet",
+                ]
+            )
+
+        capsys.readouterr()
+        events = [
+            event for event in read_events(telemetry_path, trusted_root=tmp_path)
+            if event.event_name == "ctx.cli.resume"
+        ]
+        assert [event.payload["ctx.run.phase"] for event in events] == [
+            "started",
+            "failed",
+        ]
+        failed = events[-1]
+        assert failed.outcome == "error"
+        assert failed.error_kind == "RuntimeError"
+        assert failed.payload["ctx.exception.message_hash"].startswith("sha256:")
+        assert failed.payload["ctx.exception.stack_hash"].startswith("sha256:")
+        assert failed.payload["ctx.exception.escaped"] is True
+        raw = telemetry_path.read_text(encoding="utf-8")
+        assert "private resume provider failure" not in raw
+        assert "/Users/example/private-repo" not in raw
+        assert "private resume task" not in raw
+
+    def test_runtime_lifecycle_respects_telemetry_disabled(
+        self,
+        fake_litellm: Any,
+        tmp_path: Path,
+        capsys: pytest.CaptureFixture[str],
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        import ctx.adapters.generic.runtime_lifecycle as runtime_lifecycle
+
+        lifecycle_dir = tmp_path / "runtime"
+        monkeypatch.setenv("CTX_RUNTIME_LIFECYCLE_DIR", str(lifecycle_dir))
+        monkeypatch.setattr(runtime_lifecycle, "telemetry_enabled", lambda: False)
+
+        exit_code = main(
+            [
+                "run",
+                "--model", "ollama/x",
+                "--task", "private task",
+                "--sessions-dir", str(tmp_path / "sessions"),
+                "--session-id", "lifecycle-disabled",
+                "--quiet",
+            ]
+        )
+
+        assert exit_code == 0
+        capsys.readouterr()
+        assert not (lifecycle_dir / "events.jsonl").exists()
+
     def test_resume_reuses_recorded_provider_settings(
         self,
         fake_litellm: Any,

src/tests/test_harness_ctx_core.py

@@ -15,7 +15,9 @@ from __future__ import annotations
 
 import json
 import os
+import sys
 from pathlib import Path
+from types import SimpleNamespace
 from typing import Any
 
 import networkx as nx
@@ -30,6 +32,8 @@ from ctx.adapters.generic.ctx_core_tools import (
     make_tool_executor,
 )
 from ctx.adapters.generic.providers import ToolCall, ToolDefinition
+from ctx.core.graph.graph_packs import write_base_pack, write_overlay_pack
+from ctx.core.wiki.wiki_packs import write_wiki_base_pack, write_wiki_overlay_pack
 
 
 # ── Helpers: build a synthetic wiki + graph for the toolbox ────────────────
@@ -187,6 +191,81 @@ def test_graph_cache_reloads_when_graph_json_changes(tmp_path: Path) -> None:
     assert second["results"][0]["name"] == "new-target"
 
 
+def test_graph_cache_reloads_when_graph_pack_overlay_changes(tmp_path: Path) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    graph_path = graph_dir / "graph.json"
+    packs_dir = graph_dir / "packs"
+    base = nx.Graph()
+    base.add_node("skill:seed", label="seed", type="skill", tags=[])
+    base.add_node("skill:old-target", label="old-target", type="skill", tags=[])
+    base.add_edge("skill:seed", "skill:old-target", weight=1.0)
+    write_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-1",
+        model_id="model-1",
+        graph=base,
+    )
+    toolbox = CtxCoreToolbox(wiki_dir=tmp_path / "wiki", graph_path=graph_path)
+
+    first = json.loads(toolbox.dispatch(ToolCall(
+        id="c1",
+        name="ctx__graph_query",
+        arguments={"seeds": ["seed"], "max_hops": 1},
+    )))
+    write_overlay_pack(
+        pack_dir=packs_dir / "overlay-new-target",
+        pack_id="overlay-new-target",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-1",
+        model_id="model-1",
+        nodes=[{"id": "skill:new-target", "label": "new-target", "type": "skill", "tags": []}],
+        edges=[{"source": "skill:seed", "target": "skill:new-target", "weight": 1.0}],
+        tombstones=[],
+    )
+    second = json.loads(toolbox.dispatch(ToolCall(
+        id="c2",
+        name="ctx__graph_query",
+        arguments={"seeds": ["seed"], "max_hops": 1},
+    )))
+
+    first_names = {item["name"] for item in first["results"]}
+    second_names = {item["name"] for item in second["results"]}
+    assert "old-target" in first_names
+    assert "new-target" not in first_names
+    assert "new-target" in second_names
+
+
+def test_graph_cache_uses_wiki_packs_when_explicit_graph_path_is_missing(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    graph = nx.Graph()
+    graph.add_node("skill:seed", label="seed", type="skill", tags=[])
+    graph.add_node("skill:pack-target", label="pack-target", type="skill", tags=[])
+    graph.add_edge("skill:seed", "skill:pack-target", weight=1.0)
+    write_base_pack(
+        pack_dir=wiki / "graphify-out" / "packs" / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-1",
+        model_id="model-1",
+        graph=graph,
+    )
+    assert not (wiki / "graphify-out" / "graph.json").exists()
+
+    toolbox = CtxCoreToolbox(wiki_dir=wiki, graph_path=tmp_path / "missing.json")
+    result = json.loads(toolbox.dispatch(ToolCall(
+        id="c1",
+        name="ctx__graph_query",
+        arguments={"seeds": ["seed"], "max_hops": 1},
+    )))
+
+    assert [row["name"] for row in result["results"]] == ["pack-target"]
+
+
 def test_graph_file_signature_detects_same_size_rewrite(
     tmp_path: Path,
 ) -> None:
@@ -231,6 +310,48 @@ def test_wiki_page_cache_reloads_when_entity_page_changes(tmp_path: Path) -> Non
     assert second["results"][0]["slug"] == "new-skill"
 
 
+def test_wiki_page_cache_reloads_when_wiki_pack_overlay_changes(tmp_path: Path) -> None:
+    wiki = tmp_path / "wiki"
+    packs_dir = wiki / "wiki-packs"
+    write_wiki_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="wiki-export-1",
+        pages={"entities/skills/old-skill.md": "# Old\n"},
+    )
+    toolbox = CtxCoreToolbox(wiki_dir=wiki, graph_path=tmp_path / "missing.json")
+    first = json.loads(toolbox.dispatch(ToolCall(
+        id="c1",
+        name="ctx__wiki_search",
+        arguments={"query": "packunique"},
+    )))
+
+    write_wiki_overlay_pack(
+        pack_dir=packs_dir / "overlay-packunique",
+        pack_id="overlay-packunique",
+        base_export_id="wiki-export-1",
+        parent_export_id="wiki-export-1",
+        pages={
+            "entities/skills/pack-skill.md": (
+                "---\n"
+                "name: pack-skill\n"
+                "tags: [packunique]\n"
+                "---\n"
+                "# Pack Skill\n"
+            ),
+        },
+        tombstones=[],
+    )
+    second = json.loads(toolbox.dispatch(ToolCall(
+        id="c2",
+        name="ctx__wiki_search",
+        arguments={"query": "packunique"},
+    )))
+
+    assert first["results"] == []
+    assert second["results"][0]["slug"] == "pack-skill"
+
+
 def test_semantic_miss_cache_clears_when_embedding_artifacts_change(
     tmp_path: Path,
     monkeypatch: pytest.MonkeyPatch,
@@ -296,6 +417,27 @@ class TestToolDefinitions:
         )
         assert td.parameters["required"] == ["seeds"]
 
+    def test_read_tools_expose_optional_response_format(
+        self,
+        toolbox: CtxCoreToolbox,
+    ) -> None:
+        read_tools = {
+            "ctx__recommend_bundle",
+            "ctx__graph_query",
+            "ctx__wiki_search",
+            "ctx__wiki_get",
+        }
+        by_name = {definition.name: definition for definition in toolbox.tool_definitions()}
+
+        for tool_name in read_tools:
+            schema = by_name[tool_name].parameters
+            output_format = schema["properties"]["output_format"]
+            assert output_format["enum"] == ["json", "gcf"]
+            assert "output_format" not in schema.get("required", [])
+            response_format = schema["properties"]["_response_format"]
+            assert response_format["enum"] == ["json", "gcf"]
+            assert "_response_format" not in schema.get("required", [])
+
 
 # ── Namespace + dispatch ───────────────────────────────────────────────────
 
@@ -315,8 +457,135 @@ class TestDispatchRouting:
         with pytest.raises(ValueError, match="unknown ctx-core tool"):
             toolbox.dispatch(ToolCall(id="c1", name="ctx__bogus", arguments={}))
 
+    def test_read_tools_default_to_json(self, toolbox: CtxCoreToolbox) -> None:
+        raw = toolbox.dispatch(ToolCall(
+            id="c1",
+            name="ctx__wiki_search",
+            arguments={"query": "python", "top_n": 1},
+        ))
+
+        payload = json.loads(raw)
+        assert payload["query"] == "python"
+        assert payload["results"]
+
+    def test_read_tools_can_opt_into_gcf(
+        self,
+        toolbox: CtxCoreToolbox,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setitem(
+            sys.modules,
+            "gcf",
+            SimpleNamespace(
+                encode_generic=lambda data: (
+                    f"GCF profile=generic\nquery={data['query']}"
+                )
+            ),
+        )
+
+        raw = toolbox.dispatch(ToolCall(
+            id="c1",
+            name="ctx__wiki_search",
+            arguments={
+                "query": "python",
+                "top_n": 1,
+                "_response_format": "gcf",
+            },
+        ))
+
+        assert raw.startswith("GCF profile=generic\n")
+        assert "query=python" in raw
+
+    def test_read_tools_accept_public_output_format_alias(
+        self,
+        toolbox: CtxCoreToolbox,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setitem(
+            sys.modules,
+            "gcf",
+            SimpleNamespace(
+                encode_generic=lambda data: (
+                    f"GCF profile=generic\nquery={data['query']}"
+                )
+            ),
+        )
+
+        raw = toolbox.dispatch(ToolCall(
+            id="c1",
+            name="ctx__wiki_search",
+            arguments={
+                "query": "python",
+                "top_n": 1,
+                "output_format": "gcf",
+            },
+        ))
+
+        assert raw.startswith("GCF profile=generic\n")
+        assert "query=python" in raw
+
+    def test_gcf_opt_in_without_codec_returns_json_error(
+        self,
+        toolbox: CtxCoreToolbox,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        monkeypatch.setitem(sys.modules, "gcf", None)
+
+        raw = toolbox.dispatch(ToolCall(
+            id="c1",
+            name="ctx__wiki_search",
+            arguments={
+                "query": "python",
+                "top_n": 1,
+                "_response_format": "gcf",
+            },
+        ))
+
+        payload = json.loads(raw)
+        assert "gcf-python" in payload["error"]
+        assert payload["response_format"] == "json"
+
 
 class TestRuntimeLifecycle:
+    def test_lifecycle_tool_emits_core_and_store_telemetry(
+        self,
+        toolbox: CtxCoreToolbox,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        import ctx.adapters.generic.ctx_core_tools as core_tools
+        import ctx.adapters.generic.runtime_lifecycle as runtime_lifecycle
+
+        events: list[dict[str, Any]] = []
+
+        def capture_record_event(event_name: str, **kwargs: Any) -> None:
+            events.append({"event_name": event_name, **kwargs})
+
+        monkeypatch.setattr(core_tools, "record_event", capture_record_event)
+        monkeypatch.setattr(runtime_lifecycle, "record_event", capture_record_event)
+
+        result = json.loads(
+            toolbox.dispatch(ToolCall(
+                id="c1",
+                name="ctx__load_entity",
+                arguments={
+                    "session_id": "s-1",
+                    "entity_type": "skill",
+                    "slug": "fastapi-pro",
+                },
+            ))
+        )
+
+        assert result["ok"] is True
+        event_names = [event["event_name"] for event in events]
+        assert "ctx.runtime_lifecycle.record" in event_names
+        assert "ctx.core.lifecycle" in event_names
+        for event in events:
+            payload = event["payload"]
+            assert payload["otel.status_code"] == "OK"
+            assert payload["ctx.entity.type"] == "skill"
+            assert payload["ctx.slug.hash"].startswith("sha256:")
+            assert "fastapi-pro" not in json.dumps(payload)
+
     def test_lifecycle_tools_append_events(
         self,
         toolbox: CtxCoreToolbox,
@@ -724,6 +993,42 @@ def test_session_state_suppresses_current_dev_window_unloads(
 
 
 class TestRecommendBundle:
+    def test_recommend_bundle_emits_core_telemetry_without_raw_query(
+        self,
+        toolbox: CtxCoreToolbox,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        import ctx.adapters.generic.ctx_core_tools as core_tools
+
+        events: list[dict[str, Any]] = []
+
+        def capture_record_event(event_name: str, **kwargs: Any) -> None:
+            events.append({"event_name": event_name, **kwargs})
+
+        monkeypatch.setattr(core_tools, "record_event", capture_record_event)
+        raw_query = "private acme python web api"
+
+        result = json.loads(
+            toolbox.dispatch(
+                ToolCall(
+                    id="c1",
+                    name="ctx__recommend_bundle",
+                    arguments={"query": raw_query, "top_k": 5},
+                )
+            )
+        )
+
+        event = events[-1]
+        payload = event["payload"]
+        assert event["event_name"] == "ctx.core.recommend_bundle"
+        assert event["source"] == "ctx-core"
+        assert event["outcome"] == "ok"
+        assert payload["ctx.operation"] == "recommend_bundle"
+        assert payload["ctx.query.length"] == len(raw_query)
+        assert payload["ctx.query.hash"].startswith("sha256:")
+        assert payload["ctx.result.count"] == len(result["results"])
+        assert raw_query not in json.dumps(payload)
+
     def test_happy_path_ranks_by_tag_overlap(
         self, toolbox: CtxCoreToolbox
     ) -> None:
@@ -1106,6 +1411,51 @@ class TestWikiGet:
         assert result["wikilink"] == "[[entities/mcp-servers/f/filesystem]]"
         assert "Filesystem MCP" in result["body"]
 
+    def test_reads_entity_page_from_wiki_pack_before_stale_file(
+        self, tmp_path: Path
+    ) -> None:
+        wiki = _build_synthetic_wiki(tmp_path)
+        (wiki / "entities" / "skills" / "python-patterns.md").write_text(
+            "---\n"
+            "name: python-patterns\n"
+            "title: Stale Physical Page\n"
+            "tags: [stale]\n"
+            "---\n"
+            "# Stale Physical Page\n",
+            encoding="utf-8",
+        )
+        write_wiki_base_pack(
+            pack_dir=wiki / "wiki-packs" / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="export-1",
+            pages={
+                "entities/skills/python-patterns.md": (
+                    "---\n"
+                    "name: python-patterns\n"
+                    "title: Fresh Pack Page\n"
+                    "tags: [pack]\n"
+                    "---\n"
+                    "# Fresh Pack Page\n\n"
+                    "This content came from the merged wiki pack.\n"
+                )
+            },
+        )
+        toolbox = CtxCoreToolbox(wiki_dir=wiki, graph_path=tmp_path / "missing.json")
+
+        result = json.loads(
+            toolbox.dispatch(
+                ToolCall(
+                    id="c1",
+                    name="ctx__wiki_get",
+                    arguments={"slug": "python-patterns", "entity_type": "skill"},
+                )
+            )
+        )
+
+        assert "error" not in result
+        assert result["frontmatter"]["title"] == "Fresh Pack Page"
+        assert "merged wiki pack" in result["body"]
+
 
 # ── _query_to_tags ────────────────────────────────────────────────────────
 

src/tests/test_harness_install.py

@@ -991,6 +991,8 @@ def test_recommend_mode_passes_structured_harness_requirements(
         "build a code agent",
         "--model",
         "openai/gpt-5.5",
+        "--api-key-env",
+        "OPENAI_API_KEY",
         "--harness-runtime",
         "windows python",
         "--harness-autonomy",
@@ -1013,6 +1015,7 @@ def test_recommend_mode_passes_structured_harness_requirements(
         "verification": "pytest ruff",
         "privacy": "private repo no secrets",
         "attach_mode": "mcp",
+        "api_key_env": "OPENAI_API_KEY",
     }
 
 
@@ -1099,6 +1102,32 @@ def test_recommend_no_fit_prints_custom_harness_plan(
     assert "Privacy/network: offline source code" in output
 
 
+def test_recommend_mode_accepts_huggingface_api_key_env(
+    monkeypatch: Any,
+    capsys: Any,
+) -> None:
+    monkeypatch.setattr(harness_install, "recommend_harnesses_for_cli", lambda **_: [])
+
+    rc = harness_install.main([
+        "--recommend",
+        "--goal",
+        "build a code review harness for a small hosted model",
+        "--model-provider",
+        "huggingface",
+        "--model",
+        "HuggingFaceTB/SmolLM2-135M-Instruct",
+        "--api-key-env",
+        "HF_TOKEN",
+        "--plan-on-no-fit",
+    ])
+
+    assert rc == 0
+    output = capsys.readouterr().out
+    assert "Model provider: huggingface" in output
+    assert "API key env var: HF_TOKEN" in output
+    assert "hf_" not in output
+
+
 def test_recommend_no_fit_writes_custom_harness_plan(
     tmp_path: Path,
     monkeypatch: Any,

src/tests/test_harness_recommendations.py

@@ -13,6 +13,17 @@ import ctx_init
 import scan_repo
 from ctx.core.resolve import resolve_skills
 
+_REAL_LOAD_HARNESS_CATALOG_GRAPH = ctx_init._load_harness_catalog_graph
+
+
+@pytest.fixture(autouse=True)
+def _isolate_harness_catalog_fast_path(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(
+        ctx_init,
+        "_load_harness_catalog_graph",
+        ctx_init._empty_harness_graph,
+    )
+
 
 def _minimal_profile() -> dict[str, Any]:
     return {
@@ -262,6 +273,21 @@ def test_ctx_init_keeps_domain_goal_strong_with_install_requirements(
     assert "gpt-5" not in results[0]["fit_signals"]
 
 
+def test_ctx_init_rejects_narrow_domain_harness_for_generic_coding_agent(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(ctx_init, "_load_recommendation_graph", _harness_graph)
+
+    results = ctx_init.recommend_harnesses(
+        "build an openai python coding agent with filesystem and test verification",
+        top_k=5,
+        model_provider="openai",
+        model="openai/gpt-4.1",
+    )
+
+    assert "text-to-cad" not in [row["name"] for row in results]
+
+
 def test_ctx_init_recommends_harness_from_wiki_frontmatter_only(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
@@ -295,6 +321,126 @@ def test_ctx_init_recommends_harness_from_wiki_frontmatter_only(
     assert set(results[0]["fit_signals"]) >= {"agent", "automation", "browser", "openai"}
 
 
+def test_ctx_init_uses_harness_catalog_without_loading_full_graph(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    harnesses = tmp_path / "entities" / "harnesses"
+    harnesses.mkdir(parents=True)
+    (harnesses / "hf-code-review.md").write_text(
+        "---\n"
+        "name: hf-code-review\n"
+        "type: harness\n"
+        "tags: [harness, huggingface, python, code, review, pytest, filesystem]\n"
+        "model_providers: [huggingface]\n"
+        "capabilities: [code review, pytest verification, filesystem tools]\n"
+        "runtimes: [python, windows, macos, linux]\n"
+        "attach_modes: [mcp]\n"
+        "---\n\n# HF Code Review\n",
+        encoding="utf-8",
+    )
+
+    import ctx_config
+
+    monkeypatch.setattr(
+        ctx_config,
+        "cfg",
+        type("Cfg", (), {
+            "wiki_dir": tmp_path,
+            "claude_dir": tmp_path / ".claude",
+            "recommendation_top_k": 5,
+            "harness_recommendation_min_fit_score": 0.85,
+        })(),
+    )
+    monkeypatch.setattr(
+        ctx_init,
+        "_load_recommendation_graph",
+        lambda: pytest.fail("interactive harness recommendation loaded full graph"),
+    )
+    monkeypatch.setattr(
+        ctx_init,
+        "_load_harness_catalog_graph",
+        _REAL_LOAD_HARNESS_CATALOG_GRAPH,
+    )
+
+    results = ctx_init.recommend_harnesses(
+        "build a huggingface python code review harness with pytest and filesystem tools",
+        model_provider="huggingface",
+        model="HuggingFaceTB/SmolLM2-135M-Instruct",
+    )
+
+    assert [row["name"] for row in results] == ["hf-code-review"]
+    assert results[0]["fit_score"] >= 0.85
+
+
+def test_ctx_init_uses_runtime_harness_body_for_cloud_tool_fit(
+    tmp_path: Path,
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    harnesses = tmp_path / "entities" / "harnesses"
+    harnesses.mkdir(parents=True)
+    (harnesses / "mirage.md").write_text(
+        "---\n"
+        "title: Mirage\n"
+        "type: harness\n"
+        "tags: [harness, virtual-filesystem, sandbox, agent-tools]\n"
+        "model_providers: [openai, local, model-agnostic]\n"
+        "capabilities:\n"
+        "  - filesystem-like access to cloud services and remote resources\n"
+        "runtimes: [python, node, linux, macos]\n"
+        "---\n\n"
+        "# Mirage\n\n"
+        "Use when the user wants their own model with sandboxed filesystem-like "
+        "tool access across GitHub, Slack, S3, Google Drive, Linear, and Notion.\n",
+        encoding="utf-8",
+    )
+
+    import ctx_config
+
+    monkeypatch.setattr(
+        ctx_config,
+        "cfg",
+        type("Cfg", (), {
+            "wiki_dir": tmp_path,
+            "claude_dir": tmp_path / ".claude",
+            "recommendation_top_k": 5,
+            "harness_recommendation_min_fit_score": 0.85,
+        })(),
+    )
+    monkeypatch.setattr(
+        ctx_init,
+        "_load_recommendation_graph",
+        lambda: pytest.fail("runtime harness recommendation loaded full graph"),
+    )
+    monkeypatch.setattr(
+        ctx_init,
+        "_load_harness_catalog_graph",
+        _REAL_LOAD_HARNESS_CATALOG_GRAPH,
+    )
+
+    results = ctx_init.recommend_harnesses(
+        "I use my own OpenAI-compatible local model and need sandboxed "
+        "filesystem-like tool access across GitHub Slack S3 Google Drive "
+        "Linear and Notion for coding agents",
+        model_provider="openai",
+        model="gpt-4.1",
+    )
+
+    assert [row["name"] for row in results] == ["mirage"]
+    assert results[0]["fit_score"] >= 0.85
+    assert set(results[0]["fit_signals"]) >= {
+        "agents",
+        "filesystem",
+        "github",
+        "linear",
+        "notion",
+        "openai",
+        "sandboxed",
+        "slack",
+        "tool",
+    }
+
+
 def test_ctx_init_rejects_weak_single_signal_harness_match(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:

src/tests/test_huggingface_sync.py

@@ -56,6 +56,11 @@ def test_hf_hydrated_artifact_min_size_contract() -> None:
     }
 
 
+def test_hf_sync_defaults_to_dataset_repo_type() -> None:
+    assert sync_huggingface.DEFAULT_REPO_ID == "Stevesolun/ctx"
+    assert sync_huggingface.DEFAULT_REPO_TYPE == "dataset"
+
+
 class _FakeRepoInfo:
     sha = "abc1234"
 
@@ -73,13 +78,17 @@ class _FakeHfApi:
         self.calls.append(("list_repo_files", kwargs))
         return self.remote_files
 
-    def upload_large_folder(self, **kwargs: object) -> None:
-        self.calls.append(("upload_large_folder", kwargs))
-
     def upload_folder(self, **kwargs: object) -> _FakeCommitInfo:
         self.calls.append(("upload_folder", kwargs))
         return _FakeCommitInfo()
 
+    def upload_file(self, **kwargs: object) -> _FakeCommitInfo:
+        path = kwargs.get("path_or_fileobj")
+        if isinstance(path, str):
+            kwargs = {**kwargs, "content": Path(path).read_text(encoding="utf-8")}
+        self.calls.append(("upload_file", kwargs))
+        return _FakeCommitInfo()
+
     def repo_info(self, **kwargs: object) -> _FakeRepoInfo:
         self.calls.append(("repo_info", kwargs))
         return _FakeRepoInfo()
@@ -156,11 +165,20 @@ def test_hf_sync_workflow_uses_secret_and_hardened_script() -> None:
     assert "HF_TOKEN: ${{ secrets.HF_TOKEN }}" in text
     assert "lfs: false" in text
     assert "git lfs pull" not in text
-    assert "gh release download" in text
+    assert "Resolving graph artifacts from matching release assets" in text
+    assert 'tag_name.startswith("graph-artifacts-")' in text
+    assert "latest_tag" not in text
     for artifact in _required_hydrated_artifacts():
         assert artifact.as_posix() in text
-        assert f"--pattern {artifact.name}" in text
+        assert f'hydrate_from_release("{artifact.as_posix()}"' in text
     assert "scripts/sync_huggingface.py" in text
+    assert "--repo-type dataset" in text
+    assert "--repo-type model" not in text
+    assert "Classify sync scope" in text
+    assert "card_only_files" in text
+    assert 'SYNC_MODE" == "card"' in text
+    assert "--card-only" in text
+    assert "timeout-minutes: 60" in text
     assert "Set the HF_TOKEN repository secret" in text
     assert "hf_" not in text
 
@@ -193,7 +211,7 @@ def test_hf_sync_tolerates_create_rate_limit_when_repo_exists_after_retry() -> N
     ]
 
 
-def test_hf_upload_prefers_large_folder_when_remote_has_no_stale_paths(
+def test_hf_upload_uses_clean_folder_commit(
     tmp_path: Path,
 ) -> None:
     export_dir = tmp_path / "export"
@@ -209,20 +227,16 @@ def test_hf_upload_prefers_large_folder_when_remote_has_no_stale_paths(
         repo_id="Stevesolun/ctx",
         repo_type="dataset",
         head="abcdef1234567890",
-        prefer_large_upload=True,
     )
 
-    assert url == "https://huggingface.co/datasets/Stevesolun/ctx/commit/abc1234"
-    assert [call[0] for call in api.calls] == [
-        "list_repo_files",
-        "upload_large_folder",
-        "repo_info",
-    ]
-    large_upload = api.calls[1][1]
-    assert large_upload["repo_id"] == "Stevesolun/ctx"
-    assert large_upload["repo_type"] == "dataset"
-    assert large_upload["folder_path"] == str(export_dir)
-    assert large_upload["print_report"] is True
+    assert url == "https://huggingface.co/datasets/Stevesolun/ctx/commit/fallback"
+    assert [call[0] for call in api.calls] == ["upload_folder"]
+    upload = api.calls[0][1]
+    assert upload["repo_id"] == "Stevesolun/ctx"
+    assert upload["repo_type"] == "dataset"
+    assert upload["folder_path"] == str(export_dir)
+    assert upload["delete_patterns"] == "*"
+    assert upload["commit_message"] == "Sync ctx abcdef1"
 
 
 def test_hf_upload_falls_back_to_clean_upload_when_remote_has_stale_paths(
@@ -239,16 +253,41 @@ def test_hf_upload_falls_back_to_clean_upload_when_remote_has_stale_paths(
         repo_id="Stevesolun/ctx",
         repo_type="dataset",
         head="abcdef1234567890",
-        prefer_large_upload=True,
     )
 
     assert url == "https://huggingface.co/datasets/Stevesolun/ctx/commit/fallback"
-    assert [call[0] for call in api.calls] == ["list_repo_files", "upload_folder"]
-    clean_upload = api.calls[1][1]
+    assert [call[0] for call in api.calls] == ["upload_folder"]
+    clean_upload = api.calls[0][1]
     assert clean_upload["delete_patterns"] == "*"
     assert clean_upload["commit_message"] == "Sync ctx abcdef1"
 
 
+def test_hf_card_upload_only_patches_readme(tmp_path: Path) -> None:
+    repo = tmp_path / "repo"
+    repo.mkdir()
+    (repo / "README.md").write_text("# ctx\n\nbody\n", encoding="utf-8")
+    api = _FakeHfApi(remote_files=[])
+
+    url = sync_huggingface._upload_readme_card(
+        api=api,
+        repo=repo,
+        repo_id="Stevesolun/ctx",
+        repo_type="dataset",
+        head="abcdef1234567890",
+    )
+
+    assert url == "https://huggingface.co/datasets/Stevesolun/ctx/commit/fallback"
+    assert [call[0] for call in api.calls] == ["upload_file"]
+    upload = api.calls[0][1]
+    assert upload["repo_id"] == "Stevesolun/ctx"
+    assert upload["repo_type"] == "dataset"
+    assert upload["path_in_repo"] == "README.md"
+    assert upload["commit_message"] == "Sync ctx card abcdef1"
+    rendered = str(upload["content"])
+    assert rendered.startswith("---\nlicense: mit\n")
+    assert rendered.endswith("# ctx\n\nbody\n")
+
+
 def test_hf_export_copies_hydrated_artifacts_even_when_untracked(
     tmp_path: Path, monkeypatch
 ) -> None:

src/tests/test_incremental_attach_az_flow.py

@@ -101,7 +101,7 @@ def test_entity_onboarding_incremental_attach_a_to_z(
     skill_add = _fresh_module("skill_add")
     mcp_add = _fresh_module("mcp_add")
     harness_add = _fresh_module("harness_add")
-    cm = _fresh_module("ctx_monitor")
+    mt = _fresh_module("ctx.monitor.testing")
     mcp_entity = _fresh_module("mcp_entity")
 
     claude = tmp_path / ".claude"
@@ -115,8 +115,8 @@ def test_entity_onboarding_incremental_attach_a_to_z(
     monkeypatch.setattr(skill_add, "record_embedding", lambda **_kwargs: None)
     monkeypatch.setattr(mcp_add, "check_intake", _allow_intake)
     monkeypatch.setattr(mcp_add, "record_embedding", lambda **_kwargs: None)
-    monkeypatch.setattr(cm, "_claude_dir", lambda: claude)
-    monkeypatch.setattr(cm, "_dashboard_graph_index_archives", lambda: [])
+    monkeypatch.setattr(mt, "claude_dir", lambda: claude)
+    monkeypatch.setattr(mt, "dashboard_graph_index_archives", lambda: [])
 
     source = tmp_path / "SKILL.md"
     source.write_text(
@@ -270,17 +270,17 @@ def test_entity_onboarding_incremental_attach_a_to_z(
     assert attached["status"] == "inserted"
     assert overlay.is_file()
 
-    graph_payload = cm._graph_neighborhood("az-attached", entity_type="skill")
+    graph_payload = mt.graph_neighborhood("az-attached", entity_type="skill")
     assert graph_payload["center"] == "skill:az-attached"
     assert {node["data"]["id"] for node in graph_payload["nodes"]} >= {
         "skill:az-attached",
         "skill:existing-python-helper",
     }
-    rendered = cm._render_graph("az-attached", "skill")
+    rendered = mt.render_graph("az-attached", "skill")
     assert "Knowledge graph" in rendered
     assert "az-attached" in rendered
 
-    ok, message = cm._delete_wiki_entity("az-skill", "skill")
+    ok, message = mt.delete_wiki_entity("az-skill", "skill")
     assert ok is True, message
     assert not (wiki / "entities" / "skills" / "az-skill.md").exists()
     jobs = wiki_queue.list_jobs(wiki_queue.queue_db_path(wiki))

src/tests/test_incremental_attach_calibration.py

@@ -12,6 +12,12 @@ from ctx.core.graph.incremental_attach import (
     main,
     render_calibration_markdown,
 )
+from ctx.core.graph.graph_packs import (
+    build_pack_manifest,
+    load_merged_pack_graph,
+    write_base_pack,
+    write_pack_manifest,
+)
 from ctx.core.graph.resolve_graph import load_graph
 from ctx.core.graph.vector_index import build_vector_index
 
@@ -102,6 +108,28 @@ def test_main_calibrate_outputs_json(tmp_path, capsys) -> None:
     assert '"recommended_min_semantic_score": 0.8' in output
 
 
+def test_main_calibrate_accepts_pack_only_graph_dir(tmp_path, capsys) -> None:
+    graph_dir = tmp_path / "graphify-out"
+    G = nx.Graph()
+    G.add_node("skill:a", type="skill")
+    G.add_node("skill:b", type="skill")
+    G.add_edge("skill:a", "skill:b", semantic_sim=0.8, final_weight=0.4)
+    write_base_pack(
+        pack_dir=graph_dir / "packs" / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-1",
+        model_id="model-1",
+        graph=G,
+    )
+
+    assert main(["calibrate", "--graph-dir", str(graph_dir), "--json"]) == 0
+
+    output = capsys.readouterr().out
+    assert '"node_count": 2' in output
+    assert '"recommended_min_semantic_score": 0.8' in output
+
+
 def test_main_attach_dry_run_outputs_overlay_without_writing(tmp_path, capsys) -> None:
     index_dir = tmp_path / "vector-index"
     build_vector_index(
@@ -138,6 +166,113 @@ def test_main_attach_dry_run_outputs_overlay_without_writing(tmp_path, capsys) -
     assert '"target": "skill:python-testing"' in output
 
 
+def test_main_attach_queries_delta_vector_indexes(tmp_path, capsys) -> None:
+    index_dir = tmp_path / "base-vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-a",
+        node_ids=["skill:base-ruby"],
+        content_hashes=["hb"],
+        vectors=np.asarray([[0.0, 1.0]], dtype="float32"),
+    ).save(index_dir)
+    delta_index_dir = tmp_path / "delta-vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-a",
+        node_ids=["skill:delta-python"],
+        content_hashes=["hd"],
+        vectors=np.asarray([[1.0, 0.0]], dtype="float32"),
+    ).save(delta_index_dir)
+    overlay = tmp_path / "entity-overlays.jsonl"
+
+    rc = main([
+        "attach",
+        "--index-dir", str(index_dir),
+        "--delta-index-dir", str(delta_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",
+        "--min-score", "0.5",
+        "--dry-run",
+    ])
+
+    assert rc == 0
+    assert not overlay.exists()
+    output = capsys.readouterr().out
+    assert '"target": "skill:delta-python"' in output
+    assert '"target": "skill:base-ruby"' not in output
+
+
+def test_main_validate_indexes_reports_base_and_delta(tmp_path, capsys) -> None:
+    index_dir = tmp_path / "base-vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-a",
+        node_ids=["skill:base-python"],
+        content_hashes=["hb"],
+        vectors=np.asarray([[1.0, 0.0]], dtype="float32"),
+    ).save(index_dir)
+    delta_index_dir = tmp_path / "delta-vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-a",
+        node_ids=["skill:delta-python"],
+        content_hashes=["hd"],
+        vectors=np.asarray([[0.9, 0.1]], dtype="float32"),
+    ).save(delta_index_dir)
+
+    rc = main([
+        "validate-indexes",
+        "--index-dir", str(index_dir),
+        "--delta-index-dir", str(delta_index_dir),
+        "--json",
+    ])
+
+    assert rc == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["ok"] is True
+    assert payload["model_id"] == "model-a"
+    assert payload["index_count"] == 2
+    assert payload["node_count"] == 2
+    assert [item["role"] for item in payload["indexes"]] == ["base", "delta"]
+
+
+def test_main_validate_indexes_rejects_incompatible_delta(tmp_path, capsys) -> None:
+    index_dir = tmp_path / "base-vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-a",
+        node_ids=["skill:base-python"],
+        content_hashes=["hb"],
+        vectors=np.asarray([[1.0, 0.0]], dtype="float32"),
+    ).save(index_dir)
+    delta_index_dir = tmp_path / "delta-vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-b",
+        node_ids=["skill:delta-python"],
+        content_hashes=["hd"],
+        vectors=np.asarray([[0.9, 0.1]], dtype="float32"),
+    ).save(delta_index_dir)
+
+    rc = main([
+        "validate-indexes",
+        "--index-dir", str(index_dir),
+        "--delta-index-dir", str(delta_index_dir),
+        "--json",
+    ])
+
+    assert rc == 1
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["ok"] is False
+    assert "delta vector index is unreadable or stale" in payload["error"]
+
+
 def test_main_attach_writes_idempotent_overlay_used_by_resolver(tmp_path) -> None:
     index_dir = tmp_path / "vector-index"
     build_vector_index(
@@ -205,6 +340,123 @@ def test_main_attach_writes_idempotent_overlay_used_by_resolver(tmp_path) -> Non
     assert not loaded_after_change.has_edge("skill:new-python", "skill:python-testing")
 
 
+def test_main_attach_writes_idempotent_overlay_pack(tmp_path, capsys) -> None:
+    index_dir = tmp_path / "vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-a",
+        node_ids=["skill:python-testing"],
+        content_hashes=["ha"],
+        vectors=np.asarray([[1.0, 0.0]], dtype="float32"),
+    ).save(index_dir)
+
+    packs_dir = tmp_path / "packs"
+    base_dir = packs_dir / "base-export-1"
+    base_dir.mkdir(parents=True)
+    graph_json = base_dir / "graph.json"
+    graph_json.write_text(
+        json.dumps({
+            "graph": {"export_id": "export-1"},
+            "nodes": [{"id": "skill:python-testing", "type": "skill"}],
+            "edges": [],
+        }),
+        encoding="utf-8",
+    )
+    write_pack_manifest(
+        base_dir / "graph-pack-manifest.json",
+        build_pack_manifest(
+            pack_dir=base_dir,
+            pack_id="base-export-1",
+            pack_type="base",
+            base_export_id="export-1",
+            parent_export_id=None,
+            config_hash="config-sha",
+            model_id="model-a",
+            node_count=1,
+            edge_count=0,
+            artifact_paths=["graph.json"],
+        ),
+    )
+    overlay = tmp_path / "entity-overlays.jsonl"
+    args = [
+        "attach",
+        "--index-dir", str(index_dir),
+        "--overlay", str(overlay),
+        "--pack-root", str(packs_dir),
+        "--base-export-id", "export-1",
+        "--config-hash", "config-sha",
+        "--node-id", "skill:new-python",
+        "--label", "new-python",
+        "--type", "skill",
+        "--tag", "python",
+        "--text", "new python testing helper",
+        "--model-id", "model-a",
+        "--vector-json", "[1.0, 0.0]",
+        "--top-k", "1",
+        "--min-score", "0.5",
+        "--json",
+    ]
+
+    assert main(args) == 0
+    first = json.loads(capsys.readouterr().out)
+    assert first["overlay_pack"]["status"] == "inserted"
+    assert main(args) == 0
+    second = json.loads(capsys.readouterr().out)
+
+    assert second["status"] == "unchanged"
+    assert second["overlay_pack"]["status"] == "unchanged"
+    assert len([path for path in packs_dir.iterdir() if path.name.startswith("overlay-")]) == 1
+    graph = load_merged_pack_graph(packs_dir)
+    assert graph.has_edge("skill:new-python", "skill:python-testing")
+
+
+def test_main_attach_overlay_pack_replaces_stale_incident_edges(tmp_path, capsys) -> None:
+    index_dir = tmp_path / "vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-a",
+        node_ids=["skill:old-target", "skill:new-target"],
+        content_hashes=["ha", "hb"],
+        vectors=np.asarray([[1.0, 0.0], [0.0, 1.0]], dtype="float32"),
+    ).save(index_dir)
+    packs_dir = tmp_path / "packs"
+    base_graph = nx.Graph()
+    base_graph.add_node("skill:old-target", type="skill")
+    base_graph.add_node("skill:new-target", type="skill")
+    write_base_pack(
+        pack_dir=packs_dir / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-sha",
+        model_id="model-a",
+        graph=base_graph,
+    )
+    overlay = tmp_path / "entity-overlays.jsonl"
+    common = [
+        "attach",
+        "--index-dir", str(index_dir),
+        "--overlay", str(overlay),
+        "--pack-root", str(packs_dir),
+        "--base-export-id", "export-1",
+        "--config-hash", "config-sha",
+        "--node-id", "skill:changing",
+        "--label", "changing",
+        "--type", "skill",
+        "--model-id", "model-a",
+        "--top-k", "1",
+        "--min-score", "0.5",
+        "--json",
+    ]
+
+    assert main([*common, "--text", "old body", "--vector-json", "[1.0, 0.0]"]) == 0
+    capsys.readouterr()
+    assert main([*common, "--text", "new body", "--vector-json", "[0.0, 1.0]"]) == 0
+
+    graph = load_merged_pack_graph(packs_dir)
+    assert not graph.has_edge("skill:changing", "skill:old-target")
+    assert graph.has_edge("skill:changing", "skill:new-target")
+
+
 def test_main_attach_default_min_score_matches_build_floor(tmp_path) -> None:
     index_dir = tmp_path / "vector-index"
     build_vector_index(

src/tests/test_incremental_attach_shadow.py

@@ -8,6 +8,7 @@ import networkx as nx
 import numpy as np
 
 from ctx.core.graph.incremental_shadow import main, run_shadow_validation
+from ctx.core.graph.graph_packs import write_base_pack
 from ctx.core.graph.semantic_edges import (
     _l2_normalize,
     _topk_pairs,
@@ -141,6 +142,42 @@ def test_shadow_cli_returns_nonzero_when_gate_fails(tmp_path: Path, capsys) -> N
     assert '"gate_passed": false' in capsys.readouterr().out
 
 
+def test_shadow_cli_accepts_pack_only_graph_dir(tmp_path: Path, capsys) -> None:
+    index_dir = tmp_path / "vector-index"
+    build_vector_index(
+        kind="numpy-flat",
+        model_id="model-a",
+        node_ids=["skill:alpha", "skill:beta"],
+        content_hashes=["ha", "hb"],
+        vectors=np.asarray([[1.0, 0.0], [0.95, 0.05]], dtype="float32"),
+    ).save(index_dir)
+    graph_dir = tmp_path / "graphify-out"
+    graph = nx.Graph()
+    graph.add_edge("skill:alpha", "skill:beta", semantic_sim=0.9)
+    write_base_pack(
+        pack_dir=graph_dir / "packs" / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-1",
+        model_id="model-a",
+        graph=graph,
+    )
+
+    rc = main([
+        "--index-dir", str(index_dir),
+        "--graph-dir", str(graph_dir),
+        "--node", "skill:alpha",
+        "--top-k", "1",
+        "--min-score", "0.5",
+        "--json",
+    ])
+
+    assert rc == 0
+    output = capsys.readouterr().out
+    assert '"baseline": "graph-semantic-edges"' in output
+    assert '"gate_passed": true' in output
+
+
 def test_shadow_incremental_graph_matches_full_graph(
     tmp_path: Path,
     monkeypatch,

src/tests/test_link_conversions.py

@@ -25,6 +25,7 @@ import pytest
 sys.path.insert(0, str(Path(__file__).parents[1]))
 
 import link_conversions as _lc
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_wiki_base_pack
 from link_conversions import (
     ConvertedSkill,
     _build_new_entity_page,
@@ -504,6 +505,31 @@ class TestRun:
         log_content = (wiki / "log.md").read_text()
         assert "link-conversions" in log_content
 
+    def test_pack_only_wiki_is_updated_through_overlays(self, tmp_path):
+        wiki = tmp_path / "wiki"
+        (wiki / "converted").mkdir(parents=True)
+        write_wiki_base_pack(
+            pack_dir=wiki / "wiki-packs" / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="export-1",
+            pages={
+                "index.md": "# Index\n\n## Skills\n\n## Total pages: 0 | Last updated: 2024-01-01\n",
+                "log.md": "# Log\n",
+            },
+        )
+        _make_converted_skill(wiki, "react")
+
+        result = run(wiki, tmp_path / "skills")
+
+        assert result.created == ["react"]
+        assert result.errors == []
+        assert not (wiki / "entities" / "skills" / "react.md").exists()
+        merged = load_merged_wiki_pages(wiki / "wiki-packs")
+        assert "has_pipeline: true" in merged["entities/skills/react.md"]
+        assert "[[entities/skills/react]]" in merged["index.md"]
+        assert "link-conversions" in merged["log.md"]
+        assert "react" in merged["converted-index.md"]
+
 
 # ---------------------------------------------------------------------------
 # main()

src/tests/test_lint.py

@@ -7,6 +7,7 @@ Every test builds its own minimal wiki structure via tmp_path so the real
 
 from __future__ import annotations
 
+import re
 import sys
 from pathlib import Path
 
@@ -14,11 +15,12 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 
 from ctx.core.wiki import wiki_lint as wl  # noqa: E402
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_wiki_base_pack  # noqa: E402
 
 from ._wiki_helpers import _FRESH_DATE, _STALE_DATE, make_entity_page, make_wiki  # noqa: E402
 
 
-def _collect(wiki: Path) -> dict[str, Path]:
+def _collect(wiki: Path) -> dict[str, wl.WikiPage]:
     """Thin wrapper around wiki_lint's internal page collector."""
     return wl._collect_pages(wiki)
 
@@ -225,3 +227,55 @@ class TestLintFixIndex:
         assert text.index("- [[entities/mcp-servers/g/github]]") > text.index("## MCP Servers")
         assert text.index("- [[entities/harnesses/openhands]]") > text.index("## Harnesses")
         assert text.index("- [[entities/agents/reviewer]]") < text.index("## MCP Servers")
+
+    def test_fix_index_writes_pack_overlay_when_wiki_is_pack_only(self, tmp_path: Path) -> None:
+        wiki = tmp_path / "wiki"
+        write_wiki_base_pack(
+            pack_dir=wiki / "wiki-packs" / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="wiki-export-1",
+            pages={
+                "index.md": "# Index\n\n## Skills\n\n## Agents\n",
+                "entities/skills/pack-skill.md": """---
+title: pack-skill
+created: 2026-01-01
+updated: 2026-03-01
+type: skill
+tags: [python]
+---
+
+Body with [[entities/skills/pack-skill]].
+""",
+            },
+        )
+
+        pages = _collect(wiki)
+        assert "entities/skills/pack-skill" in pages
+        added = wl.fix_index(wiki, ["entities/skills/pack-skill"])
+
+        assert added == 1
+        assert not (wiki / "index.md").exists()
+        merged = load_merged_wiki_pages(wiki / "wiki-packs")
+        assert "- [[entities/skills/pack-skill]]" in merged["index.md"]
+
+
+class TestLintFixLogRotation:
+    def test_fix_log_rotation_writes_pack_overlay_when_wiki_is_pack_only(
+        self, tmp_path: Path
+    ) -> None:
+        wiki = tmp_path / "wiki"
+        entries = "".join(f"## [2026-01-{(i % 28) + 1:02d}] entry {i}\n\n" for i in range(505))
+        write_wiki_base_pack(
+            pack_dir=wiki / "wiki-packs" / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="wiki-export-1",
+            pages={"log.md": "# Log\n\n" + entries},
+        )
+
+        assert wl.fix_log_rotation(wiki) is True
+
+        merged = load_merged_wiki_pages(wiki / "wiki-packs")
+        assert len(re.findall(r"^##\s+\[", merged["log.md"], re.MULTILINE)) == 100
+        archive = f"log-archive-{wl.TODAY.isoformat()}.md"
+        assert archive in merged
+        assert "entry 0" in merged[archive]

src/tests/test_maintainer_script_bom_inputs.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+import sys
+import zlib
+from pathlib import Path
+
+from scripts import audit_backup
+from scripts.build_dashboard_graph_index import build_dashboard_index
+
+
+def test_audit_backup_accepts_bom_manifest(
+    tmp_path: Path,
+    monkeypatch,
+    capsys,
+) -> None:
+    claude_home = tmp_path / "home" / ".claude"
+    claude_home.mkdir(parents=True)
+    config = claude_home / "skill-system-config.json"
+    config.write_text('{"ok": true}', encoding="utf-8")
+    snapshot = tmp_path / "snapshot"
+    snapshot.mkdir()
+    manifest = {
+        "entries": [
+            {
+                "source": str(config),
+                "dest": "skill-system-config.json",
+                "size": config.stat().st_size,
+            }
+        ]
+    }
+    (snapshot / "manifest.json").write_text(json.dumps(manifest), encoding="utf-8-sig")
+
+    monkeypatch.setattr(audit_backup, "CLAUDE_HOME", claude_home)
+    monkeypatch.setattr(sys, "argv", ["audit_backup.py", str(snapshot)])
+
+    assert audit_backup.main() == 0
+    output = capsys.readouterr().out
+    assert "entries:   1" in output
+    assert "OK:" in output
+
+
+def test_dashboard_graph_index_accepts_bom_graph_json(tmp_path: Path) -> None:
+    graph_json = tmp_path / "graph.json"
+    output = tmp_path / "dashboard.sqlite3"
+    graph_json.write_text(
+        json.dumps({
+            "graph": {"export_id": "fixture"},
+            "nodes": [
+                {
+                    "id": "skill:alpha",
+                    "label": "Alpha",
+                    "type": "skill",
+                    "tags": ["python", "test"],
+                    "quality_score": 0.9,
+                },
+                {
+                    "id": "mcp-server:github",
+                    "label": "GitHub",
+                    "type": "mcp-server",
+                    "tags": ["github"],
+                },
+            ],
+            "links": [
+                {
+                    "source": "skill:alpha",
+                    "target": "mcp-server:github",
+                    "weight": 0.77,
+                    "shared_tags": ["github"],
+                    "reasons": ["fixture"],
+                }
+            ],
+        }),
+        encoding="utf-8-sig",
+    )
+
+    build_dashboard_index(graph_json, output, top_k=5)
+
+    conn = sqlite3.connect(output)
+    try:
+        assert conn.execute(
+            "SELECT value FROM meta WHERE key='nodes_count'",
+        ).fetchone() == ("2",)
+        payload = conn.execute(
+            "SELECT payload FROM neighbors WHERE source='skill:alpha'",
+        ).fetchone()[0]
+    finally:
+        conn.close()
+    neighbors = json.loads(zlib.decompress(payload).decode("utf-8"))
+    assert neighbors[0]["target"] == "mcp-server:github"

src/tests/test_mcp_add.py

@@ -31,6 +31,7 @@ if str(SRC_DIR) not in sys.path:
 
 from mcp_entity import McpRecord  # noqa: E402
 from ctx.core.wiki import wiki_queue  # noqa: E402
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_wiki_base_pack  # noqa: E402
 
 
 # ---------------------------------------------------------------------------
@@ -248,7 +249,17 @@ class TestAddMcpExistingReview:
         self, patched_mcp_add: Any, wiki_dir: Path
     ) -> None:
         record_a = _make_record(name="github-mcp", sources=["awesome-mcp"])
-        patched_mcp_add.add_mcp(record=record_a, wiki_path=wiki_dir)
+        packs_dir = wiki_dir / "wiki-packs"
+        write_wiki_base_pack(
+            pack_dir=packs_dir / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="wiki-export-1",
+            pages={
+                "entities/mcp-servers/g/github-mcp.md": (
+                    patched_mcp_add.generate_mcp_page(record_a)
+                )
+            },
+        )
 
         record_b = _make_record(
             name="github-mcp",
@@ -263,13 +274,15 @@ class TestAddMcpExistingReview:
         )
 
         page = wiki_dir / "entities" / "mcp-servers" / "g" / "github-mcp.md"
-        text = page.read_text(encoding="utf-8")
+        merged = load_merged_wiki_pages(packs_dir)
+        text = merged["entities/mcp-servers/g/github-mcp.md"]
         _, fm_block, _ = text.split("---", 2)
         fm = yaml.safe_load(fm_block)
         assert isinstance(fm, dict)
         assert result["is_new_page"] is False
         assert result["skipped"] is False
         assert result["merged_sources"] == ["awesome-mcp", "pulsemcp"]
+        assert not page.exists()
         assert fm["sources"] == ["awesome-mcp", "pulsemcp"]
         assert fm["description"] == record_b.description
         assert record_b.description in text
@@ -526,15 +539,27 @@ class TestCrossSourceCanonicalKeyDedup:
     def test_second_source_merges_into_first_entity_path(
         self, patched_mcp_add: Any, wiki_dir: Path
     ) -> None:
-        # awesome-mcp adds the repo first under its name-derived slug.
+        # awesome-mcp exists first under its name-derived slug, but only
+        # inside the modular wiki base pack.
         record_awesome = _make_record(
             name="modelcontextprotocol/servers",
             github_url="https://github.com/modelcontextprotocol/servers",
             sources=["awesome-mcp"],
         )
-        result1 = patched_mcp_add.add_mcp(record=record_awesome, wiki_path=wiki_dir)
-        assert result1["is_new_page"] is True
-        first_path = Path(result1["path"])
+        first_path = (
+            wiki_dir / "entities" / "mcp-servers" / record_awesome.entity_relpath()
+        )
+        packs_dir = wiki_dir / "wiki-packs"
+        write_wiki_base_pack(
+            pack_dir=packs_dir / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="wiki-export-1",
+            pages={
+                first_path.relative_to(wiki_dir).as_posix(): (
+                    patched_mcp_add.generate_mcp_page(record_awesome)
+                )
+            },
+        )
 
         # pulsemcp finds the same repo under a different slug.
         record_pulsemcp = _make_record(
@@ -557,11 +582,67 @@ class TestCrossSourceCanonicalKeyDedup:
             first_path.relative_to(wiki_dir)
         ).replace("\\", "/")
 
-        # And only ONE entity file exists in the wiki.
-        all_entities = list(
-            (wiki_dir / "entities" / "mcp-servers").rglob("*.md")
+        # And only ONE logical MCP page exists in the merged wiki.
+        merged_pages = {
+            relpath: text
+            for relpath, text in load_merged_wiki_pages(packs_dir).items()
+            if relpath.startswith("entities/mcp-servers/") and relpath.endswith(".md")
+        }
+        assert sorted(merged_pages) == [first_path.relative_to(wiki_dir).as_posix()]
+        assert not first_path.exists()
+
+    def test_second_source_uses_pack_canonical_index_without_physical_scan(
+        self,
+        patched_mcp_add: Any,
+        wiki_dir: Path,
+        monkeypatch: pytest.MonkeyPatch,
+    ) -> None:
+        record_awesome = _make_record(
+            name="modelcontextprotocol/servers",
+            github_url="https://github.com/modelcontextprotocol/servers",
+            sources=["awesome-mcp"],
+        )
+        mcp_dir = wiki_dir / "entities" / "mcp-servers"
+        first_path = mcp_dir / record_awesome.entity_relpath()
+        packs_dir = wiki_dir / "wiki-packs"
+        write_wiki_base_pack(
+            pack_dir=packs_dir / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="wiki-export-1",
+            pages={
+                first_path.relative_to(wiki_dir).as_posix(): (
+                    patched_mcp_add.generate_mcp_page(record_awesome)
+                )
+            },
+        )
+        target = patched_mcp_add._normalize_github_url(record_awesome.github_url)
+        assert target is not None
+        patched_mcp_add.mcp_canonical_index.upsert(
+            mcp_dir,
+            target,
+            slug=first_path.stem,
+            relpath=first_path.relative_to(mcp_dir).as_posix(),
+        )
+
+        def fail_physical_scan(*args: Any, **kwargs: Any) -> None:
+            raise AssertionError("physical MCP scan should not run on indexed pack hit")
+
+        monkeypatch.setattr(
+            patched_mcp_add,
+            "_scan_for_github_url",
+            fail_physical_scan,
+        )
+
+        record_pulsemcp = _make_record(
+            name="modelcontextprotocol-servers-mcp",
+            github_url="https://github.com/modelcontextprotocol/servers",
+            sources=["pulsemcp"],
         )
-        assert len(all_entities) == 1, f"expected 1 entity, found {all_entities}"
+        result = patched_mcp_add.add_mcp(record=record_pulsemcp, wiki_path=wiki_dir)
+
+        assert result["is_new_page"] is False
+        assert result["path"] == str(first_path)
+        assert result["merged_sources"] == ["awesome-mcp", "pulsemcp"]
 
     def test_records_without_github_url_still_use_slug_dedup(
         self, patched_mcp_add: Any, wiki_dir: Path
@@ -751,3 +832,120 @@ class TestAddMcpFromFixtures:
         record = McpRecord.from_dict(data)
         result = patched_mcp_add.add_mcp(record=record, wiki_path=wiki_dir)
         assert result["is_new_page"] is True
+
+
+class TestAddMcpCliInput:
+    def test_from_json_accepts_utf8_bom(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        tmp_path: Path,
+    ) -> None:
+        import mcp_add  # noqa: PLC0415
+
+        record_path = tmp_path / "mcp.json"
+        record_path.write_text(
+            "\ufeff"
+            + json.dumps(
+                {
+                    "name": "bom-json-mcp",
+                    "description": "MCP loaded from a Windows UTF-8 BOM JSON file.",
+                    "sources": ["test"],
+                    "github_url": "https://github.com/example/bom-json-mcp",
+                    "tags": ["testing"],
+                }
+            ),
+            encoding="utf-8",
+        )
+        wiki = tmp_path / "wiki"
+        monkeypatch.setattr(sys, "argv", [
+            "mcp_add.py",
+            "--from-json", str(record_path),
+            "--wiki", str(wiki),
+        ])
+        monkeypatch.setattr("mcp_add.check_intake", _fake_allow)
+        monkeypatch.setattr("mcp_add.record_embedding", _fake_record_embedding)
+        monkeypatch.setattr("mcp_add.update_index", lambda *a, **k: None)
+        monkeypatch.setattr("mcp_add.append_log", lambda *a, **k: None)
+
+        mcp_add.main()
+
+        assert (
+            wiki / "entities" / "mcp-servers" / "b" / "bom-json-mcp.md"
+        ).exists()
+
+    def test_from_stdin_accepts_utf8_bom(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        tmp_path: Path,
+    ) -> None:
+        import io
+        import mcp_add  # noqa: PLC0415
+
+        wiki = tmp_path / "wiki"
+        monkeypatch.setattr(sys, "argv", [
+            "mcp_add.py",
+            "--from-stdin",
+            "--wiki", str(wiki),
+        ])
+        monkeypatch.setattr(
+            sys,
+            "stdin",
+            io.StringIO(
+                "\ufeff"
+                + json.dumps(
+                    {
+                        "name": "bom-stdin-mcp",
+                        "description": (
+                            "MCP loaded from a Windows UTF-8 BOM stdin stream."
+                        ),
+                        "sources": ["test"],
+                        "github_url": "https://github.com/example/bom-stdin-mcp",
+                        "tags": ["testing"],
+                    }
+                )
+                + "\n"
+            ),
+        )
+        monkeypatch.setattr("mcp_add.check_intake", _fake_allow)
+        monkeypatch.setattr("mcp_add.record_embedding", _fake_record_embedding)
+        monkeypatch.setattr("mcp_add.update_index", lambda *a, **k: None)
+        monkeypatch.setattr("mcp_add.append_log", lambda *a, **k: None)
+
+        mcp_add.main()
+
+        assert (
+            wiki / "entities" / "mcp-servers" / "b" / "bom-stdin-mcp.md"
+        ).exists()
+
+    def test_rejected_batch_exits_nonzero(
+        self,
+        monkeypatch: pytest.MonkeyPatch,
+        tmp_path: Path,
+    ) -> None:
+        import mcp_add  # noqa: PLC0415
+
+        record_path = tmp_path / "mcp.json"
+        record_path.write_text(
+            json.dumps(
+                {
+                    "name": "rejected-cli-mcp",
+                    "description": "Rejected MCP candidate for exit-code regression.",
+                    "sources": ["test"],
+                    "github_url": "https://github.com/example/rejected-cli-mcp",
+                    "tags": ["testing"],
+                }
+            ),
+            encoding="utf-8",
+        )
+        monkeypatch.setattr(sys, "argv", [
+            "mcp_add.py",
+            "--from-json", str(record_path),
+            "--wiki", str(tmp_path / "wiki"),
+        ])
+        monkeypatch.setattr("mcp_add.check_intake", _fake_reject)
+        monkeypatch.setattr("mcp_add.record_embedding", _fake_record_embedding)
+
+        with pytest.raises(SystemExit) as exc:
+            mcp_add.main()
+
+        assert exc.value.code == 1

src/tests/test_mcp_canonical_index.py

@@ -30,6 +30,7 @@ if str(SRC_DIR) not in sys.path:
     sys.path.insert(0, str(SRC_DIR))
 
 import mcp_canonical_index as mci  # noqa: E402
+from ctx.core.wiki.wiki_packs import write_wiki_base_pack  # noqa: E402
 
 
 # ── Helpers ──────────────────────────────────────────────────────────────────
@@ -222,6 +223,42 @@ class TestRebuild:
         assert skipped == 0
         assert idx["by_github_url"] == {}
 
+    def test_rebuilds_from_pack_only_wiki_pages(self, tmp_path: Path) -> None:
+        wiki = tmp_path / "wiki"
+        mcp_dir = wiki / "entities" / "mcp-servers"
+        write_wiki_base_pack(
+            pack_dir=wiki / "wiki-packs" / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="wiki-export-1",
+            pages={
+                "entities/mcp-servers/a/alpha.md": (
+                    "---\n"
+                    "name: alpha\n"
+                    "github_url: https://github.com/Org/Alpha\n"
+                    "---\n"
+                    "# alpha\n"
+                ),
+                "entities/mcp-servers/b/beta.md": (
+                    "---\n"
+                    "name: beta\n"
+                    "---\n"
+                    "# beta\n"
+                ),
+            },
+        )
+
+        idx, indexed, skipped = mci.rebuild_from_scan(mcp_dir)
+
+        assert indexed == 1
+        assert skipped == 1
+        assert idx["by_github_url"] == {
+            "https://github.com/org/alpha": {
+                "slug": "alpha",
+                "relpath": "a/alpha.md",
+            }
+        }
+        assert (mcp_dir / mci.INDEX_FILENAME).is_file()
+
 
 # ── Integration: mcp_add._find_existing_by_github_url with cache ────────────
 

src/tests/test_mcp_enrich_render_scalar.py

@@ -26,6 +26,7 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).parents[1]))
 
 import mcp_enrich as _me
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_wiki_base_pack
 
 
 class TestRenderScalar:
@@ -119,3 +120,47 @@ class TestRenderScalar:
             f"YAML injection via newline succeeded — found status keys: "
             f"{status_keys!r}\nFull frontmatter:\n{fm}"
         )
+
+    def test_enrich_entities_updates_pack_only_mcp_page(self, tmp_path, monkeypatch):
+        wiki = tmp_path / "wiki"
+        relpath = "entities/mcp-servers/p/pack-only.md"
+        write_wiki_base_pack(
+            pack_dir=wiki / "wiki-packs" / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="wiki-export-1",
+            pages={
+                relpath: (
+                    "---\n"
+                    "name: Pack Only\n"
+                    "homepage_url: https://www.pulsemcp.com/servers/source-slug\n"
+                    "github_url: null\n"
+                    "stars: null\n"
+                    "updated: '2026-01-01'\n"
+                    "---\n"
+                    "# Pack Only\n"
+                )
+            },
+        )
+
+        class Source:
+            def fetch_details(self, slug, *, refresh=False):  # noqa: ARG002, ANN001, ANN201
+                assert slug == "source-slug"
+                return {"github_url": "https://github.com/example/pack-only", "stars": 7}
+
+        monkeypatch.setitem(_me.SOURCES, "pulsemcp", Source())
+
+        entity_paths = list(_me._iter_entities(wiki))
+        checkpoint = _me._empty_checkpoint("pulsemcp")
+        _me.enrich_entities(
+            entity_paths,
+            source_name="pulsemcp",
+            wiki_path=wiki,
+            checkpoint=checkpoint,
+            sleep_seconds=0,
+            report_progress=False,
+        )
+
+        merged = load_merged_wiki_pages(wiki / "wiki-packs")
+        assert 'github_url: "https://github.com/example/pack-only"' in merged[relpath]
+        assert "stars: 7" in merged[relpath]
+        assert not (wiki / relpath).exists()

src/tests/test_mcp_quality.py

@@ -18,6 +18,7 @@ import sys
 from datetime import datetime
 from pathlib import Path
 
+import networkx as nx
 import pytest
 
 SRC_DIR = Path(__file__).resolve().parents[1]
@@ -25,7 +26,9 @@ if str(SRC_DIR) not in sys.path:
     sys.path.insert(0, str(SRC_DIR))
 
 import mcp_quality as mq  # noqa: E402
+from ctx.core.graph.graph_packs import write_base_pack, write_overlay_pack  # noqa: E402
 from ctx.core.quality.quality_signals import SignalResult  # noqa: E402
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages, write_wiki_base_pack  # noqa: E402
 
 
 # ---------------------------------------------------------------------------
@@ -389,6 +392,30 @@ class TestPersistQuality:
         assert "- **Grade:** B" in content
         assert "- **Computed:** 2026-04-21T00:00:00+00:00" in content
 
+    def test_recompute_all_updates_pack_only_mcp_page(self, tmp_path: Path) -> None:
+        wiki_dir = tmp_path / "wiki"
+        relpath = "entities/mcp-servers/g/github.md"
+        write_wiki_base_pack(
+            pack_dir=wiki_dir / "wiki-packs" / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="wiki-export-1",
+            pages={relpath: _entity_frontmatter(name="github")},
+        )
+
+        assert mq.discover_mcp_slugs(wiki_dir) == ["github"]
+
+        scores, failures = mq.recompute_all(
+            wiki_dir=wiki_dir,
+            sidecar_dir=tmp_path / "quality",
+        )
+
+        assert failures == []
+        assert [score.slug for score in scores] == ["github"]
+        merged = load_merged_wiki_pages(wiki_dir / "wiki-packs")
+        assert "quality_score:" in merged[relpath]
+        assert "<!-- quality:begin -->" in merged[relpath]
+        assert not (wiki_dir / relpath).exists()
+
 
 # ---------------------------------------------------------------------------
 # TestLoadGraphIndex
@@ -470,6 +497,60 @@ class TestLoadGraphIndex:
         # Cross-type = 2 (skill + agent only)
         assert node["cross_type_degree"] == 2
 
+    def test_active_graph_packs_override_stale_graph_json(
+        self, tmp_path: Path
+    ) -> None:
+        wiki_dir = tmp_path / "wiki"
+        graph_dir = wiki_dir / "graphify-out"
+        packs_dir = graph_dir / "packs"
+        graph_dir.mkdir(parents=True)
+        (graph_dir / "graph.json").write_text(
+            json.dumps({
+                "directed": False,
+                "multigraph": False,
+                "graph": {},
+                "nodes": [
+                    {"id": "mcp-server:github", "type": "mcp-server"},
+                    {"id": "mcp-server:stale", "type": "mcp-server"},
+                ],
+                "edges": [
+                    {"source": "mcp-server:github", "target": "mcp-server:stale"},
+                ],
+            }),
+            encoding="utf-8",
+        )
+        graph = nx.Graph()
+        graph.add_node("mcp-server:github", type="mcp-server")
+        graph.add_node("skill:git", type="skill")
+        graph.add_edge("mcp-server:github", "skill:git")
+        write_base_pack(
+            pack_dir=packs_dir / "base-export-1",
+            pack_id="base-export-1",
+            base_export_id="export-1",
+            config_hash="config-sha",
+            model_id="test-model",
+            graph=graph,
+        )
+        write_overlay_pack(
+            pack_dir=packs_dir / "overlay-agent",
+            pack_id="overlay-agent",
+            base_export_id="export-1",
+            parent_export_id="export-1",
+            config_hash="config-sha",
+            model_id="test-model",
+            nodes=[{"id": "agent:coder", "type": "agent"}],
+            edges=[{"source": "mcp-server:github", "target": "agent:coder"}],
+            tombstones=[],
+        )
+
+        index = mq.load_graph_index(wiki_dir)
+
+        assert "mcp-server:stale" not in index
+        assert index["mcp-server:github"] == {
+            "degree": 2,
+            "cross_type_degree": 2,
+        }
+
 
 # ---------------------------------------------------------------------------
 # TestCLI

src/tests/test_mcp_server.py

@@ -32,6 +32,7 @@ from typing import Any
 
 import pytest
 
+import ctx.mcp_server.server as mcp_server
 from ctx.adapters.generic.tools import (
     McpClient,
     McpServerConfig,
@@ -110,6 +111,19 @@ def _mcp_subprocess_env(wiki: Path, graph_path: Path) -> dict[str, str]:
     }
 
 
+@pytest.fixture()
+def captured_mcp_events(
+    monkeypatch: pytest.MonkeyPatch,
+) -> list[dict[str, Any]]:
+    events: list[dict[str, Any]] = []
+
+    def _capture_record_event(event_name: str, **kwargs: Any) -> None:
+        events.append({"event_name": event_name, **kwargs})
+
+    monkeypatch.setattr(mcp_server, "record_event", _capture_record_event)
+    return events
+
+
 # ── Server-level loop behaviour ─────────────────────────────────────────────
 
 
@@ -130,6 +144,22 @@ class TestRunServerLifecycle:
         # id is null when the request couldn't be parsed.
         assert frames[0]["id"] is None
 
+    def test_invalid_json_emits_parse_error_telemetry(
+        self,
+        captured_mcp_events: list[dict[str, Any]],
+    ) -> None:
+        raw_frame = "{not valid json"
+
+        _drive((raw_frame + "\n").encode("utf-8"))
+
+        event = captured_mcp_events[-1]
+        assert event["event_name"] == "ctx.mcp.request"
+        assert event["outcome"] == "error"
+        assert event["error_kind"] == "parse_error"
+        assert event["payload"]["rpc.method"] == "<parse-error>"
+        assert event["payload"]["otel.status_code"] == "ERROR"
+        assert raw_frame not in json.dumps(event["payload"])
+
     def test_non_object_request_rejected(self) -> None:
         frames = _drive(b"[1, 2, 3]\n")
         assert frames[0]["error"]["code"] == _ErrorCode.INVALID_REQUEST
@@ -188,6 +218,20 @@ class TestNotifications:
         frames = _drive(_encode_notification("ping"))
         assert frames == []
 
+    def test_ping_notification_emits_no_response_telemetry(
+        self,
+        captured_mcp_events: list[dict[str, Any]],
+    ) -> None:
+        frames = _drive(_encode_notification("ping"))
+
+        assert frames == []
+        event = captured_mcp_events[-1]
+        assert event["event_name"] == "ctx.mcp.request"
+        assert event["outcome"] == "ok"
+        assert event["payload"]["rpc.method"] == "ping"
+        assert event["payload"]["ctx.notification"] is True
+        assert event["payload"]["ctx.response_emitted"] is False
+
     def test_cancelled_notification_is_silent(self) -> None:
         frames = _drive(_encode_notification("notifications/cancelled", {"requestId": 1}))
         assert frames == []
@@ -234,6 +278,37 @@ class TestToolsCall:
         frames = _drive(_encode_request(1, "tools/call", {"arguments": {}}))
         assert frames[0]["error"]["code"] == _ErrorCode.INVALID_PARAMS
 
+    def test_tool_call_emits_otel_telemetry_without_raw_arguments(
+        self,
+        captured_mcp_events: list[dict[str, Any]],
+    ) -> None:
+        raw_query = "private acme query"
+        frames = _drive(
+            _encode_request(
+                1,
+                "tools/call",
+                {
+                    "name": "fs__read_file",
+                    "arguments": {"query": raw_query, "top_k": 3},
+                },
+            )
+        )
+
+        assert frames[0]["error"]["code"] == _ErrorCode.METHOD_NOT_FOUND
+        event = captured_mcp_events[-1]
+        assert event["event_name"] == "ctx.mcp.request"
+        assert event["source"] == "ctx-mcp-server"
+        assert event["transport"] == "mcp-jsonrpc"
+        assert event["outcome"] == "error"
+        assert event["payload"]["rpc.method"] == "tools/call"
+        assert event["payload"]["ctx.tool.name"] == "fs__read_file"
+        assert event["payload"]["ctx.arguments.keys"] == ["query", "top_k"]
+        assert event["payload"]["ctx.query.length"] == len(raw_query)
+        assert event["payload"]["ctx.query.hash"].startswith("sha256:")
+        assert event["payload"]["ctx.arguments.top_k"] == 3
+        assert event["payload"]["otel.status_code"] == "ERROR"
+        assert raw_query not in json.dumps(event["payload"])
+
     def test_non_dict_arguments_yields_invalid_params(self) -> None:
         frames = _drive(
             _encode_request(

src/tests/test_monitor_testing_api.py

@@ -0,0 +1,13 @@
+"""Stable testing facade for ctx monitor internals."""
+
+from __future__ import annotations
+
+import importlib
+
+
+def test_monitor_testing_facade_exposes_public_helper_names() -> None:
+    testing = importlib.import_module("ctx.monitor.testing")
+
+    assert callable(testing.read_jsonl)
+    assert callable(testing.render_graph)
+    assert callable(testing.make_monitor_server)

src/tests/test_pack_compaction.py

@@ -0,0 +1,621 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+import networkx as nx
+import pytest
+
+from ctx.core.graph.graph_packs import (
+    discover_pack_manifests,
+    load_merged_pack_graph,
+    write_base_pack,
+    write_overlay_pack,
+)
+from ctx.core.graph.graph_store import graph_store_is_fresh, search_nodes
+from ctx.core.wiki import pack_compaction
+from ctx.core.wiki.pack_compaction import (
+    PackCompactionError,
+    compact_active_pack_sets,
+    pack_compaction_status,
+    promote_staged_pack_sets,
+)
+from ctx.core.wiki.wiki_packs import (
+    discover_wiki_pack_manifests,
+    load_merged_wiki_pages,
+    write_wiki_base_pack,
+    write_wiki_overlay_pack,
+)
+
+
+def test_compact_active_pack_sets_stages_graph_and_wiki_without_mutating_active(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    graph_packs, wiki_packs = _write_active_pack_sets(wiki)
+    staging_dir = tmp_path / "staged-compaction"
+
+    result = compact_active_pack_sets(
+        wiki_path=wiki,
+        base_export_id="export-2",
+        staging_dir=staging_dir,
+    )
+
+    assert result.graph_manifest.pack_id == "base-export-2"
+    assert result.wiki_manifest.pack_id == "base-export-2"
+    assert [entry.manifest.pack_id for entry in discover_pack_manifests(graph_packs)] == [
+        "base-export-1",
+        "overlay-new",
+    ]
+    assert [entry.manifest.pack_id for entry in discover_wiki_pack_manifests(wiki_packs)] == [
+        "base-export-1",
+        "overlay-new",
+    ]
+    compacted_graph = load_merged_pack_graph(staging_dir / "graph-packs")
+    assert "skill:old" not in compacted_graph
+    assert compacted_graph.has_edge("skill:new", "skill:keep")
+    assert load_merged_wiki_pages(staging_dir / "wiki-packs") == {
+        "entities/skills/keep.md": "# Keep\n",
+        "entities/skills/new.md": "# New\n",
+    }
+    manifest = json.loads((staging_dir / "pack-compaction-manifest.json").read_text())
+    assert manifest["schema_version"] == 1
+    assert manifest["operation"] == "pack-compaction-stage"
+    assert manifest["base_export_id"] == "export-2"
+    assert manifest["staged_graph_packs_dir"] == str(staging_dir / "graph-packs")
+    assert manifest["staged_wiki_packs_dir"] == str(staging_dir / "wiki-packs")
+    assert manifest["graph"]["pack_id"] == "base-export-2"
+    assert manifest["wiki"]["pack_id"] == "base-export-2"
+
+
+def test_compact_active_pack_sets_rejects_graph_wiki_mismatch_before_return(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    graph_packs, wiki_packs = _write_active_pack_sets(wiki)
+    staging_dir = tmp_path / "staged-compaction"
+    write_overlay_pack(
+        pack_dir=graph_packs / "overlay-missing-wiki",
+        pack_id="overlay-missing-wiki",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-1",
+        model_id="model-1",
+        nodes=[{"id": "skill:missing-wiki", "type": "skill", "label": "missing wiki"}],
+        edges=[{"source": "skill:missing-wiki", "target": "skill:keep", "weight": 0.8}],
+        tombstones=[],
+    )
+
+    with pytest.raises(PackCompactionError, match="missing wiki pages"):
+        compact_active_pack_sets(
+            wiki_path=wiki,
+            base_export_id="export-2",
+            staging_dir=staging_dir,
+        )
+
+    assert not staging_dir.exists()
+    assert [entry.manifest.pack_id for entry in discover_pack_manifests(graph_packs)] == [
+        "base-export-1",
+        "overlay-new",
+        "overlay-missing-wiki",
+    ]
+    assert [entry.manifest.pack_id for entry in discover_wiki_pack_manifests(wiki_packs)] == [
+        "base-export-1",
+        "overlay-new",
+    ]
+
+
+def test_pack_compaction_cli_emits_json_for_staged_pack_sets(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    staging_dir = tmp_path / "staged-compaction"
+
+    result = pack_compaction.main([
+        "compact",
+        "--wiki-path",
+        str(wiki),
+        "--base-export-id",
+        "export-2",
+        "--staging-dir",
+        str(staging_dir),
+        "--json",
+    ])
+
+    assert result == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["graph"]["pack_id"] == "base-export-2"
+    assert payload["wiki"]["pack_id"] == "base-export-2"
+    assert payload["staged_graph_packs_dir"] == str(staging_dir / "graph-packs")
+    assert payload["staged_wiki_packs_dir"] == str(staging_dir / "wiki-packs")
+    assert "skill:old" not in load_merged_pack_graph(staging_dir / "graph-packs")
+    assert "entities/skills/old.md" not in load_merged_wiki_pages(staging_dir / "wiki-packs")
+
+
+def test_pack_compaction_status_reports_overlay_threshold(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+
+    default_status = pack_compaction_status(wiki_path=wiki)
+    assert default_status["overlay_threshold"] == 25
+    assert default_status["needs_compaction"] is False
+
+    status = pack_compaction_status(
+        wiki_path=wiki,
+        overlay_threshold=1,
+    )
+
+    assert status["base_export_id"] == "export-1"
+    assert status["graph_overlay_count"] == 1
+    assert status["wiki_overlay_count"] == 1
+    assert status["max_overlay_count"] == 1
+    assert status["overlay_threshold"] == 1
+    assert status["needs_compaction"] is True
+    assert status["can_compact_now"] is True
+    assert status["graph_pack_ids"] == ["base-export-1", "overlay-new"]
+    assert status["wiki_pack_ids"] == ["base-export-1", "overlay-new"]
+    validation = status["validation"]
+    assert isinstance(validation, dict)
+    assert validation["graph_nodes"] == 2
+    assert validation["wiki_pages"] == 2
+
+
+def test_pack_compaction_cli_status_emits_json(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+
+    rc = pack_compaction.main([
+        "status",
+        "--wiki-path",
+        str(wiki),
+        "--overlay-threshold",
+        "2",
+        "--json",
+    ])
+
+    assert rc == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["base_export_id"] == "export-1"
+    assert payload["max_overlay_count"] == 1
+    assert payload["overlay_threshold"] == 2
+    assert payload["needs_compaction"] is False
+    assert payload["can_compact_now"] is True
+
+
+def test_promote_staged_pack_sets_replaces_graph_and_wiki_with_backups(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    staged = compact_active_pack_sets(
+        wiki_path=wiki,
+        base_export_id="export-2",
+        staging_dir=tmp_path / "staged-compaction",
+    )
+
+    result = promote_staged_pack_sets(
+        wiki_path=wiki,
+        staged_graph_packs_dir=staged.staged_graph_packs_dir,
+        staged_wiki_packs_dir=staged.staged_wiki_packs_dir,
+        graph_backup_packs_dir=tmp_path / "graph-packs.backup",
+        wiki_backup_packs_dir=tmp_path / "wiki-packs.backup",
+    )
+
+    active_graph = load_merged_pack_graph(wiki / "graphify-out" / "packs")
+    assert "skill:old" not in active_graph
+    assert active_graph.has_edge("skill:new", "skill:keep")
+    assert load_merged_wiki_pages(wiki / "wiki-packs") == {
+        "entities/skills/keep.md": "# Keep\n",
+        "entities/skills/new.md": "# New\n",
+    }
+    backup_graph = load_merged_pack_graph(tmp_path / "graph-packs.backup")
+    assert "skill:old" not in backup_graph
+    assert backup_graph.has_edge("skill:new", "skill:keep")
+    assert [entry.manifest.pack_id for entry in discover_pack_manifests(tmp_path / "graph-packs.backup")] == [
+        "base-export-1",
+        "overlay-new",
+    ]
+    assert load_merged_wiki_pages(tmp_path / "wiki-packs.backup") == {
+        "entities/skills/keep.md": "# Keep\n",
+        "entities/skills/new.md": "# New\n",
+    }
+    assert [entry.manifest.pack_id for entry in discover_wiki_pack_manifests(tmp_path / "wiki-packs.backup")] == [
+        "base-export-1",
+        "overlay-new",
+    ]
+    assert result.graph.promoted_pack_ids == ["base-export-2"]
+    assert result.wiki.promoted_pack_ids == ["base-export-2"]
+    store_path = wiki / "graphify-out" / "graph-store.sqlite3"
+    assert result.graph_store == {"rebuilt": True, "nodes": 2, "edges": 1}
+    assert graph_store_is_fresh(store_path, wiki / "graphify-out") is True
+    assert [row["id"] for row in search_nodes(store_path, "new")] == ["skill:new"]
+
+
+def test_pack_compaction_cli_promotes_staged_pack_sets(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    staged = compact_active_pack_sets(
+        wiki_path=wiki,
+        base_export_id="export-2",
+        staging_dir=tmp_path / "staged-compaction",
+    )
+
+    rc = pack_compaction.main([
+        "promote",
+        "--wiki-path",
+        str(wiki),
+        "--staged-graph-packs-dir",
+        str(staged.staged_graph_packs_dir),
+        "--staged-wiki-packs-dir",
+        str(staged.staged_wiki_packs_dir),
+        "--graph-backup-packs-dir",
+        str(tmp_path / "graph-packs.backup"),
+        "--wiki-backup-packs-dir",
+        str(tmp_path / "wiki-packs.backup"),
+        "--json",
+    ])
+
+    assert rc == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["graph"]["promoted_pack_ids"] == ["base-export-2"]
+    assert payload["wiki"]["promoted_pack_ids"] == ["base-export-2"]
+    assert "skill:old" not in load_merged_pack_graph(wiki / "graphify-out" / "packs")
+    assert "entities/skills/old.md" not in load_merged_wiki_pages(wiki / "wiki-packs")
+
+
+def test_pack_compaction_cli_compact_promote_one_shot(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    staging_dir = tmp_path / "staged-one-shot"
+    store_path = tmp_path / "graph-store.sqlite3"
+
+    rc = pack_compaction.main([
+        "compact-promote",
+        "--wiki-path",
+        str(wiki),
+        "--base-export-id",
+        "export-2",
+        "--staging-dir",
+        str(staging_dir),
+        "--graph-backup-packs-dir",
+        str(tmp_path / "graph-packs.backup"),
+        "--wiki-backup-packs-dir",
+        str(tmp_path / "wiki-packs.backup"),
+        "--graph-store-db",
+        str(store_path),
+        "--json",
+    ])
+
+    assert rc == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["compaction"]["base_export_id"] == "export-2"
+    assert payload["promotion"]["graph"]["promoted_pack_ids"] == ["base-export-2"]
+    assert payload["promotion"]["wiki"]["promoted_pack_ids"] == ["base-export-2"]
+    assert payload["promotion"]["graph_store"] == {"rebuilt": True, "nodes": 2, "edges": 1}
+    assert "skill:old" not in load_merged_pack_graph(wiki / "graphify-out" / "packs")
+    assert "entities/skills/old.md" not in load_merged_wiki_pages(wiki / "wiki-packs")
+    assert graph_store_is_fresh(store_path, wiki / "graphify-out") is True
+
+
+def test_pack_compaction_cli_validates_active_pack_sets(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+
+    rc = pack_compaction.main([
+        "validate",
+        "--wiki-path",
+        str(wiki),
+        "--json",
+    ])
+
+    assert rc == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["graph_nodes"] == 2
+    assert payload["graph_edges"] == 1
+    assert payload["wiki_pages"] == 2
+    assert payload["graph_pack_ids"] == ["base-export-1", "overlay-new"]
+    assert payload["base_export_id"] == "export-1"
+    assert payload["missing_wiki_pages"] == 0
+    assert payload["orphan_wiki_pages"] == 0
+    assert payload["stale_wiki_links"] == 0
+
+
+def test_pack_compaction_cli_validates_staged_pack_sets_with_manifest(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    staged = compact_active_pack_sets(
+        wiki_path=wiki,
+        base_export_id="export-2",
+        staging_dir=tmp_path / "staged-compaction",
+    )
+
+    rc = pack_compaction.main([
+        "validate",
+        "--staged-graph-packs-dir",
+        str(staged.staged_graph_packs_dir),
+        "--staged-wiki-packs-dir",
+        str(staged.staged_wiki_packs_dir),
+        "--require-compaction-manifest",
+        "--json",
+    ])
+
+    assert rc == 0
+    payload = json.loads(capsys.readouterr().out)
+    assert payload["graph_nodes"] == 2
+    assert payload["graph_edges"] == 1
+    assert payload["wiki_pages"] == 2
+    assert payload["graph_pack_ids"] == ["base-export-2"]
+    assert payload["base_export_id"] == "export-2"
+
+
+def test_pack_compaction_validate_rejects_stale_entity_wikilinks(
+    tmp_path: Path,
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    write_wiki_overlay_pack(
+        pack_dir=wiki / "wiki-packs" / "overlay-z-stale-link",
+        pack_id="overlay-z-stale-link",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        pages={"entities/skills/new.md": "# New\n\n[[entities/skills/missing]]\n"},
+        tombstones=[],
+    )
+
+    rc = pack_compaction.main([
+        "validate",
+        "--wiki-path",
+        str(wiki),
+        "--json",
+    ])
+
+    assert rc == 1
+    assert "stale wiki links: 1" in capsys.readouterr().err
+
+
+def test_promote_staged_pack_sets_rejects_invalid_staged_wiki_before_graph_swap(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    staged = compact_active_pack_sets(
+        wiki_path=wiki,
+        base_export_id="export-2",
+        staging_dir=tmp_path / "staged-compaction",
+    )
+    pages_path = staged.staged_wiki_packs_dir / "base-export-2" / "pages.jsonl"
+    pages_path.write_text('{"path":"entities/skills/new.md","text":"tampered","sha256":"bad"}\n')
+
+    with pytest.raises(PackCompactionError, match="checksum mismatch"):
+        promote_staged_pack_sets(
+            wiki_path=wiki,
+            staged_graph_packs_dir=staged.staged_graph_packs_dir,
+            staged_wiki_packs_dir=staged.staged_wiki_packs_dir,
+        )
+
+    assert [entry.manifest.pack_id for entry in discover_pack_manifests(wiki / "graphify-out" / "packs")] == [
+        "base-export-1",
+        "overlay-new",
+    ]
+    assert [entry.manifest.pack_id for entry in discover_wiki_pack_manifests(wiki / "wiki-packs")] == [
+        "base-export-1",
+        "overlay-new",
+    ]
+
+
+def test_promote_staged_pack_sets_rejects_graph_wiki_entity_mismatch(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    staged = compact_active_pack_sets(
+        wiki_path=wiki,
+        base_export_id="export-2",
+        staging_dir=tmp_path / "staged-compaction",
+    )
+    staged_wiki_base = staged.staged_wiki_packs_dir / "base-export-2"
+    pages_path = staged_wiki_base / "pages.jsonl"
+    page_rows = [
+        json.loads(line)
+        for line in pages_path.read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    page_rows = [
+        row
+        for row in page_rows
+        if row["path"] != "entities/skills/new.md"
+    ]
+    pages_path.write_text(
+        "".join(json.dumps(row, sort_keys=True, separators=(",", ":")) + "\n" for row in page_rows),
+        encoding="utf-8",
+    )
+    wiki_manifest_path = staged_wiki_base / "wiki-pack-manifest.json"
+    wiki_manifest = json.loads(wiki_manifest_path.read_text(encoding="utf-8"))
+    wiki_manifest["page_count"] = len(page_rows)
+    wiki_manifest["checksums"]["pages.jsonl"] = _sha256_file(pages_path)
+    wiki_manifest_path.write_text(json.dumps(wiki_manifest, indent=2, sort_keys=True) + "\n", encoding="utf-8")
+    compaction_manifest = json.loads(staged.manifest_path.read_text(encoding="utf-8"))
+    compaction_manifest["wiki"] = wiki_manifest
+    staged.manifest_path.write_text(
+        json.dumps(compaction_manifest, indent=2, sort_keys=True) + "\n",
+        encoding="utf-8",
+    )
+
+    with pytest.raises(PackCompactionError, match="missing wiki pages"):
+        promote_staged_pack_sets(
+            wiki_path=wiki,
+            staged_graph_packs_dir=staged.staged_graph_packs_dir,
+            staged_wiki_packs_dir=staged.staged_wiki_packs_dir,
+        )
+
+    assert [entry.manifest.pack_id for entry in discover_pack_manifests(wiki / "graphify-out" / "packs")] == [
+        "base-export-1",
+        "overlay-new",
+    ]
+
+
+def test_promote_staged_pack_sets_rejects_missing_compaction_manifest(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    staged = compact_active_pack_sets(
+        wiki_path=wiki,
+        base_export_id="export-2",
+        staging_dir=tmp_path / "staged-compaction",
+    )
+    staged.manifest_path.unlink()
+
+    with pytest.raises(PackCompactionError, match="pack-compaction-manifest.json"):
+        promote_staged_pack_sets(
+            wiki_path=wiki,
+            staged_graph_packs_dir=staged.staged_graph_packs_dir,
+            staged_wiki_packs_dir=staged.staged_wiki_packs_dir,
+        )
+
+    assert [entry.manifest.pack_id for entry in discover_pack_manifests(wiki / "graphify-out" / "packs")] == [
+        "base-export-1",
+        "overlay-new",
+    ]
+
+
+def test_promote_staged_pack_sets_rejects_manifest_dir_mismatch(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    staged = compact_active_pack_sets(
+        wiki_path=wiki,
+        base_export_id="export-2",
+        staging_dir=tmp_path / "staged-compaction",
+    )
+    manifest = json.loads(staged.manifest_path.read_text(encoding="utf-8"))
+    manifest["staged_wiki_packs_dir"] = str(tmp_path / "other-wiki-packs")
+    staged.manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+
+    with pytest.raises(PackCompactionError, match="staged_wiki_packs_dir"):
+        promote_staged_pack_sets(
+            wiki_path=wiki,
+            staged_graph_packs_dir=staged.staged_graph_packs_dir,
+            staged_wiki_packs_dir=staged.staged_wiki_packs_dir,
+        )
+
+
+def test_promote_staged_pack_sets_rejects_manifest_graph_section_drift(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    staged = compact_active_pack_sets(
+        wiki_path=wiki,
+        base_export_id="export-2",
+        staging_dir=tmp_path / "staged-compaction",
+    )
+    manifest = json.loads(staged.manifest_path.read_text(encoding="utf-8"))
+    manifest["graph"]["edge_count"] = 999
+    staged.manifest_path.write_text(json.dumps(manifest), encoding="utf-8")
+
+    with pytest.raises(PackCompactionError, match="graph manifest"):
+        promote_staged_pack_sets(
+            wiki_path=wiki,
+            staged_graph_packs_dir=staged.staged_graph_packs_dir,
+            staged_wiki_packs_dir=staged.staged_wiki_packs_dir,
+        )
+
+
+def test_promote_staged_pack_sets_rejects_unrecorded_staged_wiki_overlay(
+    tmp_path: Path,
+) -> None:
+    wiki = tmp_path / "wiki"
+    _write_active_pack_sets(wiki)
+    staged = compact_active_pack_sets(
+        wiki_path=wiki,
+        base_export_id="export-2",
+        staging_dir=tmp_path / "staged-compaction",
+    )
+    write_wiki_overlay_pack(
+        pack_dir=staged.staged_wiki_packs_dir / "overlay-extra",
+        pack_id="overlay-extra",
+        base_export_id="export-2",
+        parent_export_id="export-2",
+        pages={"entities/skills/extra.md": "# Extra\n"},
+        tombstones=[],
+    )
+
+    with pytest.raises(PackCompactionError, match="exactly one base pack"):
+        promote_staged_pack_sets(
+            wiki_path=wiki,
+            staged_graph_packs_dir=staged.staged_graph_packs_dir,
+            staged_wiki_packs_dir=staged.staged_wiki_packs_dir,
+        )
+
+
+def _write_active_pack_sets(wiki: Path) -> tuple[Path, Path]:
+    graph_packs = wiki / "graphify-out" / "packs"
+    wiki_packs = wiki / "wiki-packs"
+    graph = nx.Graph()
+    graph.add_node("skill:old", type="skill", label="old")
+    graph.add_node("skill:keep", type="skill", label="keep")
+    graph.add_edge("skill:old", "skill:keep", weight=0.2)
+    write_base_pack(
+        pack_dir=graph_packs / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        config_hash="config-1",
+        model_id="model-1",
+        graph=graph,
+    )
+    write_overlay_pack(
+        pack_dir=graph_packs / "overlay-new",
+        pack_id="overlay-new",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        config_hash="config-1",
+        model_id="model-1",
+        nodes=[{"id": "skill:new", "type": "skill", "label": "new"}],
+        edges=[{"source": "skill:new", "target": "skill:keep", "weight": 0.9}],
+        tombstones=[{"node_id": "skill:old"}],
+    )
+    write_wiki_base_pack(
+        pack_dir=wiki_packs / "base-export-1",
+        pack_id="base-export-1",
+        base_export_id="export-1",
+        pages={
+            "entities/skills/old.md": "# Old\n",
+            "entities/skills/keep.md": "# Keep\n",
+        },
+    )
+    write_wiki_overlay_pack(
+        pack_dir=wiki_packs / "overlay-new",
+        pack_id="overlay-new",
+        base_export_id="export-1",
+        parent_export_id="export-1",
+        pages={"entities/skills/new.md": "# New\n"},
+        tombstones=["entities/skills/old.md"],
+    )
+    return graph_packs, wiki_packs
+
+
+def _sha256_file(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()

src/tests/test_pack_full_wiki_tar.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+import io
+import json
+import tarfile
+from pathlib import Path
+
+from ctx.core.wiki.wiki_packs import load_merged_wiki_pages
+from scripts.pack_full_wiki_tar import repack_full_wiki_tar
+
+
+def _add_text(tf: tarfile.TarFile, name: str, text: str) -> None:
+    payload = text.encode("utf-8")
+    info = tarfile.TarInfo(name)
+    info.size = len(payload)
+    tf.addfile(info, io.BytesIO(payload))
+
+
+def test_repack_full_wiki_tar_moves_high_fanout_pages_into_wiki_pack(
+    tmp_path: Path,
+) -> None:
+    source = tmp_path / "wiki-graph.tar.gz"
+    target = tmp_path / "wiki-graph-packed.tar.gz"
+    with tarfile.open(source, "w:gz") as tf:
+        _add_text(tf, "index.md", "# Wiki\n")
+        _add_text(tf, "entities/skills/current.md", "# Current Skill\n")
+        _add_text(tf, "entities/skills/empty.md", "")
+        _add_text(tf, "entities/agents/reviewer.md", "# Reviewer Agent\n")
+        _add_text(tf, "entities/mcp-servers/github.md", "# GitHub MCP\n")
+        _add_text(tf, "entities/harnesses/langgraph.md", "# LangGraph Harness\n")
+        _add_text(tf, "concepts/empty.md", "")
+        _add_text(
+            tf,
+            "graphify-out/graph-export-manifest.json",
+            json.dumps({"export_id": "test-export"}),
+        )
+        _add_text(tf, "graphify-out/graph-report.md", "# Graph Report\n")
+        _add_text(tf, "graphify-out/graph.json", json.dumps({"nodes": [], "edges": []}))
+        _add_text(tf, "external-catalogs/skills-sh/catalog.json", json.dumps({"skills": []}))
+
+    stats = repack_full_wiki_tar(source, target)
+
+    assert stats.removed_expanded_markdown_pages == 5
+    assert stats.packed_pages == 8
+    with tarfile.open(target, "r:gz") as tf:
+        names = {member.name for member in tf.getmembers()}
+        tf.extractall(tmp_path / "extracted")
+
+    assert "entities/skills/current.md" not in names
+    assert "entities/skills/empty.md" not in names
+    assert "entities/agents/reviewer.md" not in names
+    assert "entities/mcp-servers/github.md" not in names
+    assert "entities/harnesses/langgraph.md" in names
+    assert "concepts/empty.md" not in names
+    assert "graphify-out/graph-report.md" in names
+    assert "wiki-packs/base-test-export/wiki-pack-manifest.json" in names
+    assert "wiki-packs/base-test-export/pages.jsonl" in names
+
+    pages = load_merged_wiki_pages(tmp_path / "extracted" / "wiki-packs")
+    assert pages["entities/skills/current.md"] == "# Current Skill\n"
+    assert pages["entities/skills/empty.md"] == "<!-- empty markdown page -->\n"
+    assert pages["entities/agents/reviewer.md"] == "# Reviewer Agent\n"
+    assert pages["entities/mcp-servers/github.md"] == "# GitHub MCP\n"
+    assert pages["concepts/empty.md"] == "<!-- empty markdown page -->\n"
+
+    second_target = tmp_path / "wiki-graph-packed-again.tar.gz"
+    repack_full_wiki_tar(target, second_target)
+    with tarfile.open(second_target, "r:gz") as tf:
+        second_names = {member.name for member in tf.getmembers()}
+        tf.extractall(tmp_path / "extracted-again")
+    assert "graphify-out/graph-report.md" in second_names
+    repacked_pages = load_merged_wiki_pages(tmp_path / "extracted-again" / "wiki-packs")
+    assert repacked_pages["entities/skills/current.md"] == "# Current Skill\n"
+    assert repacked_pages["entities/agents/reviewer.md"] == "# Reviewer Agent\n"
+    assert repacked_pages["entities/mcp-servers/github.md"] == "# GitHub MCP\n"

src/tests/test_pack_validation.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+import networkx as nx
+
+from ctx.core.wiki.pack_validation import validate_graph_wiki_consistency
+
+
+def test_validate_graph_wiki_consistency_accepts_matching_entity_pages() -> None:
+    graph = nx.Graph()
+    graph.add_node("skill:python", type="skill")
+    graph.add_node("agent:reviewer", type="agent")
+    graph.add_node("mcp-server:github", type="mcp-server")
+    graph.add_node("harness:mirage", type="harness")
+    pages = {
+        "entities/skills/python.md": "# Python\n",
+        "entities/agents/reviewer.md": "# Reviewer\n",
+        "entities/mcp-servers/g/github.md": "# GitHub\n",
+        "entities/harnesses/mirage.md": "# Mirage\n",
+    }
+
+    report = validate_graph_wiki_consistency(graph, pages)
+
+    assert report.ok is True
+    assert report.missing_wiki_pages == []
+    assert report.orphan_wiki_pages == []
+
+
+def test_validate_graph_wiki_consistency_reports_missing_wiki_pages() -> None:
+    graph = nx.Graph()
+    graph.add_node("skill:python", type="skill")
+    graph.add_node("mcp-server:github", type="mcp-server")
+
+    report = validate_graph_wiki_consistency(graph, {"entities/skills/python.md": "# Python\n"})
+
+    assert report.ok is False
+    assert report.missing_wiki_pages == [
+        {
+            "node_id": "mcp-server:github",
+            "expected_paths": [
+                "entities/mcp-servers/g/github.md",
+                "entities/mcp-servers/github.md",
+            ],
+        },
+    ]
+
+
+def test_validate_graph_wiki_consistency_reports_orphan_wiki_pages() -> None:
+    graph = nx.Graph()
+    graph.add_node("skill:python", type="skill")
+    pages = {
+        "entities/skills/python.md": "# Python\n",
+        "entities/harnesses/mirage.md": "# Mirage\n",
+    }
+
+    report = validate_graph_wiki_consistency(graph, pages)
+
+    assert report.ok is False
+    assert report.orphan_wiki_pages == [
+        {
+            "path": "entities/harnesses/mirage.md",
+            "expected_node_id": "harness:mirage",
+        },
+    ]

src/tests/test_package_scaffold.py

@@ -36,6 +36,8 @@ _EXPECTED_SUBPACKAGES: tuple[str, ...] = (
     "ctx.adapters.generic.providers",
     "ctx.adapters.generic.tools",
     "ctx.cli",
+    "ctx.monitor",
+    "ctx.monitor.pages",
     "ctx.mcp_server",
     "ctx.utils",
 )
@@ -45,8 +47,10 @@ _EXPECTED_CONSOLE_SCRIPTS: tuple[str, ...] = (
     "ctx-agent-add",
     "ctx-agent-install",
     "ctx-agent-mirror",
+    "ctx-agent-unload",
     "ctx-bundle-suggest",
     "ctx-dedup-check",
+    "ctx-graph-store",
     "ctx-harness-add",
     "ctx-harness-install",
     "ctx-incremental-attach",
@@ -64,6 +68,7 @@ _EXPECTED_CONSOLE_SCRIPTS: tuple[str, ...] = (
     "ctx-mcp-server",
     "ctx-mcp-uninstall",
     "ctx-monitor",
+    "ctx-pack-compact",
     "ctx-recommend",
     "ctx-scan-repo",
     "ctx-skill-add",
@@ -71,8 +76,14 @@ _EXPECTED_CONSOLE_SCRIPTS: tuple[str, ...] = (
     "ctx-skill-install",
     "ctx-skill-mirror",
     "ctx-skill-quality",
+    "ctx-skill-unload",
+    "ctx-skillspector-audit",
+    "ctx-skillspector-remediation",
+    "ctx-skillspector-scan",
     "ctx-source-registry",
     "ctx-tag-backfill",
+    "ctx-telemetry-export",
+    "ctx-telemetry-retention",
     "ctx-toolbox",
     "ctx-wiki-graphify",
     "ctx-wiki-worker",